From Nomad to Kubernetes: training for your team

Private, instructor-led training for platform and application engineers who need to move services and batch jobs from Nomad to Kubernetes.

Your team already knows Nomad jobs, task groups, and allocations. Next, you need to decide which containers belong together, how services connect, and what happens during updates.

LearnKube helps your team make these decisions in Kubernetes through a sample service and batch job. Your engineers will practice deployment, discovery, and recovery together.

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.

What the move requires from your engineers

Deploy each workload by choosing Pods and controllers for its lifecycle, so services and batch jobs behave as intended.
Preserve service access by tracing discovery and credential delivery, so applications can reach their dependencies after the move.
Diagnose failed releases by inspecting rollout status, probes, and Pod events, so engineers can identify the next recovery action.
Agree on support ownership by documenting application checks and platform escalation paths, so each team knows where its responsibility starts.

Jobs and task groups need a new model

A Nomad job describes work that the scheduler places as allocations. Task groups bring related tasks together, but their behavior needs review before choosing Kubernetes Pod boundaries. Kubernetes controllers manage Pods according to workload type. A long-lived service and a batch process need different completion and recovery behavior.

I do not map a task group to a Pod until the team explains why its tasks belong together. Shared placement is useful, but independently released components need a deliberate decision about their lifecycle.
— Daniele Polencic, LearnKube founder and Kubernetes instructor

Current task or requirement	New concept or decision	Practice
Group related tasks	Pod lifecycle boundaries	Choose container groupings
Run a batch job	Job completion and retries	Recover a failed Job
Discover a service	Services and cluster DNS	Trace a dependency call
Update a service	Readiness and rollout controls	Rehearse a failed release

Case Study: Joynext

Joynext needed practical Kubernetes training as its Navigation cloud moved from Nomad toward EKS. Its OTA environment already used EKS.

Developers had different levels of Kubernetes experience and access to generic online courses. The team wanted practical instruction connected to its own use cases. LearnKube delivered a private three-day course.

The training went well and we appreciate the expertise and looking forward to implementing some of the ideas shared.
— Chukwuemeka, Manager Cloud, Joynext.

A recommended four-day workshop for your move

We recommend this four-day agenda for your team. We will spend less time on container basics and focus more on workload boundaries and shared services.

Day 1

From Nomad jobs to Kubernetes workloads

You will compare task groups and allocations with Pods, Deployments, and Jobs. We will show how probes and update policies affect service availability, then explain batch completion and retries.

Hands-on exercises

Deploy a service and a batch job with appropriate controllers.
Introduce a failed readiness check and restore the previous service release.

Day 2

Reusable releases and cluster recovery

We will explain Helm releases, environment configuration, and Kubernetes architecture. You will see how the API, controllers, and kubelet coordinate recovery after a node failure.

Hands-on exercises

Package the service configuration in a Helm chart.
Simulate a node failure and observe replacement Pods and Job behavior.

Day 3

Discovery, traffic, and placement

You will trace Kubernetes DNS, Services, and ingress, then compare them with your Nomad discovery setup. We explain network policies, service mesh use cases, affinity, and topology spread.

Hands-on exercises

Trace a request through ingress to the application and its dependency.
Diagnose a connection blocked by a Service selector or network policy.

Day 4

Credentials, state, and scaling

We will show how secrets and persistent storage meet your application's needs. You will compare metrics-based service scaling with parallel batch execution, then review authentication and RBAC.

Hands-on exercises

Supply credentials and persistent storage to a sample workload.
Generate service load and observe autoscaling independently of batch execution.

Your Nomad jobs, discovery integrations, and support responsibilities can shape the agenda. Get in touch to tailor the workshop to your Nomad-to-Kubernetes transition.

Review workload boundaries with an instructor

An engineer can bring a Nomad task group and explain why its tasks run together. The instructor can identify containers that need separate releases and show how different Pod lifecycles behave. Your team can discuss the tradeoffs before choosing a shared deployment pattern.

Start with your Nomad jobs

Tell us which jobs you run, how the Kubernetes platform will provide discovery and credentials, and who will support the workloads. We will recommend exercises for those decisions.

Discuss your team's training