Skip to navigation
Skip to main content
Skip to footer
Docs
Light
Dark
Light
Dark
Introduction
Getting started
Overview
First Deployment
First Deployment
Define and use variables
Approvals with Manual Interventions
Add deployment targets
Deploy a sample package
First Runbook Run
First Runbook Run
Configure Runbook Environments
Create a Project
Create a runbook
Defining the runbook process for workers
Running a Runbook
Runbook specific variables
Add runbook deployment targets
Defining the runbook process for targets
Publishing a runbook
Managing Octopus subscriptions
Samples
Reference architectures
Reference architectures
EKS reference architecture
Web App reference architecture
Glossary
Octopus Cloud
Overview
Getting started with Cloud
Migrating to Octopus Cloud
Static IP address
Dynamic workers
Task cap
Azure Private Links
IP address allow list
Uptime SLO
Maintenance windows
Disaster recovery
Permissions
Octopus Cloud FAQ
Installation
Overview
Installation requirements
SQL Database
Overview
Self-Managed SQL Server
AWS RDS
Azure SQL
GCP Cloud SQL
File Storage
Overview
Local File Storage
AWS File Storage
Azure Files
GCP File Storage
Windows NFS File Storage
Load Balancers
Overview
Configuring Netscaler
Use NGINX as a reverse proxy for Octopus Deploy
Use IIS as a reverse proxy for Octopus Deploy
AWS Load Balancers
Azure Load Balancers
GCP Load Balancers
Permissions for the Octopus Windows Service
Using a Managed Service Account (MSA)
Automating Octopus installation
Troubleshooting the Octopus installation
Octopus Server Linux Container
Octopus Server Linux Container
Octopus Server Container with Docker Compose
Octopus Server Container with systemd
Octopus Server in Kubernetes
Migration
Migration
Migrate to Octopus Server Linux Container from Windows Server
Migrate to Octopus Server Linux Container from Windows Container
Troubleshooting Octopus Server in a Container
Isolated Octopus Servers
Best Practices
Overview
Deployments
Overview
Environments, Deployment Targets, and Target Tags
Lifecycles and Environments
Projects and Project Groups Structure
Variable Recommendations
Step Templates and Script Modules
Deployment and Runbook Processes
Releases and Deployments
Notifications
Octopus Administration
Overview
Partition Octopus with Spaces
Offload Work to Workers
Users, Roles, and Teams
Ongoing Maintenance
Self-Hosted Octopus
Overview
Installation Guidelines
High Availability
Disaster Recovery
Platform Engineering
Overview
What is platform engineering?
Octopus enterprise patterns
Managing Octopus with code
Managing space resources
Managing project resources
Managing runbook resources
Forking Git repositories
Finding drift
Merging repos
Validating CaC PRs
Secret variables
Octopus AI
Overview
Octopus AI Assistant
Overview
Getting started
Cookbook
Overview
Analyze step template usage
Audit environment naming and counts
Audit PCI deployments
Audit target role distribution
Check retention policy consistency
Create a .NET Azure App deployment process
Detect overlapping variable names
Detect unused variables
Evaluate deployment frequency
Fix variable binding errors
Generate deployment rollback plan
Improve multi-tenant deployments
Investigate production deployment failure
Kubernetes deployment pipeline
List failed deployments
Recommend variable scoping
Report runbook scheduling
Report skipped steps
Resolve rolling deployment timeouts
Restart Windows services Runbook
Review runbook usage
Security best practices check
Speed up Lifecycle phases
Summarize Ops Runbooks
Summarize tag set coverage
Summarize worker pool health
Best Practices Adviser
Deployment failure analyzer
Prompt-based project creation
Custom prompts
Octopus MCP
Overview
Use Cases
Octopus Recovery Agent
Kubernetes
Overview
Targets
Overview
Kubernetes agent
Overview
Permissions
Granular Permissions
Kubernetes Monitor
Storage
Automated Installation
HA Cluster Support
Upgrading
Troubleshooting
General Troubleshooting
SHA1 Certificates on older Windows versions
Default images
Supported Versions Policy
Kubernetes API
Overview
OpenShift Kubernetes cluster
Rancher Kubernetes cluster
Steps
Overview
Deploy Kubernetes YAML
Deploy a Helm chart
Deploy with Kustomize
Configure and apply Kubernetes resources
Configure and apply a Kubernetes Service
Configure and apply a Kubernetes Ingress
Deployment Verification
Step Verification
Applied Manifests
Overview
Diffs
Resources
Glob Pattern Cheat Sheet
Server-Side Apply
kubectl
Tutorials
First Kubernetes deployment
Rollback Kubernetes deployment
Automatically tracking third party helm charts
Live Object Status
Overview
Installation
Troubleshooting
Argo CD
Overview
Argo CD Instances
Overview
Argo CD Authentication
Automated Installation
Deployment Steps
Overview
Update Argo CD Application Image Tags
Update Argo CD Application Manifests
Annotated Application View
Annotations
Scoping Annotations
Cluster Annotations
Helm Annotations
Supported Use Cases
Live Object Status
Troubleshooting
Infrastructure
Overview
Deployment targets
Deployment targets
Counting deployment targets
Target tags
Octopus Tentacle
Octopus Tentacle
Windows Tentacle
Windows Tentacle
Tentacle installation requirements
Tentacle installation requirements
Legacy Tentacle installation requirements
Permissions required for the Tentacle Windows Service
Running Tentacle under a specific user account
Clustered Listening Tentacles
Automating Tentacle installation
Polling Tentacles over WebSockets
Azure virtual machines
Azure virtual machines
Installing the Tentacle via DSC in an ARM template
Installing the Tentacle VM extension via the Azure Portal
Installing the Tentacle VM extension via the classic Azure Portal
Installing the Tentacle VM extension via PowerShell
Installing the Tentacle VM extension via the Azure CLI
Tentacle VM extension configuration structure
Diagnosing Tentacle VM extension issues
Linux Tentacle
Tentacle communication modes
Octopus Tentacle in a Container
Polling Tentacles over Standard HTTPS Port
Agent vs Agentless
Troubleshooting Tentacles
Troubleshooting Tentacles
Troubleshooting Listening Tentacles
Troubleshooting Polling Tentacles
Linux targets
Linux targets
SSH target
SSH target requirements
SSH deployments
Sudo commands
Amazon ECS cluster
Azure targets
Azure targets
Azure Service Fabric cluster targets
Azure Web App targets
Offline package drop
Cloud regions
Cloud Target Discovery
Dynamic infrastructure
Dynamic infrastructure
Create AWS account command
Create Azure Service Principal account command
Create token account command
Create username/password command
Create Azure Web App target command
Create Azure Service Fabric target command
Create Kubernetes Target Command
New Octopus Target Command
Remove Octopus Target Command
Machine policies
Proxy support
Environments
Environments
Environment recommendations
Accounts
Accounts
Azure
AWS accounts
Google cloud accounts
SSH key pair account
Token account
Username and password accounts
OpenID Connect
Workers
Workers
Built-in Worker
Kubernetes Worker
Kubernetes Worker
Storage
Cluster Configuration
Scaling Behavior
Automated Installation
Troubleshooting
Worker pools
Dynamic Worker pools
Dynamic Worker pools
Ubuntu 18.04 End-of-life
Windows 2019 End-of-life
Worker Tools, Versioning and Caching
Git credentials
Signing Keys
Ephemeral Environments
Platform Hub
Overview
Process Templates
Overview
Troubleshooting
Best Practices
Policies
Getting started
Examples
Schema for policies
Best Practices
Troubleshooting
Packaging applications
Overview
Create packages
Create packages
Versioning schemes
Create packages with the Octopus CLI
Create packages with OctoPack
Create packages with OctoPack
Include BuildEvent files
Troubleshooting OctoPack
Build server integration
Build server integration
Build information
AppVeyor integration
Azure DevOps
Azure DevOps
Using the Octopus extension
Using the Octopus extension
Build versions and packaging in Azure DevOps
Azure DevOps and Team Foundation Server Extension Version Compatibility
Installing the Octopus CLI as a capability
Bamboo
BitBucket Pipelines
Codefresh Pipelines
Continua CI
GitHub Actions
Jenkins
Jenkins
Jenkins Pipeline projects
TeamCity
Troubleshooting build server integrations
Package repositories
Package repositories
Built-in Octopus repository
Docker Container Registry
Docker Container Registry
Octopus versioning scheme
GitHub Repository feeds
Maven feeds
NuGet feeds
Artifactory Generic Feeds
Guides
Guides
Container registries
Container registries
Artifactory container registry
AWS Elastic Container Registry (ECR)
Azure Container Registry
Docker Hub
GitLab container registry
Google Cloud Container Registry (GCR)
Nexus Container Registry
Oracle Cloud Infrastructure Container Registry
ProGet Container Registry
NuGet repositories
NuGet repositories
Artifactory Local NuGet repository
Azure DevOps and TFS package management
GitHub NuGet repository
GitLab NuGet repository
Nexus Hosted NuGet repository
ProGet NuGet repository
Maven repositories
Maven repositories
Nexus Hosted Maven repository
GitLab Maven repository
ProGet Maven repository
Artifactory Maven repository
Cloudsmith Multi-format repositories
AWS S3 Bucket feeds
Projects
Overview
Deployment process
Deployment process
Artifacts
Performance
Setting up projects and project groups
Project dashboard
Project recommendations
Steps
Steps
Configuration features
Configuration features
Custom installation directory
IIS websites and application pools
Windows Services
Structured configuration variables
.NET XML configuration variables feature
.NET Configuration transforms
.NET Configuration transforms
Environment specific .NET configuration transforms with sensitive values
Troubleshooting .NET configuration transforms
Substitute variables in templates
NGINX Web Server
Conditions
Execution containers for workers
Built-in step templates
Built-in step templates
Email notification step
Manual intervention and approval step
Health check step
Automatic step template updates
Exporting and Importing Projects
Ephemeral Environments
Community step templates
Custom step templates
Custom step templates
Custom step templates stored in Git
Updating step templates
Variables
Variables
Getting started with variables
Variable substitutions
Variable filters
System variables
Output variables
Prompted variables
Sensitive variables
Certificate variables
Worker Pool variables
Google Cloud account variables
Azure account variables
AWS account variables
Username and password account variables
Tenant variables
Variable sets
Tenants
Overview
Bulk connection
Project triggers
Project triggers
Deployment target triggers
Scheduled deployment triggers
External feed triggers
Built-in package repository triggers
Git repository triggers
Coordinating multiple projects
Coordinating multiple projects
Project coordination code samples
Deploy a release step
Configuration as Code
Configuration as Code
Converting projects to Git
Converting projects to Git
Migrating variables to Git
Configuration as Code reference
Editing a project with version control enabled
GitHub integration
Creating and deploying releases on a version-controlled project
Creating releases from a build server plugin on a version-controlled project
Unsupported Configuration as Code Scenarios
Moving version control
OCL Syntax for Config as Code
Tenants
Overview
Tenant types
Tenant creation
Tenant creation
Tenanted deployments
Connecting projects
Tenant variables
Tag sets
Tenant tags
Tenant infrastructure
Tenant lifecycles
Tenant roles and security
Multi-tenant deployment guides
Multi-tenant deployment guides
Multi-tenant regions
Multi-tenant SaaS applications
Multi-tenant teams
Multi-tenant teams
Creating new tenants
Assigning a team to a tenant
Deploying to a team tenant
Tenants sharing machine targets
Tenants sharing machine targets
Creating the tenant tag set
Assign tags to tenants
Assign tags to targets
Deploying before the concurrency tag is changed
Setting the Concurrency Tag
Deploying after the concurrency tag is changed
Summary and FAQ
Multi-tenant deployments FAQ
Troubleshooting multi-tenant deployments
Releases
Overview
Creating a release
Lifecycles
Channels
Guided failures
Prevent release progression
Deleting releases
Manually fail a task
Issue trackers
Issue trackers
Jira issue tracking
GitHub issue tracking integration
Azure DevOps work item tracking integration
Release versioning
Deployment changes
Deployment Timeline
Release notes
Deployments
Overview
AWS
AWS
Amazon S3 Create Bucket
Deploy an AWS CloudFormation template
Update Amazon ECS Service
Deploy Amazon ECS Service
AWS permissions required by Octopus
Delete an existing AWS CloudFormation stack
Upload to AWS S3 template
Google Cloud
Google Cloud
Google cloud CLI scripts
Azure
Azure
Azure Service Fabric
Azure Service Fabric
Packaging a Service Fabric application
Deploying a package to an Azure Service Fabric cluster
Version automation with Service Fabric application packages
Connecting securely with client certificates
Connecting securely with Azure Active Directory
Varying Azure subscription by environment
Azure environments
Azure app service environments
Deploying to Azure via a firewall
Azure web apps
Azure web apps
Deploying Web Jobs
Using Deployment Slots with Azure Web Apps
Running Azure PowerShell
Running Azure PowerShell
Configuring the version of the Azure CLI
Configuring the version of the Azure PowerShell Modules
.NET deployments
.NET deployments
ASP.NET Core webapp
Docker Containers
Docker Containers
Accessing container details
Docker run with networking
Windows
Windows
Windows Services
IIS Websites and application pools
Virtual hard drives
Certificates
Certificates
Add a certificate to Octopus
Certificate chains
Import certificate to Windows certificate store
Import certificates into Tomcat
Import certificates into WildFly and JBoss EAP
Export a certificate
Export a certificate to a Java KeyStore
Replace a certificate
Archive and delete certificates
Troubleshooting invalid certificates
Databases
Databases
Database configuration
Database configuration
Install Tentacles and Workers for database deployments
Recommended database permissions
SQL Server deployments
SQL Server deployments
SQL Server permissions
SQL Server DACPAC deployment
Deploy to SQL Server using Redgate SQL change automation
Common patterns
Common patterns
Manual approvals
Automatic approvals
Ad-hoc data change scripts
Database backups and rollbacks
MySQL flyway deployment
Terraform
Terraform
Preparing your Terraform environment
Terraform step configuration
Planning changes made by Terraform templates
Applying changes from Terraform templates
Terraform output variables
Terraform plugin cache
Java applications
Java applications
Deploying a sample Java application
Java error messages and troubleshooting
NGINX deployments
NGINX deployments
Configuring target machine
Create and push an ASP.NET Core project
Configure Octopus Deploy project
Node deployments
Node deployments
Deploying Node applications to Linux
Packages
Packages
Dynamically selecting packages at deployment time
Delta compression for package transfers
Stage package uploads
Package deployment feature ordering
Deploying packages to your Octopus Server
Transfer package
Troubleshoot missing packages
Custom scripts
Custom scripts
Run a script step
Scripts in packages
Scripts in packages
Reference files within a package
Using variables in scripts
Passing parameters to scripts
Logging messages from scripts
Error handling
Output variables
Raw scripting
Azure CLI and PowerShell Scripts
AWS CLI and PowerShell scripts
Service Fabric PowerShell scripts
PowerShell Core
Debugging PowerShell scripts
Debugging PowerShell scripts
Debugging PowerShell scripts on remote machines
Script modules
HTML and JavaScript applications
Bulk deployment creation
Deployment freezes
Deployment freezes
Project deployment freezes
Patterns and practices
Patterns and practices
Rolling deployments
Blue-green deployments in Octopus using Environments
Blue-green deployments in Octopus using Environments
Blue-green deployments in IIS
Rollbacks
Rollbacks
Rollback .NET Application on Windows Server
Rolling back a Tomcat deployment
Rolling back an NGINX deployment
Multi-region deployment pattern
Elastic and transient environments
Elastic and transient environments
Deploying to Transient Targets
Keeping deployment targets up to date
Cleaning up Environments
Immutable Infrastructure
Canary deployments
Branching
Deployment process as code
Transferring packages before deployment
Transferring packages before deployment
Transferring packages with a separate environment
Transferring packages with a separate project
Runbooks
Overview
Runbooks vs Deployments
Config as Code runbooks
Runbooks permissions
Runbook variables
Runbooks publishing
Scheduled runbook triggers
Runbooks examples
Runbooks examples
Routine operations
Routine operations
IIS Runbooks
Install software with Chocolatey
Updating Windows
Updating Linux
Hardening Windows
Hardening an Ubuntu server
Installing Apache
Hardening Apache runbook
Install NGINX
Installing Tomcat on Ubuntu
Restarting a Tomcat Web application
Renew Let's Encrypt certificates
Services Runbooks
Emergency operations
Emergency operations
Manually failover DNS
Automatically failover DNS with monitoring
Restart server
Database examples
Database examples
Backup SQL database
Restore SQL database
Restore SQL database to another environment
Create MySQL database
Create PaaS MySQL database server
Backup MySQL database
Backup RDS SQL database to S3
Restore RDS SQL database from S3
AWS
AWS
Provision an AWS RDS instance
Change AWS load balancer target group
Delete an AWS CloudFormation stack
Azure
Azure