Kubernetes is an open-source container orchestration platform used to automate the deployment, scaling, and management of containerized applications. It provides a container-centric management environment that automates many of the manual processes involved in deploying and scaling containerized applications. Kubernetes architecture is designed to be scalable, fault-tolerant, and extensible.

The Kubernetes architecture consists of several components that work together to provide a complete container orchestration platform. Here are the main components of the Kubernetes architecture:

kube-apiserver

The API server is a core component of the Kubernetes control plane, which provides a RESTful API for managing the Kubernetes cluster. It exposes a set of REST endpoints that enable clients to interact with the Kubernetes cluster and perform operations such as creating, updating, and deleting resources such as pods, services, and deployments.

The API server is responsible for validating and processing requests, authenticating users, and storing the state of the Kubernetes cluster in etcd. It also provides a mechanism for extending Kubernetes with custom resources and controllers.

Clients can interact with the API server using various tools, such as kubectl, a command-line tool for managing Kubernetes clusters, or the Kubernetes Dashboard, a web-based user interface for managing Kubernetes clusters.

The API server is designed to be highly available and scalable. It can be deployed as a single instance or as a highly available cluster of instances to provide fault tolerance and load balancing. Additionally, it can be secured using TLS encryption and authentication mechanisms such as client certificates and bearer tokens.

Overall, the API server is a critical component of the Kubernetes architecture that provides a central point of control for managing the Kubernetes cluster.

etcd

etcd is a distributed key-value store that is used as a data store by Kubernetes. It is responsible for storing the configuration and state data of the Kubernetes cluster, including cluster topology, resource definitions, and workload status.

The Kubernetes control plane components, such as the API server and controller manager, use etcd to store the current state of the Kubernetes objects, such as pods, services, and deployments. This state is stored as key-value pairs and is updated whenever there is a change to the Kubernetes objects.

etcd is designed to be highly available and fault-tolerant. It uses a leader-based consensus algorithm to ensure that only one node in the cluster is responsible for processing writes. In the event of a failure of the leader node, another node is elected as the new leader. Additionally, etcd can be deployed as a cluster of nodes, which provides redundancy and fault tolerance.

Overall, etcd is a critical component of the Kubernetes architecture that provides a reliable and consistent way to store and access the state of the Kubernetes cluster. It is a fast and scalable key-value store that is essential for the operation of Kubernetes.

kube-scheduler

Kube-scheduler is a component of the Kubernetes control plane that is responsible for scheduling workloads to run on the nodes in the cluster. When a new workload is created or updated, such as a pod or a deployment, the kube-scheduler is responsible for selecting a node on which to run the workload.

The kube-scheduler makes scheduling decisions based on several factors, including the resource requirements of the workload, the quality of service requirements, and any user preferences. It takes into account the available resources on each node, such as CPU, memory, and storage, and tries to distribute workloads evenly across the nodes in the cluster.

The kube-scheduler also supports pluggable scheduling algorithms, which can be used to customize the scheduling behavior based on specific requirements. For example, a scheduling algorithm can be used to ensure that workloads are scheduled on nodes with specific hardware capabilities or to ensure that workloads are spread across availability zones in a cloud provider.

Overall, kube-scheduler is a critical component of the Kubernetes architecture that provides efficient and intelligent scheduling of workloads in the cluster. It helps ensure that workloads are running in the most optimal and efficient way possible.

kube-controller-manager

Kube-controller-manager is a core component of the Kubernetes control plane that runs various controllers that are responsible for maintaining the desired state of the Kubernetes objects. These controllers monitor the state of the Kubernetes objects and take actions to ensure that the actual state matches the desired state.

Some of the controllers that are managed by kube-controller-manager include:

1. Node controller: This controller is responsible for monitoring the state of the nodes in the cluster and taking actions to ensure that the desired number of nodes are running.

2. Replication controller: This controller is responsible for ensuring that the desired number of replicas of a pod or a deployment are running.

3. Endpoint controller: This controller is responsible for updating the endpoints of a service whenever the set of pods backing the service changes.

4. Namespace controller: This controller is responsible for creating and deleting namespaces and ensuring that resources are properly labeled and assigned to the correct namespace.

Kube-controller-manager is designed to be highly available and fault-tolerant. It can be deployed as a single instance or as a highly available cluster of instances to provide fault tolerance and load balancing.

Overall, kube-controller-manager is a critical component of the Kubernetes architecture that provides automated management of the Kubernetes objects and ensures that the desired state of the cluster is maintained.

Node Components

Node components run on every node, maintaining running pods and providing the Kubernetes runtime environment.

kubelet

1. Kubelet is a node-level agent that runs on each node in the Kubernetes cluster. It is responsible for managing the containers on that node and ensuring that they are running as expected. Specifically, the kubelet receives the desired state of the containers from the Kubernetes API server and takes actions to ensure that the actual state of the containers matches the desired state. This includes starting, stopping, and restarting containers as necessary.

Kubelet also monitors the health of the containers and reports any issues to the Kubernetes control plane. It also provides metrics about the containers and the node itself, which can be used for monitoring and debugging.

kube-proxy

1. Kube-proxy is another node-level component that runs on each node in the Kubernetes cluster. It is responsible for managing network communication between containers and services. Specifically, kube-proxy implements the Kubernetes Service abstraction, which provides a consistent IP address and DNS name for a set of pods.

Kube-proxy also provides load balancing for services by distributing traffic among the pods in the service. It can be configured to use various load balancing algorithms, such as round-robin or least connections.

Install Kubernetes

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo install minikube-linux-amd64 /usr/local/bin/minikube

sudo apt-get update

sudo apt-get install \ ca-certificates \ curl \ gnupg

sudo install -m 0755 -d /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
"deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu
"$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" |
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

sudo usermod -aG docker $USER

minikube start --driver=docker