Kubernetes agents in Jenkins - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to specify the Kubernetes cloud name in Jenkins agent configuration.

Jenkins

kubernetes {
  cloud "[1]"
}

Drag options to blanks, or click blank then click option'

Ak8s-cloud

Bdocker-cloud

Clocal-cloud

Daws-cloud

Attempts:

3 left

💡 Hint

Common Mistakes

Using a cloud name that does not exist in Jenkins configuration.

Confusing Docker or AWS cloud names with Kubernetes cloud.

The Kubernetes cloud name must match the configured cloud in Jenkins, commonly named 'k8s-cloud'.

2fill in blank

medium

Complete the code to define the container template name for the Kubernetes agent.

Jenkins

containerTemplate(name: '[1]', image: 'jenkins/inbound-agent')

Drag options to blanks, or click blank then click option'

Aworker-container

Bbuild-container

Ctest-container

Dagent-container

Attempts:

3 left

💡 Hint

Common Mistakes

Using generic names that do not match the pipeline's container template.

Confusing container image name with container template name.

The container template name is often 'worker-container' to represent the agent doing the work.

3fill in blank

hard

Fix the error in the pod template YAML by completing the missing field for the container image.

Jenkins

podTemplate(containers: [containerTemplate(name: 'jnlp', image: '[1]')])

Drag options to blanks, or click blank then click option'

Aubuntu:latest

Bnginx:alpine

Cjenkins/inbound-agent:latest

Dbusybox

Attempts:

3 left

💡 Hint

Common Mistakes

Using unrelated images like 'ubuntu' or 'nginx' which won't work as Jenkins agents.

Omitting the image tag causing unexpected behavior.

The correct image for Jenkins Kubernetes agent is 'jenkins/inbound-agent:latest' to connect properly.

4fill in blank

hard

Fill both blanks to configure the Kubernetes agent pod with a label and a default container.

Jenkins

podTemplate(label: '[1]', defaultContainer: '[2]') {
  node('[1]') {
    stage('Build') {
      container('[2]') {
        echo 'Running build inside container'
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Ak8s-agent

Bjnlp

Cworker

Dbuild

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching label and container names causing pod scheduling issues.

Using container names that do not exist in the pod template.

The pod label is 'k8s-agent' and the default container is 'jnlp' for Jenkins Kubernetes agents.

5fill in blank

hard

Fill all three blanks to define a Kubernetes agent pod with a container template, label, and image.

Jenkins

podTemplate(label: '[1]', containers: [containerTemplate(name: '[2]', image: '[3]')]) {
  node('[1]') {
    stage('Test') {
      container('[2]') {
        echo 'Running tests inside container'
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Ak8s-agent

Bjnlp

Cjenkins/inbound-agent:latest

Dubuntu:20.04

Attempts:

3 left

💡 Hint

Common Mistakes

Using mismatched labels and container names.

Using incorrect container images that do not support Jenkins agent functionality.

The pod label is 'k8s-agent', container name is 'jnlp', and image is 'jenkins/inbound-agent:latest' for Jenkins Kubernetes agents.

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