Day 30: Kubernetes Architecture

Kubernetes Overview

What is Kubernetes and why is it called k8s?

Kubernetes is an open-source platform for managing containerized workloads and services. Think of it as a container orchestration engine that automates the deployment, scaling, and management of applications. It's like a central control system for all your Docker containers, ensuring they run smoothly and efficiently. We call it k8s as a numeronym, which is a shorthand for a long word. In this case, it represents the eight letters between "K" and "s" in "Kubernetes."

Benefits of Using Kubernetes

• Portability: Kubernetes can run on various environments, including public clouds (like AWS, Azure), private clouds, and on-premise servers.
• Scalability: It can automatically scale your application up or down based on traffic and resource needs, ensuring performance during peak loads.
• Self-Healing: Kubernetes can automatically restart failed containers, replace dead ones, and kill containers that don't respond to health checks.
• Load Balancing: It distributes traffic across multiple instances of your application, preventing any single instance from becoming a bottleneck.
• Service Discovery: It automatically assigns unique DNS names to containers and services, making it easy for different parts of your application to find each other.

Kubernetes Architecture

The Kubernetes architecture is divided into two main parts: the Control Plane and the Worker Nodes.

• Control Plane: The control plane is the brain of the cluster. It's responsible for managing the state of the cluster, making decisions, and responding to events. It ensures the desired state (e.g., "I need three copies of my web application running") matches the actual state of the cluster.
• Worker Nodes: These are the machines (VMs or physical servers) that run your containerized applications. Each worker node has a Kubelet that communicates with the control plane and runs the containers.

What is the Control Plane?

The Control Plane is a collection of components that manages the state of the Kubernetes cluster. It is composed of several key parts:

• API Server: The central communication hub for the cluster.
• etcd: A highly available key-value store that holds the entire cluster state and configuration data.
• Scheduler: Monitors newly created Pods and assigns them to a worker node based on resource requirements and other constraints.
• Controller Manager: Runs a set of controllers that regulate the cluster's state, such as ensuring the correct number of replicas are running for a deployment.
• Cloud Controller Manager: Integrates with underlying cloud provider APIs (e.g., AWS, GCP) to manage resources like load balancers and storage volumes.

kubectl vs. Kubelets

Feature	kubectl	kubelet
Role	Command-line tool for users to interact with the Kubernetes API Server.	Agent that runs on each worker node and communicates with the control plane.
Function	Used to deploy applications, inspect cluster resources, and manage cluster state from a user's machine.	Ensures that containers are running in a Pod and are healthy, as instructed by the API Server.
Location	Run by developers and operators on their local machine or a jump box.	Runs on every worker node in the cluster.

The Role of the API Server

The API Server is the central component of the Kubernetes control plane. It's the front end for the entire cluster and the only component that directly communicates with the etcd store. Its primary roles include:

• Exposing the Kubernetes API: It exposes the RESTful API that all other components, including kubectl, kubelet, and other services, use to communicate with the cluster.
• Authentication and Authorization: It validates and processes requests, ensuring that users and other components are authorized to perform actions.
• Gateway to etcd: It's the only component that can directly read from and write to the etcd database, acting as a gatekeeper for the cluster's state. All changes to the cluster's desired state are sent to the API Server.