With the growing popularity of containers, the spotlight has landed firmly on Kubernetes as the gold standard for container orchestration. To get a clear understanding of Kubernetes, it’s first imperative to understand containers. Google defines containers as, “...packages of software that contain all of the necessary elements to run in any environment.” Containers virtualize at the OS (Operating System) level, leading to greater workload portability and application isolation. The Aberdeen Strategy and Research (ASR) survey reports that over 50% applications are already using container technology, with 20% organizations using multi-cluster orientation.

Kubernetes, the container management software of choice, was originally developed by Google and released as an open-source platform in 2014. So, let’s take a deep dive into what Kubernetes is and the reasons that make it an indispensable part of digital ecosystems.

Kubernetes: A Definition

Kubernetes, also known as K8s, is an open-source container orchestration platform used to deploy, scale, and manage containerized applications. Kubernetes makes it easy to bundle and distribute application load and performance by automating critical container management tasks with infrastructure abstraction and real-time service health monitoring. In other words, it enables delivery of a highly productive platform as a service (PaaS) to streamline cloud-native application development processes. As a result, it frees up development teams to focus more on coding and innovation instead of infrastructure and operations-related tasks.

In a traditional IT infrastructure setup, applications run on physical servers leading to issues with scalability and resource utilization if you're running multiple applications on a single server. The introduction of virtual machines (VMs) solved this problem to an extent by allowing server abstraction from a single physical server. As a result, you could run multiple VMs with their own OS instances on a single physical server. Allocate individual applications to their own VMs and you've solved problems related to scalability and resource usage.

Containers take this concept of infrastructure abstraction one step further. They share the virtualized hardware and also share a virtualized OS kernel, allowing you to run more applications on fewer machines and OS instances. Consequently, containers are more lightweight, portable and have better resource utilization than VMs.

Every application consists of clusters of containers. The containers ensure the application is compatible with various platforms by managing all dependencies. According to a survey by Statista, 61% of responds are using Kubernetes architecture, making it the orchestration platform of choice for scheduling and automating container-related tasks.

In other words, it provides built-in commands to automate day-to-day tasks and health checks so the developers can focus on the application instead of worrying about computing, networking and storage-related tasks.

What are Kubernetes Clusters?

A Kubernetes cluster is a set of one or more and a control plane, designed to run containerized applications optimally. The control plane is responsible for the worker nodes and pods in the cluster, who in turn run the applications and the workloads.

The Kubernetes cluster is an integral component of what makes the platform special; they can manage and schedule containers across multiple machines and production environments, both physical and virtual, with high fault tolerance and availability.

Business Impact Analysis of the Benefits of Kubernetes

Below are some of the benefits of using Kubernetes:

1. Container orchestration cost savings

In today’s business climate, most companies need a microservices architecture, irrespective of size and scale. The Kubernetes platform, with built-in commands for managing and automating container-related operations, provides a unique solution to help businesses save on their resources and process management costs. It automatically provisions and fits containers into nodes for the best use of resources.

Kubernetes’s container orchestration makes for a more efficient workflow with less need to repeat the same processes, which means not only fewer servers but also less need for clunky, inefficient administration. Because Kubernetes clusters are configured applications that can run with minimal downtime, they need less support when a node or pod fails.

2. Improved DevOps productivity

Kubernetes architecture leverages container integration and multicloud storage to make development, testing and deployment simpler. Creating container images with everything an application needs to run, is easier and more efficient than creating virtual machine (VM) images. This leads to faster development and optimized release and deployment times.

3. Deploying workloads in multicloud environments

We can deploy an application on a virtual machine and redirect it to point to a domain name system (DNS) server to it. Kubernetes clusters allow the simple and accelerated migration of containerized applications from on-premises infrastructure to hybrid deployments across any cloud provider’s public cloud or private cloud infrastructure without compromising on functionality or performance.

This helps migrate workloads to a closed or exclusive system without vendor lock-in. One of the use cases is where IBM Cloud, Amazon Web Services (AWS), Google Cloud Platform and Microsoft Azure, all offer effortless integrations with Kubernetes-based applications.

4. More flexibility with less chance of vendor lock-in

Kubernetes containers provide our applications with a lightweight and agile way to handle virtualization as compared to virtual machines (VMs).

Because containers contain only the resources an application needs (i.e., its code, installations and dependencies), and use the features and resources of the host operating system (OS), they are smaller, faster and more portable.

For example, hosting four applications on four virtual machines would generally require four copies of a guest OS to run on that server. A Kubernetes architecture will allow you to run those four apps in a container approach, which means containing all of them within a single container where they will share one version of the host OS.

5. Automation of deployment and scalability

Generally, Kubernetes has a feature of auto scaling, where it allows the teams to scale up or down to meet the requirements of a particular project.

During an online event launch, there’s a rapid increase in requests. Autoscaling sets up new containers when needed to deal with high load of traffic/requests or spikes due to CPU usage and memory thresholds or custom metrics. When the requirement is completed, Kubernetes scales down resources automatically to reduce waste. As a result, the platform scales infrastructure resource utilization up and down as needed, allowing for easy scaling horizontally and vertically.

6. Application stability and availability

In a cloud environment, Kubernetes allows you to run your containerized applications accurately. It automatically places and balances containerized workloads and scales clusters appropriately to accommodate increasing demand and keep the system live. If one node in a multi-node cluster fails, the workload is redistributed to others without disrupting availability to users. It has the capacity to self-heal and will restart, reschedule or replace a container when it fails or when nodes die.

Kubernetes architecture allows you to do rolling updates to your software without downtime. Even high-availability apps can be set up in Kubernetes on one or more public cloud services in a way that supports a remarkably high uptime. One use case of note is Amazon, which used Kubernetes to transition from a monolithic to a microservices architecture.

7. Kubernetes has power to rollback

During a live application deployment, when something has gone wrong, Kubernetes has the power to rollback an application change and make it stable without causing any outage to the frontend website or application.


1. How do I build a high availability (ha) cluster in Kubernetes?

A high availability (ha) cluster consists of an etcd cluster of 3 or more nodes and multiple master nodes for cluster management. As an open-source, distributed, key-value store, etcd holds and manages the critical information needed by distribution systems and clusters of machines, which is the sole stateful part of a Kubernetes cluster.

There are two approaches to creating a HA cluster in Kubernetes. You can either use stacked control plane nodes where the control plane nodes are co-located with the etcd components, or an external etcd cluster where the etcd members and control plane nodes exist separately.

If you choose to go with the stacked control plane node approach, the steps are as below:

  • Create reliable nodes with a process watcher like kubelet for HA master implementation.
  • Leverage clustered etcd to set up a reliable and redundant data storage layer for data protection
  • Set up replicated Kubernetes API servers with a network load balancer.
  • Set up replicated instances of the controller manager and scheduler with a lease-lock in the API for master selection.

2. Pods vs nodes in Kubernetes

Pods are the smallest units of executable code in the Kubernetes object model while nodes are the virtual machines (VMs) that collectively form the Kubernetes cluster. Inside a cluster, a node is the worker machine that runs the pods, which in turn, holds one or more containers to enable easy sharing of storage and network resources.

The control plane manages the state of the Kubernetes cluster using a set of components including the API server, etcd, and the controller manager and scheduler.

3. What is the right time to migrate to Kubernetes?

Migrating to Kubernetes comes with a steep learning curve and we recommend that most organizations consider this if they have budgetary constraints and no in-house technical expertise necessary to attempt a migration to Kubernetes. Just because it is good technology, doesn’t mean it’s the best solution for your specific use case.

In general, if your organization has completed the cloud migration process successfully, and your workforce has had enough exposure to developing and deploying cloud-native services and containerized applications, then it’s a good time to consider migration to Kubernetes.

4. How do I access the Kubernetes API from within a pod?

You can use the official client libraries to locate and authenticate access from within a pod to the Kubernetes API. However, before you attempt access, please ensure you have a Kubernetes cluster with the kubectl command-line tool configured to communicate with the cluster.

5. What monitoring and metrics tools do people use for Kubernetes?

There are multiple open-source tools you can use to monitor and measure performance metrics for Kubernetes.

Some of the popular options are:

Dynatrace: Dynatrace is a full-stack monitoring solution that specializes in deep cloud observability, real user and synesthetic monitoring, log analysis and runtime application security. It combines a user-friendly UI with dedicated problem-solving capabilities to provide a robust monitoring interface.

Prometheus: It’s an open-source monitoring tool for Kubernetes that’s also part of the Cloud Native Computing Foundation (CNCF). It has a multi-dimensional data model, a proprietary querying language called PromQL, built-in alerting mechanisms and a pull vs. push model.

Grafana: It comes with data visualization dashboards, authentication and authorization, alerts, filtering, source-specific querying and more.

The ELK Stack: ELK, an acronym for Elasticsearch, Logstash and Kibana, is another popular open-source monitoring tool capable of performing rich data analysis. It’s capable of storing and searching millions of documents, resulting in comprehensive logging capabilities.

cAdvisor: cAdvisor is built into Kubernetes and is used to record, analyze and expose resource utilization and performance metrics for running containers.

kubewatch: It watches for change in events in specific Kubernetes resources like replication controllers, configuration maps, pods and deployments and reports the events to specific endpoints.

About the author


Rafiya Begum

Senior Software Engineer

Rafiya is a Senior Software Engineer at THIS with a focus on cloud computing, Kubernetes, DevOps , AWS, and Python. She has been with THIS for 7+ years and is currently working as project lead on microservice deployment with Kubernetes clusters.