jenkins agent kubernetes

Jenkins Agent Kubernetes

Jenkins is a popular open-source automation tool used for continuous integration and continuous delivery (CI/CD) pipelines. It allows developers to automate the building, testing, and deployment of their software projects. Jenkins agents, also known as Jenkins slaves, are responsible for executing the tasks defined in Jenkins pipelines. Kubernetes, on the other hand, is a container orchestration platform that simplifies the management of containerized applications.

In this article, we will explore how to set up a Jenkins agent in a Kubernetes cluster. We will cover the steps required to create a Jenkins agent Docker image, deploy it to the Kubernetes cluster, and configure Jenkins to use the Kubernetes agent for executing pipelines.

Prerequisites

To follow along with this tutorial, you will need the following:

• A Kubernetes cluster up and running
• Jenkins installed and accessible
• Docker installed on your local machine
• kubectl command-line tool installed

Creating the Jenkins Agent Docker Image

The first step is to create a Docker image for the Jenkins agent. This image will include all the necessary tools and dependencies required for executing pipeline tasks.

Here is an example Dockerfile for the Jenkins agent:

FROM jenkins/jnlp-agent

USER root

# Install required tools and dependencies
RUN apt-get update && apt-get install -y \
    curl \
    git \
    ...

# Switch back to the Jenkins user
USER jenkins

Save this Dockerfile in a project directory and build the Docker image using the following command:

docker build -t my-jenkins-agent .

Once the image is built, you can push it to a container registry, such as Docker Hub or a private registry, so that it can be accessed by the Kubernetes cluster.

Deploying the Jenkins Agent to Kubernetes

To deploy the Jenkins agent to the Kubernetes cluster, we will create a Kubernetes Deployment and a Service.

Create a file named jenkins-agent.yaml and add the following content:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins-agent
  template:
    metadata:
      labels:
        app: jenkins-agent
    spec:
      containers:
        - name: jenkins-agent
          image: my-jenkins-agent
          imagePullPolicy: Always
          env:
            - name: JENKINS_URL
              value: 
            - name: JENKINS_SECRET
              value: <agent_secret>
            - name: JENKINS_AGENT_NAME
              value: my-agent
---
apiVersion: v1
kind: Service
metadata:
  name: jenkins-agent
spec:
  selector:
    app: jenkins-agent
  ports:
    - name: jnlp
      protocol: TCP
      port: 50000
      targetPort: 50000

Replace <agent_secret> with the secret token for connecting the agent to Jenkins. You can find this token in the Jenkins web interface by navigating to Manage Jenkins > Manage Nodes and Clouds > New Node > Secret.

Apply the Kubernetes manifest using the following command:

kubectl apply -f jenkins-agent.yaml

This will create a Deployment and a Service for the Jenkins agent in the Kubernetes cluster.

Configuring Jenkins to Use the Kubernetes Agent

Now that the Jenkins agent is deployed to the Kubernetes cluster, we need to configure Jenkins to use the Kubernetes agent for executing pipelines.

In the Jenkins web interface, navigate to Manage Jenkins > Configure System. Scroll down to the Cloud section and click on Add a new cloud > Kubernetes.

Configure the Kubernetes plugin with the following settings:

• Kubernetes URL: `
• Kubernetes Namespace: default
• Credentials: Select or add the Kubernetes credentials for authenticating with the Kubernetes cluster.
• Jenkins URL: The URL of your Jenkins instance.

Save your changes and navigate to the Jenkins pipeline configuration to use the Kubernetes agent. Here is an example Jenkinsfile that uses the Kubernetes agent:

pipeline {
    agent {
        kubernetes {
            label 'my-agent'
            defaultContainer 'jnlp'
            yaml """
                apiVersion: v1
                kind: Pod
                spec:
                  containers:
                  - name: my-container
                    image: my-image
                    ...
            """
        }
    }
    stages {
        stage('Build') {
            steps {
                // Build your application
            }
        }
        stage('Test') {
            steps {
                // Run tests
            }
        }
        stage('Deploy') {
            steps {
                // Deploy your application
            }
        }
    }
}

Replace my-agent with the name of the Jenkins agent defined in the Kubernetes manifest, and update the yaml section with the desired pod configuration for running your pipeline tasks.

Save the Jenkinsfile and start a new pipeline build. Jenkins will now dynamically provision a Kubernetes agent to execute the pipeline stages.

Conclusion

In this article, we learned how to set up a Jenkins agent in a Kubernetes cluster. We created a Docker image for the agent