Kubernetes deployment strategies: Shift from Jenkins to modern CD
For years, Jenkins has been the default choice for CI/CD automation for many teams, and this is still true in 2024. However, we’re seeing more and more teams building cloud-native systems running on Kubernetes shift to modern tooling. This offers 3 main benefits.
- Less time writing and maintaining custom automation scripts.
- Repeatable deployments through environments with rollback support.
- Better observability of the status of their releases and clusters.
Modern organizations can’t survive without shipping software, but it’s getting harder. With complex architectures, increasing scalability requirements, and an evolving Kubernetes ecosystem, building a CI/CD pipeline that supports your team is critical.
Teams around the world choose Jenkins because it’s free and has a huge library of community plugins. Unfortunately, Jenkins also presents challenges for software developers and DevOps engineers.
- They need to write and maintain custom automation scripts.
- It’s hard to deploy and roll back releases through environments.
- There’s limited observability. What version is in staging? Who approved the last production release?
Managing Jenkins instance at scale and have a good backup strategy is very challenging
Jenkins is not Kubernetes or Cloud native
These challenges motivate teams to shift from Jenkins to modern CD solutions like ArgoCD, Codefresh, and Octopus Deploy for their cloud-native deployments to Kubernetes.
This blog post explores why teams are shifting to modern solutions and reviews their benefits. In future posts in this series, we’ll explore how they move from Jenkins to a modern CD solution.
Why teams shift from Jenkins to modern CD solutions
For over 10 years, Jenkins has been the de facto solution for automated CI/CD processes. In 2024, teams still choose Jenkins for their automation needs, including Kubernetes deployments.
Like any platform, Jenkins has pros and cons.
Source: https://www.jenkins.io/zh/blog/2016/05/26/introducing-blue-ocean/
Jenkins benefits
- Lets teams automate CI/CD processes.
- Free and open-source solution with hundreds of plugins, including Kubernetes (K8s).
- Supports Config as Code projects with Jenkins pipelines.
- BlueOcean plugin enables teams to visualize pipelines.
- Active community who are still releasing updates.
Jenkins challenges
- Teams typically need to write custom scripts to automate processes.
- Learning the Jenkins domain specific language (DSL) is cumbersome for non-Java teams
- Handing plugins and shared libraries in big installations can be a full time job
- Lack of observability makes it challenging to understand release and system status.
- What version of an application is in staging?
- Who approved the last release?
- Was the deployment successful? What changed in our K8s cluster?
- It’s difficult to control environment progression and rollbacks. (This often requires teams to write more custom scripts.)
- Lack of technical support if something breaks or there are security issues.
- Lack of GitOps support.
Cloud-native applications running Kubernetes can make these problems worse because modern architectures are becoming more complex, with increased scaling and resilience requirements. Teams are modernizing their older monolithic systems and introducing microservices, requiring more advanced release orchestration, visibility, and support.
Jenkins has over 20 Kubernetes-related plugins that add support for various automation tasks. These include everything from cluster authentication to deployments using kubectl, the Kubernetes client API, and more. While these plugins help configure automated processes and connect to Kubernetes clusters, they still require custom scripting or deep knowledge of kubectl to orchestrate deployments. This can increase the complexity of your CI/CD processes, making them risky to change without clear visibility into your release status, promotions, or rollbacks.
It’s important to point out that Jenkins lacks GitOps support. GitOps has grown in popularity in the Kubernetes community and is emerging as the standard approach to deploying K8s resources and applications. This feature is a big gap for teams that want to adopt GitOps.
These challenges motivate teams to shift from Jenkins to modern tooling like ArgoCD, Codefresh, and Octopus Deploy.
Best-of-breed Continuous Delivery solutions for Kubernetes deployments
CI is not CD
Teams using Jenkins often use it to automate their CI/CD processes. They use Jenkins for Continuous Integration (CI), also known as their build process, and Continuous Delivery (CD), also known as their deployment process. It’s important to note that CI is not CD, and they’re 2 different tasks with different inputs and outputs.
- Continuous Integration is an automated process in which the output is a Docker container pushed to a container registry. CI processes include building code, running tests, analytics, and publishing the build output.
- Continuous Delivery is an automated process in which the output is your applications/services running in an environment like dev, test, staging, or production.
With this in mind, we can look at modern solutions that can help address the challenges of using Jenkins for Continuous Delivery. We review 3 premier CD solutions for Kubernetes deployments based on community and industry feedback:
- Argo CD
- Codefresh
- Octopus Deploy
Don’t abandon Jenkins for CI
Building a best-of-breed CI/CD pipeline is becoming more common by combining Jenkins for CI with a modern CD solution. This means you don’t need to abandon Jenkins completely. You can use its strengths in stateless build automation to compile your projects, run tests, run DevSecOps processes, and publish your containerized applications and services.
Using Jenkins for CI along with ArgoCD, Codefresh, or Octopus Deploy for CD allows teams to improve their software delivery with less effort. All of these solutions integrate smoothly with a Jenkins CI process. Teams don’t need to rebuild their entire CI/CD pipelines. They can iteratively improve their software deployments while maintaining their existing build processes.
ArgoCD
ArgoCD has emerged as the most popular GitOps CD solution. Like Jenkins, it’s a free and open-source solution designed to help teams manage and automate application deployments to Kubernetes clusters.
The large community using it shares that it makes Kubernetes deployments incredibly easy and has a fantastic user interface with clear visibility into an application’s state. You install ArgoCD in a cluster, and configure projects to deploy applications to an environment configured with GitOps principles.
As outlined in the introduction, teams are shifting from Jenkins to ArgoCD for a number of reasons…
Spend less time writing and maintaining custom automation scripts
ArgoCD simplifies the process of deploying cloud-native applications to Kubernetes and can significantly reduce the time needed to write custom scripts. It automatically handles deploying and updating applications based on the configuration in the repository. It ensures the live state of your application matches the declared state.
- Declarative configuration: You define your application’s desired state in a Git repository using YAML files. These files specify the configuration of Kubernetes resources like deployments, services, and config maps.
- GitOps workflow: ArgoCD continuously monitors the Git repository for changes. When it detects changes, the Kubernetes cluster state synchronizes to the configuration in the repository. This means the desired state defined in Git is automatically applied to the cluster.
- Argo CD itself is stateless. Disaster recovery is straightforward.
Repeatable deployments through environments with rollback support
ArgoCD uses a GitOps workflow to deploy an application in a Kubernetes cluster. There are multiple approaches to model GitOps environments to extend this to enable teams to deploy to environments like dev, test, staging, and production.
ArgoCD and a GitOps approach support rollback features, and they’re quite simple. If something goes wrong, you can revert to a previous state of a Git repository, and Argo will automatically sync to the desired state. It also keeps a history of changes for auditing and troubleshooting purposes.[1] [2]
It’s worth noting that while these approaches work, they’re not ideal. You can achieve automatic progression with additional tooling, but this generally requires multiple copies of configuration files. It can be tedious to constantly apply changes to copies of YAML configuration files and can lead to human error.
Better observability of the status of their releases and clusters
One of ArgoCD’s best features is its web-based user interface and full-featured CLI. These let you view the state of your applications, manually trigger deployments, and monitor their health.
The ArgoCD UI gives you clear insight into the state of your deployed resources, ReplicaSets, and Pods. This is a big advantage over Jenkins.
Codefresh
Codefresh provides the industry-leading GitOps CD solution for Kubernetes. It’s a commercial, Argo-based GitOps platform that’s scalable, secure, and supported.
In other words, Codefresh builds on the foundation of the Argo open-source family of projects with enterprise features to help teams scale safely and securely.
Codefresh provides additional benefits for teams that like ArgoCD but need better support and security. Codefresh offers:
- Fully tested, secured, and managed version of the Argo OSS project.
- Single control plane to manage Argo at scale so organizations can bring all Argo projects together into a single location.
- Fully supported solution, with a service level agreement (SLA), maintenance, and more.
- Secure solution with single-sign-on (SSO), role-based access control (RBAC), and more.
Teams are shifting from Jenkins to Codefresh for many of the same reasons as the ArgoCD open-source solution. It aligns with GitOps principles but provides additional value for teams operating at scale.
Less custom scripts
Like ArgoCD, Codefresh handles most of the complexity required to deploy applications automatically. Codefresh extends ArgoCD to provide a control plane to manage tens or hundreds of ArgoCD instances enabling teams to see this value at scale. This is a significant advantage over Jenkins.
Repeatable deployments through environments and rollbacks
As mentioned, there are multiple approaches to model GitOps environments to enable teams to deploy to environments like dev, test, staging, and production. This often involves duplicate configuration, custom scripts, or additional tooling to achieve a repeatable and reliable release pipeline.
Codefresh has built-in support for products and environments. Environments let teams structure their applications’ lifecycle on their way to production. Products let you group multiple ArgoCD applications together into a single unit. This enables teams to standardize and simplify the way they promote their applications in a GitOps world.
Environments in Codefresh let teams see the status of their applications and deploy releases through environments in a consistent manner. You can define promotion workflows with support to control promotion with policies.
Like ArgoCD, Codefresh enables straightforward rollbacks with a GitOps approach. If something goes wrong, you can revert to a previous state of a Git repository and Argo will automatically sync to the desired state. It also keeps a history of changes for auditing and troubleshooting purposes.
Better observability into the status of releases and clusters
Codefresh provides significantly better clarity and visibility into deployment status and application states. It includes the excellent functionality of ArgoCD, but extends it further with application dashboards to help teams understand the status of their applications.
The GitOps dashboard displays a global overview of GitOps Runtimes, clusters managed by the Runtimes, deployment history, and most active applications. This central control plane provides insight into a virtually unlimited number of ArgoCD instances and Kubernetes clusters.
The Environments dashboard provides clear visibility of applications deployed across environments based on their software development lifecycles. It offers a centralized view of applications as they progress through various promotions, placing them within the broader context of their development journey.
The Release Timeline dashboard for applications helps teams link the various artifacts in a GitOps release workflow. You can get clear visibility into what’s related to a release from built container versions, application manifest changes, pull requests, and any related Jira issues.
Codefresh also offers built-in DORA metrics[3] to help measure the tempo and stability of its software delivery. This can help you celebrate successes and identify areas for improvement.
Octopus Deploy
Octopus Deploy is a commercial, best-of-breed Continuous Delivery (CD) platform. It offers release orchestration, deployment automation, and runbook automation while handling the scale, complexity, and governance expectations of even the largest organizations with the most complex deployment challenges.
Octopus differs from ArgoCD and Codefresh because it’s not Argo-based and offers broad infrastructure support from heritage to cloud-native technologies. This means teams can use a single solution to deploy to older systems running on virtual machines, application servers, and cloud services, as well as modern solutions running on Kubernetes, Amazon ECS, and more.
Like Codefresh, Octopus provides a single control plane for organizations to manage their systems at scale across multi-cloud, hybrid, and on-premises environments.
Teams are shifting from Jenkins to Octopus for Kubernetes deployments for numerous reasons.
Spend less time writing and maintaining custom automation scripts
Octopus includes over 500 step templates that let teams automate their deployments to a wide range of technologies without writing custom scripts. This can greatly reduce the effort required to automate processes without the burden of custom script maintenance.
Repeatable deployments through environments with rollback support
Octopus provides straightforward release management so teams can deploy their applications consistently through environments, like dev, test, staging, and production, and redeploy older versions in case of problems.
Releases in Octopus snapshot your project’s deployment process and associated resources like scripts, container versions, and any configuration settings that change as you deploy through environments. This means you set your deployment process once and execute that process across all the environments in your application lifecycle. You can promote a release between environments in an automated or manual way. You can also configure approvals or restrict who can deploy to specific environments like production.
Environments are a concrete concept and not a string value in a configuration file. They’re visible throughout the solution, and releases get deployed through environments in a safe, repeatable, and reliable manner.
You can deploy releases with the Octopus web portal or trigger deployments using the Octopus CLI or Rest API.
This is very powerful, and it’s a big improvement over Jenkins.
Better observability of the status of releases and clusters
Octopus Deploy provides a range of dashboards and insights to help teams understand the status of their deployments, Kubernetes clusters, and team performance.
The Deployment dashboard clearly shows you the status of all of your deployments. You can see which version of each application or service you’ve deployed to each environment, and can click through to view who did it and what was changed with full logs, and linked build, commits, and approvals.
The Project dashboard shows you project-specific release details. You can see your recent releases and which environments they’ve deployed to. You can select a deployment to view the details or promote a release to the next environment.
Kubernetes Object Status (KOS) is an important feature that helps teams understand the result of a deployment to Kubernetes without direct access to a Kubernetes cluster or kubectl. It shows you the results of a Kubernetes deployment including the affected resources and errors. Octopus is extending Kubernetes Object Status to provide ongoing live support so teams can understand the ongoing result of changes deployed to a cluster.
The Insights feature reveals your project-specific or enterprise-wide DevOps performance and areas that need attention based on the 4 key DORA metrics. It focuses on deployment lead time, frequency, failure rate, and time to recovery.
Conclusion
Jenkins is a well-established build and automation tool that’s been used by teams worldwide for years. However, it presents challenges when building and deploying complex applications. Teams are shifting to modern CD tools like ArgoCD, Codefresh, and Octopus Deploy for 3 main reasons:
- Spend less time writing and maintaining custom automation scripts
- Repeatable deployments through environments with rollback support
- Better observability of the status of their releases and clusters
