Putting Jenkins on Kubernetes may be a game-changer for any development team looking to maximize their pipeline for continuous integration and delivery. Jenkins can manage several builds and tests in parallel by utilizing Kubernetes' scalability and flexibility, which lowers bottlenecks and speeds up deployment times. You will be guided through every stage of the setup process by this all-inclusive guide, which will guarantee that your Jenkins setup on Kubernetes is reliable and effective.
Introduction
Jenkins, an open-source automation server, enables developers to build, test, and deploy their software. Kubernetes, an open-source container orchestration platform, allows for the automated deployment, scaling, and management of containerized applications. Together, they create a powerful combination for continuous integration and continuous delivery (CI/CD).
Prerequisites
Before diving into the setup, ensure you have the following prerequisites:
A Kubernetes cluster (local or cloud-based).
kubectl command-line tool configured to communicate with your cluster.
Helm package manager installed on your local machine.
Basic knowledge of Kubernetes concepts such as Pods, Services, Deployments, and Persistent Volumes.
Step 1: Setting Up a Kubernetes Cluster
If you do not have a Kubernetes cluster, you can set one up using Minikube for local development or a managed Kubernetes service like Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS), or Azure Kubernetes Service (AKS) for production environments.
Using Minikube
To install Minikube, follow these steps:
Download and install Minikube from the official Minikube installation guide.
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
sudo mv minikube /usr/local/bin/
Start Minikube:
minikube start
Using GKE, EKS, or AKS
For cloud-based clusters, follow the respective provider's documentation:
GKE Quickstart
EKS Getting Started Guide
AKS Quickstart
Step 2: Installing Helm
Helm is a package manager for Kubernetes that simplifies the deployment of applications. Install Helm by following these steps:
Download and install Helm from the official Helm installation guide.
curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash
Verify the installation:
helm version
Step 3: Deploying Jenkins Using Helm
Helm makes it easy to deploy Jenkins on Kubernetes. We will use the Jenkins Helm chart to perform the deployment.
Add the Jenkins Helm repository:
helm repo add jenkins https://charts.jenkins.io
helm repo update
Create a namespace for Jenkins:
kubectl create namespace jenkins
Install Jenkins using the Helm chart:
helm install jenkins jenkins/jenkins --namespace jenkins
Verify the deployment:
kubectl get pods -n jenkins
You should see the Jenkins Pod running.
Step 4: Accessing Jenkins
By default, the Jenkins service is exposed as a ClusterIP service, which is only accessible within the cluster. To access Jenkins from your local machine, you can use kubectl port-forward:
kubectl port-forward svc/jenkins 8080:8080 -n jenkins
Now, open your browser and navigate to http://localhost:8080. You will be prompted to enter the Jenkins admin password, which you can retrieve using the following command:
kubectl exec --namespace jenkins -it svc/jenkins -c jenkins -- /bin/cat /run/secrets/chart-admin-password && echo
Step 5: Configuring Jenkins
Installing Plugins
Jenkins has a vast ecosystem of plugins. To install plugins, navigate to Manage Jenkins -> Manage Plugins and install the necessary plugins such as Kubernetes, Git, and Pipeline.
Setting Up Nodes (Agents)
Jenkins uses agents to execute build tasks. You can configure Kubernetes-based agents to leverage the scalability of your Kubernetes cluster.
Install the Kubernetes plugin for Jenkins.
Navigate to Manage Jenkins -> Manage Nodes and Clouds -> Configure Clouds.
Add a new Kubernetes cloud and configure it with the following settings:
Kubernetes URL: https://kubernetes.default.svc
Kubernetes Namespace: jenkins
Jenkins URL: http://:8080
Credentials: Add Kubernetes credentials (service account token).
Configure Pod Templates to define the Pods that Jenkins will use as agents. For example, you can define a Pod with a container that has Docker and Maven installed:
apiVersion: v1
kind: Pod
metadata:
name: jenkins-agent
spec:
containers:
- name: jnlp
image: jenkins/inbound-agent
- name: docker
image: docker:latest
- name: maven
image: maven:latest
Save the configuration and create a new Jenkins pipeline job to test the setup.
Step 6: Creating a Jenkins Pipeline
Create a new Jenkins pipeline job and define a simple pipeline script to verify the configuration:
pipeline {
agent {
kubernetes {
label 'jenkins-agent'
defaultContainer 'jnlp'
yaml """
apiVersion: v1
kind: Pod
metadata:
name: jenkins-agent
spec:
containers:
- name: jnlp
image: jenkins/inbound-agent
- name: docker
image: docker:latest
- name: maven
image: maven:latest
"""
}
}
stages {
stage('Build') {
steps {
container('maven') {
sh 'mvn --version'
}
}
}
stage('Test') {
steps {
container('docker') {
sh 'docker --version'
}
}
}
}
}
Conclusion
A scalable and adaptable CI/CD solution may be achieved by installing Jenkins on Kubernetes. The entire procedure, from installing Jenkins and configuring agents to building up a Kubernetes cluster, has been guided through by this tutorial. With this configuration, you can effectively manage your Jenkins builds and deployments by utilizing Kubernetes' capabilities.
For further reading and resources, refer to the following links:
Jenkins Official Documentation
Kubernetes Official Documentation
Helm Official Documentation
By following this guide, you now have a robust Jenkins setup on Kubernetes, ready to handle your CI/CD needs.
Top comments (0)