Chapter 11,219w
The Application Is More Than Its Source Code
Runtimes, dependencies, configuration, and external services; why manually prepared machines drift; VM and container boundaries.
AIDevOps Cloud Native Series · Book 03
Docker & Kubernetes: A Practical Introduction by John Bae
From Docker to Kubernetes: A Hands-On Guide to Containers with kind — 2026 Edition
Contents 5 sections
Overview
About this book
A hands-on introduction for developers meeting containers for the first time. One small Web · API · Redis application is packaged as an image, connected to its dependencies, hardened for delivery, orchestrated with a three-node Swarm, and finally rebuilt on Kubernetes with Deployments, Services, ConfigMaps, persistent volumes, and Ingress. Each chapter asks you to observe a concrete boundary and explain what the evidence proves — and the book shows the real output of every lab.
Tested with
Docker 29 · kind 0.33 · Kubernetes v1.37 — every lab executed
Length
26,034 words (21 chapters + 5 appendices)
Status
Complete — preparing Kindle (KDP) publication
Fictional system — Mini CloudShop
A deliberately small application: an Nginx web page calls an Express API, which increments a counter in Redis. The same three parts run as single containers, as a Compose project, as a Swarm stack, and finally as a Kubernetes application, so the platform’s responsibilities stay visible.
About the author — John Bae
An enterprise cloud architect with more than 20 years of experience in software development, application architecture, and technical architecture. He has designed, built, and operated Kubernetes-based platforms and has taught developers and engineers through Inflearn. He is the founder and operator of AIDevOps.kr.
Table of Contents
21 chapters
Chapters 1-9 cover Docker fundamentals with one small application. Chapters 10-12 strengthen image and operational reasoning, Chapters 13-14 introduce orchestration with Docker Swarm, and Chapters 15-21 rebuild the same application on Kubernetes. Five appendices add a command reference, worked cases, and a troubleshooting lab.
Chapter 2956w
Images, Containers, and the Docker Engine
Follow a command from the CLI to the engine, separate the image template from the container instance, and read the lifecycle.
Chapter 3968w
Run Your First Container and Trace a Request
Start a named web server, read both sides of a port mapping, and work through a failed request with evidence.
Chapter 4956w
Know Which Image You Are Running
Layers, image references, the local image store, and why pulling, tagging, and pushing are separate operations.
Chapter 5969w
Build an Image with a Dockerfile
The build context as an input boundary, cache-friendly ordering, CMD versus ENTRYPOINT, and what a successful build does not prove.
Chapter 6881w
Package the Mini CloudShop API
Read the application by its boundaries, build and start the API, and see why localhost inside a container is not your laptop.
Chapter 7863w
Connect the API to Redis
A user-defined network and service names, one request traced end to end, and name resolution separated from connectivity.
Chapter 8872w
Decide Which Data Must Survive
The writable layer, named volumes, replacement versus restart, bind mounts, and cleanup commands that delete data.
Chapter 9955w
Describe the Whole Application with Compose
One file for Web, API, and Redis; startup order versus readiness; and stopping an application without losing its data.
Chapter 10892w
Improve the Image Without Losing the Evidence
Multi-stage builds, a non-root user, health checks, BuildKit, buildx, and SBOMs — with the baseline recorded first.
Chapter 11779w
Publish, Retrieve, and Identify an Image
A local registry, push and pull, digests that keep naming the tested image after a tag moves, and a release record.
Chapter 12894w
Operate and Debug Containers Systematically
Five tools for five questions, a bounded restart policy, a reproduced memory-limit kill, and a timeline before any fix.
Chapter 13948w
Why Container Orchestration Exists
Desired state and reconciliation, what automatic recovery does not recover, and control traffic versus request traffic.
Chapter 14778w
Experience Orchestration with Docker Swarm
A three-node nested Swarm: services and tasks, worker loss and replacement, and a failed update that rolls back.
Chapter 151,006w
Open the Kubernetes Control Plane
API server, scheduler, kubelet, and controllers; installing kind and kubectl; following a declaration through the control loop.
Chapter 16785w
Let a Deployment Maintain the Application
A standalone Pod versus a Deployment, intentional scaling, and a failed rollout recovered with rollout undo.
Chapter 17789w
Give Changing Pods a Stable Address
Services select workloads, not instances; a deliberately broken selector; ClusterIP versus external exposure.
Chapter 18794w
Separate Configuration and Persistent Data
ConfigMaps and Secrets without rebuilding, a PersistentVolumeClaim for Redis, and emptyDir compared with persistent storage.
Chapter 19791w
Route HTTP Through an Ingress Controller
An Ingress rule is not a router: install Traefik deliberately and locate which component produced an error.
Chapter 20780w
Rebuild Mini CloudShop on Kubernetes
Map Compose responsibilities to Kubernetes objects, deploy into its own namespace, and prove replacement and persistence.
Chapter 21979w
Turn the Experiments into Operational Judgment
Explain one request end to end, keep a compact evidence record, and know the limits of an introductory system.
Appendix A — A Command Reference Organized by Question
Docker and kubectl commands grouped by the question they answer.
Appendix B — Read Dockerfiles and YAML as Contracts
What each file promises, and the indentation and quoting mistakes that change it.
Appendix C — Three Worked Operational Cases
A broken button, a release that never arrives, and a replacement Pod with an empty directory.
Appendix D — Official References and Further Study
Where to read the authoritative documentation for each tool.
Appendix E — A Troubleshooting Lab with Four Distinct Failures
Pending, ImagePullBackOff, OOMKilled, and a configuration collision — diagnosed and recovered.
Companion Materials
Companion manifests & lab files
Every companion/... path referenced throughout the book maps to the same path inside the zip downloadable from this page. The zip holds 32 files: the Mini CloudShop API and Web source, Dockerfiles, the Compose file, the Swarm lab, and every Kubernetes manifest — including four deliberately broken ones for the troubleshooting lab. This page is the official distribution point for the companion materials.
Chapter 6-7
api/
The Express API (server.js, package.json) and its Dockerfile.
Chapter 9
compose.yaml
Web, API, and Redis with a named volume for Redis data.
Chapter 9, 20
web/
The Nginx web page and the template that proxies /api to the API.
Chapter 10
api/Dockerfile.secure
A multi-stage, non-root image with a HEALTHCHECK.
Chapter 14
swarm/
Three nested Docker engines, a registry, and the stack file for the Swarm lab.
Chapter 16-17
k8s/pod.yaml, deployment.yaml, service.yaml
A standalone Pod, a Deployment, and a ClusterIP Service.
Chapter 18
k8s/config.yaml, deployment-config.yaml, redis.yaml, emptydir-pod.yaml
ConfigMap and Secret, Redis with a PersistentVolumeClaim, and an emptyDir comparison.
Chapter 19
k8s/ingress.yaml
The first Ingress rule, served by Traefik.
Chapter 20
k8s/app/
The full application in namespace cloudshop: configuration, Redis with a PVC, API, Web, and Ingress.
Appendix E
k8s/broken/
Four deliberately broken manifests: Pending, ImagePullBackOff, OOMKilled, and a missing REDIS_PORT.
All
README.md, LEARNING_RECORD.md
How to use the files, and a template for your learning record.
Publication Status
Publication status
All chapters are complete and every lab has been run on Docker 29, kind 0.33, and Kubernetes v1.37; the book shows the real output. It is being prepared for Kindle (KDP) publication. The companion files below are free and final.
Done
- 21 chapters and 5 appendices written
- 56 figures
- Kindle EPUB and 6 × 9 paperback interior built
- EPUBCheck: 0 errors, 0 warnings
- Every lab executed (Compose, registry, Swarm, Kubernetes)
- Real command output included
Remaining
- Kindle Previewer pass
- KDP publication
AIDevOps Cloud Native Series
Next in the series
This book is the entry point of the series: it takes a developer from a first container to a first Kubernetes application. The books below continue from there.
AIDevOps Cloud Native Series roadmap
- Book 04 — Kubernetes: Understanding and Practice: a three-node kind cluster, StatefulSets, Jobs, access control, Gateway API, and failure drills (English edition)
- Book 01 — Kubernetes Production Engineering: production design, security, observability, troubleshooting, and GitOps
AIDevOps Books · Learn. Build. Operate. Evolve.
← Back to all books