Kubernetes Architecture

Welcome to Kubernetes! It's a powerful system for managing containerized applications across many machines.

Before we dive into running apps, it's essential to understand its core structure. Think of it as learning the parts of a car before driving it!

At its heart, Kubernetes operates as a cluster. A cluster is a group of machines, called nodes, that work together.

These nodes are divided into two main types:

• Control Plane (Master Node): The brain of the cluster.
• Worker Nodes: The workhorses that run your applications.

The Control Plane (often called the Master Node in older docs) is responsible for managing the cluster.

It makes global decisions about the cluster (like scheduling applications) and detects and responds to cluster events (like restarting a failed application). It doesn't run your applications directly.

The API Server is the front-end of the Kubernetes Control Plane. It's the only component that interacts directly with you (via kubectl).

It exposes the Kubernetes API and handles all communications within the cluster, validating and configuring data for API objects like Pods and Services.

etcd is a consistent and highly available key-value store. Think of it as the cluster's permanent memory.

It stores all cluster data, including configuration, state, and metadata. If etcd goes down, your cluster loses its memory and can't function correctly!

The Scheduler watches for newly created Pods (your application instances) that have no assigned worker node.

It then selects the best node for each Pod to run on, considering factors like resource requirements, hardware constraints, and policies.

The Controller Manager runs various controllers, which are background loops that regulate the cluster's state.

For example, a Node Controller monitors node health, and a Replication Controller ensures the correct number of Pods are running. It's always working to match the desired state with the current state.

Worker Nodes (also called Minions in older docs) are the machines where your actual containerized applications (packaged into Pods) run.

Each worker node has components that enable it to communicate with the Control Plane and manage the containers running on it.

On each Worker Node:

• Kubelet: An agent that ensures containers are running in a Pod. It receives instructions from the API Server and manages the Pods.
• Container Runtime: This is the software responsible for running containers (e.g., Docker, containerd, CRI-O). Kubelet uses it to pull images and run your applications.

Kube-proxy runs on each Worker Node and handles network proxying for Kubernetes Services.

It maintains network rules on the node, allowing network communication to your Pods from both inside and outside the cluster. It ensures your applications can be reached.

Based on what you've learned, which of the following components are part of the Kubernetes Control Plane?

Great job! You've now got a foundational understanding of Kubernetes architecture.

• The Control Plane (API Server, etcd, Scheduler, Controller Manager) manages the cluster.
• Worker Nodes (Kubelet, Container Runtime, Kube-proxy) run your applications.

Next, we'll dive into the smallest deployable unit in Kubernetes: Pods!