Top 7 Kubernetes Opensource CD Tools (Don't miss!)

What is Continuous Delivery (CD)?

Continuous Delivery is a software development practice where code changes are automatically built, tested, and prepared for release to production.

What does Kubernetes Continuous Delivery (CD) mean?

Kubernetes Continuous Delivery (CD) refers to the practice of automatically deploying and managing applications in a Kubernetes cluster.

With Kubernetes CD, these practices are extended to manage and deploy applications within Kubernetes, ensuring that they are always in a desired state as defined by the configuration files (e.g., YAML manifests)

Key Components of Kubernetes CD

1. Declarative Configuration: Kubernetes CD relies on declarative configuration files, which specify the desired state of the application and its environment. Tools like Helm and Kustomize help manage these configurations.
2. Automated Deployment: CD tools automate the deployment process, ensuring that the application is deployed consistently and reliably. This includes building, testing, and deploying the application automatically whenever changes are made to the codebase.
3. GitOps: A popular approach in Kubernetes CD where Git repositories are used as the source of truth for the desired state of the system. Changes to the application's state are made via Git operations, and CD tools like Argo CD or Flux continuously sync the Kubernetes cluster with the state defined in Git.
4. Continuous Monitoring: Kubernetes CD tools continuously monitor the state of the deployed applications and the cluster to ensure they match the desired state. If discrepancies are detected, they attempt to reconcile the actual state with the desired state.

Now, let's explore the top 7 Kubernetes CD Tools:

1. Argo CD:

GitHub link: https://github.com/argoproj/argo-cd

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. It continuously monitors Git repositories and ensures the desired state of your Kubernetes resources.

Installation Instructions:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml        

Sample code:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: example-app
  namespace: argocd
spec:
  destination:
    namespace: default
    server: https://kubernetes.default.svc
  source:
    path: k8s
    repoURL: https://github.com/your-repo/example-app
    targetRevision: HEAD
  project: default
        

2. Flux 2 :

GitHub Link: https://github.com/fluxcd/flux2

Flux is a set of continuous and progressive delivery solutions for Kubernetes, powered by GitOps. It synchronizes your Kubernetes environment with your Git repository.

Installation Instructions:

curl -s https://fluxcd.io/install.sh | sudo bash        

sample code:

apiVersion: helm.toolkit.fluxcd.io/v2
kind: HelmRelease
metadata:
  name: podinfo
  namespace: podinfo
spec:
  releaseName: podinfo
  chart:
    spec:
      chart: podinfo
      sourceRef:
        kind: HelmRepository
        name: podinfo
        namespace: flux-system
  interval: 50m
  values:
    ingress:
      enabled: true
      className: nginx        

3. Spinnaker:

GitHub link: https://github.com/spinnaker/spinnaker

Spinnaker is a multi-cloud continuous delivery platform that helps you release software changes with high velocity and confidence.

Installation instructions:

curl -O https://raw.githubusercontent.com/spinnaker/halyard/master/install/debian/InstallHalyard.sh

sudo bash InstallHalyard.sh

hal config deploy apply        

Sample code:

apiVersion: v1
kind: Service
metadata:
  name: spinnaker
  labels:
    app: spinnaker
spec:
  ports:
    - port: 9000
  selector:
    app: spinnaker        

4. Tekton:

GitHub link: https://github.com/tektoncd/pipeline

Tekton is a Kubernetes-native framework for creating CI/CD systems. It provides reusable building blocks for defining, managing, and running CI/CD pipelines.

Installation Instructions:

kubectl apply --filename https://storage.googleapis.com/tekton-releases/pipeline/latest/release.yaml
        

Sample code:

apiVersion: tekton.dev/v1beta1
kind: Task
metadata:
  name: echo-hello-world
spec:
  steps:
    - name: echo
      image: ubuntu
      script: |
        #!/usr/bin/env bash
        echo "Hello World"        

5. Skaffold:

GitHub link: https://github.com/GoogleContainerTools/skaffold

Skaffold handles the workflow for building, pushing, and deploying your Kubernetes application, allowing you to focus on writing code.

Installation Instructions:

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin        

Sample code:

apiVersion: skaffold/v2beta10
kind: Config
metadata:
  name: example
build:
  artifacts:
    - image: gcr.io/example-app
deploy:
  kubectl:
    manifests:
      - k8s-*        

6. GoCD:

GitHub Link: https://github.com/gocd/gocd

GoCD is a free and open-source CI/CD server that enables you to model and visualize complex workflows with ease. It integrates well with Kubernetes for continuous delivery pipelines.

Installation Instructions:

helm repo add gocd https://gocd.github.io/helm-chart
helm install gocd gocd/gocd        

Example Kubernetes Code:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gocd-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gocd-server
  template:
    metadata:
      labels:
        app: gocd-server
    spec:
      containers:
        - name: gocd-server
          image: gocd/gocd-server:v20.9.0
          ports:
            - containerPort: 8153
              name: web
            - containerPort: 8154
              name: ssl        

7. Drone:

GitHub Link: https://github.com/harness/gitness/tree/drone

Drone is a container-native, continuous delivery platform that helps you automate your build, test, and deployment processes. It integrates seamlessly with Kubernetes.

Installation Instructions:

kubectl apply -f https://raw.githubusercontent.com/drone/drone/master/install/kubernetes/deployment.yaml
        

Example code:

kind: pipeline
type: kubernetes
name: default

steps:
- name: build
  image: golang
  commands:
    - go build
    - go test        

I hope you have learned something new in this!

If this article reaches 100 likes / repost, I will create a video tutorial for each ??

- Sandip Das