Architecture et composants de Kubernetes

Welcome! In this lesson, we'll dive into the core architecture of a Kubernetes cluster. Understanding how Kubernetes is put together is key to effectively deploying and managing your applications.

It helps you grasp how K8s manages applications and troubleshoot issues when they arise.

At a high level, a Kubernetes cluster consists of two main types of nodes:

• Master Node(s): These are the 'brains' that manage the entire cluster.
• Worker Node(s): These are where your actual applications (containers) run.

Together, they form a robust system for orchestrating your workloads.

The Master node hosts what's known as the Control Plane. These components make global decisions about the cluster, like scheduling, and detect and respond to cluster events.

Key components of the Control Plane include:

• Kube-APIServer
• etcd
• Kube-Scheduler
• Kube-Controller-Manager

The Kube-APIServer is the front-end for the Kubernetes control plane. It's the central hub for all communication.

• It exposes the Kubernetes API.
• All communication between internal cluster components and external users (like you!) goes through it.
• Think of it as the main gateway to interact with your cluster.

etcd is a consistent and highly available key-value store. It's the persistent storage for all cluster data.

• It stores all cluster configurations, desired state, and metadata.
• It's critical for the cluster's operation.
• You can think of it as the cluster's long-term memory.

The Kube-Scheduler watches for newly created Pods that don't have an assigned node yet.

• It selects the best available node for each Pod to run on.
• Factors like resource requirements (CPU/memory), hardware constraints, and policy constraints are all considered during this decision.

The Kube-Controller-Manager runs various controller processes that monitor the cluster's state.

• Controllers continuously monitor the cluster's actual state.
• They work to move the current state towards the desired state you've defined.
• Examples include the Node Controller, Replication Controller, and Endpoint Controller.

Worker nodes are where your applications run. Each worker node contains the following key components:

• Kubelet: An agent that ensures containers are running in a Pod.
• Kube-proxy: Maintains network rules on nodes, enabling network communication to your Pods.
• Container Runtime: Software like Docker or containerd that executes containers.

A Pod is the smallest deployable unit in Kubernetes. It's the fundamental building block for your applications.

• A Pod represents a single instance of a running process in your cluster.
• Pods can contain one or more containers (e.g., your app and a helper sidecar container).
• All containers within a Pod share the same network namespace and storage.

We've explored the fundamental architecture of a Kubernetes cluster:

• The Master Node hosts the Control Plane (API Server, etcd, Scheduler, Controller Manager) to manage the cluster.
• Worker Nodes run your applications, managed by Kubelet and Kube-proxy.
• Pods are the smallest deployable units, encapsulating one or more containers.

Understanding these components is key to deploying and managing applications effectively. Next, we'll learn how to deploy your first Pod!