Why Kubernetes Dominates Cloud Native: Architecture, Components, and Benefits

What is Kubernetes?

Kubernetes is an open‑source container orchestration system originally developed by Google, based on their internal Borg platform. It provides a portable, extensible, and self‑healing environment for deploying and managing containerized applications across public, private, hybrid, or multi‑cloud infrastructures.

Key characteristics of Kubernetes include:

Portability : Works on any cloud or on‑premises environment.

Scalability : Modular and pluggable architecture supports extensive extensions.

Self‑healing : Declarative management enables automatic restarts, replication, and scaling.

Using Kubernetes lets you deploy applications quickly and predictably, scale on demand, release new features without disrupting existing services, and optimize hardware utilization to reduce costs.

Kubernetes is a declarative system, contrasting with imperative approaches. In a declarative model you specify the desired state, and the system determines how to achieve it, whereas imperative models require step‑by‑step instructions.

Kubernetes Architecture

Kubernetes follows a master‑slave design.

The main components are:

etcd stores the entire cluster state and is accessed only by the API server.

API Server provides the sole entry point for resource operations, handling authentication, authorization, admission control, and API discovery.

Controller Manager maintains cluster state, performing tasks such as fault detection, auto‑scaling, and rolling updates.

Scheduler assigns Pods to appropriate nodes based on resource requirements and policies.

Kubelet manages the lifecycle of containers on each node and handles volume (CSI) and network (CNI) integration.

Container runtime executes containers according to the CRI.

Kube‑proxy implements service discovery and load balancing within the cluster.

Registry stores container images.

kubectl and Dashboard are client tools.

For high availability, production clusters typically run multiple master nodes behind a load balancer and separate etcd from the masters.

Design principles include: only the API server accesses etcd; a single master failure should not affect cluster state; components should continue processing after failure recovery; state is stored in etcd and observed via the API server; and event‑driven communication is preferred over polling.

Important Kubernetes Components

The components collaborate as follows:

kubectl converts CLI commands into RESTful API calls to the API server. After authentication and authorization, the API server stores task metadata in etcd. The scheduler selects a suitable node, updates etcd, and creates the task. The kubelet on the target node watches the API server, creates the container via the local runtime, and reports status back to etcd. kube‑proxy watches for network policy changes and updates iptables/ipvs rules. The controller manager continuously works to keep the actual state aligned with the desired state.

Etcd – a highly available key‑value store that holds all API objects.

API Server – the central control plane exposing REST APIs, handling authentication, authorization, admission, and caching etcd data.

Controller Manager – runs various controllers (node, job, endpoint, service‑account, etc.) to reconcile the cluster state.

Scheduler – selects optimal nodes for unscheduled Pods based on resources, constraints, and policies.

Kubelet – runs on each node, pulls Pod specs, manages containers via CRI, and reports health and status.

Kube‑proxy – maintains network rules for Service discovery and load balancing.

Etcd

Etcd provides a consistent, highly available key‑value store used for service discovery, configuration sharing, and state consistency. In Kubernetes it is the sole source of truth for all API objects and is accessed only through the API server.

API Server

The API server is the core component that offers RESTful interfaces for cluster management, handles authentication, authorization, admission control, and caches etcd data to reduce load.

Controller Manager

Controller processes monitor changes in the cluster and act to drive the current state toward the desired state, such as node failures, job completions, endpoint updates, and service‑account provisioning.

Scheduler

The scheduler watches newly created Pods without assigned nodes, evaluates resource requirements, constraints, affinity, and selects the best node in three phases: Predict (filter), Priority (rank), and Bind (assign).

Kubelet

Kubelet runs on each node, fetches Pod specifications from various sources, abstracts container runtime, network, and storage via CRI, CNI, and CSI, reports node health, and performs health checks on Pods.

Kube‑proxy

Kube‑proxy runs on every node, implements Service abstraction by maintaining iptables/ipvs rules for intra‑cluster and external traffic routing.

Additional Ecosystem Components

CoreDNS (kube‑dns) – provides DNS services for the cluster.

Ingress Controller – exposes services to external traffic.

Metrics‑Server – supplies resource usage metrics.

Dashboard – GUI for cluster management.

Prometheus – collects and monitors metrics.

Grafana – visualizes monitoring data.

ELK – aggregates and queries cluster logs.