What is Kubernetes?

The success of your business today relies to an ever increasing extent on the applications that are running on your IT infrastructure. Like the finest symphony ever created to delight and engage its audience requires an excellent conductor to evoke the best from every member of the orchestra, the most dynamic enterprises recognize the value of Kubernetes to manage not only today’s containerized applications, the soloists featured in the performance and lifeblood of a company’s value and reputation, but all of the musicians which represent the diverse, supporting infrastructure. Kubernetes is a highly sophisticated tool to orchestrate all of your applications, with automated deployment and control whether you’re using public clouds, on-prem or edge infrastructures, as well as any combination of these. It is the distribution manager for workloads in a cluster, automatically adjusting the dynamic networking requirements for all containers. Often referred to as “k8s”, Kubernetes also manages the allocation of storage and persistent volumes, and automates scaling to provide maximum reliability and availability.

See More

What are Kubernetes Clusters?

Kubernetes clusters are basically a group of nodes that run applications that have been containerized, and include whatever services and dependencies that app requires. With Kubernetes clusters, containerized applications can be managed across any virtual, physical, cloud-based or on-premises environment or combination thereof. 

A Kubernetes cluster has what’s called a master node and worker nodes, all of which are either virtual or physical machines.

The master node serves as the control plane of the cluster, constantly managing the actual state of the cluster to its defined, desired state. The master node coordinates all tasks including the scheduling and scaling of applications, executing updates, and automatically maintaining  the desired state of the cluster.

The worker nodes host the components that are necessary for deploying and running the containerized application. They’re called worker nodes because they execute the tasks assigned to them by the master node. 

A functional Kubernetes cluster has at least one master and one worker node.  

In addition, users can deploy so-called namespaces to arrange multiple clusters in a single physical cluster. Namespaces are Kubernetes objects that separate Kubernetes clusters into multiple virtual ones, which allows users to allocate resource quotas to specific teams or projects.

See More

What are Kubernetes’ Key Benefits?

Kubernetes is an open source platform that manages containers so that applications are available 24/7 and new versions can be deployed anytime without downtime, running wherever and whenever you want with the resources and tools that are required to get the job done.

Its many features include:

Flexible, Automatic Scaling

Via the user interface command or automatically, based on CPU usage for the best use of existing resources.

Availability/Self Healing

Containers are automatically restarted when they fail and disabled when not compliant to existing health checks. Non-functioning nodes are automatically replaced and rescheduled to provide maximum resiliency.

Storage Orchestration

Kubernetes allows you to add the storage system of your choice automatically including local storage, public cloud providers, and many others.

Service Discovery & Load Balancing

Service discovery is essential if you run a microservice architecture. Kubernetes assigns each pod an IP address and each set of pods a DNS name, so that you can easily discover your services. If a container has too much traffic, Kubernetes can load balance and provide you with superior stability.

Who Develops Kubernetes?

Originally developed and designed by engineers at Google, Kubernetes has evolved into the most popular container management system, thanks to its truly open source platform. This has also resulted in significant, ongoing contributions from the open source community and the Cloud Native Computing Foundation, which currently maintains the project.

Introduction to Kubernetes Architecture

A Kubernetes Cluster has:

  • a control plane, referred to as the master node,
  • one or more worker nodes that run containerized applications.  

The Master Node is at the center of the K8s cluster, manages it and provides access to the API. It contains the cloud-controller-manager, etcd, the kube-controller-manager, the kube-api server, and the kube-scheduler.

Control Plane / Master Cluster Components


The cloud-controller-manager controls the cloud-specific logic. It connects your clusters with your cloud provider’s API and makes sure that the right components interact with the underlying cloud infrastructure.  


The backing store for all cluster data is etcd, a key value store that also replicates the state of the Kubernetes cluster. Once you have created a Kubernetes cluster and configured the command-line tool to communicate with it, you can run etcd; just take the extra step and create a backup plan for that data.


This component is part of the control plane that manages controller processes. Controllers are organized into a single binary, so that they run in one simple process, although strictly speaking, each is in fact its own separate and distinct process.

Controllers within this manager include:

  • Node controller: controls the activities of the nodes
  • Endpoints controller: ties together services and pods by populating Endpoints objects
  • Job controller: monitors one-off tasks and generates pods to complete them
  • Replication controller: maintains object replications in the cluster
  • Service Account & Token controllers: provision default accounts and provide API access tokens when a namespace is created


The Kube-apiserver exposes the Kubernetes API. It scales horizontally by creating additional instances, and if you have several instances, the traffic can be managed between them. 


Any Pod that has been created without an assigned node is detected by Kube-scheduler, which then determines and selects one for that Pod.

This decision is made based on several criteria, including workload and policy limitations, deadlines, as well as the resources required.


A node is either a physical or a virtual machine that holds and has the components required to run pods and is managed by the control plane. There are two distinct types of nodes in Kubernetes, Master and Worker.

Master nodes support the control plane elements of a cluster, manage worker nodes and are responsible for API endpoints for users and scheduling for pods across available resources. Workload distribution and the state of the cluster is managed by the master node.

Worker nodes are used to run containers and perform tasks assigned by the Master node. They process the stored data and communicate with the master about resources.


The kubelet is a node component that oversees the operation of all cycles of each node within every pod. It looks after the health of each pod by checking new or altered specs created by the master nodes and makes sure that its state corresponds/agrees with its specifications.


Each node runs Kube-proxy, which is a network proxy that keeps track of the rules that allow for communication sessions to Pods inside or outside of a cluster. It is used for load balancing and to reach Kubernetes services.

How Does Kubernetes Work?

Kubernetes is an open source system that manages containers to accelerate the deployment, scaling and administration of applications. It creates a set of components that provide these activities based on either memory, CPU or specially designed measurements. All elements that form a part of or run on Kubernetes are tied into the Kubernetes API. The platform controls compute and storage resources by classifying and managing them as objects. 

A fundamental concept at the heart of Kubernetes is its ability to constantly attempt to match the state in which your containers are actually running with your desired state. This approach, based on declaring your desired state and Kubernetes’ capability to continually monitor and correct for it, is why it‘s so popular with DevOps for application lifecycle management.