Certified Kubernetes Administrator - Exam Preparation — Session 4

Overview

This session concludes Day 1 of a Kubernetes training course, summarizing foundational concepts and hands-on experience with core Kubernetes resources: Pods, Deployments, ReplicaSets, labels, selectors, probes, volumes, and rollout strategies. The trainer reinforces understanding of the Kubernetes control plane components (API Server, Controller Manager, Scheduler, Kubelet) and their reconciliation logic, while previewing Day 2’s focus on Services and use-case-driven deep dives. The session ends with Q&A addressing controller architecture and port conflict misconceptions, clarifying that Services abstract direct Pod access.

Topic (Timeline)

1. Day 1 Recap and Day 2 Preview [00:00:00 - 00:02:49]

• Recap of Day 1’s scope: motivation for containers (overcoming monolith challenges), transition to microservices, and Kubernetes as the orchestration layer.
• Overview of Kubernetes cluster formation via host grouping.
• Introduction to the Pod as the atomic unit, including lifecycle commands and resource specification (probes, volumes).
• Hands-on creation of Deployments and ReplicaSets.
• Explanation of ReplicaSet functionality via label selectors and the app=web-style label matching.
• Deployment strategy and rollout mechanics covered, with emphasis on declarative configuration and self-healing.

2. Control Plane Architecture and Reconciliation Logic [00:03:53 - 00:08:43]

• Breakdown of Kubernetes control plane components: API Server, Controller Manager (including Deployment and ReplicaSet controllers), Scheduler, and Kubelet.
• ReplicaSet controller runs an infinite loop to ensure desired state (DS) matches current state (CS) by querying the API Server.
• Deployment controller manages rollout strategies (e.g., rolling update) and delegates Pod creation to ReplicaSet.
• All controllers interact with etcd to read/write cluster state; API Server is stateless and serves as the sole interface to etcd.
• Scheduler makes node assignment decisions based on resource availability, node affinity, pod anti-affinity, and other constraints.
• When a Pod is scaled up or replaced, the Scheduler assigns it to a node, then instructs the corresponding Kubelet to create the container via the container runtime.
• Kubelet handles liveness/readiness probes and container lifecycle management locally.

3. Service Abstraction and Port Conflict Clarification [00:08:45 - 00:09:48]

• Addressed concern: multiple Pods on the same node using port 80 — clarified this is not a practical issue because Pods are not accessed directly.
• Emphasized that direct Pod port exposure is avoided; access is mediated via Services (introduced as Day 2 topic).
• Confirmed that multiple Pods of the same application can coexist on a node without port conflict due to Service-level abstraction.

4. Custom Schedulers and Final Q&A [00:09:51 - 00:10:27]

• Noted possibility of deploying custom schedulers for specific workloads, while default Scheduler handles others.
• Reiterated that all state is persisted in etcd; API Server is the central coordination point.
• Final Q&A confirmed understanding of controller roles and service-based access model.
• Closing remarks: Day 2 starts at 9 a.m., course materials remain accessible until end of Day 3, and feedback is welcome via email.

Appendix

Key Principles

• Declarative Configuration: Kubernetes ensures desired state via controllers; users define what, not how.
• Label-Driven Orchestration: ReplicaSets and Services use labels and selectors to dynamically group and route to Pods.
• Reconciliation Loop: Controllers continuously compare actual state with desired state and take corrective action.
• Service Abstraction: Direct Pod access is avoided; Services provide stable endpoints and load balancing.

Tools & Components

• API Server: Central interface to etcd; stateless.
• Controller Manager: Houses Deployment, ReplicaSet, and other controllers.
• Scheduler: Makes node assignment decisions based on cluster state and constraints.
• Kubelet: Agent on worker nodes; executes container creation and health checks.
• etcd: Distributed key-value store holding all cluster state.

Common Pitfalls (Clarified)

• Port Conflicts on Nodes: Not an issue — Pods are accessed via Services, not directly.
• Manual Pod Scheduling: Avoided; Scheduler handles placement based on policies.
• Misunderstanding Controller Roles: Deployment → ReplicaSet → Pod hierarchy; each has distinct responsibilities.

Next Steps (Day 2 Preview)

• Deep dive into Service resources: ClusterIP, NodePort, LoadBalancer.
• Use-case-driven exploration of ConfigMaps, Secrets, Ingress, and Helm.
• Hands-on: Exposing applications, implementing rolling updates, and managing configuration.