“Cracking the Kubernetes Interview” 🍘 Book Review

#kubernetes #books

My second book review of a book I finished during the new year’s holidays of 2026!

Introduction

This is another book I had the pleasure of finishing over the Christmas and New Year holidays. Although my current role does not involve direct cloud or infrastructure management, I have developed a deep passion for Kubernetes ever since I first began working with IBM Cloud Kubernetes Service (IKS) and Red Hat OpenShift (OCP).

Furthermore, as the industry shifts toward deploying Generative AI applications and infrastructures — such as llm-operator (llm-d) — directly on Kubernetes, my commitment to staying current with cluster technologies has only intensified. Understanding the intersection of orchestration and AI is no longer just a hobby; it is a critical component of building the next generation of scalable applications.

Usual Disclosure/Disclaimer: As always, I want to clarify that I maintain no financial ties, professional affiliations, or promotional agreements with Packt Publication or the authors of this book.

All images and codes provided are from Packt Publications editions and those of the authors of the book.

Setting the introductions aside, let’s explore the factual synthesis of the book’s contents. 🛫

Part 1-General Overview

“Cracking the Kubernetes Interview” (2025 edition) by Viktor Vedmich and Alexander Dovnar is a comprehensive guide designed to help engineers bridge the gap between theoretical knowledge and the practical communication skills required for senior-level technical interviews. The book moves beyond basic facts to focus on trade-offs, troubleshooting frameworks, and real-world production contexts.

Core Structure and Content

The book is organized into five major parts that follow a logical progression from fundamentals to advanced operational management:

Part 1: Introduction and Architecture: Establishes the foundation by comparing containers to virtual machines and detailing the internal components of the Kubernetes control plane (API Server, etcd, Scheduler) and worker nodes (Kubelet, Kube-proxy).
Part 2: Workloads and Scaling: Covers the lifecycle of Pods and specialized controllers like Deployments, StatefulSets, and DaemonSets. It provides a deep dive into scaling mechanisms, including the Horizontal Pod Autoscaler (HPA), Vertical Pod Autoscaler (VPA), and advanced node autoscalers like Karpenter.
Part 3: Networking, Storage, and Security: Explores the “cluster-as-a-city” analogy, detailing Pod-to-Pod communication, Ingress controllers, and the Gateway API. It also covers persistent storage through the Container Storage Interface (CSI) and security best practices such as Role-Based Access Control (RBAC) and Network Policies.
Part 4: Deployment and GitOps: Analyzes real-world deployment strategies (Blue-Green, Canary, Shadow) and the principles of GitOps using tools like Kustomize, Helm, and Argo CD.
Part 5: Reliability and Troubleshooting: Focuses on maintaining high availability (HA), observability (monitoring, logging, and tracing), and disaster recovery. It introduces a systematic “layered debugging model” for diagnosing production issues.

Key Learning Objectives

The book aims to transform technical expertise into professional interview performance through several specific methodologies:

The Troubleshooter’s Mindset: Rather than just memorizing kubectl commands, readers are taught to use an "observability-driven flow" and a "layered model" to isolate root causes in complex distributed systems.
Answer-Shaping Frameworks: It advocates for the STAR method (Situation, Task, Action, Result) to turn technical experiences into concise, outcome-driven stories that demonstrate judgment and leadership.
The Feynman Technique: The text encourages the use of analogies (e.g., comparing a Service to a restaurant host) to prove deep understanding by explaining complex concepts simply.
Practical Synthesis: Each chapter includes “Interview Tips” with specific questions, follow-ups, and common “gotchas” that distinguish good candidates from great ones.

Part 2 — The Chapters which retained my Highest Interests

While the book is excellent in its entirety, three specific chapters particularly captured my attention and stood out as the most impactful for my professional development. Chapter 9 provides a rigorous deep dive into Security Best Practices and RBAC, which is essential for maintaining cluster integrity. Chapter 12 explores Custom Resource Definitions (CRDs) and Operators — a critical area for anyone looking to extend Kubernetes’ capabilities or automate complex application lifecycles. Finally, Chapter 14 offers a comprehensive look at Monitoring Best Practices, providing the frameworks necessary to ensure long-term observability and reliability in production environments.

Security and RBAC (Chapter 9): This section moves beyond simple permissioning to explain the principle of least privilege within a cluster. It details how Role-Based Access Control (RBAC) functions as the gatekeeper for the API server and covers the strategic implementation of Network Policies to isolate workloads.

![Uploading image](...

CRDs and Operators (Chapter 12): This chapter focuses on the “extensibility” of Kubernetes. It explains how Custom Resource Definitions allow users to create their own API objects, and how the Operator pattern uses custom controllers to automate the management of stateful applications (like databases) as if they were native Kubernetes resources.

Monitoring Best Practices (Chapter 14): This part of the book outlines the shift from traditional monitoring to modern cloud-native observability. It covers the “Four Golden Signals” (Latency, Traffic, Errors, and Saturation) and discusses the integration of tools like Prometheus and VictoriaMetrics to provide actionable insights into cluster health.

The Anatomy of Technical Writing: Insights into Quality, Structural Schemas, and Code Standards

From a pedagogical standpoint, the book is exceptionally well-structured, balancing technical depth with remarkable clarity. Each chapter is concise, cutting through complexity to deliver essential concepts without unnecessary filler. The visual aids — including the diagrams and architectural schemas — are clean, professional, and highly effective at illustrating abstract orchestration patterns. Furthermore, the accompanying GitHub repository provides high-quality, practical code examples. I was particularly impressed by the material in the chapter on Operators; having previously worked on a team dedicated to developing enterprise-grade operators for business partners, I found the book’s implementation to be both accurate and reflective of industry best practices.

Beyond the personal endorsement, the book’s technical delivery can be objectively summarized as follows:

Architectural Visualization: The “clean and neat” schemas mentioned refer to the book’s use of structured visual layouts to explain the relationship between the Control Plane and Worker Nodes. This helps readers visualize the “brain” of Kubernetes (etcd and the API server) in a way that aligns with real-world deployments like IBM Cloud’s IKS.
Practical Code Repositories: The GitHub integration allows for a hands-on “Lab” experience. For the Operators section (Chapter 12), the code demonstrates the Control Loop (Observe, Diff, Act) and how to manage the lifecycle of complex, stateful applications — a critical skill for professional-level automation.

package controllers

import (
    "context"
    "fmt"

    "k8s.io/apimachinery/pkg/runtime"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/log"

    packtv1 "github.com/PacktPublishing/Kubernetes-Interview-Guide/chapter-11/books-operator/api/v1"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type BookReconciler struct {
    client.Client
    Scheme *runtime.Scheme
}

// Reconcile is part of the main Kubernetes reconciliation loop
func (r *BookReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    _ = log.FromContext(ctx)

    // Fetch the Book instance
    book := &packtv1.Book{}
    err := r.Get(ctx, req.NamespacedName, book)
    if err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }

    // Print the Book spec to stdout
    fmt.Printf("Reconciling Book: %s, Year: %d\n", book.Spec.Book, book.Spec.Year)

    // Define a new Pod object
    pod := &corev1.Pod{
        ObjectMeta: metav1.ObjectMeta{
            Name:      book.Name + "-pod",
            Namespace: "default", // Always create the pod in the default namespace
        },
        Spec: corev1.PodSpec{
            Containers: []corev1.Container{
                {
                    Name:  "busybox",
                    Image: "busybox",
                    Command: []string{
                        "sh",
                        "-c",
                        fmt.Sprintf("while true; do echo Book: %s, Year: %d; sleep 1; done", book.Spec.Book, book.Spec.Year),
                    },
                },
            },
        },
    }

    // Check if the Pod already exists
    found := &corev1.Pod{}
    err = r.Get(ctx, client.ObjectKey{Name: pod.Name, Namespace: pod.Namespace}, found)
    if err != nil && client.IgnoreNotFound(err) != nil {
        return ctrl.Result{}, err
    }

    if err == nil {
        // Pod already exists - don't requeue
        return ctrl.Result{}, nil
    }

    // Create the Pod
    fmt.Printf("Creating Pod %s/%s\n", pod.Namespace, pod.Name)
    err = r.Create(ctx, pod)
    if err != nil {
        return ctrl.Result{}, err
    }

    // Pod created successfully - don't requeue
    return ctrl.Result{}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *BookReconciler) SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        For(&packtv1.Book{}).
        Complete(r)
}

Concise Modular Design: The book is organized so that each chapter can serve as a standalone reference. This modularity is why it is effective for both continuous reading and quick reference before a technical deep-dive or interview.

Conclusion

To conclude, these insights are shared simply as a reflection of my personal reading journey and a passion for the evolving Kubernetes ecosystem. For those who share these technical interests, I believe such reviews are vital in navigating the vast amount of literature available today. Like many, I rely heavily on community feedback and peer reviews before investing in a new title. However, I also frequently take the leap on newly published works the moment they hit the shelves — a practice that can result in either a rewarding discovery or a disappointing waste of resources; meaning money and time. In the case of Cracking the Kubernetes Interview, I am pleased to say it was a genuinely ‘nice surprise’ and a worthy addition to any cloud-native professional’s library.