Master container technologies like Docker, Podman, and CRI-O within the context of Kubernetes clusters. This course focuses on Kubernetes-specific implementations, omitting standalone features like networking, persistence, and resource/health management found in traditional Docker/Podman environments. Perfect for those using containers in Kubernetes.

Students should be familiar with general principles of software development. Some basic knowledge of software systems such as databases, web servers, etc is also required. Not a requirement, but having basic linux operating skills is very helpful. No prior knowledge of docker is required.

Note: This masterclass is tailored for individuals leveraging container technologies specifically within Kubernetes. If you're seeking a comprehensive Docker/Podman course, we recommend our DOCKER-CORE offering. There, you'll dive into essential features for running Docker/Podman independently, including networking, persistence, resource/health management, Compose, and Podman pods.

This comprehensive masterclass covers all the essential fundamentals while also going beyond the basics to explore the underlying technologies that power containerization, including Linux namespaces, overlay2 filesystems, and the runtime engines like crun/runc. This deep technical approach not only helps students develop a thorough understanding of container technologies at the system level, but also equips them with advanced troubleshooting techniques that aren't typically covered by standard container courses or exposed by the container technologies themselves. Students will gain insights into the low-level mechanisms

Introduction

• Introduction to Containers
• Docker history
• overview of Podman
• OCI Container technologies (Docker, Moby,Podman, Buildah)
• Discuss runc/crun in Podman/Docker/Containerd,
• What problems do containers solve
• Benefits of using containers
• Introduce the Open Container Initiative (OCI)
• Understand container isolation
• Containers vs virtual machines
• How containers facilitates devops
• Installing Docker CE or Podman

Containers

• Deeper dive into container isolation
• Introduce Images and the relation with containers
• Linux Namespaces (PID, UTS, NET, etc) and containers
• Understand ephemeral containers
• Discuss the various states of a container (Created, Up, Paused, …)
• Running and Stopping containers
• Run detached containers in the background
• Managing containers (listing, removing, inspecting, killing, pausing, restarting)
• Discuss go-templates for inspecting containers
• Interactive containers
• Executing commands in running containers
• Copying files and directories to and from containers
• How to Expose (and map) network ports
• user management and permissions
• running containers as non-root
• adding and dropping Linux Capabilities
• Introduce use of linux namespaces (e.g, user namespaces in podman)
• Troubleshooting containers
• getting information (logs, exit codes, oom kill, …)
• debugging containers
• using namespaces to troubleshoot containers
• Discuss benefits of transient mode (podman)
• Using systemd

Container Images (OCI)

• Introduce Container repositories (Docker Hub, Quay.io)
• Appreciate that images are immutable
• Understand the Linux overlay2 filesystem and how it is used by containers and images.
• Managing images (listing, removing, inspecting)
• Fully understand image layers (including intermediate)
• List different ways to create images
• Container images FROM scratch
• Creating base images (e.g., Debian)
• Building an image from Containers
• Using Multi-stage builds

Creating and Using Container Files

• Building images using different tools (docker, buildkit, buildah)
• Understand the syntax of a Containerfile/Dockerfile
• Choosing and specifying a base image
• Adding meta-data
• Understand the build process
• Understand the build context
• Introduce dockerignore files
• How to optimise reusing of layers
• Running commands effectively
• Understand shell-form and exec-form when running commands
• Keeping your builds deterministic
• Copying files and directories
• improve performance using COPY --link
• Difference between COPY and ADD
• Understand the working directory (and changing it)
• Defining network ports
• Changing the container's environment
• Building executable containers
• Understand how to use ENTRYPOINT and/or CMD
• Writing entrypoint scripts (e.g, entrypoint.sh) and replacing PID 1
• Best practices in creating images
• Using traditional build containers
• Using multi-stage build files
• using mounts in dockerfiles (e.g., secrets, *ssh, …)
• speed-up builds using cache mounts