Your team uses Swarm on MKE. Prepare them to deploy and operate workloads on Kubernetes.

We offer private, instructor-led training for DevOps teams that move containerized applications from Docker Swarm on Mirantis MKE to Kubernetes.

Your engineers know containers well. However, Swarm service definitions do not show how Kubernetes separates application lifecycle, network access, and release health.

LearnKube links familiar deployment tasks to Kubernetes through a sample application. Your team will practice deployment, traffic routing, updates, and recovery.

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

Preview: course-wide figures are not yet available.

  • Hands-on learning
    Of instruction time spent on labs and challenges.
  • Troubleshooting confidence
    Of respondents report greater confidence diagnosing Kubernetes problems.
  • Relevant to your work
    Of respondents say the course addressed their engineering responsibilities.
  • Skills put into practice
    Of respondents applied their new skills at work within 90 days.
  • Deploy the application by separating Swarm service definitions into Deployments, Pods, and Services, so each resource has a clear purpose.
  • Control release traffic by configuring readiness probes and rehearsing updates and rollback, so new replicas receive traffic only when ready.
  • Diagnose unavailable services by inspecting Pod events, logs, and Service endpoints, so engineers can distinguish application errors from routing problems.
  • Define support responsibilities by documenting application checks and cluster escalation paths, so developers and platform engineers know which actions they own.

In Swarm, a service definition brings together the container specification, replica count, update policy, and network attachments. Kubernetes distributes these responsibilities across related resources. A Deployment manages application replicas through ReplicaSets and Pods. A Service provides a stable network endpoint for selected Pods, independently of their replacement.

I start a Swarm migration with release behavior, not manifest conversion. Readiness must reflect whether the application can serve requests. Otherwise, an update can send traffic to a running container that cannot serve users.

— Daniele Polencic, LearnKube founder and Kubernetes instructor

Current task or requirementNew concept or decisionPractice
Define a replicated serviceDeployments, Pods, ServicesDeploy related resources
Release an applicationProbes and rolling updatesRehearse a failed update
Route service trafficService selectors and ingressTrace an application route
Place workloads on nodesAffinity and topology spreadCompare placement rules

The Ameritas DevOps team had years of experience with containerized development and used Docker Swarm on Mirantis MKE. Its next step required Kubernetes skills.

Jim, Manager, DevOps & Observability at Ameritas, described the goal before the course:

We have been containerized in new development for many years, we are looking to bridge the gap from Swarm to Kube.

The team identified cluster strategy, Pod design, and GitHub integration as priorities. LearnKube delivered private Kubernetes training in two blocks of two days. Cloud workstations were available for engineers with restricted company laptops.

This proposed agenda builds on your team's Swarm experience. We keep container basics brief and focus on the Kubernetes decisions for deployment and operations.

Day 1

You will compare Swarm service definitions with Deployments, Pods, and Services. We will connect container configuration to Kubernetes basics and explain probes, rolling updates, and rollback.

  • Deploy a representative application with separate workload and Service resources.
  • Introduce an unready release, inspect its rollout, and restore the previous version.

Day 2

We will explain Helm templates and releases, and compare Kustomize for environment-specific configuration. You will see how the control plane, kubelet, and reconciliation relate to Swarm recovery.

  • Package the application as a Helm chart and change its configuration through a release.
  • Simulate a node failure and observe Pod replacement and application availability.

Day 3

You will compare Swarm service discovery and published ports with Kubernetes DNS, Services, and ingress. We will explain network policies and show where service meshes add traffic controls. You will also compare placement constraints with node affinity, taints, and topology spread.

  • Trace a request from ingress through a Service to its Pods.
  • Diagnose a blocked connection through DNS, Service endpoints, and network policy checks.

Day 4

You will compare configuration, secrets, and volume requirements on both platforms. We will explain persistent storage, metrics-based autoscaling, authentication, and RBAC. You will learn to tell the difference between application replicas and node capacity.

  • Configure persistent storage and confirm that application data survives Pod replacement.
  • Generate application load and observe how metrics drive the Horizontal Pod Autoscaler.

Your Swarm workloads, GitHub integration, and application-support responsibilities can shape the agenda. Get in touch to tailor the workshop to your Swarm-to-Kubernetes transition.

An engineer can bring a sample Swarm service definition and explain its update policy. If the engineer treats readiness as a restart mechanism, the instructor can show the difference through a failed rollout. The team can then discuss which probes fit the application and who investigates each failure.

Paul described the labs in a separate LearnKube course:

Labs, the labs were fantastic.

— Paul, Infrastructure Automation Guild Lead at Research Innovations.

Tell us which workloads run on Swarm, what they need from Kubernetes, and who will deploy and support them. We will recommend a course focus and exercises for your transition.