Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment · evaluation · observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification · coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
🤖 AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
📱 Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
⚙️ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
💾 Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
🧪 Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
Kubernetes: Understanding & Practice cover

Core · hands-onAIDevOps Cloud Native Series · Book 04

Kubernetes: Understanding & Practice

Hands-On Kubernetes with kind — From Core Concepts to Deployment and Operations — 2026 English Edition

FOR
Developers who have finished a first Kubernetes deployment
CONTENTS
20 chapters + 4 appendices
EDITION
English edition · coming soon
Free lab files← All books

Contents

0 / 6
  1. Overview
  2. Lab Environment
  3. Chapters (20)
  4. Companion Materials
  5. Publication Status
  6. Next in Series
Contents 6 sections
  1. Overview
  2. Lab Environment
  3. Chapters (20)
  4. Companion Materials
  5. Publication Status
  6. Next in Series

Overview

About this book

Move from a first Kubernetes deployment to a system you can operate and explain. Twenty chapters follow Mini CloudShop through Pods, Deployments, Services, Traefik Ingress, configuration, persistent storage, probes, HPA, Jobs, StatefulSets, RBAC, NetworkPolicy, and Gateway API. Recorded lab output, 44 diagrams, a 125-term glossary, four worked cases, and forty additional questions with reasoning connect concepts to observed behavior. Finish by rebuilding the application in a fresh three-node cluster and running recovery drills.

Recorded lab environment

Docker 29.2 · kind 0.33 · Kubernetes v1.37 · Traefik 41.6 · Gateway API 1.5.1

Length

25,431 words (20 chapters + 4 appendices)

Status

Local edition complete — preparing KDP publication

Fictional system — Mini CloudShop

An Nginx Web front end calls an Express API backed by Redis. The same small application makes request paths, workload recovery, storage lifetime, and policy boundaries visible.

About the author — John Bae

Enterprise cloud architect and founder of AIDevOps. His teaching connects application architecture, platform operations, and evidence-based troubleshooting.

Download companion files (.zip)View on GitHub ↗

Lab Environment

Every lab runs on a three-node kind cluster

Every manifest in this book can be applied to a three-node cluster created with kind (Kubernetes in Docker) on one computer with Docker installed. The cluster has one control plane and two workers, so you can watch Pods being placed on and replaced across several nodes locally, with no cloud account or separate server. Apply the manifests from the free companion files in chapter order.

Chapter 4 · Environment

Create a kind cluster with one control plane and two workers (named cloudshop-en) and load the API and Web images you build into its nodes.

Chapters 5–14 · Core objects

Pods, Deployments, Services, Ingress, ConfigMaps and Secrets, PVCs, probes and resource settings, and HPA are applied in turn on the same cluster. HPA is checked after installing metrics-server.

Chapters 15–18 · Extended topics

Jobs and CronJobs, StatefulSets, quota, LimitRange and RBAC, NetworkPolicy, and the Gateway API run on the kind cluster so you see what is allowed, what is blocked, and how state changes.

Chapters 19–20 · Diagnosis and the final lab

Diagnose representative failures from evidence, then build a fresh cluster, redeploy the whole of Mini CloudShop from scratch, and practice recovery.

1. Create the three-node kind cluster (Chapter 4)

The companion files include kind.yaml, which defines one control plane and two workers. The cluster name is cloudshop-en throughout, with context kind-cloudshop-en.

BASH
cat kind.yaml
# kind: Cluster
# apiVersion: kind.x-k8s.io/v1alpha4
# nodes:
#   - role: control-plane
#   - role: worker
#   - role: worker
kind create cluster --name cloudshop-en --config kind.yaml --wait 5m

2. Build the images and load them into the nodes (Chapter 4)

Build the images from the api and web folders in the companion files and hand them to the cluster with kind load, because a kind node cannot see the images on the host.

BASH
docker build -t intro-api:1.0 ./api
docker build -t intro-web:1.0 ./web
kind load docker-image intro-api:1.0 intro-web:1.0 --name cloudshop-en

3. Apply the manifests in chapter order (Chapters 5–18)

Apply the files in the order of the chapter number at the start of each file name. Do not apply the whole folder at once; pick the files for each chapter.

BASH
kubectl apply -f k8s/07-deployment.yaml
kubectl apply -f k8s/09-service.yaml
kubectl apply -f k8s/11-config.yaml
kubectl apply -f k8s/12-redis-pvc.yaml
kubectl apply -f k8s/13-api-operational.yaml

4. Reach the application through Ingress and the Gateway API (Chapters 10, 18)

Install Traefik with Helm. A local kind cluster has no external load balancer, so the Service stays ClusterIP and you connect with port-forward. Chapter 18 installs the Gateway API CRDs and turns on the Gateway provider of the same Traefik.

BASH
helm repo add traefik https://traefik.github.io/charts
helm upgrade --install traefik traefik/traefik --version 41.6.0 \
  --namespace traefik --create-namespace \
  --set providers.kubernetesIngress.enabled=true \
  --set providers.kubernetesGateway.enabled=false \
  --set service.spec.type=ClusterIP
kubectl port-forward -n traefik service/traefik 8080:80

# Chapter 18: Gateway API CRDs
kubectl apply --server-side -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.5.1/standard-install.yaml

5. Install metrics-server for HPA (Chapter 14)

On a local cluster such as kind, metric collection can fail on kubelet certificate verification, so the --kubelet-insecure-tls option is added for local labs only.

BASH
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.8.0/components.yaml
kubectl patch deployment metrics-server -n kube-system --type='json' \
  -p='[{"op":"add","path":"/spec/template/spec/containers/0/args/-","value":"--kubelet-insecure-tls"}]'
kubectl apply -f k8s/14-hpa.yaml

6. Start again from an empty cluster (Chapter 20)

The final lab deploys the whole application from scratch on a separate, fresh cluster named cloudshop-final-en. Use the delete commands to clean up when you finish.

BASH
kind create cluster --name cloudshop-final-en --config kind.yaml --wait 5m

# Clean up
kind delete cluster --name cloudshop-final-en
kind delete cluster --name cloudshop-en

The lab environment recorded for this edition is Docker 29.2, kind 0.33, Kubernetes v1.37, Traefik Helm chart 41.6.0, and Gateway API v1.5.1, and all 20 live validation checks passed on it. Pod names, timestamps, and counter values differ per environment. kind is a local learning cluster, so production conditions such as an external load balancer or cloud storage are not covered.

Table of Contents

20 chapters

Chapters 1–6 establish the control model and local environment. Chapters 7–14 connect workloads, networking, configuration, storage, health, and scaling. Chapters 15–20 add finite tasks, StatefulSets, policy, Gateway API, diagnosis, and a fresh-cluster recovery lab. Kubernetes Learning Series, Volume 2.

Chapter 1981w

From Running Containers to Maintaining a Service

Connect Docker experience to Kubernetes responsibilities and distinguish desired state from observed state.

Chapter 2937w

Follow the Control Plane and the Request Path

Trace declarations through the control plane and follow user requests through the application.

Chapter 3874w

Use kubectl with a Known Target

Inspect contexts, namespaces, resources, logs, and Events before changing a cluster.

Chapter 4808w

Build a Three-Node Learning Environment

Create a three-node kind cluster and load locally built application images.

Chapter 5887w

Treat the Pod as an Execution Boundary

Observe Pod lifetime, container sharing, and what happens when an unmanaged Pod disappears.

Chapter 6848w

Read YAML as a Resource Contract

Read API version, kind, metadata, and spec as a resource contract.

Chapter 7728w

Maintain and Update a Deployment

Follow Deployment and ReplicaSet reconciliation, scaling, rolling updates, and rollback.

Chapter 8774w

Connect Objects with Namespaces, Labels, and Selectors

Use namespaces, labels, and selectors deliberately and diagnose mismatched targets.

Chapter 9671w

Build a Stable Service over Changing Pods

Connect stable Service names to changing Pods and inspect EndpointSlices.

Chapter 10712w

Give the Application an HTTP Entry Point

Install Traefik, route Web and API requests, and distinguish rules from the controller.

Chapter 11628w

Deliver Configuration without Rebuilding the Image

Deliver ConfigMap and Secret values and verify when changed configuration reaches a process.

Chapter 12777w

Give Data a Deliberate Lifetime

Compare temporary storage with PVC-backed Redis data and test persistence after replacement.

Chapter 13812w

Define Resource and Health Expectations

Set resource requests and limits; distinguish startup, readiness, and liveness probes.

Chapter 14756w

Scale from Measurements and Recover a Release

Use measured CPU for HPA decisions and recover a failed application release.

Chapter 15695w

Run Work That Should Finish

Run bounded Jobs and CronJobs; inspect completion, retries, and failure limits.

Chapter 16659w

Preserve Identity with a StatefulSet

Preserve StatefulSet identity and storage while understanding independent Redis members.

Chapter 17871w

Put Boundaries around Capacity, Permissions, and Traffic

Verify quotas, default resources, RBAC permissions, and denied versus allowed network clients.

Chapter 18768w

Rebuild the Entry Point with Gateway API

Replace the Ingress entry point with Gateway API and inspect route acceptance.

Chapter 19825w

Diagnose the Failed Responsibility

Diagnose scheduling, image, memory, and process failures with status, logs, and Events.

Chapter 20887w

Rebuild Mini CloudShop and Run Recovery Drills

Rebuild the full application in a fresh cluster and practice data, release, and policy recovery.

Appendix A — Commands Organized by the Question They Answer

A question-first command reference.

Appendix B — Four Worked Operational Cases

Follow evidence through a justified diagnosis and recovery.

Appendix C — Official References and Version Records

Authoritative references for the lab tools and APIs.

Appendix D — Forty Practice Questions with Worked Reasoning

Two additional questions for every chapter.

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 free ZIP contains 34 files: English API/Web sources, locked npm dependencies, a three-node kind configuration, staged manifests, diagnostic examples, and a learning record. Start with README.md and follow the chapter sequence.

The same files are also on GitHub, where the README covers the folder layout and a chapter-by-chapter lab guide: github.com/aidevops-books/kubernetes-understanding-practice-en

Start here

README.md

Archive layout and lab sequence.

Application

api/, web/

API and Web source used to build the lab images.

Chapters 5–20

k8s/

Progressive workload, Service, storage, policy, and Gateway manifests.

Publication Status

Publication status

The English EPUB, 196-page Reading PDF, and 200-page print interior passed local publication checks. EPUBCheck reported zero errors or warnings, and all 20 live checks passed. Kindle/KDP account-side preview and publication remain pending. The free companion is available here.

Done

  • 20 chapters complete
  • EPUB and print files built
  • EPUBCheck: zero errors and warnings
  • 20 live validation checks passed
  • Free companion materials

Remaining

  • Kindle/KDP final preview
  • KDP publication

AIDevOps Cloud Native Series

Next in the series

Learning Volume 1 introduces Docker and a first Kubernetes application; this is Volume 2. Continue to Kubernetes Production Engineering for production architecture and operations. Repository series numbers differ from learning-volume numbers.

AIDevOps Cloud Native Series roadmap

  • Book 01 — Kubernetes Production Engineering: Learning Volume 3: production design, reliability, security, observability, and delivery

AIDevOps Books · Learn. Build. Operate. Evolve.

← Back to all books