Understanding Kubernetes: Core Components and How They Work Together

Docker is a familiar container technology that runs a Docker Engine on the host to pull images, start containers, mount data, and map ports, offering a simple entry point compared to Kubernetes (K8s).

Kubernetes is a distributed cluster management system built on container technology, originating from Google’s large‑scale container experience. It manages large clusters through many components, making its setup more complex, especially in environments that rely on Google‑hosted images.

Question 1: How do the master and worker nodes communicate?

When the master node starts, it runs the kube-apiserver process, which provides the cluster management API and serves as the central hub for data exchange and security mechanisms.

On each worker node, the kubelet component runs a process that reports node status to the master, registers the node, reports health, and receives commands to create Pods.

A Pod is the basic unit in K8s; it may contain one or more containers that share network resources, allowing them to communicate via

localhost

. Each Pod starts a pause container (a Google image) that holds the network namespace, enabling other containers in the Pod to share its network.

Question 2: How does the master schedule Pods onto specific Nodes?

The kube-scheduler performs this task, running algorithms (e.g., round‑robin) to select the best Node for each Pod. To force a Pod onto a particular Node, you can match Node labels with the Pod’s

nodeSelector

attribute.

Question 3: Where is the cluster state stored and who maintains it?

Kubernetes uses the etcd component as a highly available, strongly consistent key‑value store for all configuration and state data. All read/write operations on this data are performed through the kube-apiserver , which also exposes a REST API for internal components and external users (e.g., via

kubectl

).

Question 4: How do external users access Pods inside the cluster?

Unlike a single Docker container that uses bridge networking and port mapping, Kubernetes introduces the Service abstraction. A Service groups Pods with the same label, stores its definition in etcd via the Service Controller, and relies on kube-proxy on each node to route traffic and perform load balancing.

Question 5: How does Pod scaling work?

Scaling is achieved by adjusting the replica count of a Pod via the Replication Controller . When the actual number of Pods differs from the desired count, the controller creates or deletes Pods to match the target.

Question 6: How do the various components cooperate?

The kube-controller-manager runs multiple controllers (e.g., Service Controller, Replication Controller, Node Controller, ResourceQuota Controller, Namespace Controller). It watches the shared cluster state via the apiserver and attempts to reconcile the actual state with the desired state for each controller.

Summary

This high‑level Q&A overview introduces the fundamental concepts of Kubernetes without delving into implementation details, covering:

Node

Pod

Label

Selector

Replication Controller

Service Controller

ResourceQuota Controller

Namespace Controller

Node Controller

Key processes include:

kube-apiserver

kube-controller-manager

kube-scheduler

kubelet

kube-proxy

pause

This summary reflects the author’s personal consolidation of Kubernetes architecture after initial hands‑on experience.