Setting Up Jenkins on Kubernetes

Kubernetes has emerged as a leading platform for orchestrating containerized applications, providing flexibility, scalability, and resilience. When combined with Jenkins, it enables teams to efficiently manage their CI/CD pipelines, automatically scaling Jenkins agents as needed. This post will guide you through the process of setting up Jenkins on a Kubernetes cluster, covering essential configurations, best practices, and troubleshooting tips.

1. Understanding Jenkins on Kubernetes

Jenkins is a widely-used open-source automation server that facilitates continuous integration and continuous delivery (CI/CD). Running Jenkins on Kubernetes allows you to leverage Kubernetes features such as:

Automatic scaling: Jenkins can dynamically provision agents based on workload demands.
Resource management: Kubernetes manages resources efficiently, enabling better utilization of underlying infrastructure.
Isolation: Each Jenkins job can run in its own container, providing a clean environment and minimizing conflicts.

With these advantages, Jenkins on Kubernetes is a powerful combination for modern software development.

2. Prerequisites

Before setting up Jenkins on Kubernetes, ensure you have the following prerequisites:

Kubernetes Cluster: A running Kubernetes cluster (local or cloud-based).
kubectl: The Kubernetes command-line tool installed and configured to access your cluster.
Helm (optional): A package manager for Kubernetes that simplifies application deployment.
Docker: Installed for building Docker images if needed.

3. Creating a Kubernetes Cluster

You can create a Kubernetes cluster using various methods. This section covers two popular approaches: using Minikube for local development and cloud providers for production environments.

3.1 Using Minikube

Minikube is a tool that allows you to run a Kubernetes cluster locally. To set up Minikube:

Install Minikube: Follow the official installation guide for your operating system.

Verify Installation:

kubectl get nodes

Start Minikube:

minikube start

3.2 Using Cloud Providers

Most cloud providers offer managed Kubernetes services, such as:

Amazon EKS: Amazon Elastic Kubernetes Service
Google GKE: Google Kubernetes Engine
Microsoft AKS: Azure Kubernetes Service

Follow the respective documentation for creating a Kubernetes cluster on your chosen cloud provider.

4. Installing Jenkins on Kubernetes

There are two primary methods to install Jenkins on Kubernetes: using Helm or deploying with Kubernetes manifests.

4.1 Using Helm

Helm simplifies the deployment of applications on Kubernetes. To install Jenkins using Helm:

Check the Status:

kubectl get pods --namespace jenkins

Install Jenkins:

helm install jenkins jenkins/jenkins --namespace jenkins --create-namespace

Add the Jenkins Helm Chart Repository:

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

4.2 Using Kubernetes Manifests

Alternatively, you can create Kubernetes manifests to deploy Jenkins:

Apply the Manifests:

kubectl apply -f jenkins-namespace.yaml
kubectl apply -f jenkins-pvc.yaml
kubectl apply -f jenkins-deployment.yaml
kubectl apply -f jenkins-service.yaml

Create a Service:

apiVersion: v1
kind: Service
metadata:
  name: jenkins
  namespace: jenkins
spec:
  type: LoadBalancer
  ports:
    - port: 8080
      targetPort: 8080
  selector:
    app: jenkins

Create a Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
  namespace: 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-home
              mountPath: /var/jenkins_home
      volumes:
        - name: jenkins-home
          persistentVolumeClaim:
            claimName: jenkins-pvc

Create a Persistent Volume Claim (PVC) (for data storage):

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: jenkins-pvc
  namespace: jenkins
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Create a Namespace:

apiVersion: v1
kind: Namespace
metadata:
  name: jenkins

5. Configuring Jenkins

5.1 Accessing Jenkins

Once Jenkins is installed, access the Jenkins UI:

Access Jenkins:
Open your web browser and navigate to http://<jenkins-service-ip>:8080, where <jenkins-service-ip> is the external IP of the Jenkins service.

Get the Jenkins Admin Password:

kubectl exec -it <jenkins-pod-name> --namespace jenkins -- cat /var/jenkins_home/secrets/initialAdminPassword

Get the Jenkins Pod Name:

kubectl get pods --namespace jenkins

5.2 Setting Up Jenkins Admin User

Login: Use the initial admin password to log in.
Customize Jenkins: Follow the setup wizard to customize Jenkins, including installing recommended plugins and creating an admin user.

6. Scaling Jenkins Agents with Kubernetes

One of the primary benefits of running Jenkins on Kubernetes is the ability to scale Jenkins agents dynamically based on the workload.

6.1 Configuring Kubernetes Plugin in Jenkins

Install the Kubernetes Plugin:
- Go to Manage Jenkins > Manage Plugins and search for the "Kubernetes" plugin to install it.
Configure the Plugin:
- Go to Manage Jenkins > Configure System and locate the Kubernetes section.
- Enter the Kubernetes URL and credentials.
- Specify the Jenkins URL (typically http://<jenkins-service-ip>:8080).

6.2 Dynamic Agent Provisioning

To enable dynamic agent provisioning, define pod templates in Jenkins:

Go to the Kubernetes Section: In the Jenkins configuration, locate the Kubernetes Pod Templates section.
Add a Pod Template: Click Add Pod Template and define the following:
- Name: Provide a name for the pod template.
- Labels: Set labels that Jenkins jobs will use to select this pod.
- Containers: Specify the container image, e.g., maven:3.6.3-jdk-8, and configure resource requests and limits.
Use the Pod Template in Jobs: When configuring a Jenkins job, use the label you defined to run the job on the dynamically provisioned agent.

7. Best Practices for Running Jenkins on Kubernetes

Resource Requests and Limits: Set appropriate resource requests and limits for Jenkins and agent containers to ensure stable performance.
Persistent Storage: Use persistent storage for Jenkins home to prevent data loss during pod restarts.
Monitoring: Implement monitoring for Jenkins and Kubernetes using tools like Prometheus and

Grafana to track performance and troubleshoot issues.

Backup Strategies: Regularly back up your Jenkins configuration and jobs to prevent data loss.

8. Troubleshooting Common Issues

8.1 Pod Fails to Start

Verify resource availability on the cluster.

Check logs for the pod:

kubectl logs <pod-name> --namespace jenkins

8.2 Jenkins UI is Unreachable

Check firewall rules or security groups if using cloud providers.

Confirm the service is running:

kubectl get services --namespace jenkins

Conclusion

Setting up Jenkins on Kubernetes can greatly enhance your CI/CD capabilities by providing a scalable and efficient environment for managing builds and deployments. By following the steps outlined in this guide, you should have a functional Jenkins installation running on Kubernetes, complete with dynamic agent provisioning. As you continue to explore Jenkins on Kubernetes, remember to leverage best practices and monitor your environment for optimal performance.

This post should provide a comprehensive overview of setting up Jenkins on Kubernetes, helping you to harness the power of both technologies for your CI/CD pipelines. If you have any questions or need further assistance, feel free to reach out!