Kubernetes Basics and Architecture

Introduction:

In cloud-native world, deploying and managing containerized applications at scale requires more than just Docker. That’s where Kubernetes comes in—a powerful, open-source container orchestration platform that automates the deployment, scaling, and management of applications.

What is Kubernetes?

Kubernetes, often abbreviated as K8s, is an open-source platform originally developed by Google and now maintained by the Cloud Native Computing Foundation (CNCF). It provides a framework to run distributed systems resiliently.

At its core, Kubernetes helps you:

• Deploy applications consistently.

• Scale applications automatically.

• Maintain desired application states.

• Roll out new versions without downtime.

Key Concepts and Components:

1. Pods

A Pod is the smallest deployable unit in Kubernetes. It can contain one or more containers that share storage, network, and a specification for how to run the containers.

2. Nodes

A Node is a physical or virtual machine where Kubernetes runs your workload. There are two types of nodes:

• Master Node (Control Plane)

• Worker Node.

3. Clusters

A Cluster is a set of nodes that run containerized applications. It includes both master and worker nodes.

Kubernetes Architecture:

The architecture of Kubernetes is modular and includes several components, each with a specific role.

1. Control Plane (Master Node)

Responsible for managing the Kubernetes cluster.

• API Server: Acts as the front end. Accepts REST requests and processes them.

• etcd: A key-value store that saves cluster state and configuration.

• Scheduler: Assigns workloads to suitable nodes based on resource availability.

• Controller Manager: Monitors the cluster state and performs background tasks (like replication).

• Cloud Controller Manager: Manages cloud-specific control logic.

  
  

2. Worker Nodes

Run the actual application containers.

• Kubelet: Agent that ensures containers are running in a pod as expected.

• Kube Proxy: Maintains network rules and enables communication between pods.

• Container Runtime: Software responsible for running containers (e.g., Docker, containerd).

How Kubernetes Works (Simplified Flow):

• You define the desired state in a YAML/JSON file (e.g., a Deployment).

• You submit it via kubectl to the API Server.

• The Scheduler places the workload on an appropriate node.

• The Kubelet on that node instructs the Container Runtime to start the container(s).

• The Controller Manager keeps watching and makes sure the desired state matches the current state (e.g., restarts failed containers).

Networking and Services:

Kubernetes provides internal DNS and service discovery to ensure reliable communication between components. It uses Services to expose applications running on a set of Pods, which enables:

• Load balancing

• Internal communication

• External access (via Ingress or NodePort)

Key Features of Kubernetes:

• Self-healing: Restarts failed containers, replaces and reschedules pods when nodes die.

• Horizontal Scaling: Scale applications up/down based on demand.

• Rolling Updates and Rollbacks: Update your application with zero downtime.

• Service Discovery & Load Balancing: Makes internal/external access seamless.

• Secret & Config Management: Manage sensitive information securely.

Conclusion:

Kubernetes revolutionizes how applications are deployed and operated. Whether you’re running a small app or managing a microservices-based enterprise system, Kubernetes gives you the tools to scale efficiently, manage complexity, and ensure high availability.