Technology

What is Kubernetes (K8s): A Comprehensive Guide

venkatesh varikuti

• 10 min read
What is Kubernetes (K8s)

Kubernetes, often called K8s, is a powerful tool that helps manage and organize applications that run in containers. To understand what is Kubernetes in simple terms, think of containers as small, lightweight packages that contain everything an application needs to run, such as code, libraries, and dependencies.

Kubernetes ensures that these containers run smoothly and efficiently, especially when the application grows or needs to handle more users.

Why is Kubernetes so useful?

Understanding what is Kubernetes and its benefits is crucial for modern application development. Here's why it's so useful:

1. Automates Deployment

Kubernetes takes care of launching your application containers across multiple servers. You just need to tell Kubernetes how many copies of your application you want running, and it handles the rest. This ensures your app is always ready to serve users.

2. Handles Scaling Easily

As your application gets more users, Kubernetes can automatically add more containers to keep up with the demand. Similarly, when the demand decreases, Kubernetes reduces the number of containers, saving resources and costs.

3. Self-Healing Capabilities

If something goes wrong with one of your containers, Kubernetes detects the problem and replaces it with a new, healthy container. This helps keep your application running without interruptions.

4. Rollbacks Made Simple

When you update your application, Kubernetes can manage the process step by step. If the new update causes an issue, Kubernetes can quickly roll back to the previous version, ensuring minimal downtime or disruption.

5. Manages Storage Efficiently

Kubernetes allows your application to access storage easily, whether it’s on the cloud, a local server, or a network. This flexibility makes it possible to store data in the most convenient location for your needs.

6. Simplifies Networking

Kubernetes helps manage how different parts of your application communicate with each other and with users. It provides tools to handle tasks like routing traffic, balancing loads, and ensuring secure connections.

7. Adaptable to Any Environment

You can use Kubernetes in almost any setup whether it’s on your own servers, in the cloud, or a mix of both. This makes it suitable for companies of all sizes and industries.

8. Large Ecosystem of Tools

Kubernetes is supported by a huge community of developers who have built additional tools to make it even more useful. These tools can help with things like monitoring, logging, and security, making Kubernetes a great choice for running complex, real-world applications.

Kubernetes is widely used because it simplifies the work of deploying and managing modern applications. Whether you’re a small startup or a large enterprise, Kubernetes helps ensure your applications are reliable, scalable, and ready to handle any challenges.

Now that we understand why Kubernetes is valuable, let's explore how its architecture enables these capabilities.

The Architecture of Kubernetes

Kubernetes follows a master-worker architecture where the control plane manages the cluster and the worker nodes run the application workloads.

The Key Components of Kubernetes Architecture

  1. Cluster: A Kubernetes cluster consists of one or more nodes that work together to run containerized applications.
  2. Nodes: Nodes are the physical or virtual machines that run the workloads. There are two types of nodes:
    • Control Plane: Manages the cluster and handles scheduling, scaling, and updates.
    • Worker Nodes: Run the containerized applications (Pods).
  3. Control Plane: The control plane manages the Kubernetes cluster, including scheduling, scaling, and maintaining the desired state of the applications.
Source

Within this architecture, the most fundamental unit of deployment is the Pod. Let's understand what Pods are and how they work.

What is a Pod In Kubernetes?

A Pod is the smallest and simplest deployable unit in Kubernetes. It represents a single instance of a running application within the cluster. A Pod can contain one or more tightly coupled containers that share resources, such as networking and storage. Pods act as a logical host for the application and ensure that the containers within them work together seamlessly.

The Key Features of Pods 

1. Shared Network

All containers within a Pod share the same network namespace, including the Pod’s IP address and port space. This allows containers in the same Pod to communicate with each other directly using localhost and specific ports. However, communication with containers outside the Pod requires the use of a Service or Ingress.

2. Shared Storage

Pods can include shared storage volumes, which are accessible to all containers within the Pod. These volumes allow containers to share data and maintain state between them. For example, one container might write log files to a shared volume, while another container reads and processes those logs.

3. Ephemeral Nature

Pods are inherently ephemeral and designed to be disposable. If a Pod fails, Kubernetes replaces it with a new one to maintain the desired state of the application. This ephemeral nature ensures high availability and resilience but requires applications to be designed with statelessness or external state persistence in mind.

4. Single Unit of Deployment

A Pod is treated as a single unit when deployed, scaled, or managed. Even if a Pod contains multiple containers, they are deployed and operated together as a cohesive unit.

5. Support for Sidecar Containers

Pods can include helper containers, commonly known as sidecar containers, which enhance the functionality of the primary container. For instance, a sidecar might handle logging, monitoring, or proxying traffic to the main application container.

What are the Practical Uses of Pods?

While individual Pods can be deployed manually, Kubernetes usually manages Pods indirectly through higher-level abstractions like Deployments, StatefulSets, and DaemonSets. These abstractions ensure that Pods are automatically recreated or scaled based on defined policies, minimizing manual intervention.

By encapsulating an application’s containers within a Pod, Kubernetes simplifies application management and ensures seamless operation, even in dynamic and distributed environments.

Types of Services in Kubernetes

A Service is an abstraction that provides a stable network endpoint for accessing a set of Pods. Services enable communication between different components of an application.

  1. ClusterIP (Default): Exposes the Service on a cluster-internal IP address. It is accessible only within the cluster.
  2. NodePort: Exposes the Service on a static port on each node’s IP address, making it accessible from outside the cluster.
  3. LoadBalancer: Creates an external load balancer and assigns a fixed, external IP to the Service.
  4. ExternalName: Maps a Service to an external DNS name.

While Services handle networking, Controllers manage the operational aspects of your applications.

Controllers in Kubernetes

Controllers are responsible for maintaining the desired state of your cluster by monitoring the current state and making adjustments as needed.

Common Controllers in Kubernetes

  1. ReplicaSet: Ensures that a specified number of identical Pods are running at any given time.
  2. Deployment: Manages ReplicaSets and provides declarative updates for Pods.
  3. StatefulSet: Manages stateful applications that require persistent storage and unique network identifiers.
  4. DaemonSet: Ensures that a copy of a Pod runs on all (or specified) nodes in the cluster.
  5. Job: Creates one or more Pods to perform a task and then stops.
  6. CronJob: Schedules Jobs to run at specific times or intervals.

Networking in Kubernetes

Kubernetes networking enables communication between Pods, Services, and external users.

Key Networking Concepts

  1. Pod-to-Pod Communication: Kubernetes provides a flat network structure that allows Pods to communicate with each other.
  2. Pod-to-Service Communication: Services provide a stable endpoint for accessing Pods.
  3. External Communication: Kubernetes uses Ingress and LoadBalancer Services to expose applications to the outside world.

ClusterIP

  • The default Service type.
  • Provides an internal IP address for communication within the cluster.

NodePort

  • Exposes a Service on a static port on each node.
  • Accessible from outside the cluster.

LoadBalancer

  • Automatically provisions an external load balancer.
  • Useful for production environments.

Kubernetes in Action: Deployments 

A Deployment is a higher-level abstraction that manages ReplicaSets and provides advanced features like rollouts and rollbacks.

Let's look at a practical example of a Deployment configuration

Example Deployment Setup

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.17.10
        ports:
        - containerPort: 80

Hierarchical Relationship:

  • Deployment: Manages ReplicaSets.
  • ReplicaSet: Ensures the desired number of Pods.
  • Pod: The smallest deployable unit in Kubernetes.

Kubernetes in Action: ReplicaSets

A ReplicaSet ensures that a specified number of Pod replicas are running at any given time. It is responsible for maintaining the desired state of Pods by creating or deleting them as needed. However, ReplicaSets lack advanced features like rollouts and rollbacks, which are provided by Deployments.

Let's look at a practical example configuration for a ReplicaSet:

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx-replicaset
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.17.10
        ports:
        - containerPort: 80

Key Differences Between Deployments and ReplicaSets

Feature

    Deployment

ReplicaSet

Rollouts

          Supported

Not Supported

Rollbacks

          Supported

Not Supported

Use Case

            Advanced                                             

Basic Scaling

While you can create Pods directly using a ReplicaSet, it is recommended to use Deployments for more complex, managed workflows.

Kubernetes Deployment, ReplicaSet, and kubectl Watch Mechanism

Why Use a Deployment Instead of a ReplicaSet?

A ReplicaSet ensures that a specified number of Pods are running at any given time. However, Deployments offer additional capabilities on top of ReplicaSets, such as:

  • Version Control: Deployments keep track of different versions of your application, making rollbacks and upgrades seamless.
  • Declarative Updates: With Deployments, you can update Pods by simply modifying the Deployment spec. Kubernetes takes care of creating new Pods and deleting the old ones in a controlled manner.
  • Rollback Mechanism: Deployments allow you to rollback to a previous stable version if a newer version fails.

Without a Deployment, you'd need to manually manage each ReplicaSet, which is error-prone and less efficient.

How kubectl Works

kubectl is the primary command-line tool for interacting with a Kubernetes cluster. It communicates with the Kubernetes API server to manage resources within the cluster.

Command Execution Process

  1. Command Execution:
    • You execute a command on a machine with kubectl installed and configured to interact with your Kubernetes cluster.
  2. API Request:
    • kubectl sends a request to the Kubernetes API server to perform actions like creating, updating, or retrieving Kubernetes resources.

Contexts in kubectl

A context in Kubernetes refers to a combination of a cluster, user, and namespace. You can switch between multiple clusters using contexts.

View Contexts

kubectl config get-contexts

Switch Contexts

kubectl config use-context <context-name>

The Watch Mechanism in Kubernetes

The watch mechanism in Kubernetes is an event-driven architecture that ensures the system stays up to date with the desired state. It enables components to listen for changes and act accordingly.

How kubectl Uses Watch

When you apply a Deployment with kubectl, the following events occur:

  1. Command Execution
    • You run kubectl apply -f deployment.yaml to apply a Deployment.
  2. API Request
    • kubectl sends a request to the Kubernetes API server to create or update a Deployment resource.
  3. API Server Processing
    • The API server validates the request and updates the desired state in etcd.
  4. Storage in etcd
    • The Deployment definition is stored in etcd, which acts as the source of truth for the cluster's state.
  5. Deployment Controller Monitoring
    • The Deployment controller continuously watches etcd for changes.
  6. ReplicaSet Creation
    • The Deployment controller creates a ReplicaSet to manage the Pods specified in the Deployment.
  7. Pod Creation
    • The ReplicaSet controller ensures the desired number of Pods are created.
  8. Scheduler Assignment
    • The Kubernetes scheduler assigns the new Pods to suitable nodes.
  9. Node and Kubelet
    • The kubelet on the assigned nodes pulls the container images and starts the Pods.

Series of Events in Watch Mechanism

  • GET Requests
    • When you run kubectl get pods, it fetches the current state directly from etcd.
  • POST/PUT Requests
    • When you update or create resources (e.g., kubectl apply), the API server processes the request and updates etcd.
  • Watch Events
    • The watch mechanism is triggered by any changes in etcd. Controllers and components subscribe to these watch events to keep the cluster state consistent.

Setting Up a Kubernetes Cluster Locally Using Kind

Kind (Kubernetes in Docker) is a tool to create Kubernetes clusters using Docker containers. It is an excellent way to set up a local Kubernetes cluster for development and testing purposes.

Prerequisites

Before we dive into the setup process, let's ensure we have everything needed to create our local cluster.

  1. Docker: Ensure that Docker is installed and running on your machine.
  2. Kind: Install Kind by following the instructions on the Kind GitHub repository.

Install Kind on Linux/Mac:

curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64

chmod +x ./kind

mv ./kind /usr/local/bin/kind

Install Kind on Windows

Download the Kind executable from the Kind Releases and add it to your PATH.

Creating a Cluster Configuration File

Create a YAML configuration file to define your cluster setup.

File Name: kind-cluster.yaml

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker

This configuration defines a cluster with one control-plane node and two worker nodes.

Creating the Kubernetes Cluster

Use the following command to create the cluster:

kind create cluster --config kind-cluster.yaml

This command will spin up a local Kubernetes cluster based on the configuration provided in the kind-cluster.yaml file.

Verify the Cluster

After the cluster is created, you can verify it using:

kubectl get nodes

You should see the control-plane and worker nodes listed.

Managing Contexts

When you create a cluster with Kind, it automatically sets the Kubernetes context to the new cluster. You can switch between contexts using:

kubectl config get-contexts

kubectl config use-context <context-name>

Example:

kubectl config use-context kind-kind

Deploying Applications to the Cluster

Once the cluster is set up, you can deploy applications using Kubernetes manifests. Let's look at a practical example:

nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Apply the deployment using:

kubectl apply -f nginx-deployment.yaml

Deleting the Cluster

When you are done with the cluster, you can delete it using:

kind delete cluster

Now that we've covered everything from basic concepts to practical implementation, let's wrap up with key takeaways.

Our Final Words

Using Kind, you can quickly create a local Kubernetes cluster with a simple YAML configuration. This setup is ideal for development and testing, allowing you to experiment with Kubernetes features without needing a cloud provider. By now, you should have a clear understanding of what is Kubernetes and how it can transform your application deployment and management process.

Summary of the Hierarchical Relationship

  1. Deployment: Manages ReplicaSets and provides version control, rollbacks, and updates.
  2. ReplicaSet: Ensures a stable number of Pods.
  3. Pods: The smallest deployable units in Kubernetes.