DEV Community: Shiva Krishna beepeta

Kubernetes Series - Part 2: Container vs Pod vs Deployment Explained

Shiva Krishna beepeta — Fri, 25 Sep 2026 16:53:56 +0000

Kubernetes Series - Part 2: Container vs Pod vs Deployment Explained

In the previous article, we explored Kubernetes Architecture and how different components interact inside a cluster.

In this article, we'll dive into one of the most fundamental Kubernetes concepts:

Container → Pod → Deployment

Understanding these three concepts is critical because almost every Kubernetes workload is built on top of them.

Why Do We Need Container, Pod and Deployment?

A common misconception among beginners is:

"Aren't Container, Pod, and Deployment all used to run applications?"

The answer is Yes, but each solves a different problem.

Resource	Responsibility
Container	Runs the application
Pod	Hosts and groups containers
Deployment	Manages and maintains Pods

Think of it like:

Application
    ↓
Container
    ↓
Pod
    ↓
Deployment

Each layer adds new capabilities.

Step 1: Understanding Containers

A Container is the actual instance of your application.

For example:

docker run nginx

This launches an Nginx container.

A container includes:

Application code
Runtime environment
Libraries
Dependencies
Configuration

Real-World Example

Imagine you have a Java application.

Java Application
       │
       ▼
Docker Image
       │
       ▼
Container

The container contains:

JDK
+
Application JAR
+
Required Libraries

Everything needed to run the application travels together.

This is why containers work consistently across:

Local Laptop
QA Environment
Staging
Production

Problem With Using Only Containers

Suppose your container crashes.

Container
    ↓
Crash
    ↓
Application Down

Questions arise:

Who recreates the container?
Who scales containers?
Who updates them?

A standalone container cannot solve these problems.

This is where Kubernetes enters the picture.

Step 2: Understanding Pods

Kubernetes doesn't directly manage containers.

Instead, Kubernetes runs containers inside Pods.

What Is a Pod?

A Pod is the smallest deployable unit in Kubernetes.

A Pod can contain:

1 Container

Multiple Containers

Single Container Pod

Most common scenario:

Pod
 │
 └── Nginx Container

Multi-Container Pod

Pod
 │
 ├── Application Container
 │
 └── Log Forwarder Container

Example:

Application Container
       +
Fluent Bit Container

The Fluent Bit sidecar collects logs generated by the application.

Why Do Containers Need Pods?

Pods provide three important capabilities.

1. Shared Network

Every Pod gets a unique IP.

Example:

Pod IP = 10.244.1.5

All containers inside that Pod share the same IP.

Application Container
Logging Container

can communicate using:

localhost

2. Shared Storage

Containers inside the same Pod can access common storage.

volumeMounts:

Example:

Application writes logs
        ↓
Shared Volume
        ↓
Log Collector reads logs

3. Shared Lifecycle

Containers inside a Pod:

Start together
Stop together
Get scheduled together

Kubernetes treats them as a single unit.

Life of a Pod

Let's say Kubernetes creates a Pod.

Pod Created
      ↓
Container Starts
      ↓
Application Running

Everything works fine.

Suddenly:

Node Failure

Application Crash

Result:

Pod Lost

Now what?

Problem With Pods

Pods are temporary.

They are designed to be:

Created

Destroyed

Recreated

A standalone Pod does not automatically recreate itself.

Example:

kubectl delete pod nginx

Result:

Pod Deleted

No automatic recovery.

Application becomes unavailable.

Step 3: Understanding Deployments

This is where Deployments become important.

What Is a Deployment?

A Deployment is a Kubernetes controller that manages Pods.

Instead of creating Pods directly:

kind: Pod

we create:

kind: Deployment

Deployment Architecture

Deployment
     │
     ▼
ReplicaSet
     │
     ▼
Pods
     │
     ▼
Containers

Why Do We Need Deployments?

Deployments solve four major problems:

Self-Healing

Scaling

Rolling Updates

Rollbacks

1. Self-Healing

Deployment maintains a desired state.

Example:

replicas: 3

Desired state:

3 Pods Running

Current state:

Pod-1
Pod-2
Pod-3

Pod-2 crashes.

Pod-2 Down

Deployment detects:

Desired = 3
Actual  = 2

Immediately creates:

New Pod-2

Final state:

Pod-1
Pod-2
Pod-3

This feature is called Self-Healing.

2. Scaling

Traffic increases.

100 Users
    ↓
10,000 Users

You need more application instances.

Update:

replicas: 10

or run:

kubectl scale deployment nginx --replicas=10

Deployment creates additional Pods automatically.

Pod-1
Pod-2
...
Pod-10

3. Rolling Updates

Current Application:

v1.0

New Release:

v2.0

Without Deployment:

Stop Everything
Deploy New Version
Start Everything

Downtime occurs.

With Deployment:

Create New Pod
      ↓
Verify Health
      ↓
Remove Old Pod

Repeat until every Pod is updated.

No Downtime

4. Rollback

New release causes issues.

v2.0
  ↓
Application Failure

Deployment allows rollback.

kubectl rollout undo deployment/nginx

Kubernetes restores the previous working version.

v1.0 Restored

The Complete Picture

Deployment
│
├── Maintains Desired State
├── Performs Scaling
├── Handles Updates
├── Provides Rollback
└── Creates Pods
        │
        ▼
       Pod
        │
        ├── Shared Network
        ├── Shared Storage
        └── Shared Lifecycle
                │
                ▼
           Container
                │
                └── Runs Application

Real Production Example

Consider an e-commerce application.

Container

Spring Boot Application

runs inside:

Container

Pod

Pod
├── Spring Boot Container
└── FluentBit Container

Both share:

Storage
Network
Lifecycle

Deployment

replicas: 5

Ensures:

5 Healthy Pods

always remain available.

If one Pod crashes:

Automatically Recreated

If traffic spikes:

Scale to 10 Pods

If deployment fails:

Rollback

Interview Question

Why are Deployments preferred over Pods in production?

Answer:

Pods only run containers and provide a shared execution environment. They do not offer self-healing, scaling, rolling updates, or rollback capabilities. Deployments manage Pods and maintain the desired state of the application, making them the preferred choice for production workloads.

Quick Comparison

Feature	Container	Pod	Deployment
Runs Application	✅	✅	Indirectly
Smallest Kubernetes Object	❌	✅	❌
Contains Multiple Containers	❌	✅	❌
Shared Network	❌	✅	❌
Shared Storage	❌	✅	❌
Self-Healing	❌	❌	✅
Scaling	❌	❌	✅
Rolling Update	❌	❌	✅
Rollback	❌	❌	✅
Production Ready	❌	Rarely	✅

Key Takeaway

Remember this simple statement:

Containers run applications, Pods host containers, and Deployments manage Pods.

Or even simpler:

Container  = Application
Pod        = Home for Containers
Deployment = Pod Manager

Once you understand this hierarchy, concepts like Services, Ingress, HPA, StatefulSets, DaemonSets, and Argo CD become much easier to understand.

Kubernetes #DevOps #CloudNative #Containers #Docker #K8s #SRE #PlatformEngineering #ArgoCD #LearningInPublic

Kubernetes Architecture

Shiva Krishna beepeta — Thu, 24 Sep 2026 08:05:27 +0000

🚀 Kubernetes Architecture Explained

Before diving into Kubernetes architecture, let's first understand why Kubernetes is preferred for running containerized applications in production environments.

Why Kubernetes Is Preferred Over Docker

Docker is a containerization platform that helps package and run applications inside containers. However, managing hundreds or thousands of containers across multiple servers becomes difficult.

This is where Kubernetes comes into the picture.

Kubernetes is a container orchestration platform that automates the deployment, scaling, networking, and management of containerized applications.

Key Benefits of Kubernetes

✅ Cluster-Level Management

Manage containers across multiple servers (nodes) from a single control plane.

✅ Auto Scaling

Automatically increase or decrease application replicas based on workload demand.

✅ Self-Healing

Automatically recreate failed Pods and maintain the desired state.

✅ Enterprise-Grade Platform

Provides high availability, scalability, security, and strong community support.

Kubernetes Architecture

A Kubernetes cluster consists of two major parts:

Control Plane (Master Node)
Worker Nodes

                  Control Plane
                         |
    ------------------------------------------------
    |                  |                  |
 API Server       Scheduler      Controller Manager
                         |
                       etcd
                         |
--------------------------------------------------------
|                    |                    |
Worker Node 1   Worker Node 2     Worker Node 3

Worker Node Components

Worker Nodes are responsible for running application workloads.

The major components of a Worker Node are:

Pod
Kubelet
Kube-Proxy
Container Runtime

Pod

A Pod is the smallest deployable unit in Kubernetes.

A Pod can contain one or more tightly coupled containers that share:

Network
Storage
Lifecycle

Key Characteristics

Pods are ephemeral in nature.
If a Pod crashes, Kubernetes replaces it with a new identical Pod.
Pods are usually managed through a Deployment resource.

Pod Structure

Pod
 ├── Application Container
 └── Sidecar Container (Optional)

Why Pods?

Pods provide an abstraction layer over containers and allow Kubernetes to manage applications more effectively.

Kubelet

Kubelet is an agent that runs on every Worker Node.

Its primary responsibility is to ensure that containers are running according to the specifications defined in Kubernetes.

Responsibilities

Receives instructions from the API Server.
Creates and manages Pods.
Monitors Pod health and status.
Mounts storage volumes.
Reports the status of Pods and Nodes back to the Control Plane.

Kubelet Workflow

API Server
      |
      v
   Kubelet
      |
      v
     Pods

Think of Kubelet as the node manager that continuously monitors workloads running on a node.

Kube-Proxy

Kube-Proxy is responsible for networking and traffic routing inside the Kubernetes cluster.

Responsibilities

Maintains networking rules on each node.
Routes traffic to the correct Pod.
Enables Service-to-Pod communication.
Performs load balancing across Pod replicas.

Traffic Flow

Client Request
       |
       v
    Service
       |
       v
  Kube-Proxy
       |
 ------------------
 |       |        |
Pod-1   Pod-2   Pod-3

Without Kube-Proxy, Services would not be able to route requests to application Pods.

Container Runtime

The Container Runtime is responsible for running containers on Worker Nodes.

Popular container runtimes include:

containerd
CRI-O

Responsibilities

Pulling container images.
Creating containers.
Starting and stopping containers.
Managing container lifecycle operations.
Collecting and exposing container logs.

Runtime Flow

Container Image
        |
        v
Container Runtime
        |
        v
Container Creation
        |
        v
Application Running

Control Plane Components

The Control Plane acts as the brain of the Kubernetes cluster.

It is responsible for making decisions about:

Scheduling
Scaling
Cluster management
Recovery from failures

The Control Plane consists of:

API Server
Scheduler
etcd
Controller Manager

API Server

The API Server is the entry point to the Kubernetes cluster.

Every component communicates through the API Server.

Responsibilities

Handles all Kubernetes API requests.
Authenticates and authorizes users.
Validates configuration changes.
Updates cluster state.
Communicates with other Control Plane components.

Example

When you execute:

kubectl get pods

The request first reaches the API Server, which retrieves the information and returns the response.

Flow

kubectl
    |
    v
API Server
    |
    v
Cluster Components

Think of the API Server as the central communication hub of Kubernetes.

Scheduler

The Scheduler decides where newly created Pods should be placed.

Whenever a new Pod is created, the Scheduler identifies the most suitable Worker Node.

Factors Considered

CPU availability
Memory availability
Node affinity
Taints and tolerations
Resource requests and limits

Scheduling Process

New Pod Created
        |
        v
    Scheduler
        |
        v
Select Best Node
        |
        v
     Worker Node

The Scheduler ensures workloads are distributed efficiently across the cluster.

etcd

etcd is a distributed key-value database used by Kubernetes.

It stores the complete state and configuration of the cluster.

Examples of Data Stored in etcd

Pods
Services
Deployments
ConfigMaps
Secrets
Nodes
Cluster configurations

Structure

etcd
 ├── Pods
 ├── Services
 ├── ConfigMaps
 ├── Secrets
 ├── Deployments
 └── Nodes

Think of etcd as the single source of truth for the Kubernetes cluster.

If etcd becomes unavailable, the Control Plane cannot function correctly.

Controller Manager

The Controller Manager runs multiple controllers responsible for maintaining the desired cluster state.

Its main job is to continuously compare:

Desired State
      VS
Actual State

and take corrective actions whenever there is a mismatch.

Example

Desired State:

3 Pods Running

Current State:

2 Pods Running

Action Taken:

Controller Manager
        |
        v
Create New Pod

The cluster automatically returns to the desired state of three running Pods.

Responsibilities

Replica management
Node management
Endpoint management
Pod lifecycle management
Self-healing operations

This continuous reconciliation process is one of the core strengths of Kubernetes.

Putting It All Together

Let's see how all components work together when a Pod is created.

Developer
    |
kubectl apply
    |
    v
API Server
    |
    v
Scheduler
    |
Select Node
    |
    v
Kubelet
    |
Create Pod
    |
    v
Container Runtime
    |
Run Containers
    |
    v
Kube-Proxy
    |
Expose Application Traffic

Final Thoughts

Kubernetes follows a powerful architecture that enables organizations to run applications reliably at scale.

Worker Node Components

Pod runs application containers.
Kubelet manages Pods on a node.
Kube-Proxy handles networking.
Container Runtime runs containers.

Control Plane Components

API Server acts as the communication hub.
Scheduler places workloads on the best node.
etcd stores cluster state.
Controller Manager ensures the desired state is maintained.

Together, these components provide:

✅ High Availability

✅ Scalability

✅ Self-Healing

✅ Efficient Resource Utilization

✅ Enterprise-Grade Reliability

This is the reason Kubernetes has become the de facto standard for managing containerized workloads in modern cloud-native environments.

💡 Next Article

In the next article, we'll dive deeper into:

Pods vs Deployments
ReplicaSets
Services
Ingress
ConfigMaps & Secrets
Persistent Volumes
Kubernetes Networking
Kubernetes Troubleshooting ``

Beyond Basics: Unlock the power of Advanced linux commands

Shiva Krishna beepeta — Thu, 17 Jul 2025 05:32:33 +0000

🚀 Advanced Linux Commands Every Power User Should Know

Intro:

Linux is powerful, and once you move beyond the basics, a whole new world of productivity opens up. This post dives into advanced Linux commands and pro tips to help you work faster, smarter, and more efficiently on the terminal.

🔹 1. awk — Text Processing and Reporting

Awk is a scripting language used for manipulating data and generating reports. The awk command programming language requires no compiling and allows the user to use variables, numeric functions, string functions, and logical operators.

awk '{print $1, $3}' file.txt
awk options 'selection _criteria {action }' input-file > output-file

Flags/options with awk command:-

-F Sets a custom field separator
-f Reads awk program from a file
'{}' Encloses action to take on match

Use Case: Extract specific columns from structured files.

🔹 2. sed — Stream Editor for Modifying Files

The SED command (short for Stream Editor) is one of the most powerful tools for text processing in Linux and Unix systems. It's commonly used for tasks like search and replace, text transformation, and stream editing.

The basic syntax for using the SED command in Linux is:

sed [OPTIONS] 'COMMAND' [INPUTFILE...]

where,

'OPTIONS': These are optional flags that modify the behaviour of the sed command.
'COMMAND': This defines the command or sequence of commands to execute on the input file.
'INPUTFILE': One or more input files to be processed.

EXAMPLE:-

sed 's/unix/linux/' geekfile.txt

Here the "s" specifies the substitution operation. The "/" are delimiters. The "unix" is the search pattern and the "linux" is the replacement string. By default, the sed command replaces the first occurrence of the pattern in each line and it won't replace the second, third...occurrence in the line.

To replace only the nth occurance of a word in a line, use the following syntax:

> sed 's/old_word/new_word/n' filename
Use Case: Find and replace text in-place across files.

🔹 3. strace — Trace System Calls

'strace' is a powerful tool for monitoring and diagnosing processes in Linux. It is primarily used for debugging programs, troubleshooting issues, intercepting and recording system calls, and tracing running processes.

strace -p <PID>

Use Case: Debug processes or binaries by inspecting their system calls.

🔹 4. lsof — List Open Files

In the world of Linux, understanding and managing open files is crucial for system administrators and users alike. The Linux operating system provides a powerful utility called lsof (List Open Files) that allows users to gain insights into the files currently open on their system

lsof

Use Case: Identify which process is using a port or file.

🔹 5. watch — Repeat Commands Every N Seconds

The 'watch' command in Linux is a powerful utility that allows you to execute a command periodically, displaying its output in fullscreen mode.

watch -n 2 df -h

Use Case: Monitor disk usage or other outputs in real-time.

🔹 6. rsync — Efficient File Transfer

rsync or remote synchronization is a software utility for Unix-Like systems that efficiently sync files and directories between two hosts or machines.

rsync -avz /src/ user@host:/dest/

Use Case: Fast, incremental backups or file transfers.

🧠 Bonus Tips:

Use alias to speed up repeated commands.

Combine find, xargs, and grep for powerful one-liners.

Learn bash functions to automate routine terminal tasks.

📌 Final Thoughts

Mastering these commands can dramatically improve your Linux workflow. Whether you're managing servers, writing scripts, or troubleshooting systems, these tools give you the power and flexibility that make Linux truly shine.

Linux cheat sheet for day-to-day actions...!!!

Shiva Krishna beepeta — Sun, 13 Jul 2025 10:06:38 +0000

Linux is a powerful operating system that become much more manageable when you know your way around the terminal. This cheat sheet will make your day-to-day easier.

Files & Dir Navigation:-

pwd - prints current working directory

ls - list all files and directories

cd - change directory

mkdir - create directory

rmdir - remove directory

File Operations:-

touch filename - create empty file

cp file1 file2 - copy file.

mv old new - move or rename.

rm file - delete file

cat file - view the content of file

less file - view file one page at a time

head -n 10 file - show first 10 lines. modify 10 in command to get required number of lines.

tail -n 10 file - show last 10 lines.

Search & Filter:-

find . -name ".txt" - find files by name

grep "Word" filename - search for the key word in a file

grep -r "word" dir/ - search recursively for a word in directory

System Info and Monitoring:-

uname -a - kernel and system info

df -h - disk space usage

*du -sh * * - directory size summary

top - live process

free -h - memory usage

uptime - system running time

Networking commands:-

ip -a - show ip address

ping 0.0.0.0 - pings the ip address

curl https://sample.com - make http requests

wget URL - downloads files

netstat -tunlp - show open ports and services

ss -tunl - display listening ports

This linux cheat sheet is a starting point, but real understanding comes from practice. bookmark this page or print out and stick at your desk. stay tuned for more information.