Latest features and highlights

With 2024.3 comes the release of the new autoscaling worker. Previously, to run workers on your infrastructure, you had to choose between running enough workers to handle your peak deployment load or creating an in-house solution to provision workers on demand. The first option often results in high infrastructure costs. The second option means creating and maintaining an in-house solution. With our new worker, you no longer need to make this choice. The Kubernetes-based worker optimizes your infrastructure use through autoscaling, and Octopus manages the worker for you.

Helm is an excellent tool for Kubernetes configuration templates. For advanced templating, you sometimes need to reference multiple values files in one Helm command. Octopus already works with multiple values files, and we’ve improved the Helm Upgrade step so it now has smart selection for Helm values sources. This makes it easy to add and reorder multiple values files.

We continue to ensure Octopus integrates Git resources seamlessly into your deployment processes. Now, we're making your Git workflows more secure with Git protection rules that let you restrict the Git resources used in deployments. You can configure which branches and tags people can use as the source of the deployment process and variables when creating a release. You can also make sure unauthorized or outdated Git resources don't get used in sensitive environments like production.

We improved our UI based on customer feedback, including making the project dashboard quicker and more customizable. These changes make it easier to find what you’re looking for in Octopus. We also updated our dark and light themes for improved accessibility and a more modern feel.

Our Deployment Freezes feature lets you prevent deployments to selected projects and/or environments. You can do this across all spaces for a configured amount of time. This is useful when you need to:

• Block deployments to your production environment during high traffic or shutdown periods
• Perform tests or sales demonstrations in other environments

Approving manual interventions can be time-consuming and slow down your deployments. To make the process more efficient, we simplified it so you can view and approve waiting manual interventions from a single place. Now, you can view all tasks awaiting manual interventions and approve them from the task page, making this process quicker, particularly at scale.

We changed how Octopus interacts with clusters by adding a Kubernetes agent. Working inside a cluster, the agent makes deployments to Kubernetes at scale much simpler.

• Installing the agent on a cluster registers it as a target in Octopus, so you don't need to configure authentication.
• You don’t need to allow external network access to the cluster as the agent starts and maintains the connection.
• The agent runs deployment tasks, so you don’t need Workers for deployments to Kubernetes.

We’re pleased to introduce external feed triggers for Kubernetes. The external feed trigger monitors Helm chart repositories and container image registries, like Docker Hub, referenced in your deployment steps. When it detects a new version, Octopus automatically creates a release.

Using the trigger, you can implement push deployments without creating releases from your CI tool. By combining the trigger with lifecycles, you can easily model complex scenarios, like:

• Automatic deployments to dev and test environments
• Quick hotfix promotions to production

The new tenant variables dashboard improves the visibility of tenant variables and their values across projects. This makes it easier to manage variables when using tenants. It also makes it simpler to access key variable information from multiple projects.

We improved our ServiceNow integration to give you better control over the creation and progression of change requests from Octopus. These changes add emergency change request functionality. They also let you pre-populate fields in an automatically generated change in Octopus. ServiceNow can now also close change requests post-deployment.

The license usage dashboard makes it easier for customers to see usage information at a glance. You can now see project, tenant, and target use by space, and how much of your task cap you’re using. This gives you greater oversight on the use levels in each space and helps you manage your account more easily.

We changed the task queue behavior to process child tasks more effectively when constrained by the task cap for faster deployments. If you use the Deploy a Release step, and you’re currently limited by your task cap, you may see an increase in throughput.

Open ID Connect (OIDC) has become the standard way to connect tools. We built on our OIDC support for Azure and GitHub with the addition of OIDC for AWS, letting Octopus act as a client for AWS. Previously, Octopus users deploying to AWS needed to store their AWS credentials configured in Octopus. You can now deploy with Octopus to AWS without any pre-shared credentials, making the process easier and more secure.

We're introducing Artifactory Generic Feeds so you can use any file type from Artifactory as a package. This removes the need for a workaround, like Maven feeds. Capabilities like path patterns and access tokens ensure you can access the right packages securely. This makes it simpler and easier to connect Octopus with your pipeline.

In 2023.4, we enabled Octopus Server to retry failed communications to the Tentacle. Building on that, we’ve optimized the timeout logic to detect failures sooner. You'll be able to deploy more often as deployments can continue quickly, freeing up resources for the next deployment in the queue.

In 2024.1, we upgraded Octopus Server from .NET 6. to .NET 8. Along with other optimizations, this significantly improved performance across the platform. We benchmarked the 60 most commonly used endpoints in our REST API and observed an average 16% reduction in latency. The biggest improvement was 60% faster than the 2023.4 release, with equal or reduced memory consumption in all cases.

As part of our ongoing improvements to user experience based on customer feedback, we made changes to our page layouts. There’s more visual consistency to breadcrumbs and page titles, creating a more modern overall layout. Page titles and their associated menu labels are now also consistent.

Open ID Connect (OIDC) has become the standard way to connect tools. We’ve now implemented support for OIDC, letting Octopus act both as a server and a client.

Tools connecting to Octopus APIs, such as GitHub Actions, can now do so without sharing long-lived Octopus credentials. Octopus can also connect to Azure without needing Azure credentials configured in Octopus.

This means you can build with GitHub Actions and deploy with Octopus to Azure, without any pre-shared credentials. It makes the process easier and more secure.

Octopus can now source scripts from Git repositories. You can link your Git repo and specify the path to scripts and other files. This is an option instead of including scripts in packages or inserting them directly into the deployment process. This gives you more choice and flexibility in how you maintain scripts.

It’s now easier to connect tenants to many projects with our new bulk action. In one step, you can connect a new tenant to hundreds or thousands of projects, helping you more quickly focus on deploying your next set of changes.

When deploying to Tentacles on unstable network connections, intermittent connectivity issues can cause failures. When steps fail, it can take time to identify the failed step and perform a manual deployment. Octopus Server now retries failed communications to the Tentacle. This lets deployments and runbooks continue if the network gets restored in a specific time, reducing deployment failures.

Sometimes, tasks become critical and need to run before any other tasks in your queue. Examples include hotfixes, production deployments, or runbooks. This new feature lets you reprioritize tasks in your task queue, choosing a task to run before any other task that is yet to start. This gives you flexibility to manage your task queue so you can run critical tasks first.

We added functionality for AKS customers, with support for kubelogin for AKS clusters. From AKS version 1.23 onwards, kubelogin is the preferred authentication method. If you've disabled local access in your AKS cluster, you can now also use our Azure Service Principal authentication method.

Octopus now has a Kustomize step, so you can modify YAML files for Kubernetes. This makes it easier to manage multiple deployment pipelines for applications running on Kubernetes. You can use one YAML template and adjust it for an app, environment, or tenant to enforce unification and reduce maintenance costs.

To continue building our support for Helm in Octopus, we added the ability to reference Helm charts from OCI registries. You can now add OCI registries as an external feed in your library and select this chart to deploy in your ‘Upgrade a Helm Chart’ step.

Occasionally, a step or task will get stuck during deployment and you need a manual intervention to resolve it. To reduce the need for manual interventions, we added configurable step timeouts so you can set a time cap in steps and tasks. Paired with Step Retries, released in 2023.2, this improves the likelihood of successful deployments without manual interventions.

Kubernetes deployments are now even simpler in Octopus. You can connect your Git version control system to source Kubernetes configuration files. This means you don't need to configure packaging and send files to Octopus in your CI. It’s also easier to use one repository for multiple projects giving you greater flexibility in managing deployments.

Octopus 2023.3 brings a faster and more responsive audit log experience. You can now configure audit log retention limits, measured in days, to optimize the experience and make it faster to work with audit log data. This change also makes Octopus upgrades faster with less load on the server. You’ll see a 90-day retention policy with older files available for download.

You can now use bulk actions to manage your tenants at scale, making it easier to add new product offerings and locations, or transition to a new system. You can use this bulk action when you create a new project to connect to multiple tenants, or you add a new tenant and want to connect it to multiple projects.

To help improve the success rate and automation of deployments, you can now add automatic retries to deployments. This lets you enable retries automatically from a failed action. The result is fewer manual interventions when transient connectivity issues interrupt your deployments.

2023.2 brings built-in support for deploying Azure resources with a new ‘Deploy a Bicep template’ step. This step helps you if you’re using Bicep with your deployments by making the process simpler in Octopus.

The Kubernetes Object Status feature provides live status updates during the deployment process for all the Kubernetes objects you're deploying. This gives you greater visibility of your cluster to verify the status of your Kubernetes objects and detect deployment errors as early as possible.

We added more capabilities to DevOps Insights to give you better visibility on your deployment performance. This includes a filter for channels so you can delve into your insights more easily. We also added a new Deployment Duration graph which shows deployment progress from start to finish at an aggregate level so you can identify trends across your deployments.

The redesigned Tenants overview dashboard gives you better overall visibility of your tenants and tenant-related items quickly and under large data loads. It lets you access key information at a glance, including projects, environments, and tenant tags across all your tenants. Using the single dashboard view you can efficiently manage and administer thousands of tenants.

Tentacles are a critical part of many teams’ infrastructure configuration, however, their updates can take time and delay queued deployment tasks. We’ve improved this experience by:

• Slimming Tentacle Upgrade Packages so they’re up to 5 times smaller for each platform
• Introducing the ability to automatically spread the load of the upgrade across multiple server tasks, allowing multiple upgrades to occur at once and decreasing overall upgrade time
• Reducing the need for Tentacle upgrades, so they’re only required if critical. This means you won’t need to upgrade your Tentacles as frequently, and when upgrades are necessary, your Tentacle upgrades will be faster.

For those self-hosting Octopus, the official Helm chart is the simplest and easiest way to install the Kubernetes resources into your own cluster.

Fully supported, the Helm chart allows you to install a multi-node Octopus cluster and makes it easy to upgrade, so you can always be on the latest version.

We’re making it even easier to work with your audit log data with the audit log control feed as part of our Enterprise subscription. This means you can connect your audit log feed to Splunk or Sumo Logic, allowing you to search, filter and view audit log entries that are only available as a download via Octopus more easily.

The new interactive Octopus Deploy roadmap allows you to see what we’re working on, as well as what we’re considering to build in the future. This gives you visibility on what's next for Octopus Deploy, with updates along the way.

This also gives you the opportunity to help shape the future of Octopus. You can provide feedback on existing ideas at a touch of a button, as well as submit your own ideas to our product teams.

We’re improving our support for Config as Code when using the Octopus UI with built-in branch protection support. Built-in support for branch protection support helps you meet compliance needs and reduces risk of erroneous changes making it to production with the following features:

• Commit to a different branch from the start
• Define protected branches easily
• Mark which branches are protected
• Easy visibility on which branches are protected
• Guided processes for protected branches

Octopus CLI vNext represents an evolution of the current Octopus CLI (octo or octo.exe) to improve your experience when interacting with Octopus Deploy from the command line. It includes command line switches, and it’s extensible via numerous output formats and support for future plugins, providing a more interactive experience built for humans.

The Jira Service Management integration ensures that teams using this platform can access the benefits of creating change requests automatically in Octopus. This new integration links Octopus deployments to Jira Service Management change requests and automatically creates pre-populated, “Request for change” change requests. You get improved traceability out-of-the-box, and you can prove to auditors that every controlled deployment has a change request. This ensures your CI/CD and release management processes are compliant with company policies and regulation.

This feature is available as part of the Octopus Deploy Enterprise subscription.

This release brings full support to version control and evolve your configuration variables alongside your deployment process and application code. Config as Code for variables covers text variables and gives you full control over scoping text, certificate, account, Worker Pool, and prompted variables. You get the same control as the Octopus UI to scope your variables to environments, roles, specific targets, and more without restrictions or adding specific formatting or syntax.

We’ve released a number of updates for our GitHub Actions for Octopus Deploy, including:

• Usability improvements for existing GitHub Actions
• Improved usability through SemVer-based tags
• Simpler inputs with sensible defaults and less input parameters for each action
• Added support for environment variables for sensitive values (i.e. API keys) Job summaries to surface the most important details
• Push Build information GitHub Actions that allows you to provide detailed commit, build and issue tracking information

DevOps Insights (early access) in Octopus gives you better visibility into your company’s DevOps performance by surfacing insights based on the 4 key DORA metrics. These metrics help you qualify the results of your DevOps performance, as well as gain insights into areas for future improvement.

Our Service Now Integration helps you to work with your change management teams better with better traceability out-of-the-box. Features include:

• Easy workflow configuration
• Link a deployment to an existing change request
• Automatically create standard change requests at deployment time
• Use change templates to auto-create standard change requests
• View and export audit logs of controlled deployments This feature is available as part of the Octopus Deploy Enterprise subscription.

Our Service Now Integration in Early Access Preview helps you to work with your change management teams better with better traceability out-of-the-box. Features include:

• Easy workflow configuration
• Link a deployment to an existing change request
• Automatically create standard change requests at deployment time
• Use change templates to auto-create standard change requests
• View and export audit logs of controlled deployments

Two new steps provide improvements for AWS Lambda serverless function deployments. The Upload file to S3 step now supports the ability to reference files uploaded in a previous step as well as full support for variable substitution and structured variable replacement.

The new Create S3 bucket step gives you more flexibility when uploading files to new or updated locations. Create new S3 buckets or folders and then upload files to them in subsequent steps without any friction or custom scripting.

Automatic cloud discovery allows you to deploy your work to new test and production infrastructure quickly and easily. No clicking through a UI to configure it or writing custom scripts to wire it up or explicitly specifying the exact details. Connect your cloud accounts, tag your cloud resources, deploy your applications. Octopus will also periodically check if cloud infrastructure is still available and clean things up if needed in line with your company policies.

This initial release adds support for Azure App Services (Web Apps), Amazon ECS clusters and Kubernetes clusters (early access preview).

Built-in support for Amazon’s Elastic Container Service (ECS) makes it easier to get started with ECS or deploy a new service through Octopus. We added the UI-driven Deploy Amazon ECS Service step, a new target, and improved the existing Deploy an AWS CloudFormation Template step.

Octopus Deploy for Visual Studio Code is a free extension that makes working with Octopus Configuration Language (OCL) files easier. Features include:

• Syntax highlighting
• Code snippets for steps and actions
• An integrated tree view to navigate nodes in the file

Octopus Deploy now integrates with Buildkite. Our new Buildkite plugins allow your build agents to create and deploy releases, push build information, and run runbooks as part of a pipeline.

The integration provided through our new Buildkite plugins represents our initial design and release. We plan to build additional plugins and eliminate the dependency on the Octopus CLI by providing integration through Bash scripts.

Configuration as Code (Config as Code) in Octopus delivers the full power of Git with a fully functional user interface. Our implementation of Config as Code means you can see your deployment process in your Git repo next to your application code and evolve them together.

When Config as Code is enabled for a project, you can continue to use the Octopus UI as you always have, or you can edit the text files in your favorite editor. Work wherever you're the most productive.

Our new TypeScript API client provides cross-platform integration with Octopus using the Node.js and npm ecosystem. Now you can script tasks with Octopus Deploy using an accessible, familiar programming language regardless of the systems you use with Octopus.

We introduced a Workato connector for Octopus Deploy. Workato is an Integration Platform as a Service (iPaaS) to integrate apps and automate business workflows. The connector will make it easy to:

• Include Octopus Deploy in Workato workflows.
• Perform operations against Octopus Deploy, such as create and deploy releases.
• Create recipes that respond to events in Octopus through a trigger.

Dedicated integration with Google Cloud Platform (GCP) means you can:

• Connect and authenticate with GCP via a dedicated account type.
• Use gcloud, the GCP command-line tool.
• Create and tear down GCP infrastructure with Terraform.
• Store and secure your Docker images within the Google Container Registry (GCR).
• Deploy, scale and manage containerized applications on GCP with Octopus and Kubernetes.

Dedicated integration with Google Cloud Platform (GCP) means you can:

• Connect and authenticate with GCP via a dedicated account type.
• Use gcloud, the GCP command-line tool.
• Create and tear down GCP infrastructure with Terraform.
• Store and secure your Docker images within the Google Container Registry (GCR).
• Deploy, scale and manage containerized applications on GCP with Octopus and Kubernetes.

We added a new step to Octopus: Deploy an Azure App Service. This step makes it easier than ever to deploy your Azure web applications. It runs cross-platform, configures app settings and connection strings, and deploys container images.

We improved the compute and storage capabilities of Octopus Cloud so it can scale with you as your requirements change. Octopus Cloud delivers best-in-class file storage (1TB) and the ability to run more concurrent automation tasks.

More Octopus Cloud improvements will follow later in 2021.

We introduced built-in support for GitHub Actions so you can integrate your GitHub builds and other automated processes with your Octopus workflows. Push your build artifacts to Octopus, create releases, execute runbooks, and more.

The Export/Import Projects feature allows you to move projects from one space to another. With this feature, you can:

• Move projects from a self-hosted Octopus Server to Octopus Cloud.
• Split a multi-project space into multiple spaces.
• Move a project from one space to another, in the same instance or another instance.

We added a search field to the Octopus Web Portal. Find and invoke actions with a few keystrokes, and navigate to server-side resources with ease.

Global Search benefits all Octopus users. It helps first-time users gain confidence with Octopus and find what they need even when they don’t know where to look, and it allows advanced users to navigate even faster than before.

The Octopus Tentacle agent now supports ARM and ARM64 hardware. This update makes it possible to deploy your apps and services to Raspberry Pi 3 and 4, AWS A1 EC2 instances, and any ARM hardware that can run .NET Core 3.0 or later.

We are publishing our Octopus Server Linux Docker images so teams can self-host Octopus in a Linux Docker container. This image is based on the same code that powers Octopus Cloud, so you can self-host Octopus on your operating system of choice.

Octopus Cloud provides built-in Worker Pools with dynamic workers to execute scripts against your services and infrastructure. This update adds better cross-platform support with images for Windows 2019 and Ubuntu 20.04. All worker images support Execution Containers which provide the ability to simplify dependency management and streamline automation tooling.

Octopus now supports automatic configuration file updates configuration updates for JSON, YAML, XML and Properties files.

We’re adding better configuration file updates with support for YAML, XML, and property files. This makes it much easier to update any Java application files as well as numerous other platforms that use YAML and XML.

We’ve updated our runbook automation support based on customer-driven feedback.

• Runbook-only projects allow you to create operations focused projects.
• Octopus CLI support with the run-runbook command so you can execute runbooks from the command-line or scripts.
• Advanced control over runbook run settings, including environment scoping, retention policies, and guided failure support per runbook.

Our Jenkins plugin now supports Jenkins Pipelines. You can now integrate Jenkins with Octopus from your Jenkinsfile without scripting it yourself. Push packages, create and deploy releases as well as execute runbooks.

We updated our process editor to streamline the editing process with better visibility and fewer clicks. You can now see the entire deployment process to simplify navigation and make it easier to reference other step names in scripts and variables. It also allows you to edit your entire process, including updating multiple steps and saving all your changes with a single click.

Execution containers for Workers let you execute deployment work in isolation without the need to manage dependencies and containers.

We're shipping cross-platform Docker images pre-configured with the latest tools and frameworks for your deployments and runbooks.

Octopus now provides initial change management integration with Jira Service Desk that lets teams create change requests during their deployments automatically.

Developers, DevOps personnel, and operations folks love dark mode, and we’ve built a custom Octopus dark theme that is easier on your eyes.

The Octopus CLI lets you interact with an Octopus instance from a build server or local workstations. Developers can install it quickly with popular Linux and macOS package managers like Homebrew, APT, and YUM.

Operations runbooks automate routine maintenance and emergency operations tasks like infrastructure provisioning, database management, and website failover and restoration.

This feature was designed to make modeling and executing operations tasks feel as natural as deploying applications does today. It brings support to execute Runbooks directly against infrastructure and includes strong scheduling support.

We built Runbooks with teams in mind. Runbooks can be parameterized with prompted variables, and you can make changes with confidence, publishing only once they have been safely tested.

Octopus has long supported deploying applications to Linux via SSH; however, some companies operate in highly secure environments where it's not possible to open port 22 on production servers. Our customers faced scenarios where applications exist in their own DMZs with no incoming connections permitted other than HTTPS for web traffic.

We're making this scenario possible with Tentacle agent for Linux. Tentacle is a lightweight service that enables secure communication between the Octopus Server and deployment targets in a listening and polling modes. In polling mode, it contacts the Octopus Server and executes deployment work as required including retrieving application packages and deployment scripts.

Our new Octopus plugin for Jira Cloud enables teams to see the status of their releases and deployments directly in their Jira issues with deep links back to Octopus for further details. This enables greater visibility and insight for your team and company in the tool that they're most comfortable with.

Software usually runs through a CI/CD pipeline on its way to production. Developers push code to repositories like GitHub, and build servers like Azure DevOps and TeamCity, build it, and finally, Octopus deploys it. Traditionally, the linkages between each of those steps can get lost.

With the introduction of our build information and work item tracking, it’s now possible to see build, commit and issue details directly in Octopus. This allows teams to view the issues and build details that contributed to a release giving end-to-end traceability from issue to production. You can even click deep links for more information.

Release notes are a great way to help your team and customers understand what’s new in production. This is generally a manual process and can involve talking to numerous teams and reviewing project tracking tools and source code repos.

Octopus has simplified this process by leveraging metadata from your source code commits and build process to determine what’s new in an environment. It can show you which issues and changes are new since your last deployment. You can even share this with your team on Slack or send it to your customers via email.

This feature shipped with support for GitHub Issues, Jira Issues, and Azure DevOps work items.

Spaces is a new way to organize your Octopus Server, making it easy to group your projects, environments and most other things into a space for each team. It’s like moving teams from a large open plan office to private offices.

Spaces are useful for teams who have a large number of projects, environments, or tenants, and often have trouble finding the resources that are important to them. They eliminate distractions and enable teams to focus on what matters to them.

Another great benefit of Spaces is that it is a permissions boundary, simplifying the configuration of teams and roles. Octopus Server admins can delegate responsibility to “Space Managers” who are given full access to manage a space. They can define who is allowed to deploy to production and do other things within their space, without affecting teams in other spaces.

Octopus helps teams adopt and scale Kubernetes. Teams new to Kubernetes can use our rich step templates to get started quickly, and experienced teams can pick the strategy that suits them: full-control with kubectl or first-class HELM support. You can work with as much or as little YAML as you prefer, and time-saving deployment strategies help you get started faster.

Our Kubernetes support builds upon Octopus fundamentals that enable you to deploy releases in a repeatable and reliable manner. Things like promoting releases through environments like Dev and Test before deploying to Production, comprehensive variable management with scoping rules and secret storage, and separating the design time process of building a deployment from the deploy time process of selecting package versions. What this means is that as you roll out new versions of your containers and Octopus will update your YAML for you.

All of these features enable teams to create a roadmap for adopting Kubernetes that works for them.