Select Page

An Overview of CI/CD Pipelines With Kubernetes

Sudip Sengupta
Published: October 25, 2022

This is an article from DZone’s 2022 Kubernetes in the Enterprise Trend Report.

For more:

Read the Report

Automation and cross-functional collaboration are two fundamental features of a DevOps model. As one of the core components of a DevOps framework, continuous integration and continuous delivery (CI/CD) pipelines speed up application delivery by automating various stages of the software development lifecycle. Although Kubernetes inherently automates the delivery, scaling, and management of applications by deploying and orchestrating them in flexible, portable containers, adopting a CI/CD-based workflow brings a plethora of additional features by offering an iterative cycle of configuration merges and testing. 

In this article, we discuss CI/CD approaches in a Kubernetes ecosystem, best practices for implementing an efficient CI/CD framework, and popular open-source CI/CD tools.

CI/CD Pipelines in a Kubernetes Ecosystem

Kubernetes provides a combination of deployment objects, rollout strategies, and resource controllers to help automate the build, test, and integration processes of a CI/CD pipeline. Beyond container-based deployments, Kubernetes powers modern CI/CD pipelines using efficient orchestration algorithms that schedule batch jobs, enable gradual rollouts, and autoscale workloads. With containerized deployments, DevOps teams can efficiently automate the design, testing, coding, integration, delivery, and deployment of applications for comprehensive automation. 

Pull-based CI/CD pipeline

Figure 1: Pull-based CI/CD pipeline

Kubernetes CI/CD Approaches

Kubernetes supports two approaches to implement a CI/CD pipeline that essentially define how configuration changes are implemented in a workflow. These include pull-based pipelines and push-based pipelines. 

Pull-Based Pipeline

In a pull-based CI/CD pipeline, code and infrastructure changes are applied within the cluster. This architecture relies on an agent (often referred to as a controller) within the cluster that scans the cluster state and compares it with a declarative desired state. In instances where there is a difference between the desired configuration and cluster state, the controller automatically applies changes. 

To help further understand how a pull-based CI/CD pipeline can support your cloud-native workloads, let us learn some of its advantages and disadvantages: 


  • It ensures continuous security by removing manual overheads to grant admin access for every cluster change.
  • It is easier to scale identical deployments since the controller automatically applies changes to the cluster without requiring manual efforts.  
  • It only works for Kubernetes deployments.
  • In a multi-cluster framework, each Kubernetes cluster should adopt the pull-based framework.

Push-Based Pipeline

This is an agentless pipeline architecture that uses an external system to trigger deployments. In a push-based pipeline, configuration changes are committed in a repository, which then updates the environment by adding commits to a pipeline that was already successfully executed. 

Push-based CI/CD pipeline

Figure 2: Push-based CI/CD pipeline

In spite of its quick implementation and popularity, organizations should assess a push-based pipeline’s use cases before choosing it for their cloud-native workloads. Listed below are some of its advantages and disadvantages: 


  • It is simpler to implement when compared to a pull-based pipeline.
  • It offers flexibility and can be applied to environments other than Kubernetes.
  • Push pipelines standardize the deployment of workloads for both cloud and traditional environments, making it ideal for hybrid/multi-cluster models.
  • It requires external admin access to the CI/CD pipeline.
  • It compromises security as the architecture relies on opening of the cluster firewall for external services.

Considerations for Kubernetes CI/CD Pipelines

Developing and deploying applications on a Kubernetes-based CI/CD pipeline relies on an autonomous framework of various Kubernetes tools, services, and best practices that ensure security, high performance, and agility. Some key considerations for implementing efficient Kubernetes CI/CD pipelines are automated testing, validation, and rollbacks. 

Automated Testing

Detecting errors and defects during early stages of a workflow helps enhance application agility. As a recommended design, the test environment should match the production environment to streamline the build, test, and deploy cycles across different environments. Continuous, automated testing also helps create sustainable application builds that ensure the code is readable, debuggable, and maintainable. 


Since a CI/CD pipeline may have multiple builds deployed simultaneously, it is crucial to have an automated validation process to track points of failure in large-scale deployments. With appropriate validation, the pipeline integrates code changes seamlessly, thereby reducing vulnerability detection overhead. 


Rollbacks ensure code sanity by restoring a previous, stable deployment if there are flaws with a new commit/version. As one of the most critical considerations of designing a workflow, it is important to adopt a planned roll-back strategy that safeguards the availability of workloads in production.

Benefits of CI/CD Pipelines in a Kubernetes Ecosystem

Advantages of using Kubernetes-based CI/CD pipelines include: 

  • Shorter release cycles – Automated testing and deployment eliminate delays in pushing changes to production. Iterative CI/CD validation also avoids code merge collisions, subsequently expediting the frequent patching and updating of workflows in production.
  • Autoscaling – Containerizing applications makes it easy to scale and replicate workloads with changing traffic demands. Kubernetes deployment objects such as ReplicaSet, Deployment, and StatefulSet help automatically spin up replicas of containerized workloads to ensure efficient load balancing and near-zero downtime.
  • Node-usage efficiency – With Kubernetes-based workflows, administrators can set optimum resource limits and requests, ensuring efficient utilization of server compute, memory, and storage resources.
  • Microservices-based deployments – Kubernetes enforces the deployment of applications in portable containers with all necessary libraries and resources. The framework allows developers to leverage microservices for simpler, cloud-native application deployment and management.

Popular Open-Source Kubernetes CI/CD Tools

Open-source CI/CD tools are known to offer flexibility in the deployment, scaling, and management of workloads in Kubernetes CI/CD pipelines. While organizations often tend to adopt the most popular platforms, it is imperative to analyze business and technical requirements before choosing one. Some popular open-source CI/CD tools include Spinnaker, Jenkins X, and Argo CD: 

SpinnakerA multi-cloud CI/CD platform that relies on JSON to implement and configure software delivery pipelines. The platform implements in-built, production-safe deployment strategies to help deliver composite applications to their target environments without having to write any scripts.

By following an API-based modular architecture, Spinnaker allows DevOps teams to integrate external services seamlessly for enhanced security, visibility, and cost efficiency.

  • Rapid releases and deployments
  • Integrated deployment strategies
  • Rollbacks can be implemented with a single click
  • Out-of-the-box support for multi-cloud and hybrid models
  • Adds operational overhead for orchestration of multiple underlying microservices
  • Allows only immutable deployments
Jenkins XHelps accelerate software delivery by creating previews on pull requests while using Git as the single source of truth. As the platform provides an official Kubernetes plugin, it is considered one of the most adopted CI/CD tools for Kubernetes workloads.
  • Provides automated feedback on pull requests and issues
  • Relies on Git as a single source of truth
  • Limited to Kubernetes clusters and works purely on GitHub 
  • Inefficient UI and dashboard view
Argo CDA declarative, Kubernetes-centric continuous delivery tool that fetches commits made in a centralized repository and applies them to the production cluster.

The platform relies on an agent that is installed directly within the cluster to implement pull-based GitOps for managing application updates and infrastructure configuration.

  • Kubernetes-native deployments
  • Enforces portability and flexibility
  • Uses standard, declarative patterns for application delivery
  • Being dependent on a pull-based mechanism, it requires a longer implementation cycle
  • Does not offer continuous integration out of the box

Best Practices for Implementing CI/CD With Kubernetes

Although approaches toward adoption of a DevOps model may differ with varying use cases, let’s discuss some commonly recommended practices for implementing efficient Kubernetes CI/CD pipelines. 

Diligently Choosing an Ideal Environment

Developers should diligently choose the appropriate version of Kubernetes as this further defines the choice of CI/CD tools and methodologies. Depending on the complexity of workloads deployed, developers should also be sure to choose the ideal setup between managed, self-hosted, cloud-based, or on-premises since these influence critical aspects of a CI/CD workflow including scaling, security, and cost. 

Secure Secrets

Cluster Secrets and configurations are recommended not to be included within container images or Pod definitions. As an alternative, Secrets should be stored in an encrypted vault or defined as Kubernetes Secret objects. Additionally, configuration settings are recommended to be declared in a ConfigMap, which is then mounted to the container. The approach helps define specific configurations for each environment without exposing data in the container. 

Utilizing GitOps Workflows

GitOps is a modern integration workflow that ensures predictability, visibility, and ease of use. Using a single source of truth simplifies CI/CD-based application delivery and infrastructure control, while streamlining code integration and eliminating redundancy. 


Kubernetes continues to maintain favorable adoption in modern DevOps workflows as it offers seamless scalability and flexibility in modern application delivery. When configuring clusters at scale, managing a Kubernetes ecosystem can quickly become challenging. Overcoming such complexities often requires a combination of recommended practices, diligently designed architecture, and efficient tools that help achieve agility, scalability, and comprehensive automation. Although Kubernetes powers CI/CD workflows, open-source platforms are also recommended to reduce testing and deployment overhead toward configuring native pipelines.

This is an article from DZone’s 2022 Kubernetes in the Enterprise Trend Report.

For more:

Read the Report