What is Kubernetes Architecture?
Kubernetes architecture consists of various components that help users with service discovery. It enables the development, deployment, scaling, and management of containerized applications across multiple nodes and clusters.
The various components are structured in such a way that the complete design is analogous to everything the k8 infrastructure aims to accomplish with the applications it hosts on its clusters. These include efficiency, elimination of redundancy, fault tolerance, and more.
Components of Kubernetes Architecture
The architecture is broadly made up of three Kubernetes components with multiple sub-components and add-ons. The primary k8 components are:
- Kubernetes Cluster: The cluster is the overarching component that comprises the other crucial components which help in the aforementioned k8 operations.
- Kubernetes Control Plane: This plane connects to all other resources in a k8 cluster. It acts as the administrative tool or the dashboard from where an application be containerized across multiple nodes and pods, and resources for its various operations can be assigned.
- Kubernetes Nodes: The nodes are either physical or virtual machines that offer a runtime environment for the Kube infrastructure and host the actual containerized applications. The nodes consist of the pods, which are orchestrated and scheduled to run the operations for the application.
Components of Control Plane
- kube-apiserver: The API Server is the control plane's front end which handles internal and external requests of the application. It acts as a gateway for the clients to access the various Kubernetes resources such as pods, services, and nodes. The primary operation for this is to manage the end-to-end operations and scale horizontally by deploying more instances and load balancing.
- etcd: The etcd is a repository which is a key-value store. It stores the clusters' data, which signifies the cluster’s state and configuration. In a way, it acts as a single source of truth that retrieves and shares different data about parameters as and when requested.
- kube-scheduler: The primary function of this sub-component is to maintain the cluster’s health at all times by monitoring the various pods and seeing if any new resource is required. It determines if a new container must be deployed and where it should be deployed. These decisions are based on multiple factors, including resource limitations, affinity specs, policies, timelines, and more.
- kube-controller-manager: The controller is responsible for matching the current state of the different resources and their desired state. There are different kinds of controllers for nodes, jobs, namespaces, endpoints, and more. However, these are all compiled into a single binary and run.
- cloud-controller-manager: This is only used when an application is run on a cloud-based Kubernetes infrastructure. It helps in coupling and decoupling the Kubernetes cluster with different components that interact with the cloud provider. It has various control loops combined into a single binary process that can be scaled horizontally. The controllers that possess cloud provider dependencies include node controller, service controller, and route controller.
Components of Nodes
- kubelet: The kubelet is responsible for the running of containers in pods. Every node communicates with the control plane with this kubelet which takes the specifications of the pods from the control plane through the API server and deploys them. Once this is done, kubelet ensures the pods run in a healthy manner.
- kube-proxy: This is a proxy service within the node that runs networking services. It is responsible for traffic routing for all external and internal requests based on the network rules it maintains. It either forwards the traffic by itself or uses the packet filtering layer in the operating system.
- Container runtime: This is the runtime environment that the nodes provide for the containers and helps run the applications.
Add-Ons and Other Components
Besides these, numerous other add-ons provide diverse features to the applications, including the DNS, Web UI, cluster-level logging, and resource monitoring. They offer functionalities such as recording DNS servers of the k8 clusters, managing cluster applications, monitoring and storing data metrics and their values, and even periodically saving cluster logs.
Overall, this is the complete Kubernetes architecture and its various components that facilitate the efficient functioning of containerized applications. It has numerous benefits, which include the following:
- The architecture itself possesses the traits that the containerized applications it hosts possess.
- With the architecture, balancing the application load on the Kubernetes clusters becomes simple.
- All requests are handled in a timely and cost-efficient manner.
- The incoming traffic is monitored at all times, which helps prevent any fraudulent activities.
- The architecture is such that any application can be scaled with relative ease.
- The container orchestration process is designed to help one deploy applications across different environments without redesigning them.
- This architecture automates all the manual tasks, such as resource development, backing up data, and others.
Thus, these are the main benefits of leveraging the Kubernetes architecture.