Chapter 1 · Lesson 1

Welcome to the Course

What you'll build, how the labs and knowledge checks work, and the Docker → Kubernetes path you're about to walk.
8 min read Text Updated 2 hours ago Free preview
In this lesson you'll learn
  • Understand what this course covers and the complete system you will build by the end.
  • Identify whether this course is for you and confirm the prerequisites you need.
  • See how the five parts of the course connect into a single Docker-to-Kubernetes path.
  • Know which tools to install and how the labs and knowledge checks reinforce learning.
The five-part course roadmap from Foundations to Capstone Your Learning Path Part 1 Foundations Part 2 Docker Part 3 Kubernetes Part 4 Delivery & Production Part 5 Capstone What you build A complete microservices system: containerized services, a database, and an automated deployment onto a Kubernetes cluster.
The course flows from Foundations through Docker and Kubernetes to Production delivery, ending in a hands-on Capstone.

Welcome aboard

Welcome to a hands-on, text-based course on Docker and Kubernetes. By the time you finish, you will be able to package an application into a container, run a small fleet of services together, and deploy that system onto a Kubernetes cluster the way modern engineering teams do every day. This is not a course you only read — it is a course you do. Every concept is paired with commands you type into a real terminal and output you verify with your own eyes.

Containers and Kubernetes have become the default way to ship software. Whether you are a backend developer, a frontend engineer curious about deployment, a data professional, or someone moving into platform and DevOps work, these skills are now part of the baseline. The goal here is to take you from "I have heard of Docker" to "I can design, build, and operate a containerized system" — without hand-waving.

What you will build

The course is anchored by a single growing project. You start by containerizing one small web service, then gradually add the pieces of a realistic microservices system:

  • A stateless API service, containerized with a clean, multi-stage Dockerfile.
  • A second service that talks to the first over the network.
  • A database running as a container with persistent storage.
  • Local orchestration with docker compose using a compose.yaml file.
  • A full Kubernetes deployment: Pods, Deployments, Services, ConfigMaps, Secrets, and Ingress.
  • An automated delivery pipeline that builds images and rolls them out safely.

Each part builds on the last, so by the Capstone you are not assembling toy fragments — you are operating a coherent system you understand top to bottom.

Who this course is for

This course is written for beginners to containers who are nonetheless comfortable with a few basics. You do not need any prior Docker or Kubernetes experience. You do need:

  • Basic comfort with a command line — running commands, moving between folders, editing a file.
  • A rough understanding of how a web application works (a client makes a request, a server responds).
  • Willingness to read carefully and type the commands yourself rather than skim.

If you can clone a Git repository and run a program from a terminal, you are ready. Where deeper knowledge helps, the text fills in the gaps as you go.

How the course is structured

The material is organized into five parts that map directly to the roadmap above:

  1. Foundations — the mental models: why containers exist, how deployment evolved, and how to use this course.
  2. Docker — images, containers, the Dockerfile, volumes, networking, and docker compose.
  3. Kubernetes — the cluster, Pods, Deployments, Services, configuration, and scaling.
  4. Delivery & Production — registries, automated builds, rollouts, observability, and security basics.
  5. Capstone — you assemble and deploy the complete system yourself.

Throughout, you will use current tooling: Docker Engine with BuildKit enabled by default, the v2 docker compose command (not the old docker-compose binary), and Kubernetes v1.29+. The commands and file formats you learn here reflect how teams work today.

The tools you will install

You do not need everything on day one — each part tells you exactly what to set up. The full toolkit is:

  • Docker Desktop (Windows/macOS) or Docker Engine (Linux) — to build and run containers.
  • kubectl — the command-line client for talking to a Kubernetes cluster.
  • Minikube or Kind — to run a real Kubernetes cluster on your own machine.
  • Helm — a package manager for Kubernetes applications.
  • Git — for the course project and version control.
  • VS Code (or your editor of choice) — with the Docker and Kubernetes extensions.

You can confirm the two you need first like this:

docker --version
docker compose version

If both print a version, your Docker setup is ready for Part 2. We will install kubectl and a local cluster when we reach Kubernetes.

How labs and knowledge checks work

Two recurring features keep the learning active. Labs (marked with a 🧪) give you numbered steps to run, plus the expected output so you can confirm you got it right. Knowledge checks appear between sections to help the ideas stick. The next lesson explains why containers exist by tracing how application deployment evolved — and the lesson after that walks you through exactly how to use this text course effectively.

Lesson Summary
  • This is a do-it-yourself course: you build a real microservices system across five connected parts.
  • No Docker or Kubernetes experience is required — just basic command-line comfort.
  • You will use current tooling: Docker Engine with BuildKit, docker compose v2, and Kubernetes v1.29+.
  • Labs come with expected output so you always know whether a step worked.
Sign up to track progress