In this section, we will explore how Jenkins can be integrated with Kubernetes to create a powerful CI/CD pipeline. Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. By combining Jenkins with Kubernetes, you can achieve scalable and efficient continuous integration and continuous delivery (CI/CD) pipelines.

1. Kubernetes Overview:

   • Cluster: A set of nodes (machines) that run containerized applications.
   • Node: A single machine in the Kubernetes cluster.
   • Pod: The smallest deployable unit in Kubernetes, which can contain one or more containers.
   • Service: An abstraction that defines a logical set of Pods and a policy by which to access them.
   • Deployment: A resource that provides declarative updates to applications.

2. Jenkins Kubernetes Plugin:

   • Allows Jenkins to dynamically provision Kubernetes Pods to run Jenkins agents.
   • Provides scalability by leveraging Kubernetes' ability to manage containerized workloads.

• A running Kubernetes cluster.
• Jenkins installed and running.
• kubectl command-line tool configured to interact with your Kubernetes cluster.

1. Install the Kubernetes Plugin in Jenkins

1. Navigate to Manage Jenkins > Manage Plugins.
2. Go to the Available tab and search for "Kubernetes".
3. Install the Kubernetes plugin and restart Jenkins if required.

2. Configure Kubernetes Cloud in Jenkins

1. Go to Manage Jenkins > Configure System.
2. Scroll down to the Cloud section and click Add a new cloud > Kubernetes.
3. Configure the Kubernetes cloud with the following details:
   • Kubernetes URL: The URL of your Kubernetes API server.
   • Kubernetes Namespace: The namespace where Jenkins agents will be created.
   • Credentials: Add Kubernetes credentials if required.
   • Jenkins URL: The URL of your Jenkins instance.
   • Jenkins Tunnel: The Jenkins agent tunnel address (optional).

3. Define Pod Templates

1. In the Kubernetes cloud configuration, click Add Pod Template.
2. Configure the Pod template with the following details:
   • Name: A unique name for the Pod template.
   • Labels: Labels to match the Jenkins jobs that will use this template.
   • Containers: Define the containers that will run in the Pod. For example:

     - name: jnlp
       image: jenkins/inbound-agent
       args: ${computer.jnlpmac} ${computer.name}
     - name: maven
       image: maven:3.6.3-jdk-8
       command: cat
       tty: true
     

4. Create a Jenkins Pipeline

1. Create a new Jenkins pipeline job.
2. Define the pipeline script to use the Kubernetes Pod template. For example:

   pipeline {
       agent {
           kubernetes {
               label 'k8s-agent'
               defaultContainer 'jnlp'
               yaml """
               apiVersion: v1
               kind: Pod
               metadata:
                 labels:
                   some-label: some-value
               spec:
                 containers:
                 - name: maven
                   image: maven:3.6.3-jdk-8
                   command:
                   - cat
                   tty: true
               """
           }
       }
       stages {
           stage('Build') {
               steps {
                   container('maven') {
                       sh 'mvn clean install'
                   }
               }
           }
       }
   }
   

Exercise: Create a Jenkins pipeline that builds a simple Java application using a Kubernetes Pod.

1. Setup:

   • Ensure you have a running Kubernetes cluster and Jenkins instance.
   • Install the Kubernetes plugin in Jenkins.

2. Steps:

   • Configure the Kubernetes cloud in Jenkins.
   • Define a Pod template with a Maven container.
   • Create a Jenkins pipeline job with the following script:

     pipeline {
         agent {
             kubernetes {
                 label 'k8s-agent'
                 defaultContainer 'jnlp'
                 yaml """
                 apiVersion: v1
                 kind: Pod
                 metadata:
                   labels:
                     some-label: some-value
                 spec:
                   containers:
                   - name: maven
                     image: maven:3.6.3-jdk-8
                     command:
                     - cat
                     tty: true
                 """
             }
         }
         stages {
             stage('Build') {
                 steps {
                     container('maven') {
                         sh 'mvn clean install'
                     }
                 }
             }
         }
     }
     

3. Run the Pipeline:

   • Trigger the pipeline job and observe the logs to ensure the build is executed within the Kubernetes Pod.

• Kubernetes API Access: Ensure Jenkins has the necessary permissions to interact with the Kubernetes API.
• Pod Template Configuration: Verify the Pod template configuration, especially the container names and images.
• Resource Limits: Define resource limits for the containers to avoid overloading the Kubernetes cluster.

Integrating Jenkins with Kubernetes allows you to leverage the scalability and flexibility of Kubernetes for your CI/CD pipelines. By dynamically provisioning Jenkins agents as Kubernetes Pods, you can efficiently manage build workloads and optimize resource utilization. In the next section, we will explore how to use Jenkins with Docker to further enhance your CI/CD workflows.