From Jenkins static agents to Kubernetes: training for CI teams

We offer private, instructor-led training for CI engineers who run Jenkins jobs on long-lived agents and need short-lived Kubernetes-based agents.

Your team knows the existing jobs and machines. A fresh agent cannot depend on yesterday's workspace, installed tools, cached credentials, or artifacts left on a persistent host.

LearnKube connects those requirements through a representative build pipeline. Proposed Jenkins exercises explain agent Pods, repeatable tool images, capacity, and the lifecycle of build outputs.

Discuss your team's training

Learning in practice

Hands-on learning and the skills engineers take back to work.

Preview: course-wide figures are not yet available.

Hands-on learning
60%
Of instruction time spent on labs and challenges.
Troubleshooting confidence
86%
Of respondents report greater confidence diagnosing Kubernetes problems.
Relevant to your work
92%
Of respondents say the course addressed their engineering responsibilities.
Skills put into practice
95%
Of respondents applied their new skills at work within 90 days.

Make each build reproducible on a fresh agent

Run the pipeline on agent Pods by defining tool images and Pod templates, so a build does not depend on manual preparation of a long-lived machine.
Preserve required build outputs by separating disposable workspaces from caches and retained artifacts, so agent cleanup does not remove the evidence or packages the team needs.
Diagnose agent failures by inspecting Pod events, container logs, and controller connectivity, so engineers distinguish build errors from image, capacity, or connection problems.
Define CI-platform responsibilities by documenting image, credential, namespace, and cleanup ownership, so short-lived agents have a clear operating model.

Jenkins keeps the pipeline, while agents become replaceable

Long-lived Jenkins agents can accumulate tools and files outside the pipeline definition. The Kubernetes plugin creates agents as Pods from templates. Their workspaces can disappear with those Pods, so images, credentials, caches, and retained artifacts need explicit definitions. Jenkins still coordinates the build; Kubernetes provides the environment in which its agent runs.

I want the second build to succeed on a completely new agent. If it needs a tool or file left by the first build, the image, cache, or artifact contract is still incomplete.
— Daniele Polencic, LearnKube founder and Kubernetes instructor

Current task or requirement	New concept or decision	Practice
Prepare a build machine	Tool images and Pod templates	Launch a fresh agent
Reuse a workspace	Disposable files and explicit caches	Repeat a clean build
Retain build outputs	Artifact publication and storage	Retrieve outputs after cleanup
Supply build capacity	Pod requests and node capacity	Diagnose a Pending agent

How we approach this transition

We propose a Kubernetes workshop customized around a representative Jenkins pipeline. Your team inventories its tools, workspace assumptions, credentials, and output requirements before choosing an agent template.

The exercises focus on agent adoption while Jenkins continues to coordinate builds. They expose dependencies on persistent machines and clarify which files, permissions, and integrations must remain available after an agent disappears.

A recommended four-day workshop for CI-platform teams

This proposed agenda connects the Kubernetes baseline to build-agent operations. Jenkins-specific examples adapt the course around your pipeline rather than replace it with a new CI system.

Day 1

Tool images and agent Pod lifecycle

We compare a prepared build host with container images, Pods, and workload controllers. You will review probes and release concepts, then examine the different lifecycle of a short-lived Jenkins agent.

Hands-on exercises

Run a representative build on an agent Pod with declared tool dependencies.
Repeat the build on a fresh agent and identify any hidden workspace assumptions.

Day 2

Templates, configuration, and recovery

You will use Helm and compare Kustomize for supporting Kubernetes resources, alongside the selected agent-template configuration. We explain node and controller behavior to separate a lost agent from a failed build step.

Hands-on exercises

Prepare reusable agent configuration without embedding credentials in the image.
Interrupt an agent and examine the pipeline's configured recovery behavior.

Day 3

Agent connectivity and workload isolation

We trace connections to Jenkins, registries, and artifact services through cluster networking. You will examine Services, ingress where required, network policies, service mesh implications, and node placement.

Hands-on exercises

Diagnose an agent that starts but cannot connect to the Jenkins controller.
Inspect a Pending agent whose resource or placement requirements cannot be satisfied.

Day 4

Workspaces, artifacts, credentials, and capacity

You will distinguish temporary workspace data from retained artifacts and deliberate caches. We cover storage, secrets, authentication, RBAC, and the relationship between queued builds, agent demand, and node capacity.

Hands-on exercises

Retrieve a build artifact after the agent Pod has been removed.
Run concurrent sample builds and inspect resource demand and credential scope.

Your pipelines, tool images, and CI support responsibilities can shape the agenda. Get in touch to tailor the workshop to your Kubernetes-agent adoption.

Expose the state that made the old agent work

When a build passes only on its original agent, the instructor can run it with a fresh workspace and declared image. Your team can separate a missing dependency from a cache optimization or an artifact-retention requirement.

The pace of the course was just about right, and I've been using bits of docker and helm for a while but not really understood what I was doing, I now have a solid understanding of what I've been doing (wrong mostly) and more importantly how to apply what I've learnt back to my scrum team.
— Shaun, Quality Engineer at Matillion.

Start with one pipeline and its agent assumptions

Tell us how your static agents are prepared, which build outputs must survive, and who will operate the Kubernetes capacity. We will recommend exercises for a reproducible agent environment.

Discuss your team's training