Kubernetes agents in Jenkins - Commands & Configuration

Introduction

Kubernetes agents in Jenkins let you run your build jobs inside Kubernetes pods. This helps you use containers to isolate builds and scale your build environment automatically.

When you want to run Jenkins build jobs in isolated containers to avoid conflicts.

When you need to scale Jenkins build capacity up or down automatically based on demand.

When you want to use Kubernetes to manage the lifecycle of Jenkins build agents.

When you want to run different build environments for different projects without manual setup.

When you want to reduce resource waste by creating agents only when needed.

Config File - kubernetes-agent.yaml

kubernetes-agent.yaml

apiVersion: v1
kind: Pod
metadata:
  labels:
    jenkins-agent: "true"
spec:
  containers:
  - name: jnlp
    image: jenkins/inbound-agent:4.10-4
    args: ['$(JENKINS_SECRET)', '$(JENKINS_NAME)']
    env:
    - name: JENKINS_URL
      value: "http://jenkins.example.com"
  restartPolicy: Never

This YAML defines a Kubernetes pod for a Jenkins agent.

• apiVersion, kind: Define this as a pod resource.
• metadata.labels: Labels help Jenkins identify this pod as an agent.
• spec.containers: Defines the container running the Jenkins inbound agent.
• args: Passes Jenkins secret and agent name for secure connection.
• env: Sets the Jenkins server URL for the agent to connect.
• restartPolicy: Never restart the pod automatically after completion.

Commands

This command creates the Kubernetes pod that will act as a Jenkins agent. It tells Kubernetes to start the pod defined in the YAML file.

Terminal

kubectl apply -f kubernetes-agent.yaml

Expected Output

pod/kubernetes-agent created

This command lists all pods labeled as Jenkins agents to check if the agent pod is running.

Terminal

kubectl get pods -l jenkins-agent=true

Expected Output

NAME               READY   STATUS    RESTARTS   AGE

kubernetes-agent   1/1     Running   0          10s

→

-l - Filter pods by label

This command shows the logs of the Jenkins agent pod to verify it connected successfully to the Jenkins server.

Terminal

kubectl logs pod/kubernetes-agent

Expected Output

INFO: Connected to Jenkins at http://jenkins.example.com

INFO: Agent started

Key Concept

If you remember nothing else from this pattern, remember: Kubernetes agents let Jenkins run builds inside pods that start and stop automatically, giving you isolated and scalable build environments.

Common Mistakes

Not setting the correct JENKINS_URL environment variable in the pod spec.

The agent cannot connect to the Jenkins server without the correct URL, so builds will fail to start.

Always set JENKINS_URL to your Jenkins server's full URL in the pod environment variables.

Forgetting to label the pod with 'jenkins-agent=true'.

Jenkins uses this label to find agent pods; without it, Jenkins won't recognize the pod as an agent.

Add the label 'jenkins-agent: true' under metadata.labels in the pod YAML.

Using a restartPolicy other than 'Never' for the agent pod.

If the pod restarts automatically, it can cause duplicate agents or resource waste.

Set restartPolicy to 'Never' so pods stop after the build completes.

Summary

Create a Kubernetes pod YAML that defines the Jenkins agent container and connection details.

Apply the YAML with kubectl to start the agent pod in the cluster.

Verify the pod is running and check logs to confirm the agent connected to Jenkins.

Practice

1. What is the main purpose of using Kubernetes agents in Jenkins?

easy

A. To run Jenkins jobs inside isolated pods on a Kubernetes cluster

B. To store Jenkins job logs permanently on the master node

C. To replace Jenkins pipelines with Kubernetes scripts

D. To run Jenkins jobs only on physical machines

Solution

1. Step 1: Understand Kubernetes agents role

   Kubernetes agents run Jenkins jobs inside pods, providing isolation and scalability.

2. Step 2: Compare options

   Only To run Jenkins jobs inside isolated pods on a Kubernetes cluster correctly describes running jobs inside pods on Kubernetes clusters.

3. Final Answer:

   To run Jenkins jobs inside isolated pods on a Kubernetes cluster -> Option A

4. Quick Check:

   Kubernetes agents = isolated pods for Jenkins jobs [OK]

Hint: Kubernetes agents run jobs inside pods, not on master node [OK]

Common Mistakes:

• Thinking agents run jobs on master node
• Confusing Kubernetes agents with storage solutions
• Assuming Kubernetes replaces Jenkins pipelines

2. Which Jenkins pipeline syntax correctly defines a Kubernetes agent using podTemplate?

easy

A. containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent') { podTemplate { node { /* steps */ } } }

B. node { podTemplate(containers: [containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent')]) { /* steps */ } }

C. podTemplate(containers: [containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent')]) { node { /* steps */ } }

D. podTemplate { node(containers: ['jnlp']) { /* steps */ } }

Solution

1. Step 1: Identify correct podTemplate usage

   The podTemplate block wraps the node block and defines containers properly.

2. Step 2: Validate syntax correctness

   podTemplate(containers: [containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent')]) { node { /* steps */ } } correctly places podTemplate outside node and defines containerTemplate properly.

3. Final Answer:

   podTemplate(containers: [containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent')]) { node { /* steps */ } } -> Option C

4. Quick Check:

   podTemplate wraps node with containerTemplate [OK]

Hint: podTemplate wraps node, containerTemplate inside podTemplate [OK]

Common Mistakes:

• Placing podTemplate inside node block
• Using containerTemplate outside podTemplate
• Incorrect nesting of blocks

3. Given this Jenkins pipeline snippet, what will be the output if the pod agent is correctly configured?

podTemplate(containers: [containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent')]) {
  node {
    stage('Test') {
      echo 'Running inside Kubernetes agent'
    }
  }
}

medium

A. The pipeline will fail because podTemplate is missing a label

B. The message 'Running inside Kubernetes agent' will be printed in the Jenkins console log

C. Nothing will print because echo is not supported inside podTemplate

D. The pipeline will run on the Jenkins master node ignoring podTemplate

Solution

1. Step 1: Understand podTemplate and node behavior

   The podTemplate defines the Kubernetes pod agent, and node runs the steps inside it.

2. Step 2: Analyze echo command inside stage

   The echo command prints the message to the Jenkins console log during the 'Test' stage.

3. Final Answer:

   The message 'Running inside Kubernetes agent' will be printed in the Jenkins console log -> Option B

4. Quick Check:

   echo inside podTemplate prints message [OK]

Hint: echo prints messages in Jenkins console inside podTemplate [OK]

Common Mistakes:

• Assuming echo won't work inside podTemplate
• Thinking podTemplate requires label always
• Confusing podTemplate with running on master node

4. You wrote this Jenkins pipeline but it fails with "No nodes available" error:

podTemplate(containers: [containerTemplate(name: 'jnlp', image: 'jenkins/inbound-agent')]) {
  stage('Build') {
    node {
      echo 'Building...'
    }
  }
}

What is the likely cause?

medium

A. The containerTemplate name 'jnlp' is invalid

B. The stage block is outside the node block

C. The node block is outside the podTemplate block

D. The node block is missing a label matching the podTemplate

Solution

1. Step 1: Check node block label requirement

   When using podTemplate, the node block must specify the label matching the podTemplate to allocate the pod.

2. Step 2: Identify missing label causes no node available

   Without label, Jenkins cannot find the Kubernetes agent pod, causing the error.

3. Final Answer:

   The node block is missing a label matching the podTemplate -> Option D

4. Quick Check:

   node label missing = no Kubernetes pod allocated [OK]

Hint: Always specify node label matching podTemplate to avoid no nodes error [OK]

Common Mistakes:

• Not specifying node label
• Misplacing node and stage blocks
• Assuming containerTemplate name causes error

5. You want to run a Jenkins job on a Kubernetes agent with two containers: one for building with Maven and one for running tests with Node.js. Which pipeline snippet correctly defines this setup?

hard

A. podTemplate(containers: [containerTemplate(name: 'maven', image: 'maven:3.8.1'), containerTemplate(name: 'nodejs', image: 'node:16')]) {
node {
stage('Build') {
container('maven') {
sh 'mvn clean install'
}
}
stage('Test') {
container('nodejs') {
sh 'npm test'
}
}
}
}

B. podTemplate(containers: [containerTemplate(name: 'maven', image: 'maven:3.8.1')]) {
node {
stage('Build') {
sh 'mvn clean install'
}
stage('Test') {
container('nodejs') {
sh 'npm test'
}
}
}
}

C. podTemplate(containers: [containerTemplate(name: 'nodejs', image: 'node:16')]) {
node {
stage('Build') {
container('maven') {
sh 'mvn clean install'
}
}
stage('Test') {
sh 'npm test'
}
}
}

D. podTemplate(containers: [containerTemplate(name: 'maven', image: 'maven:3.8.1'), containerTemplate(name: 'nodejs', image: 'node:16')]) {
node {
stage('Build') {
sh 'mvn clean install'
}
stage('Test') {
sh 'npm test'
}
}
}

Solution

1. Step 1: Define multiple containers in podTemplate

   podTemplate(containers: [containerTemplate(name: 'maven', image: 'maven:3.8.1'), containerTemplate(name: 'nodejs', image: 'node:16')]) { node { stage('Build') { container('maven') { sh 'mvn clean install' } } stage('Test') { container('nodejs') { sh 'npm test' } } } } correctly defines two containers: 'maven' and 'nodejs' with proper images.

2. Step 2: Use container block to run commands in specific containers

   podTemplate(containers: [containerTemplate(name: 'maven', image: 'maven:3.8.1'), containerTemplate(name: 'nodejs', image: 'node:16')]) { node { stage('Build') { container('maven') { sh 'mvn clean install' } } stage('Test') { container('nodejs') { sh 'npm test' } } } } uses container('name') to run build and test commands inside respective containers.

3. Final Answer:

   Option A correctly defines two containers and uses container blocks for commands -> Option A

4. Quick Check:

   Multiple containers + container blocks = podTemplate(containers: [containerTemplate(name: 'maven', image: 'maven:3.8.1'), containerTemplate(name: 'nodejs', image: 'node:16')]) { node { stage('Build') { container('maven') { sh 'mvn clean install' } } stage('Test') { container('nodejs') { sh 'npm test' } } } } [OK]

Hint: Use container('name') block to run commands in specific pod containers [OK]

Common Mistakes:

• Not defining all containers in podTemplate
• Running commands outside container blocks
• Mixing container names or missing container blocks