What is Kuber­netes and how does it work?

Kuber­netes is an open-source platform for automated de­ploy­ment, scaling, and man­age­ment of con­tain­er­ised ap­plic­a­tions. It organises con­tain­ers into clusters and ensures services run reliably and ef­fi­ciently. With features like load balancing, self-healing, and rollouts, Kuber­netes sig­ni­fic­antly sim­pli­fies the operation of modern ap­plic­a­tions.

What is Kuber­netes?

Kuber­netes (K8s) is an open-source system for container or­ches­tra­tion, ori­gin­ally developed by Google and now main­tained by the Cloud Native Computing Found­a­tion (CNCF). It manages container ap­plic­a­tions in dis­trib­uted en­vir­on­ments by auto­mat­ic­ally starting, scaling, mon­it­or­ing, and replacing con­tain­ers as needed.

The ar­chi­tec­ture written in the Go pro­gram­ming language is based on a master node and multiple worker nodes, with various com­pon­ents like the scheduler re­spons­ible for central man­age­ment tasks. With de­clar­at­ive con­fig­ur­a­tions (such as YAML files), the desired system state is specified, and Kuber­netes con­tinu­ously works to maintain it. The tool is aimed at use both in the cloud and on local computers or in on-premises data centres.

How does Kuber­netes work?

Kuber­netes is a container or­ches­tra­tion system. This means that the software is not meant to create con­tain­ers but to manage them. Kuber­netes relies on process auto­ma­tion for this purpose. This makes it easier for de­velopers to test, maintain, or release ap­plic­a­tions. The Kuber­netes ar­chi­tec­ture consists of a clear hierarchy:

• Container: A container holds ap­plic­a­tions and software en­vir­on­ments.
• Pod: This unit in the Kuber­netes ar­chi­tec­ture gathers con­tain­ers that must col­lab­or­ate for an ap­plic­a­tion.
• Node: One or more Kuber­netes Pods run on a node, which can be either a virtual or a physical machine.
• Cluster: Multiple nodes are combined into a Kuber­netes Cluster.

Ad­di­tion­ally, the Kuber­netes ar­chi­tec­ture is based on the principle of master and worker nodes. The described nodes serve as worker nodes, which are the con­trolled parts of the system. They are under the man­age­ment and control of the Kuber­netes master.

A master’s tasks include, for example, dis­trib­ut­ing pods across nodes. Through con­tinu­ous mon­it­or­ing, the master can also intervene if a node fails and directly duplicate it to com­pensate for the failure. The current state is always compared with the desired state and adjusted if necessary. These op­er­a­tions occur auto­mat­ic­ally. However, the master also serves as the access point for ad­min­is­trat­ors, who can or­ches­trate con­tain­ers through it.

Kuber­netes Node

The worker node is a physical or virtual server where one or more con­tain­ers are active. A runtime en­vir­on­ment for the con­tain­ers is located on the node. Ad­di­tion­ally, the so-called Kubelet is active. This is a component that enables com­mu­nic­a­tion with the master. The component also starts and stops con­tain­ers. With cAdvisor, the Kubelet has a service that records resource usage, which is useful for analyses. Finally, there is the Kube-proxy, which the system uses to perform load balancing and to enable network con­nec­tions via TCP or other protocols.

Kuber­netes Master

The master is also a server. To ensure control and mon­it­or­ing of the nodes, the Con­trol­ler Manager runs on the master. This component, in turn, combines several processes:

• The Node Con­trol­ler monitors the nodes and responds if one fails.
• The Rep­lic­a­tion Con­trol­ler ensures that the desired number of pods is always running sim­ul­tan­eously. In modern setups, it is largely replaced by Rep­lica­Se­ts, which are generally managed by de­ploy­ments.
• The Endpoints Con­trol­ler manages the endpoint object re­spons­ible for con­nect­ing services and pods.
• Service Account and Token Con­trol­ler manage the namespace and create API access tokens.

Alongside the Con­trol­ler Manager runs a database called etcd. This key-value database stores the con­fig­ur­a­tion of the cluster for which the master is re­spons­ible. With the Scheduler component, the master can automate the dis­tri­bu­tion of pods across nodes. The con­nec­tion to the node works through the API server in­teg­rated into the master. This provides a REST interface and exchanges in­form­a­tion with the cluster via JSON. For example, this allows the various con­trol­lers to access the nodes.

Are Kuber­netes and Docker com­pet­it­ors?

The question of which tool performs better in the Kuber­netes vs Docker com­par­is­on doesn’t really come up, since the two are typically used together. Docker (or another container platform like rkt) is re­spons­ible for building and running con­tain­ers—even when Kuber­netes is in use. Kuber­netes then accesses these con­tain­ers and manages or­ches­tra­tion and process auto­ma­tion. On its own, Kuber­netes cannot create con­tain­ers.

At most, the real com­pet­i­tion exists with Docker Swarm. This tool is designed for Docker or­ches­tra­tion and, like Kuber­netes, it works with clusters and provides similar func­tion­al­ity.

What are the ad­vant­ages of Kuber­netes?

Kuber­netes impresses with a multitude of ad­vant­ages that enhance scalab­il­ity, op­er­a­tion­al re­li­ab­il­ity, and ef­fi­ciency.

✓ Automated scaling: To save costs, Kuber­netes can perfectly utilise resources. Instead of keeping currently un­ne­ces­sary machines running, Kuber­netes can release these resources and either use them for other tasks or not use them at all—which can save costs.

✓ High fault tolerance: Through rep­lic­a­tion and automatic recovery, Kuber­netes ensures that ap­plic­a­tions continue to run even in the event of errors or failures of in­di­vidu­al com­pon­ents.

✓ Resource-efficient or­ches­tra­tion: Pods and con­tain­ers are in­tel­li­gently dis­trib­uted across the available nodes, op­tim­ising the use of computing power.

✓ Easy rollout and rollback: New versions of ap­plic­a­tions can be rolled out with minimal effort. If necessary, a quick rollback to previous versions is also possible.

✓ Platform in­de­pend­ence: Kuber­netes runs on local servers, in the cloud, or in a Hybrid Cloud; workloads remain portable.

✓ Service discovery and load balancing: Kuber­netes auto­mat­ic­ally detects services within the cluster and evenly dis­trib­utes traffic without the need for external load balancers.

✓ Efficient man­age­ment through APIs: A central API allows all cluster com­pon­ents to be managed and automated, even con­trolled by external tools and CI/CD pipelines.

What is Kuber­netes suitable for?

Kuber­netes is par­tic­u­larly well-suited for running ap­plic­a­tions in con­tain­ers when a scalable and highly available in­fra­struc­ture is required. Common use cases include:

• Mi­croservice ar­chi­tec­tures: In practice, K8s is often used to operate mi­croservice ar­chi­tec­tures, where many small services are developed, tested, and updated in­de­pend­ently. Companies rely on Kuber­netes to automate both de­vel­op­ment and pro­duc­tion en­vir­on­ments and to respond quickly to new re­quire­ments.
• CI/CD: Kuber­netes is fre­quently applied in con­tinu­ous in­teg­ra­tion and con­tinu­ous de­ploy­ment pipelines, enabling automated de­ploy­ments and reliable version man­age­ment.
• Multi- and hybrid-cloud: In multi-cloud or hybrid-cloud strategies, Kuber­netes allows workloads to be deployed in­de­pend­ently of the un­der­ly­ing platform and moved flexibly between providers or data centres.
• Big data and machine learning: Kuber­netes is also valuable for big data and machine learning workloads that require many short-lived con­tain­ers to run in parallel.
• Large platforms: For platforms with a high number of users, Kuber­netes is in­dis­pens­able to auto­mat­ic­ally manage traffic spikes and maintain re­li­ab­il­ity.