Corporate Training · Containers · 3 Days

Container Training – From Your First Container to a Production-Ready Stack.

In three days, your team learns to move applications into containers with Podman and Docker and run them properly. Participants rebuild the order shop of a fictional company step by step – from the first container start to their own hardened images and a stack of shop, catalog and database that starts automatically and can be updated in minutes.

Duration
3 days
Format
In-house or remote
Language
German or English – course and materials
Level
Beginner
Lab
Dedicated lab environment per participant
Dates
By arrangement
Price
€5,950 net
fixed price, up to 8 participants
includes materials and handouts
includes lab environment per participant
includes Ask the Trainer after the course
plus travel and accommodation on-site
fixed price, up to 8 participants
includes materials
includes lab per participant
includes Ask the Trainer
plus travel expenses

Learning Objectives

What Your Team Can Do After the Container Training

After three days, participants do not just know the Podman and Docker commands – they have moved a multi-part application into containers themselves, secured it and set it up for production.

  • Explain the technology behind containers – namespaces, cgroups and the overlay file system – and distinguish containers from virtual machines.
  • Start, inspect and limit containers with Podman and Docker and fix errors systematically.
  • Assess images by layers, tags and digests and choose trustworthy base images.
  • Build your own lean, reproducible images without a root user using Containerfiles and multi-stage builds.
  • Store data persistently with volumes and bind mounts, back it up and restore it.
  • Connect multiple containers into one application via dedicated networks, DNS and pods.
  • Describe multi-container applications declaratively with Compose and manage images in your own registry.
  • Secure containers with rootless operation, capabilities, SELinux, secrets and image scanning.
  • Start containers automatically with systemd and Quadlet, update them and roll back in a controlled way.

Target Audience

Who the Container Training Is For

The training is designed for administrators, DevOps engineers and developers who have not built their own containers yet or have used Docker by following online guides.

Audience

  • Administrators and operations teams who will run applications in containers
  • DevOps engineers responsible for images and deployments
  • Developers who move their own applications into containers
  • Teams that have used Docker by following online guides and want to learn it properly

Prerequisites

  • Basic Linux skills (command line, editor)

No container experience is needed.

Tools

Podman and Docker

The course uses Podman, the standard tool on enterprise Linux today, daemonless and rootless. Everything you learn applies to Docker as well: the commands are nearly identical, and differences and migration paths are covered explicitly. The lab runs on Podman, Docker is compared on the slides.

The Hands-On Project

Mission Waffle Works – the Shop Moves into Containers

Clusterhausen Waffle Works runs its order shop WaffelOrder on a single server behind the bakery, set up years ago and untouched since. Every new version means an evening of manual work, test and production never look the same, and nobody dares to update the operating system.

Your team takes over: on day one the shop runs in a container, on day two you build your own images for shop, catalog and database and connect them, on day three you make the stack production-ready – hardened, starting automatically, easy to update. Finally, you generate a Kubernetes manifest from it and see where the next step leads.

Target Picture from Day One

The map shows every building block of the stack. Before each chapter, it is clear which building block is being created now and what it is for.

Things Go Wrong – On Purpose

A container will not start, a port is taken, a memory limit kicks in. The team tracks down the cause with logs and inspection and fixes it before it ever shows up in production.

Growing Independence

The first exercises provide close guidance; later, the sheets only define the goal and the acceptance criteria. Participants solve the finale largely on their own.

A Restore Point After Every Exercise

For every exercise, all Containerfiles and Compose files are available as a ready-made restore point. Anyone who gets stuck picks it up and is right back in.

Map of the container hands-on project: on the manufactory server with Podman, the shop frontend, catalog and MariaDB containers with a volume run in a shared network, plus a secret, a Compose file, autostart via systemd and Quadlet, a private registry, hardening and, as an outlook, the Kubernetes manifest – as numbered building blocks. Customers · online MANUFACTORY SERVER · PODMAN, ROOTLESS NETWORK waffelorder CONTAINER Shop Frontend shop:1.4 8080 → 80 CONTAINER Catalog catalog:2.1 Health check · Limits DATABASE MariaDB mariadb:lts Volume orderdb Secret DB credentials Compose compose.yaml · 3 services Autostart systemd · Quadlet · update/rollback YOUR OWN REGISTRY registry.clusterhausen.internal Containerfile → build → push Hardening Rootless · read-only Trivy scan · capabilities OUTLOOK Pod Kubernetes manifest generated from the stack 1 2 3 4 5 6 7 7 8 1 Shop container 2 Your own images 3 Database + volume 4 Network 5 Compose 6 Registry 7 Hardening/autostart 8 Manifest
The target picture on day one: the map returns before every chapter and places the next building block.

Agenda

Container Training in Three Days

Day one brings the shop into a container, day two builds the whole application from your own images, and day three makes it production-ready. Every chapter leads into an exercise that moves the company’s stack a step forward.

Day 1 The First Container What containers are technically, how Podman and Docker differ and what an image is made of. In the afternoon, the shop frontend runs in a container and survives the first deliberately built-in errors.

Topics

  • Mission Waffle Works: starting point, goal, map of the three days
  • Why containers: motivation, containers vs. virtualization, namespaces, cgroups, overlay file system, OCI standard
  • Podman and Docker: daemon, rootless, CLI compatibility, storage model, installation
  • Working with containers: lifecycle, inspection, resource limits, environment variables, port publishing
  • Understanding images: layers, tags and digests, registries, provenance and supply chain, choosing base images

Exercises

  • Start the shop frontend and inspect it
  • Provoke and fix errors
Milestone: The shop frontend runs in a container, and the team can start and examine containers and fix errors in a targeted way.
Day 2 Your Own Images and the Whole Application Other people’s images become your own: shop and catalog are built from Containerfiles, the database gets a volume, and a dedicated network connects all the parts.

Topics

  • Building container images: Containerfile, build context, layer cache, multi-stage builds, Buildah
  • Best practices: small base images, non-root users, health checks, labels, tags, reproducible builds
  • Data: volumes and bind mounts, persistent database, backup and restore
  • Networking: Podman and Docker networks, DNS between containers, port publishing, rootless specifics
  • Pods: running containers together

Exercises

  • Build shop and catalog yourself
  • Database with volume
  • Connect everything over a dedicated network
Milestone: Shop, catalog and database run from your own images, talk to each other over a dedicated network and keep their data.
Day 3 Production-Ready and Beyond The stack is described as a Compose file, stored in your own registry, hardened and set up to start automatically. Finally, a Kubernetes manifest is generated from it.

Topics

  • Compose: multi-container applications declaratively, dev and prod from the same file
  • Your own registry: running, publishing, securing, Skopeo
  • Security: rootless and user namespaces, capabilities, read-only file systems, SELinux, secrets, image scanning with Trivy, hardening
  • Operations: logging, health checks and restart policies, limits and OOM, autostart with systemd and Quadlet, update and rollback
  • Limits of Podman and Docker: what a single host cannot do
  • Outlook: generating a Kubernetes manifest from the stack, OCI and CNCF, Podman Desktop

Exercises

  • Stack as a Compose file
  • Images into your own registry
  • Hardening and scanning
  • Autostart
  • Generating the manifest
Milestone: The stack is hardened, starts automatically and can be updated in minutes – and the Kubernetes manifest for the next step is ready.

We adapt the order and depth to the group’s prior knowledge and pace. On request, we set priorities, such as extra time for security, migrating from Docker to Podman or examples from your environment.

Lab Environment

A Dedicated Container Environment for Every Participant

Every participant works in their own fully prepared environment with all the tools used in the course. The required base images are preloaded, so the exercises start without waiting.

Your Own Environment per Participant

Nobody shares a system. Everyone can start and delete containers and provoke errors without disturbing anyone else.

Access via the Browser

The environment is conveniently accessible via the browser. No local installation is needed, and your IT department does not have to open anything up.

Tools Ready to Go

Podman, Buildah, Skopeo, an image scanner and an editor with support for Containerfiles and Compose files are set up.

Fully Tested Before Every Course

All exercises are run through completely in the lab environment beforehand, including the deliberately built-in failure scenarios.

Ready-Made Restore Points

After every exercise, all Containerfiles and Compose files are available as a restore point, so participants can rejoin at any time.

Diagram of how a container image is built: the Containerfile instructions FROM, RUN, COPY, USER and HEALTHCHECK each create a read-only layer with the writable container layer on top; below, the multi-stage build from the build stage to the slim runtime stage that goes to the registry. CONTAINERFILE FROM registry/base-runtime:stable base image RUN install --no-cache … runtime packages COPY --from=build /app /app application from the build stage USER 1001 non-root user HEALTHCHECK CMD curl -f localhost:80/health health check Layer cache: unchanged lines are not rebuilt IMAGE shop:1.4 FROM 180 MB RUN 42 MB COPY 9 MB USER 0 B HEALTHCHECK 0 B Container · shop-frontend container layer writable, ephemeral read-only layers digest sha256:7f3a… · tag 1.4 · registry MULTI-STAGE BUILD build stage compiler, tools · 900 MB COPY --from=build runtime stage application only · 231 MB Registry
Our own explanatory diagrams like this image layer build accompany every chapter.

Materials

What Participants Take Home

Slide Deck as a Handout

All chapters with our own diagrams, overview tables and a side-by-side comparison of Podman and Docker for easy reference.

Exercise Sheets with Reference Solutions

Every exercise with a goal, prediction checks and tested Containerfiles as the reference solution.

Review Quizzes with Answers

Short reviews on the course mornings reinforce what was covered the day before.

The Project Files

All Containerfiles, Compose files and Quadlet units created during the course serve as templates for your own applications.

Ask the Trainer

One hour for your practical questions, two to four weeks after the course. Included in the price of every training.

Formats

Container Training In-House or Online

In-House at Your Site

The training takes place on your premises. Your team learns together and brings in questions about its own applications directly.

Remote in a Virtual Classroom

Live instruction with joint exercise phases and direct support in each participant’s own environment – ideal for distributed teams.

Customized Corporate Training

We align focus areas and examples with your environment, such as security, migrating from Docker to Podman or running your own applications.

Individual Training as a Workshop

Your team already works with containers and wants to dive deeper into a specific topic – such as image hardening, rootless operation or autostart with Quadlet? Then a tailored workshop is the right fit.

After the course

Ask the Trainer

The real work starts after the course. That is why every training includes an Ask the Trainer session: two to four weeks after the course, we meet online for one hour. Your participants send in the questions that came up while applying what they learned in your environment. That leaves the session free for what matters: specific answers for your systems, not the textbook case. The session is included in the price.

Pricing

3 days · €5,950 net for your team of up to 8 participants

includes materials, lab environment and Ask the Trainer session, plus travel and accommodation for on-site delivery

See the training overview for all terms.

Bundle offer

Learning path Containers + Kubernetes

Both courses booked together: €9,950 net instead of €11,900, six days for the price of five. The courses run as two separate dates at least two weeks apart, both within six months, for the same team of up to 8 participants. Each course includes its own Ask the Trainer session, so the one from the container course falls right between the two dates.

Request bundle

FAQ

Frequently Asked Questions About the Container Training

Who is the container training suitable for?
For administrators, DevOps engineers and developers who have not built their own containers yet or have used Docker by following online guides. The course is aimed at beginners and goes all the way to a hardened stack that starts automatically.
What prior knowledge is needed for the container course?
Basic Linux skills are enough, meaning the command line and an editor. No container experience is needed – we cover the fundamentals on day one.
Do I need this course before the Kubernetes training?
No, both courses are independent. If you have never built your own containers, however, Kubernetes will be considerably easier with the container fundamentals from this course. The Kubernetes training continues with the same example application.
Is the container training also available online?
Yes. The training can be booked as in-house training on site or remotely in a virtual classroom. In both formats, every participant works in their own environment, conveniently via the browser.
What is Clusterhausen Waffle Works all about?
Clusterhausen Waffle Works is a fictional company that ties all the exercises of the container training together into one connected project: the company moves its order shop WaffelOrder from the server behind the bakery into containers, and the participants build the stack piece by piece. This creates realistic reasons for every topic and a clear target picture the group works toward together.
Can the agenda be adapted to our environment?
Yes. We agree on focus areas, depth and examples with you in advance, such as extra time for security, migrating from Docker to Podman or questions about your own applications.
How much does the container training cost?
The container training costs €5,950 net. This is a fixed price for up to 8 participants, including course materials, lab environment and Ask the Trainer session, plus travel expenses for on-site delivery. See the training overview for all terms.
Is there a bundle offer for Containers and Kubernetes?
Yes. The bundle offer learning path Containers + Kubernetes costs €9,950 net for both courses, booked separately it would be €11,900. Both courses are self-contained and run as separate dates.
What is the Ask the Trainer session?
A one-hour online session two to four weeks after the course, no later than six weeks after the course ends. Your participants submit their questions up to three business days before the session and the trainer prepares the answers. The session is included in the fixed price and covers questions related to the course topic. For in-depth consulting on your own environment, we are happy to prepare a separate offer.
How many participants can attend, and in what language is the course held?
The training is designed for teams of up to 8. We recommend small groups so that there is enough time for individual support. The course and materials are available in German or English – you choose the language when you send your request.

Request

Request Container Training for Your Team

Briefly tell us the format and preferred time frame. We will get back to you with a proposed date and an individual quote. Your request is non-binding.

    Thank You for Your Request

    Your message has reached us. We will get back to you shortly with a proposed date and a quote for the container training.