I recently had the privilege of being a technical reviewer for The Ultimate Docker Container Book — Build, ship, deploy, and scale containerized applications with Docker, Kubernetes, and the cloud by Dr. Gabriel N. Schenker, published by Packt. Reviewing a 600+ page container book — chapter by chapter, code sample by code sample — was a significant commitment, and one of the most rewarding learning experiences I’ve had in a while.
This post is a short, honest reflection on the book and what it was like to review it.
What the Book Covers
The book is genuinely broad without being shallow. It’s organized into four parts and 19 chapters, starting from “what is a container?” and ending with running production workloads on managed Kubernetes in the cloud.
Part 1 — Introduction
- Chapter 1: What Are Containers and Why Should I Use Them?
- Chapter 2: Setting Up a Working Environment
A clean on-ramp for readers who have never run docker run in their life.
Part 2 — Containerization Fundamentals
- Chapter 3: Mastering Containers
- Chapter 4: Creating and Managing Container Images
- Chapter 5: Data Volumes and Configuration
- Chapter 6: Debugging Code Running in Containers
- Chapter 7: Testing Applications Running in Containers
- Chapter 8: Increasing Productivity with Docker Tips and Tricks
This is the meat of the Docker side — Dockerfiles, image layers, multi-stage builds, volumes, environment variables, debugging, and testing inside containers. Topics like “lift and shift — containerizing a legacy app” make it directly useful for real-world work.
Part 3 — Orchestration Fundamentals
- Chapter 9: Learning about Distributed Application Architecture
- Chapter 10: Using Single-Host Networking
- Chapter 11: Managing Containers with Docker Compose
- Chapter 12: Shipping Logs and Monitoring Containers
- Chapter 13: Introducing Container Orchestration
- Chapter 14: Introducing Docker Swarm
- Chapter 15: Deploying and Running a Distributed Application on Docker Swarm
This part bridges single-container thinking to multi-service, multi-host thinking. Chapter 12 in particular — logging and monitoring — is treated as a first-class concern, not an afterthought.
Part 4 — Docker, Kubernetes, and the Cloud
- Chapter 16: Introducing Kubernetes
- Chapter 17: Deploying, Updating, and Securing an Application with Kubernetes
- Chapter 18: Running a Containerized Application in the Cloud
- Chapter 19: Monitoring and Troubleshooting an Application Running in Production
This is where it gets really interesting. Chapter 18 walks through provisioning managed Kubernetes on Azure (AKS), AWS (EKS), and Google Cloud (GKE) and deploying real applications onto them. Chapter 19 then closes the loop with production monitoring and troubleshooting.
What Stood Out to Me
A few things genuinely impressed me as I worked through the manuscript.
1. The progression is gentle but doesn’t stay shallow
The early chapters are written for someone who has never touched Docker. By the later chapters, you’re looking at multi-stage builds, image hardening, Kubernetes manifests, and clusters in three different clouds. The ramp is steep but well-paced.
2. Operational topics are treated as first-class
Logging, observability, security, and troubleshooting often get one short chapter at the end of container books. Here they show up repeatedly — debugging in containers (Ch. 6), shipping logs and monitoring (Ch. 12), securing apps on Kubernetes (Ch. 17), and production monitoring (Ch. 19). That matches reality — most of the pain in production containers isn’t building the image, it’s running it safely and being able to debug it at 2 AM.
3. The cloud chapter is practical
Covering AKS, EKS, and GKE in a single chapter is hard. It doesn’t try to be a full reference for each cloud — instead it shows the minimum viable path to get a managed cluster running and an app deployed. That’s exactly what most readers need before going deeper into a specific provider.
4. Docker Swarm is still in the conversation
A lot of newer books skip Swarm entirely. Including it (Chapters 14–15) is a smart call — it’s still the simplest way to teach orchestration concepts before jumping into the larger surface area of Kubernetes.
What It Was Like to Review
Technical reviewing is a different kind of reading. You’re not just absorbing content — you’re:
- Running the commands and code samples to make sure they work
- Checking that explanations match the current behavior of the tools
- Flagging anything that could confuse a first-time reader
- Looking for places where a small addition could save a reader hours later
Doing this across 19 chapters and 600+ pages forced me to slow down on topics I thought I already knew well. I caught myself learning small details about Docker layer caching, the container network model, and Kubernetes Deployments that I had been hand-waving for years.
It also reminded me how much of “knowing Docker and Kubernetes” is actually about knowing the workflow around them — building, shipping, observing, securing — not just the YAML.
Who Should Read It
Based on the time I spent with the manuscript, I’d recommend the book to:
- Developers who use containers occasionally and want a solid mental model
- DevOps and platform engineers who want a single, coherent reference instead of stitching together blog posts
- Cloud engineers moving into AKS, EKS, or GKE who want to understand the Docker side properly
- Tech leads who want their team to share a common baseline of container knowledge
If you already run multi-cluster production Kubernetes for a living, parts of it will feel introductory — but the operational, security, and multi-cloud chapters still hold useful material.
Final Thoughts
Being part of this book — even from the reviewer’s seat — was a great reminder of how fast this space is moving and how valuable it is to have a single resource that pulls Docker, Kubernetes, and the major clouds into one consistent narrative.
A big thank you to Dr. Gabriel N. Schenker and the team at Packt for the opportunity to contribute. If you’re looking to go from “I’ve used Docker a couple of times” to “I can confidently ship containers to a managed Kubernetes cluster on any major cloud,” this book is a very solid path to take.
