Study guide

2.1 Kubernetes Architecture & Control Plane Components

Kubernetes and Cloud Native Associate KCNA

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Introduction & Exam Overview

1.1 About the KCNA Exam & Certification Path 1.2 How to Use This Study Guide

2 Chapter 2: Kubernetes Fundamentals - Cluster Architecture & the API

2.1 Kubernetes Architecture & Control Plane Components 2.2 Worker Node Architecture & Node Components 2.3 Kubernetes API, Declarative Management & kubectl 2.4 Kubernetes Releases, API Versioning & Deprecation Policy

3 Chapter 3: Kubernetes Fundamentals - Workloads & Configuration

3.1 Core Workload Objects (Pods, Deployments & ReplicaSets) 3.2 Advanced Controllers (StatefulSets, DaemonSets, Jobs & CronJobs) 3.3 Namespaces, Labels, Selectors & Annotations 3.4 ConfigMaps, Secrets & Application Configuration 3.5 Pod & Container Lifecycle, Restart Policies & Graceful Termination

4 Chapter 4: Kubernetes Fundamentals - Scheduling & Autoscaling

4.1 Scheduling, Resource Management & Node Selection 4.2 Advanced Scheduling: Affinity, Topology Spread, Priority & Disruption Budgets 4.3 Autoscaling Workloads & Clusters (HPA, VPA, Cluster Autoscaler, KEDA)

5 Chapter 5: Kubernetes Fundamentals - Cluster Administration & Extensibility

5.1 Kubernetes Distributions, Installation Tools & Managed Services 5.2 Cluster Administration: Node Maintenance, Upgrades & etcd Backup 5.3 Extending Kubernetes: CRDs, Operators & the Controller Pattern

6 Chapter 6: Kubernetes Fundamentals - Containerization

6.1 Container Fundamentals, Runtimes & Registries 6.2 Container Image Anatomy: Layers, Tags, Digests & Pull Policy

7 Chapter 7: Container Orchestration - Networking & Service Discovery

7.1 Kubernetes Networking, Services & Ingress 7.2 Cluster DNS & Service Discovery with CoreDNS 7.3 NetworkPolicies, Zero-Trust Segmentation & the Gateway API

8 Chapter 8: Container Orchestration - Storage

8.1 Storage Concepts (PVs, PVCs, StorageClasses & CSI) 8.2 Volume Types, Snapshots & Stateful Storage Operations

9 Chapter 9: Container Orchestration - Security

9.1 Kubernetes Security & Access Control (RBAC & ServiceAccounts) 9.2 The 4C's of Cloud Native Security & Supply-Chain Trust 9.3 Service Mesh, mTLS & Zero-Trust Service Identity

10 Chapter 10: Container Orchestration - Troubleshooting

10.1 Container Troubleshooting & Health Probes 10.2 Cluster & Node-Level Troubleshooting

11 Chapter 11: Cloud Native Application Delivery

11.1 Cloud Native CI/CD Pipelines & Build Tooling 11.2 GitOps & Package Management (Helm, Kustomize, Argo CD & Flux) 11.3 Deployment Strategies & Release Management 11.4 Progressive Delivery Automation: Argo Rollouts, Flagger & Feature Flags 11.5 Application Debugging & Developer Workflows in Kubernetes 11.6 Platform Engineering & Developer Self-Service

12 Chapter 12: Cloud Native Architecture - Observability & Principles

12.1 Cloud Native Observability (Logging, Metrics & Tracing) 12.2 Cloud Native Principles & Architecture Patterns 12.3 Serverless, FaaS & Event-Driven Architecture

13 Chapter 13: Cloud Native Architecture - CNCF Ecosystem & Community

13.1 The CNCF Landscape, Governance & Project Lifecycle 13.2 Cloud Native Community, Collaboration & Contribution

2.1 Kubernetes Architecture & Control Plane Components

Key Takeaways Explain This Topic AI

The kube-apiserver is the central, stateless communication hub of the Kubernetes control plane and the sole component authorized to directly interact with the etcd datastore.

etcd is a strongly consistent, distributed key-value store relying on the Raft consensus algorithm that requires a strict majority quorum (N/2 + 1) to maintain cluster state.

The kube-scheduler assigns unallocated Pods to worker nodes through a two-phase process: Node Filtering (evaluating predicates) followed by Node Scoring (evaluating priorities).

The kube-controller-manager executes continuous reconciliation control loops that observe cluster state, compare it against desired state, and execute corrective actions.

The cloud-controller-manager decouples cloud-provider-specific infrastructure logic (such as load balancer provisioning and cloud node lifecycle) from core Kubernetes control plane code.

Last updated: August 2026

2.1 Kubernetes Architecture & Control Plane Components

Kubernetes follows a control-plane/worker architecture designed to automate container deployment, scaling, and operational management. The system is split into two primary operational tiers: the Control Plane (traditionally referred to as the master node) and Worker Nodes . The Control Plane makes global cluster decisions, responds to cluster events, and ensures the actual runtime state constantly matches the desired state specified by administrators. +-----------------------------------------------------------------------+

  • | KUBERNETES CONTROL PLANE |
  • | |
  • | +-------------------+ +------------------+ +-------------+ |
  • | | kube-scheduler | | kube-controller- | | cloud- | |
  • | | | | manager | | controller- | |
  • | +---------+---------+ +--------+---------+ | manager | |
  • | | | +------+------+ |
  • | +------------+ | | |
  • | v v v |
  • | +------------------------------------+ |
  • | | kube-apiserver | |
  • | | (REST API, AuthN/AuthZ, Admission) | |
  • | +------------------+-----------------+ |
  • | | |
  • | v |
  • | +---------------------+ |
  • | | etcd | |
  • | | (Key-Value Store) | |
  • | +---------------------+ |
  • +--------------------------------------|--------------------------------+
  • | HTTPS (Watch / API)
  • v
  • +-----------------------------------------------------------------------+
  • | WORKER NODES |
  • | +--------------------------+ +--------------------------+ |
  • | | Kubelet | | kube-proxy | |
  • | +--------------------------+ +--------------------------+ |
  • +-----------------------------------------------------------------------+
  • 1. kube-apiserver (API Server)

The kube-apiserver is the central management gateway and communication spine of a Kubernetes cluster. It exposes the Kubernetes REST API to external clients (such as kubectl , CI/CD pipelines, and web dashboards) as well as internal cluster components.

Core Responsibilities

Authentication & Authorization : Validates client identity (AuthN) via TLS certificates, bearer tokens, or OIDC providers, followed by checking access permissions (AuthZ) using Role-Based Access Control (RBAC).

Admission Control : Intercepts requests after authorization but before object persistence. Admission plugins run in sequence: Mutating Admission Webhooks (modifying requests, e.g., injecting sidecars) followed by Validating Admission Webhooks (enforcing security and schema constraints).

Schema Enforcement & Serialization : Validates incoming JSON/YAML object schemas against Kubernetes API spec definitions.

Sole etcd Interface : The API server is the only component in the entire architecture permitted to read from or write to etcd directly. All other components must issue RESTful calls to kube-apiserver .

High Availability & Scaling

The kube-apiserver is entirely stateless . Multiple instances of kube-apiserver can be deployed concurrently behind an active-active network load balancer (e.g., HAProxy or AWS NLB) to provide high availability and scale horizontal throughput.

2. etcd (Distributed Key-Value Store)

etcd is a strongly consistent, distributed key-value store developed by CoreOS (now a CNCF graduated project). It serves as the single source of truth for all Kubernetes cluster state, configuration settings, secrets, and metadata.

Consensus Protocol & Quorum

etcd implements the Raft consensus algorithm to ensure data consistency across distributed instances. Raft requires a strict majority quorum to validate write operations and elect a cluster leader. Quorum is calculated using the formula: quorum = floor(N / 2) + 1

Where N is the total number of etcd members in the cluster:

3-node cluster : Quorum is 2. The cluster tolerates 1 node failure.

5-node cluster : Quorum is 3. The cluster tolerates 2 node failures.

7-node cluster : Quorum is 4. The cluster tolerates 3 node failures.

Important: etcd clusters should always contain an odd number of members (3, 5, or 7). Growing from 3 members to 4 raises the quorum from 2 to 3 while fault tolerance stays at exactly one failure — the extra member buys write latency and cost, not resilience. The same holds at every even size: a 6-member cluster needs a quorum of 4 and still tolerates only 2 failures, identical to a 5-member cluster.

Backup, Restore, and Maintenance

Because etcd stores all cluster state, disaster recovery strategies rely on periodic snapshot backups created via etcdctl : # Save a snapshot of the etcd database

  • ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
  • -cacert=/etc/kubernetes/pki/etcd/ca.crt \
  • -cert=/etc/kubernetes/pki/etcd/server.crt \
  • -key=/etc/kubernetes/pki/etcd/server.key \
  • snapshot save /tmp/etcd-backup.db

To prevent performance degradation over time, administrators execute periodic database compaction (reclaiming space from old key revisions) and defragmentation .

3. kube-scheduler (Kube Scheduler)

The kube-scheduler is the control plane component responsible for assigning newly created Pods that lack a designated nodeName to the most appropriate worker node in the cluster.

Scheduling Cycle Workflow

The scheduler operates through a two-phase workflow for every pending Pod:

Filtering Phase (Predicates) : Evaluates nodes to filter out those that do not satisfy the Pod's hardware or operational requirements. Key predicate checks include:

PodFitsResources : Verifies if a node has sufficient allocatable CPU and memory.

NodeName : Checks if the Pod explicitly targets a specific host.

NodePorts : Ensures requested host ports are not already bound.

Taints and Tolerations : Excludes nodes with taints that the Pod cannot tolerate.

Scoring Phase (Priorities) : Ranks the remaining candidate nodes on a scale from 0 to 100 based on weighting algorithms. Key scoring rules include:

NodeResourcesBalancedAllocation : Favors nodes with balanced CPU and memory resource utilization.

ImageLocality : Favors nodes that already have the Pod's container images cached locally.

NodeAffinity & PodAffinity/AntiAffinity : Grants higher scores to nodes matching preferred affinity rules.

Once the node with the highest score is identified, the scheduler creates a Binding object, issuing an API call to kube-apiserver to update the Pod's spec.nodeName field.

4. kube-controller-manager (Controller Manager)

The kube-controller-manager is a single binary that embeds multiple distinct control loops (controllers) running within a shared execution process.

The Reconciliation Loop Pattern

Each controller continuously executes a reconciliation loop based on three steps:

Observe : Query current cluster state from kube-apiserver using HTTP Watch streams.

Compare : Compare actual observed state against desired state specified in object manifests.

Act : Issue API requests to correct any drift between actual state and desired state.

Key Embedded Controllers

Controller Name Primary Responsibility

Node Controller Monitors node health, responds when nodes stop sending heartbeats, and handles pod eviction after timeouts.

ReplicaSet Controller Ensures the exact number of matching pod replicas are running at all times.

Endpoints Controller Populates Endpoints and EndpointSlices objects linking Services to backing Pod IPs.

ServiceAccount Controller Creates default ServiceAccounts and API token secrets for newly created namespaces.

Job Controller Watches Job objects and launches Pods to execute batch tasks until successful completion.

In high-availability setups, multiple kube-controller-manager instances run across control plane nodes, using leader election so that only one active leader performs reconciliation while others remain in standby mode.

5. cloud-controller-manager (CCM)

The cloud-controller-manager decouples cloud-provider-specific logic from the core Kubernetes codebase. Prior to CCM, control plane components contained vendor-specific code for AWS, GCP, and Azure. CCM allows cloud vendors to develop out-of-tree plugins independently.

Key CCM Controllers

Node Controller : Interrogates cloud provider APIs to verify if a node instance has been terminated in the cloud when it becomes unresponsive.

Route Controller : Configures network routing infrastructure within the underlying cloud Virtual Private Cloud (VPC).

Service Controller : Communicates with cloud provider APIs to provision external cloud load balancers (e.g., AWS ELB/NLB, GCP Load Balancer) when a Kubernetes Service of type: LoadBalancer is created.

Control Plane Components Summary

  • Component Primary Function Statefulness etcd Access HA Model
  • kube-apiserver REST API gateway, AuthN/AuthZ, Admission Stateless Direct (Sole Access) Active-Active
  • etcd Persistent cluster configuration datastore Stateful N/A (Is etcd) Raft Quorum Cluster

kube-scheduler Assigns Pods to suitable worker nodes Stateless Indirect (via API) Active-Passive (Leader Election)

kube-controller-manager Executes core reconciliation loops Stateless Indirect (via API) Active-Passive (Leader Election)

cloud-controller-manager Integrates with cloud vendor infrastructure Stateless Indirect (via API) Active-Passive (Leader Election)