Kubernetes (K8s) can feel overwhelming at first glance. However, at its core, it is simply a highly efficient system for managing and orchestrating containers across multiple machines.

To master Kubernetes, you must first understand its architecture. The system is split into two massive components: the Control Plane (the brain) and the Worker Nodes (the muscle).

1. The Control Plane (The Brain)

The Control Plane is responsible for making global decisions about the cluster, such as scheduling, detecting, and responding to cluster events.

  • kube-apiserver: This is the front end of the Kubernetes control plane. Every single command you run (like kubectl get pods) talks directly to the API server. It is the only component that interacts directly with the cluster’s datastore.
  • etcd: Think of this as the cluster’s absolute source of truth. It is a highly available key-value store that holds all the cluster data and configuration states. If a node dies, the cluster looks at etcd to know what the state should be.
  • kube-scheduler: This component watches for newly created Pods that have no assigned node, and assigns them to a node based on resource requirements, hardware constraints, and policy guidelines.
  • kube-controller-manager: This runs controller processes. For example, if you tell Kubernetes you want 3 copies of an app running, the controller manager constantly checks to ensure exactly 3 copies are running. If one crashes, it spins up a new one.

2. The Worker Nodes (The Muscle)

Nodes are the physical servers or virtual machines (like your DigitalOcean Droplet) where your actual applications (containers) run.

  • kubelet: This is the tiny “captain” that lives on every single node. It listens to the Control Plane and ensures that the containers described to it are running and healthy.
  • kube-proxy: This is a network proxy that runs on each node. It maintains network rules, allowing communication to your Pods from network sessions inside or outside of your cluster.
  • Container Runtime: This is the software actually responsible for running the containers (such as containerd or CRI-O).

The Core Unit: The Pod

Kubernetes does not run containers directly; it wraps one or more containers into a higher-level structure called a Pod. A Pod is the smallest deployable unit of computing that you can create and manage in Kubernetes.

When you scale an application in Kubernetes, you are not adding more containers to an existing Pod; you are adding more identical Pods to the cluster.

Ready to deploy your first Pod? Check back for our next tutorial where we write our very first YAML configuration file!