kubernetes vs Jenkins

A popular automation server is Jenkins, while Kubernetes is an open-source framework for container orchestration. Selecting the best solution for your requirements might be difficult because Kubernetes and Jenkins both have special capabilities and advantages.

Kubernetes is used by DevOps engineers, IT system administrators, and application developers to autonomously scale, deploy, maintain, plan, and run many application containers across node clusters. Jenkins simplifies continuous integration and continuous delivery by aiding in the automation of the building, testing, and deployment processes involved in software development. It is a server-based solution that is conducted in Apache Tomcat or other servlet containers.

The following are the differences between Kubernetes and Jenkins:

Kubernetes, An open-source container orchestration platform makes software deployment, scalability, and administration automated. The Cloud Native Computing Foundation is the owner of the trademark, and a global network of volunteers now maintains the project that was initially established by Google.

Kubernetes is used by DevOps engineers, IT system administrators, and application developers to autonomously scale, deploy, maintain, plan, and run many application containers across node clusters. On host devices, containers operate on top of a common shared operating system (OS), but they are separated from one another unless a user decides to link them.

The following are the features of Kubernetes:

• Self-healing: Kubernetes automatically restarts or replaces any unhealthy instances of containers based on its monitoring of their health. This guarantees your apps’ high availability and dependability.
• Configuration management: Declarative manifests are a feature of Kubernetes that let you create configurations for your apps.
• Scalability: Kubernetes enables you to add or remove instances in response to demand, allowing you to scale your applications horizontally.
• Service discovery: Containers can easily locate and interact with one another because to Kubernetes’ integrated methods for service discovery.

The following are the benefits of Kubernetes:

• Deployment: Preferred states for container deployment are specified and modified by Kubernetes. Users have the ability to add new container instances, relocate current ones to them, and delete the previous ones.
• Load balancing: Load balancing is accomplished by Kubernetes to divide traffic among many container instances.
• Security: Tokens, SSH keys, passwords, and other private data are also managed using Kubernetes.
• Accessibility: Automatically rescheduling or resuming failed containers on healthy nodes, it may guarantee high availability of containers.

The following are the challenges of Kubernetes:

• Security: Due to its fragility and complexity, security is one of Kubernetes’ biggest problems. It might make it difficult to find vulnerabilities if it is not adequately monitored.
• Networking: Kubernetes and conventional networking techniques don’t function well together. As a result, as your deployment grows in size, so do the issues you confront.
• Clusters stability: Since Kubernetes containers are inherently transient and ephemeral, they are continuously being generated, modified, and deleted.
• Storage: Containers must be able to rotate quickly up and down. They are therefore intended to be non-persistent. But for apps to function properly in production, persistent data is needed.

Jenkins, An open-source automation server. It facilitates repeated integration and continuous delivery by aiding in the automation of the building, testing, and deployment processes involved in software development. It is a server-based solution that engage in Apache Tomcat or other servlet containers.

Code branches can be more easily integrated into a main branch by using pipelines, which also automate testing and reporting on isolated changes in a larger code base in real time. Along with building the programme, automating testing, preparing the code base for delivery, and eventually deploying the code to bare metal, cloud, and container servers, they also quickly identify issues in a code base. Jenkins comes in a number of commercial versions. Only the upstream Open Source project is covered by this definition.

The following are the effective steps for setting up Jenkins on Kubernetes:

Method 1: Install Jenkins with Helm v3

The following are the steps for the installation of Jenkins with Helm v3

Step 1: Download and install the Helm v3 from the Official Page

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

Step 2: Add Jenkins Helm Repository

helm repo add jenkins https://charts.jenkins.io
helm repo update

Step 3: Create Namespace for Jenkins with the following command:

kubectl create namespace jenkins

Step 4: Install Jenkins using Helm

helm install jenkins jenkins/jenkins --namespace jenkins

Step 5: Access Jenkins

• Get the admin password with the following command:

printf $(kubectl get secret --namespace jenkins jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

• Port forward to access the Jenkins UI:

kubectl --namespace jenkins port-forward svc/jenkins 8080:8080

• Open http://localhost:8080 in your browser and log in with the admin password.

Method 2: Install Jenkins with YAML files

• The following are steps using to Install the Jenkins with the Yaml Files

Step 1: Create a Namespace for Jenkins

 kubectl create namespace jenkins

Step 2: Create a Persistent Volume and Persistent Volume Claim

# pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: jenkins-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /mnt/data
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Step 3: Create a Deployment and Service Yaml Files, The following are the sample yaml manifest files that we are using now:

# jenkins-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins
  template:
    metadata:
      labels:
        app: jenkins
    spec:
      containers:
      - name: jenkins
        image: jenkins/jenkins:lts
        ports:
        - containerPort: 8080
        volumeMounts:
        - name: jenkins-volume
          mountPath: /var/jenkins_home
      volumes:
      - name: jenkins-volume
        persistentVolumeClaim:
          claimName: jenkins-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: jenkins
spec:
  ports:
  - port: 8080
    targetPort: 8080
  selector:
    app: jenkins

• Use the following command to apply the yaml manefist changes to the cluster:

kubectl apply -f jenkins-deployment.yaml -n jenkins

Step 4: Access Jenkins

• Get the admin password with the following command:

kubectl exec --namespace jenkins -it $(kubectl get pods --namespace jenkins -l "app=jenkins" -o jsonpath="{.items[0].metadata.name}") -- cat /var/jenkins_home/secrets/initialAdminPassword 

• Now, port forward to access the Jenkins UI with the following command:

kubectl --namespace jenkins port-forward svc/jenkins 8080:8080

• Open http://localhost:8080 in your browser and log in with the admin password.

Method 3: Install Jenkins with Jenkins Operator

The following are the steps for the installation of Jenkins with Jenkins Operator:

Step 1: Clone the Jenkins operator repository

git clone https://github.com/jenkinsci/kubernetes-operator.git
cd kubernetes-operator

• Apply the Custom Resource Definitions and the Jenkins Operator:

kubectl apply -f deploy/crds/
kubectl apply -f deploy/all-in-one-v1alpha2.yaml

Step 2: Create a Jenkins Custom Resource

# jenkins-cr.yaml
apiVersion: jenkins.io/v1alpha2
kind: Jenkins
metadata:
  name: example
  namespace: jenkins
spec:
  master:
    basePlugins:
      - name: kubernetes
        version: "1.29.7"
      - name: workflow-aggregator
        version: "2.6"
      - name: git
        version: "4.0.0"
    containers:
      - name: jenkins-master
        image: jenkins/jenkins:lts
        imagePullPolicy: Always
        livenessProbe:
          httpGet:
            path: /login
            port: 8080
          initialDelaySeconds: 80
          periodSeconds: 10

• Apply the jenkin-or.yaml manifest file to the cluster with the following command:

 kubectl apply -f jenkins-cr.yaml -n jenkins

Step 3: Access Jenkins

• Get the admin password with the following command:

 kubectl get secret example-jenkins-operator-credentials-jenkins-admin-password -o jsonpath="{.data.password}" -n jenkins | base64 --decode

• Port forward to access the jenkins UI with the following command:

kubectl --namespace jenkins port-forward svc/example-jenkins-operator-http 8080:8080

• Open http://localhost:8080 in your browser and log in with the admin password.

The following are the features of Jenkins:

• Plugins Available: Hundreds of plugins that connect with every tool in the CI and CD toolchain are available from The Update Centre.
• Distributed builds: Jenkins is capable of supporting distributed builds, which let you split up build jobs over several computers. This shortens the time needed for software delivery and enhances build speed.
• Easy Configuration: Jenkins’ online interface, which includes built-in help and error checks, makes it simple to set up and configure.
• Extensible: The plugin design of extensible Jenkins allows for extensions, resulting in practically infinite capabilities.

The following are the benefits of Jenkins:

• Open source and free: Developers and DevOps teams who work with open source and free software don’t want to worry about the expense of purchasing code pipelines. All they want is for code to be integrated into an artefact or to be deployed consistently from one central location.
• Integrations and plugins: The variety of platform plugins that Jenkins offers is one of its main benefits. Anyone can create plugins for Jenkins, and anyone may use them.
• Simple to debug: Jenkins’ comprehensive reports and logs make it simple to identify and address problems in your code. Additionally, you may configure warnings and alarms for any problems.
• Adaptable to generate jobs: Jenkins gives you the option to build jobs pipeline-style or freestyle. Moreover, you may use scripts and parameters to personalise your jobs.

The following are the challenges of Jenkins:

• Lack of cooperation: It’s challenging to transfer responsibilities between several disjointed Jenkins controllers. A team with no practical means of communicating new, more efficient methods to other isolated teams may find it difficult to share knowledge.
• Challenges with compliance: There is no system in place to guarantee that teams are conducting testing regularly. While some teams might make sure that security scans are incorporated throughout each pipeline section, others might not.
• Plugin conflicts: While plugins are a nice feature of Jenkins, the unique needs of different teams might lead to conflicts when using a monolithic Jenkins server.
• Networking: Conventional networking methods don’t work well with Jenkins. As a result, the problems you face increase in proportion to the extent of your deployment.

In this article we have learned about Kubernetes and Jenkins. Kubernetes is an open-source container orchestration platform composes software deployment, scalability, and administration automated and Jenkins is an open-source automation server preferred option for CI/CD processes.

Is Kubernetes better than Jenkins?

Kubernetes is the recommended option if deployment, scalability, and administration of containerised applications are your main concerns.

How does Docker Jenkins and Kubernetes work together?

You may combine Jenkins and Kubernetes using the Docker pipeline.

Is Kubernetes an alternative to Jenkins?

Jenkins offers advantages for streamlining your software development processes, while Kubernetes is useful for managing containerised apps.

What is Jenkins used for?

Jenkins is used to continuously develop and test software projects, which facilitates the integration of changes by developers and DevOps engineers as well as the delivery of new builds to users.