Containers and Kubernetes zero to hero

IT staff with Linux terminal skills package applications in containers, deploy, expose and scale them on an existing Kubernetes cluster, and configure them per environment. Programming skills are not required.

Your starting point in 3 questionsView route, duration & prices

THE LEARNING PATH AT A GLANCE

Containers and Kubernetes zero to hero: stages, scope and sequence

The route spans 4 stages, from “Prior knowledge” to “Operations practice”. Workshop counts, training days and price refer to the core route.

  • 4 workshops · Core route
  • 9–10 training days · Core route
  • €4,995 to €5,550 excluding VAT · Core route

  1. Prior knowledge

    Existing experience can replace individual stations.

  2. Container foundation

    Either container foundation leads into the shared Kubernetes basics.

  3. Kubernetes basics

    Practical foundations for later role responsibilities and certification goals involving hands-on exams.

  4. Operations practice

    You deepen workload practice, scaling, access and network rules, operational signals and configuration per environment.

Your route through this path

YOUR LEARNING PATH

The experience you bring

Check which learning steps you still need.

Find your starting point: 3 questions

TEAM ROUTE: OPTIONAL

Plan a shared training programme

Roles → skill gaps → shared plan

The result: a clear route for the whole team.

Your self-assessment

For each question, choose the answer that best describes your current situation.

Recommendation without contact details or sign-up

Goal set by this learning path

Skills, sequence, workshops

Which Kubernetes skills build on each other?

The learning steps show this path’s recommended sequence. Depending on your goal, they include specialisations, optional topics or certification goals. Each step shows the workshops that cover it.

How to read the learning path
  • Required or recommended
  • Choice
  • Optional further study
  • Further learning path

Preparation

Before starting, if needed; excluded from the workshop count, days and price.

Show 2 skills

  • Prior knowledge

    Existing experience can replace individual stations.

    • PRIOR KNOWLEDGEOptionalIF NEEDED
      Linux and network access

      Command line, processes, file system, connectivity, ports, SSH access

      You practise Linux commands, processes and file permissions, check network interfaces, connectivity and open ports, and connect to remote computers using SSH. The Linux workshop helps fill knowledge gaps; the Docker and Podman workshops introduce YAML as a configuration format.

      Afterwards, you can inspect files, permissions and processes in a Linux terminal, narrow down network problems and work on remote computers using SSH.

      Linux terminal skills, file permissions, processes and remote access via SSH are required. Book the Linux workshop only if participants cannot yet handle these independently.

      4 learning moves

      1. Navigate the file system

        You use shell commands to navigate directories and search file contents, so you can find your way around a Linux system.

      2. Check permissions and processes

        You check file permissions and running processes to understand access boundaries and stop unresponsive processes selectively.

      3. Examine network access

        You check network interfaces, connectivity and open ports separately to narrow down connection problems.

      4. Access remote computers with SSH

        You connect to a remote computer using SSH to apply your terminal skills on another system.

      • Prerequisite: The “Kubernetes basics” competency requires Linux and terminal fundamentals; if you already have this knowledge, you do not need the Linux workshop.
    • PRIOR KNOWLEDGEOptionalIF NEEDED
      Git and collaboration

      Commits, branches, merges, remotes, reviews

      You version changes with Git and practise collaboration through branches and reviews. Choose the Git introduction or the workshop using GitLab as its platform.

      Afterwards, you can version changes with Git, share them through branches and remotes, merge them after review and resolve merge conflicts.

      Git is not required for the core route but versions configuration for later role paths. Book only if participants lack practice with branches and reviews, choosing the GitLab workshop for GitLab teams.

      4 learning moves

      1. Record changes as commits

        You trace changes from the working directory through the staging area to a commit, so you can choose what to version.

      2. Separate work with branches

        You work on changes separately in branches and compare them before bringing the work back together.

      3. Exchange changes through remotes

        You share commits through remote repositories and distinguish fetching other people's changes from integrating them.

      4. Review and merge changes

        In reviews, you discuss changes through their differences and resolve merge conflicts to combine contributions with team input.

      Choose 1 of 2

      Choose the Git workshop to start, or the GitLab workshop if your team uses GitLab.

Core route

Each number represents one workshop included in the totals, which may cover several skills.

  1. Workshop step 1 of 4:

    Container foundation

    Either container foundation leads into the shared Kubernetes basics.

    1 workshop, alternative available

    Choose Podman if your team or target platform uses it or containers must run without root privileges; otherwise choose Docker.

    • CONTAINERCore stepSelf-declaredCHOICE
      Docker fundamentals

      Images, containers, volumes, networks

      You build container images with Dockerfiles, including multi-stage builds, and run containers with persistent storage and network connections. With Docker Compose, you run related application services.

      Afterwards, you can build custom images, connect containers with persistent storage and run related application services with Docker Compose.

      You package applications as images, run and connect containers, and persist data. Compose combines multiple containers into an application and prepares you for Kubernetes.

      4 learning moves

      1. Distinguish images from containers

        You start containers from images and inspect their state to distinguish the template from the running application.

      2. Build custom images

        When building images, you separate build stages from runtime contents so that build tools need not remain in the final image.

      3. Connect storage and networks

        You use volumes to retain data across container restarts and connect containers through networks so they can exchange data.

      4. Combine services with Compose

        In Docker Compose, you describe services, storage and networks with YAML and check how they work together in an application.

      • Recommended next step: Container experience helps with the Kubernetes introduction but is not a prerequisite for the fundamentals workshop.
      • Replacement route: The bundle connects Docker and Kubernetes through a shared booking and learning group instead of separate dates. It requires more prior knowledge: Linux command-line skills and development or system administration basics.
    • CONTAINERAlternativeCHOICE
      Podman fundamentals

      Rootless containers, pods, images

      You build container images with Podman and run containers without root privileges, with persistent storage and network connections. You group related containers into pods.

      Afterwards, you can build Podman images, run containers without root privileges using networking and persistent storage, and group them into pods.

      Choose Podman if your team or target platform uses it or runs containers without administrator privileges. The workshop provides the container foundation and adds Podman-specific content.

      4 learning moves

      1. Understand rootless operation

        Through Podman's architecture, you learn how containers run under your user account without a central daemon.

      2. Build and manage images

        You build images and manage them in registries to provide applications as a reusable basis for containers.

      3. Connect networking and storage

        With networks and volumes, you connect containers and retain data while checking file permissions in rootless operation.

      4. Group containers into pods

        In pods, you group related containers and check their communication across the shared network.

      • Recommended next step: Container experience helps with the Kubernetes introduction but is not a prerequisite for the fundamentals workshop.
  2. Workshop step 2 of 4:

    Kubernetes basics

    Practical foundations for later role responsibilities and certification goals involving hands-on exams.

    • KUBERNETES BASICSCore stepSelf-declaredCORE
      Kubernetes basics

      Architecture, pods, deployments, deployment strategies, services, namespaces, CoreDNS, storage and CSI, ConfigMaps, secrets, kubectl

      You deploy and expose applications with Kubernetes, then configure and inspect them using kubectl, the Kubernetes command-line tool. You also set up basic persistent storage for applications.

      Afterwards, you can deploy applications in Kubernetes, make them reachable, supply configuration and persistent storage, and inspect them with kubectl.

      You deploy applications, expose them through a Service, inspect them with kubectl, configure them with ConfigMaps and Secrets and use storage. The compact course replaces Docker and Kubernetes fundamentals in a continuous block.

      5 learning moves

      1. Understand architecture and pods

        You trace how the control plane, nodes and pods work together and use kubectl to inspect the state of your first pods.

      2. Deploy and update applications

        With deployments, you deploy applications and compare update strategies to assess their risks.

      3. Access and name resolution

        Services make pods reachable while you organise resources with namespaces and check name resolution with CoreDNS.

      4. Separate configuration from images

        Through ConfigMaps and Secrets, you supply configuration and sensitive values to pods so they remain separate from the image.

      5. Check persistent storage

        You attach volumes to pods, explain the roles of CSI and StorageClasses, and check whether data survives a pod restart.

      • Prerequisite: Working with Helm or Kustomize requires Kubernetes basics: Deployments, Services and simple YAML manifests.
      • Optional further study: Preparation for Kubernetes and Cloud Native Associate (KCNA) adds theory and exam questions to Kubernetes basics; it can come before or after it and does not replace practice.
  3. Workshop step 3 of 4:

    Operations practice

    You deepen workload practice, scaling, access and network rules, operational signals and configuration per environment.

    Here you deepen your knowledge of workloads, scaling, network access and basic operational signals. Each learning path specifies whether this depth is core or optional.

    • OPERATIONS PRACTICECore stepSelf-declaredCORE
      Workloads and scaling

      StatefulSets, database operators, scheduling, resource management, HPA, VPA, KEDA

      You examine stateful workloads with StatefulSets and use database operators. Through resource settings and scheduling rules, you control Pod placement. You configure autoscaling with HPA, VPA and KEDA.

      Afterwards, you can examine StatefulSets, use database operators, control pod placement and configure autoscaling with HPA, VPA and KEDA.

      You run applications that hold data, set resource requests and placement, and scale automatically with load. This step and the next share the advanced workshop at intermediate level.

      4 learning moves

      1. Understand stateful workloads

        Using a database running as a StatefulSet, you examine why stable pod identities and persistent storage belong together.

      2. Use database operators

        You set up database operators and consider their advantages and disadvantages to assess their role in database operations.

      3. Control resources and placement

        With resource requests and scheduling rules, you control which nodes pods can run on and observe their placement.

      4. Distinguish scaling approaches

        You configure HPA, VPA and KEDA, distinguishing pod counts, resource adjustments and events as a basis for scaling.

    • OPERATIONS PRACTICECore stepSelf-declaredCORE
      Networking, access and operations

      Ingress and Gateway API overview, service mesh overview, network policies, RBAC, monitoring, logging

      You place Ingress, Gateway API and service mesh in context and practise RBAC and network policies. With Prometheus and Grafana, you set up basic monitoring; with Loki, you set up logging. Gateway API migration and controller portability are outside the practical scope.

      Afterwards, you can assess networking approaches, restrict API access and communication, and set up basic monitoring and logging for Kubernetes.

      You get an overview of Ingress, Gateway API and Service Mesh for network connectivity. You practise access rights and traffic rules and set up basic monitoring and logging.

      4 learning moves

      1. Place routing and service mesh in context

        You compare the roles of Ingress, Gateway API and service mesh to understand their areas of use and limitations.

      2. Restrict API access and communication

        With RBAC, you restrict API actions and with network policies, communication, treating these as separate protection tasks.

      3. Collect and display metrics

        You set up Prometheus and Grafana through operators to collect cluster metrics and make them visible in dashboards.

      4. Centralise logs and configure alerts

        With Loki, you centralise cluster logs and add basic alerts to bring together indications of operational problems.

  4. Workshop step 4 of 4:
    • OPERATIONS PRACTICECore stepSelf-declaredCHOICE
      Manage manifests

      Environment configuration, reuse, Helm or Kustomize

      You structure Kubernetes configurations for different environments. Choose Helm with charts and values or Kustomize with bases, overlays and patches. Your choice covers work with one tool, not both tools.

      Afterwards, you can use Helm or Kustomize to structure reusable Kubernetes configurations, adapt them for different environments and check the generated resources.

      With Helm, you package, install and update your own or third-party software in versioned packages (longer, intermediate course). With Kustomize, you adapt existing manifests per environment without templates (introductory course).

      4 learning moves

      1. Identify shared and differing settings

        You distinguish shared configuration from environment differences to identify reusable parts of your manifests.

      2. Build a reusable structure

        Using Helm or Kustomize, you structure shared resources so that environment variants build on the same foundation.

      3. Implement environment variants

        In your chosen tool, you make targeted adjustments for staging and production so that each environment receives its own configuration.

      4. Check generated resources

        You inspect generated resources to check how shared settings and adjustments interact, helping you identify configuration errors.

      Choose 1 of 2

      Helm packages, versions and releases software as charts; Kustomize adapts existing manifests per environment with template-free overlays.

Possible goals

This path builds the technical foundation for these goals.

  • GoalDeploy applications on KubernetesYou containerise applications, then deploy, expose, scale and configure them per environment on existing clusters. Not yet included: cluster installation, upgrades, hardening, pipelines to build, test and deliver (CI/CD), GitOps or certification. A role path then deepens responsibilities in administration, application development, security or GitOps.This goal concludes the learning path.

Further study

Optional further study; excluded from the workshop count, days and price.

Show 1 skill

  • Kubernetes basics

    Practical foundations for later role responsibilities and certification goals involving hands-on exams.

    • CLOUD NATIVE KNOWLEDGEOptionalOPTIONAL
      Cloud native concepts

      Architecture, API objects, container runtimes, CNCF, observability, delivery

      You place Kubernetes and the cloud native ecosystem in context and work through KCNA sample questions. Prior Kubernetes practice is not required; this preparation does not replace a practical introduction to Kubernetes.

      Afterwards, you can explain Kubernetes components and cloud native concepts, classify scenarios and identify learning gaps for KCNA preparation.

      After the fundamentals, you can study Kubernetes and Cloud Native Associate (KCNA) concepts with sample questions and a mock exam; this does not replace practice. Book the exam separately with the Linux Foundation.

      4 learning moves

      1. Place architecture and runtimes in context

        You distinguish the roles of the control plane, worker nodes and container runtimes to understand orchestration.

      2. Match API objects to their tasks

        Using scenarios, you match pods, deployments and services to their tasks and explain how these API objects work together.

      3. Understand cloud native responsibilities

        Within the CNCF ecosystem, you assess architectural approaches and distinguish observability of systems from delivery of changes.

      4. Test concepts and identify learning gaps

        With KCNA sample questions, you check your understanding and use incorrect answers to identify concepts that need further study.

      • DW24 KCNA Exam PreparationConcepts, sample questions and a mock examBeginner2 daysOnline, taught in GermanKCNA: Multiple-choice, 90 min, registration only USD 250 (one retake included), as of 9 October 2026; book and pay separately with the Linux Foundation, excluded from shown prices.
      • Recommended next step: Kubernetes basics adds practice to theoretical preparation for Kubernetes and Cloud Native Associate (KCNA); it can come before or after it.

Which workshops make up the Containers and Kubernetes zero to hero example route?

The example route includes DW1, DW2, DW3 and choose between DW9 or DW22. It covers these skills: Docker fundamentals, Kubernetes basics, Workloads and scaling, Networking, access and operations and Manage manifests.

EXAMPLE ROUTE (FOUNDATION)

Containers and Kubernetes zero to hero

IT staff with Linux terminal skills package applications in containers, deploy, expose and scale them on an existing Kubernetes cluster, and configure them per environment. Programming skills are not required.

Route scope
4
Training days
9–10
List price basis, per person, excl. VAT
€4,995–€5,550
View the starting workshop for Introduction to Docker (DW1)

Included in the totals: DW1, DW2, DW3 and DW9 or DW22 (one workshop). Additional workshops are excluded.

Workshops in this example route

Each workshop shows its role, skills covered and planning details.

4 workshops, recommended technical sequence

Preparation

Preparation if needed

Excluded from the workshop count, days and price.

Core route

  1. STARTING POINT (CONTAINER)

    DW1 Introduction to Docker

    You package applications as images, run and connect containers, and persist data. Compose combines multiple containers into an application and prepares you for Kubernetes.

    SKILLS COVERED

    Images, containers, volumes, networks

    2 days, €1,110 excluding VAT

    Choose a date

    Content & dates for Introduction to Docker (DW1)

    Alternative to DW1

    DW8 Introduction to Podman

    Choose Podman if your team or target platform uses it or runs containers without administrator privileges. The workshop provides the container foundation and adds Podman-specific content.

    3 days, €1,665 excluding VAT

    +1 day, +€555. Alternative excluded from the totals.

    Content & dates for Introduction to Podman (DW8)

  2. KUBERNETES BASICS

    DW2 Introduction to Kubernetes

    You deploy applications, expose them through a Service, inspect them with kubectl, configure them with ConfigMaps and Secrets and use storage. The compact course replaces Docker and Kubernetes fundamentals in a continuous block.

    SKILLS COVERED

    Architecture, pods, deployments, deployment strategies, services, namespaces, CoreDNS, storage and CSI, ConfigMaps, secrets, kubectl

    3 days, €1,665 excluding VAT

    Choose a date

    Content & dates for Introduction to Kubernetes (DW2)

  3. OPERATIONS PRACTICE

    DW3 Advanced Kubernetes

    You run applications that hold data, set resource requests and placement, and scale automatically with load. This step and the next share the advanced workshop at intermediate level.

    SKILLS COVERED

    StatefulSets, database operators, scheduling, resource management, HPA, VPA, KEDA, Ingress and Gateway API overview, service mesh overview, network policies, RBAC, monitoring, logging

    2 days, €1,110 excluding VAT

    Choose a date

    Content & dates for Advanced Kubernetes (DW3)

  4. CHOICE STEP

    Manage manifests

    Choose 1 of 2

    With Helm, you package, install and update your own or third-party software in versioned packages (longer, intermediate course). With Kustomize, you adapt existing manifests per environment without templates (introductory course).

    SKILLS COVERED

    Environment configuration, reuse, Helm or Kustomize

Additional workshops

Excluded from the workshop count, days and price.

Further study

Optional further study

Excluded from the workshop count, days and price.
  • DW24 KCNA Exam Preparation

    After the fundamentals, you can study Kubernetes and Cloud Native Associate (KCNA) concepts with sample questions and a mock exam; this does not replace practice. Book the exam separately with the Linux Foundation.

    2 days, €1,110 excluding VAT

    Content & dates for KCNA Exam Preparation (DW24)

Why is this route structured this way?

The route follows learning questions: each station builds on the previous one. Here, we explain why the transitions make sense.

Recommended learning sequence, not formal exam eligibility.

The route principle

Each station answers a different learning question.

  1. Understand containers

    How do you build images and connect containers?

  2. Use Kubernetes

    How do pods, deployments and services work together?

  3. Deepen operational practice

    How do you manage resources, scaling and access?

  4. Structure configuration

    How do you adapt manifests for different environments?

The learning rationale in detail

Brief explanations clarify the transitions without repeating the route.

  1. DW1 then DW2: Recommended order

    Why Docker or Podman before Kubernetes?

    Experience with images and containers helps you understand pods and deployments in Kubernetes. We therefore recommend starting with Docker or Podman; container experience is not a prerequisite for the Kubernetes fundamentals workshop.

  2. DW2 then DW3: Recommended prior knowledge

    Why fundamentals before applications that hold data and automatic scaling?

    The advanced workshop expects knowledge of the fundamentals workshop content and your own Kubernetes practice. Comparable experience can replace the fundamentals workshop; attendance is not a formal admission requirement.

  3. DW3 then DW9 / DW22: Recommended order

    Why Helm or Kustomize after Kubernetes operations practice?

    We recommend Helm or Kustomize after operations practice so you can structure configurations for familiar applications. The operations workshop is not required; you choose Helm or Kustomize and need Kubernetes fundamentals plus the specified prior knowledge.

What is fixed, what is flexible?

The status shows which core stations contribute to the totals and where prior knowledge or learning goals allow flexibility. Optional additions count only when selected.

  • Included in this route

    The core step and its assigned workshop count towards the route scope; attendance is unnecessary if you already have the skills.

  • Choice of equivalent workshops

    Choose between workshops for the same learning goal, with different durations and levels shown on the cards.

  • Equivalent alternative

    Podman replaces Docker before the same next step; its duration and price are on its card and excluded from route totals.

  • Optional

    Add this step when needed, outside the route scope and price.

Sources for this route

Agenda · Practice lab · Exam body · checked on

View methodology and sources

How does the roadmap lead to practical experience?

The roadmap sets out competency goals and sequence; the workshop agenda shows the content. In practical workshops, you apply that knowledge in the browser-based Dojo. The certificate of attendance documents workshop participation and is not a certification.

From learning goal to application

4 clear steps

  1. Competency goal

    The learning goal describes a concrete task.

  2. Workshop agenda

    Content and sequence are clear.

  3. Dojo practice

    In practical workshops, you apply knowledge in Dojo exercises.

  4. Application & context

    The certificate of attendance documents participation, not certification.

What “covered” means and how we substantiate it

4 criteria: directly supported

  • Visible

    Content is transparent

    “Covered” is an editorial classification of the visible workshop agenda, not proof of assessed competence.

  • Structured

    The sequence is explained

    The agenda arranges topics in a clear learning sequence.

  • Applied

    Knowledge is applied in practice

    In practical workshops, you apply knowledge through exercises in the browser-based Dojo.

  • Distinguished

    Records remain separate

    The certificate of attendance and proof of passing an exam remain separate.

Reviewed by the expert team at DevNinjas GmbH

Sources checked on

  • AgendaDevNinjas workshop agendasVisible content, learning goals and sequence of workshops DW1, DW2, DW3, DW9 and DW22On this page
  • Practice labDevNinjas DojoCheck browser exercises, trainer discussion and conditions for Dojo access with your booked training.devninjas.io/dojo
  • Exam bodyKCNA certification (Linux Foundation: KCNA)Check KCNA exam conditions and booking, an optional goal outside the standard route.training.linuxfoundation.org

Which Kubernetes learning path fits your goal?

Compare related paths by their skills and technical focus. Check each workshop’s prerequisites before booking.

Kubernetes Administrator

For administrators and operations teams with Linux experience: you practise building and maintaining Kubernetes clusters and fixing faults. The path prepares you for the Certified Kubernetes Administrator (CKA) exam, booked separately with the Linux Foundation. Optional depth follows your team responsibilities.

  • FURTHER SPECIALISATION
  • Core route 12 days
  • 4 workshops
  • ROLE PATH: OPERATIONS

A good fit if you already have the shared foundations and want to explore a specific area in more depth.

Core routes compared

In both core routes

  • Kubernetes basicsStart
  • Workloads and scaling
  • Networking, access and operations

Only in this core route

  • Manage software with Helm
  • Cluster operations and troubleshooting
Explore the Kubernetes Administrator learning path
Compare all Kubernetes learning paths

Frequently asked questions about the Kubernetes learning path

A learning path is a recommended sequence, with no obligation to book it all. The right workshops depend on your container knowledge, target role and practical experience. The displayed duration and price refer to the core route.

Do I need programming skills for the Zero-to-Hero container introduction?

The container entry point in the Zero-to-Hero learning path requires Linux, terminal and editor skills, but no programming knowledge.

If you lack command line experience, the Linux introduction offers relevant preparation. The Linux introduction itself requires general computer skills and confidence with a text editor or IDE.

Helm or Kustomize: which Zero-to-Hero specialisation should I choose?

In the Zero-to-Hero path, Helm suits packaging and reusing charts, while Kustomize suits adapting existing manifests with overlays. We recommend operations practice before this specialisation, but it is not a prerequisite; the GitOps overview compares the tools to help you choose.

Does the Docker and Kubernetes compact course replace the Zero-to-Hero path?

Docker and Kubernetes Essentials suits learners seeking a combined introduction to both technologies; it does not replace the entire Zero-to-Hero learning path.

The rest of the path adds advanced Kubernetes practice, followed by a specialisation in Helm or Kustomize. These topics are outside the compact workshop. The learning-path overview explains how to book the remaining workshops individually and spread them over time.

Vincent Sturm, Key Account Manager

Discuss your team’s learning path with Vincent

Discuss goals, roles, timing, format and suitable workshop sequences with Vincent. You can explore technical questions with our trainers afterwards if needed.
View public workshop dates