Docker and Kubernetes Compact Workshop

You will learn Docker's architecture: daemon, CLI, images, and containers. By the end of this block, you will understand how Docker works under the hood and how containers differ from virtual machines.

Through concrete examples, you will see where Docker accelerates development processes and where its limitations lie. You will compare Docker with alternatives like Podman and assess when containers are the right approach.

You will install Docker in your cloud environment, check the running configuration, and familiarize yourself with the key settings. Afterward, you can set up Docker independently on any Linux system.

You will pull images from Docker Hub, inspect their layer structure, and push your own image to a registry. Along the way, you will learn how Docker Scout helps you detect vulnerabilities in images before they go to production.

You will start, stop, and delete containers using docker run, ps, logs, and exec. By the end, you will confidently navigate running containers and inspect their state in real time.

You will create bridge and host networks, connect containers to each other, and test the communication between them. This way, you will understand how Docker networking works and when to use which network type.

You will compare bind mounts, named volumes, and tmpfs mounts, create a volume, and verify that data survives a container restart. Afterward, you will know how to store data persistently in Docker.

You will write your first Dockerfile, build an image from it, and start a container. Along the way, you will learn the basic syntax and Docker's build process.

You will work with COPY, ADD, RUN, ENTRYPOINT, CMD, EXPOSE, VOLUME, and WORKDIR and understand when to use which command. By the end, you can read, write Dockerfiles and explain the differences between ENTRYPOINT and CMD.

You will build an image with multiple stages and see how drastically multi-stage builds shrink your images. Then you will create a distroless image that contains only the application, with no shell and no package manager.

Build context, cache boundaries, and runtime privileges determine whether a Dockerfile remains maintainable and secure. Using a prepared example, you run Hadolint, fix the reported USER finding, shrink the build context with .dockerignore, and rebuild the image. Comparing build output, cache use, and the container UID shows how the two changes affect the original version.

You will learn YAML syntax: dictionaries, lists, multiline strings, and anchors. Through practical examples, you will understand how YAML is structured and where typical errors occur.

You will create your first docker-compose.yml, start multiple containers simultaneously, and learn the key commands of the Docker Compose CLI (up, down, logs, exec).

You will configure networks, volumes, depends_on, and environment variables in Docker Compose and understand how to use it to orchestrate complex multi-service applications.

You will deploy a complete stack with database, load balancer, backend, and frontend using Docker Compose. Along the way, you will see how all services interact and how to replicate production-like environments locally.

You will learn Kubernetes architecture: Control Plane, Nodes, Pods, and API Server. By the end, you will understand how Kubernetes is structured and how its components work together.

You will learn about the key Kubernetes distributions: EKS, AKS, GKE for the cloud and on-premise variants. Through concrete examples, you will see what Kubernetes is used for and where its strengths lie.

You will install kubectl, connect to a cluster, and run your first commands (get, describe, logs, exec). By the end, you will confidently navigate your Kubernetes cluster.

You will install Krew as a plugin manager and extend kubectl with useful plugins. Then you will set up K9s, a terminal UI that lets you visually monitor your cluster and debug Pods in real time.

You will create your first Pod, observe its lifecycle, and understand why Pods are the smallest deployable unit in Kubernetes. Then you will deploy multi-container Pods and learn about the sidecar pattern.

You will configure LivenessProbes, ReadinessProbes, and StartupProbes on a running Pod. Then you will simulate a failure and watch how Kubernetes automatically restarts the unhealthy container.

You will create your first Service and use it to connect two Pods. Along the way, you will understand how Kubernetes networking works and how Services act as a stable endpoint in front of changing Pod IPs.

You will configure ClusterIP, NodePort, and LoadBalancer Services and see live how network access to your Pods changes. Afterwards, you will know which Service type to use in which scenario.

You will distribute an application across multiple Nodes, simulate a Node failure, and watch how Kubernetes automatically reschedules the Pods. This way, you experience high availability in practice.

You will create ReplicaSets, scale the replica count up and down, and watch how Kubernetes ensures the desired number of Pods. Along the way, you will learn why ReplicationControllers are deprecated.

You will create your first Deployment, update the container image, and watch how Kubernetes performs a rolling update. Afterwards, you will understand why Deployments are the central object for running your applications.

You will compare Rolling Update, Recreate, Canary, and Blue-Green Deployments and execute each strategy yourself. By the end, you will know which strategy suits which risk profile.

You will create Namespaces, move resources between them, and set Resource Quotas to limit CPU and memory per Namespace. This way, you will understand how teams cleanly separate their workloads.

You will access Services via DNS names, test name resolution across Namespaces, and debug typical DNS issues. Afterwards, you can reliably reach any application in the cluster by its Service name.

Kubernetes does not hard-wire the container runtime, networking, or storage layer; it communicates with them through CRI, CNI, and CSI. For one Pod, you trace which interface participates when its container starts, networking is attached, and a PersistentVolume is provisioned through a CSI driver, then sketch the sequence. This helps you assign later failures to orchestration or the relevant infrastructure plugin.

You will create PersistentVolumes and PersistentVolumeClaims, bind them to Pods, and test whether data survives a Pod restart. Afterwards, you will understand how persistent storage in Kubernetes works.

You will configure StorageClasses and see how dynamic provisioning automatically creates volumes. This way, you will understand how Kubernetes provides storage flexibly and scalably.

You will create ConfigMaps and Secrets, inject them as environment variables and volumes into Pods, and understand how to securely manage configuration and credentials.

To wrap up, you migrate the multi-service application from the Docker Compose setup of day 2 to Kubernetes: Deployments, Services, ConfigMaps, and Secrets replace the Compose file. This connects both halves of the workshop into a complete migration path you can apply directly to your own projects.