Forem: Omkar Sharma

Evolution of Deployment: From Bare Metal to Kubernetes (K8s Explained)

Omkar Sharma — Sat, 21 Mar 2026 12:03:04 +0000

Building an application is one challenge, but deploying it efficiently and scaling it for real-world users is an entirely different game.

Over the years, deployment strategies have evolved significantly—from physical servers to modern container orchestration tools like Kubernetes. In this blog, we will understand this journey step by step.

Step 1: Application Development

Let’s assume a developer builds an application using:

Node.js
Redis
PostgreSQL

The choice of tech stack depends on the developer’s comfort and project requirements.

Once the application is ready on the local machine, the next step is deployment.

Step 2: Traditional Deployment (Bare Metal Servers)

To make the application publicly accessible, the developer needs a server.

Options:

Buy a physical server (Bare Metal)
Rent a server from a third-party provider

Process:

Deploy application on server
Purchase a domain
Map domain to server’s static IP

Now the application is live 🎉

Challenges in Traditional Deployment

1. Environment Consistency

The application should behave the same in production as it does locally.

Famous problem: “It works on my machine”

2. Scaling Issues

As traffic grows, scaling becomes necessary.

Vertical Scaling:

Increase RAM (4GB → 16GB)
Increase CPU cores

Problems:

Expensive
Manual effort required
Limited scalability

Step 3: Cloud Computing Revolution

Cloud providers like:

AWS
Azure
GCP

transformed how applications are deployed.

Benefits:

No need to manage physical infrastructure
Deploy applications from anywhere
Ready-to-use services:
- Load Balancers
- CDN
- DNS (Route 53)
- Managed Databases (PostgreSQL, Redis)

Auto Scaling in Cloud

Cloud platforms introduced:

Auto Scaling Groups (ASG)
Policy-based scaling

Now scaling becomes:

Automatic
Faster
Cost-efficient

Still a Problem: Environment Replication

Even with cloud, consistency issues remain:

Local system → Windows
Production → Linux

Different OS and dependencies can break applications.

Step 4: Virtualization (Virtual Machines)

To solve consistency issues, Virtual Machines (VMs) were introduced.

How it works:

Each VM has:
- Its own OS
- Dependencies
- Application

Advantages:

Consistent environments

Disadvantages:

Heavy (includes full OS)
Slow startup
Resource intensive

Step 5: Containerization (Docker Era)

Containers improved virtualization.

Key Idea:

Package application + dependencies
No full OS required

Benefits:

Lightweight
Fast startup
Portable across environments
Consistent behavior everywhere

Challenge: Managing Containers at Scale

When applications grow:

Hundreds or thousands of containers are needed

Problems:

How to create containers?
How to restart failed ones?
How to manage networking?
How to scale automatically?

Manual management becomes impossible.

Step 6: Google’s Internal Solution – Borg

Google faced this challenge early due to massive traffic.

Solution:

Built Borg (around 2013–2014)

What Borg did:

Managed containers at scale
Automated scheduling and recovery
Handled failures efficiently

Step 7: Kubernetes (K8s)

Based on Borg’s experience, Google introduced Kubernetes.

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates:

Deployment
Scaling
Management of containers

Why the Name Kubernetes?

Derived from Greek word meaning “Helmsman” (ship pilot)
Represents managing containers like steering a ship
Abbreviated as K8s (8 letters between K and S)

Final Comparison

Stage	Problem Solved	Limitation
Bare Metal	Basic hosting	Hard to scale
Cloud	Easy infrastructure	Env consistency issues
Virtual Machines	Consistent environments	Heavy & slow
Containers	Lightweight & portable	Hard to manage at scale
Kubernetes	Full orchestration	Learning curve

Conclusion

The journey from bare metal servers to Kubernetes shows how deployment has evolved to handle:

Scalability
Reliability
Efficiency

Today, Kubernetes has become the industry standard for managing containerized applications at scale.

SEO Keywords (for better reach)

Kubernetes explained, what is Kubernetes, container orchestration, Docker vs Kubernetes, evolution of deployment, cloud computing, DevOps tools, K8s tutorial, container management, microservices deployment

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

Complete Guide to Jenkins CI/CD Pipeline Setup on AWS EC2 (Ubuntu)

Omkar Sharma — Fri, 27 Feb 2026 10:56:26 +0000

Developers from the Application team write the code and push it to GitHub.

Now, instead of manually building and deploying the application, we use Jenkins as a CI/CD tool to automate the entire process.

Here’s how the flow works:

Developers commit and push the code to GitHub.
Jenkins is connected to the repository using a webhook. Whenever new code is pushed, Jenkins automatically triggers a pipeline.
Jenkins pulls the latest code and starts the build process.
During the build stage, Docker is used to create a Docker image from that code.
The Docker image is then pushed to a container registry (like Docker Hub or ECR).
In the deployment stage, Jenkins deploys that image either:

On an Amazon EC2 instance, or
On a Kubernetes cluster.

Once the application is live, monitoring tools like Prometheus are used to monitor application health, metrics, and performance.

In Simple Terms

Jenkins acts as the brain of the CI/CD pipeline.

It automates:

Code integration (Continuous Integration)
Testing and building
Docker image creation
Deployment to servers or Kubernetes
And ensures the whole process runs automatically whenever new code is pushed

This is the concept of CI/CD using Jenkins — automation from code commit to production deployment and monitoring, without manual intervention.

Setting Up Jenkins on AWS EC2 (Ubuntu)

Launch EC2 Instance

Launch an Ubuntu Server EC2 instance.
Instance type: Free Tier eligible (e.g., t2.micro).
Storage: 15 GB (Free Tier eligible).
Allow Port 80 in the Security Group (HTTP traffic).
(Recommended) Also allow Port 8080 for Jenkins default access.

What is Jenkins?

Jenkins is a self-contained, open source automation server which can be used to automate all sorts of tasks related to building, testing, and delivering or deploying software.

Jenkins can be installed through native system packages, Docker, or even run standalone on any machine with a Java Runtime Environment (JRE) installed.

Installation Steps (Ubuntu/Debian)

Official Documentation:

https://www.jenkins.io/doc/book/installing/linux/#debianubuntu

Step 1: Update Packages

sudo apt update

Step 2: Install Java (Required Before Jenkins)

sudo apt install fontconfig openjdk-21-jre
java -version

On Debian/Ubuntu, it is strongly recommended to install Java before Jenkins. If Jenkins is installed first and Java is added later, the Jenkins service may fail to start with:

jenkins: failed to find a valid Java installation

Install Jenkins (Long Term Support Release)

sudo wget -O /etc/apt/keyrings/jenkins-keyring.asc \
  https://pkg.jenkins.io/debian-stable/jenkins.io-2026.key

echo "deb [signed-by=/etc/apt/keyrings/jenkins-keyring.asc]" \
  https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
  /etc/apt/sources.list.d/jenkins.list > /dev/null

sudo apt update
sudo apt install jenkins

Check Jenkins Service Status

sudo systemctl status jenkins

If the service is active and running, Jenkins has been installed successfully.

To ensure Jenkins is active and running whenever you reboot or restart your server, check whether the service is enabled:

sudo systemctl is-enabled jenkins

If the output is enabled, Jenkins will start automatically on boot.
If the output is disabled, run the following command:

sudo systemctl enable jenkins

Access Jenkins in Browser

Go to the Public IP of your EC2 instance.
Open your browser and type:

http://<public-ip>:8080

You will see the Getting Started page.

Unlock Jenkins

You need to enter the initial admin password stored in the following file on your server:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Copy the password and paste it into the Jenkins setup page.

Install Plugins

After unlocking Jenkins, click on:

Install suggested plugins

Congratulations you have setup the Jenkins

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

Docker Compose - Multi Container Setup

Omkar Sharma — Sat, 14 Feb 2026 07:30:54 +0000

Docker Recap — Environment Replication and Container Management

so now we understand how docker works and how it solves the pain point of environment replication.

Quick Recap

you need a VM or any machine where docker is installed — either docker CLI or docker desktop
once docker is set up, you can start managing the lifecycle of your containers

Example Scenario — React Application Containerization

for example, in a company developers are working on a react application and they ask you:

“hey omkar, can you containerize or dockerize this application?”

Steps involved:

create a dockerfile
set up a call with the developers to understand the application requirements
choose the base image
run commands to install all the dependencies required for the application
copy the source code
expose the required ports
define the entrypoint

Step 2 — Build and Run the Application

create the docker image using:

  docker build -t <image-name> .

after building the image:
- push it to docker hub
- run the docker container from that image

Multi-Container Scenario — Docker Compose

now consider another scenario — what if you have an e-commerce application that requires a multi-container setup?

docker compose is used to manage multi-container applications
an e-commerce application usually follows a multi-service or microservice architecture
when working with multiple containers, we need to manage the execution order and dependencies between services

Example:

a payment or catalog service will not run properly without a database
docker compose helps define all services in one place
it manages how containers start and interact with each other

Docker Recap — Environment Replication and Container Management

so now we understand how docker works and how it solves the pain point of environment replication.

Quick Recap

you need a VM or any machine where docker is installed — either docker CLI or docker desktop
once docker is set up, you can start managing the lifecycle of your containers

Example Scenario — React Application Containerization

for example, in a company developers are working on a react application and they ask you:

“Hey omkar, can you containerize or dockerize this application?”

Steps involved:

create a dockerfile
set up a call with the developers to understand the application requirements
choose the base image
run commands to install all the dependencies required for the application
copy the source code
expose the required ports
define the entrypoint

Step 2 — Build and Run the Application

create the docker image using:

  docker build -t <image-name> .

after building the image:
- push it to docker hub
- run the docker container from that image

Multi-Container Scenario — Docker Compose

now consider another scenario — what if you have an e-commerce application that requires a multi-container setup?

docker compose is used to manage multi-container applications
an e-commerce application usually follows a multi-service or microservice architecture
when working with multiple containers, we need to manage the execution order and dependencies between services

Example:

a payment or catalog service will not run properly without a database
docker compose helps define all services in one place
it manages how containers start and interact with each other

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

Docker Basics : Problem Statement, Concepts & Commands

Omkar Sharma — Wed, 11 Feb 2026 06:48:46 +0000

Problem Statement - What Problem Does Docker Solve?

“Same code works on my machine but not on yours.”

Why does this happen?

Environment Replication Issues

Example Scenario

You worked on a project for the past 3 months.
During development, you installed multiple dependencies, libraries, and packages.
Now you want to onboard another developer.
You shared the source code and asked them to install dependencies with exact versions.

Challenges

Hard to remember specific versions over time.
New developers may install latest versions instead of required ones.
Latest versions may introduce breaking changes.
Suppose you put extra effort to remember the version and dependencies but what if they are using diff OS in that case if Windows CLI you are using will not work in MAC.
Example:
- Your project uses Node.js 14.x
- Another developer installs Node.js 18.x
- Result: Application may break or behave differently.

Docker solves this by standardizing environments so applications run the same everywhere.

Installation of Docker CLI & Docker Desktop

Download Docker Desktop from:
https://www.docker.com/products/docker-desktop/

Docker Desktop includes:

Docker CLI
Docker Engine
Docker Compose
GUI Dashboard

Understanding Images vs Containers

Docker Images

Preconfigured read-only templates.
Include:
- Base OS (optional)
- Runtime (Node, Python, Java, etc.)
- Dependencies
- Application setup
Used to create containers.
Images act as blueprints.

Docker Containers

Running instances of Docker Images.
Package application and dependencies together.
Lightweight compared to VMs.
Share host OS kernel (not a full OS like VMs).
Containers are running applications created from images.

Running Ubuntu Image in a Container

docker run -it <image_name>

Example:

docker run -it ubuntu

If the image is not available locally, Docker pulls it from Docker Hub automatically.

Useful Docker Commands

List Containers

docker container ls -a

List Images

docker image ls

Enter an Existing Running Container

docker exec -it <container_name> bash

Multiple Containers

Start a Container:

docker start <container_name>

Stop a Container:

docker stop <container_name>

Key Concept

Multiple containers can run from the same image.
Each container has an isolated environment.
Example:
- Create directory in Container 1
- Create directory in Container 2
- Both remain isolated from each other.

Port Mapping

docker run -it -p <local_machine_port>:<container_port> <image_name>

Example:

docker run -it -p 3000:3000 omkarsharma2821/omkar-node-app

Allows access to container services from local machine.

Environment Variables

docker run -it -e PORT=4000 -p 4000:4000 <image_name>

Used to configure applications dynamically inside containers.

Dockerization of a Node.js Application

Initialize Node Project:

npm init

Install Express:

npm install express

Build Docker Image:

docker build -t omkar-node-app .

As if now the img is avaialbel locally to push to hub.docker.com you need to run the following coommands

docker login

Tag your image with latest

docker tag <local_image_name>:latest <dockerhub_username>/<repo_name>:latest

Example

docker tag omkar-nodejs:latest omkarsharma2821/omkar-node-app:latest

Push to docker hub

docker push <dockerhub_username>/<repo_name>:latest

Example

docker push omkarsharma2821/omkar-node-app:latest

Summary

Docker ensures consistent environments across machines.
Images are templates.
Containers are running instances.
Supports isolated environments, easy onboarding, and scalable deployments.
Essential for modern development workflows and microservices architecture.

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

GIT: Version Control System-Complete Guide

Omkar Sharma — Sun, 25 Jan 2026 11:46:12 +0000

1. What is a Version Control System (VCS)?

Version control, also known as source control, is a system that helps track and manage changes made to software code over time.

Why is it required?

As a project grows, code is continuously updated—new features are added, bugs are fixed, and existing logic is modified. In such cases, it becomes difficult to answer questions like:

Who made a specific change?
When was the change made?
Why was the change introduced?
How can we revert to an older stable version?

A Version Control System solves this by maintaining a complete timeline (history) of code changes, making collaboration, tracking, and rollback easy and reliable.

Famous VCS Tools

Git (Most popular)
Apache Subversion (SVN)
Piper (Used internally by Google)

2. Introduction to Git VCS

Download Git from the official website:

https://git-scm.com/install/

Verify Installation

git
git -v

If Git is installed correctly, it will display the installed version.

What is Git?

Git is a distributed version control system that allows multiple developers to work on the same project simultaneously while keeping track of all changes.

Why Git Configuration is Required?

In an organization, multiple developers work on the same codebase. Git uses global configuration (username and email) to identify who made which changes in the commit history.

Setting Up Git Global Configuration

First let's create a folder where we keep our source code and config the user name and email to it.

git config --global user.name "Your Name"
git config --global user.email "your@email.com"

3. Version Controlling with Git

Initializing a Git Project

By default, a folder is not Git-enabled, and Git does not track it.

To enable Git tracking:

git init

This initializes a Git repository in the folder.

Tracking Files

After initialization, files are still untracked
You must explicitly add files to Git

git add index.js
git add <File Path Name>

Once added, Git starts tracking changes to the file.

Viewing Changes

git diff

Shows differences between the working directory and the staging area.

Add Multiple Files

git add .

Adds all modified and untracked files at once.

By default, Git does not track any folder or file on your local machine unless you initialize it and add files manually.

Removing Files from VCS

git rm <FILE_PATH>

Introduction to Commits

What is a Commit?

A commit is a snapshot of the staged changes at a specific point in time.

Committing Files

git commit -m "commit message"

Staging Area

The staging area is an intermediate step where files are prepared before committing.

Viewing Commit History

git log
git log --oneline
git diff <to see the changes in code file>

git show <commit id> to see the changes made in particular commit

git blame <File Name> to see the changes made in particular file by whom

Reverting Back

git reset --hard <commit id>

here we are moving our head so we will loose the below commits

whenever we are saying VCS we should have something when we do any thing wrong we can revert back.....so Git allows reverting commits to return to a previous stable state when required.

In this feature we use the concept of Linked List head points to the latest commit.....so we just point our head where we want to revert.

git revert <commit id>

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

A Clear Introduction to DevOps and Its Importance

Omkar Sharma — Wed, 14 Jan 2026 18:23:40 +0000

What is DevOps?

DevOps is a culture and set of practices that improve an organization’s ability to deliver projects and applications efficiently.

DevOps is not only about CI/CD .... it involves many other vital aspects of a project, such as:

Improving delivery
Automation
Enhancing Quality
Monitoring (Observability)
Continuous Testing

PS: DevOps is the process of improving application delivery by automating tasks, increasing quality, and ensuring continuous monitoring and continuous testing.

Why DevOps?

As shown in the diagram earlier, all these activities were traditionally manual. Multiple teams worked in silos, and it often took many days to release a project or application. DevOps streamlines and accelerates this entire process.

How to Introduce Yourself in DevOps

“Hi, I am working as a DevOps Engineer with X years of experience. In my previous company, I worked on improving application delivery, enhancing quality, and implementing observability and monitoring practices.”

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

AWS Lambda: The Serverless Engine Powering Cloud Automation

Omkar Sharma — Mon, 12 Jan 2026 16:56:12 +0000

AWS Lambda is one of the most powerful and popular services in the AWS ecosystem. It allows you to run application logic without managing servers, making it ideal for automation, event-driven workflows, and lightweight backend tasks. With Lambda, you simply upload your code and define a trigger—AWS handles provisioning, scaling, and execution automatically.

What Is AWS Lambda?

AWS Lambda is a serverless compute service that executes your code in response to events. It supports languages like Python, Node.js, Java, Go, and more. There is no need to create or manage EC2 servers. Instead, Lambda runs your function in a fully managed environment, scales instantly, and charges you only for the compute time consumed.

Key Characteristics

No servers to configure or maintain
Automatic scaling from 0 to thousands of requests
Pay-per-use billing model
Deep integration with AWS services

Why Is AWS Lambda So Popular?

1. Completely Serverless

You don’t need to provision, patch, or maintain any infrastructure. Lambda removes the operational burden from developers and cloud teams.

2. Automatic, Instant Scaling

Lambda scales based on event load. Whether 1 or 1,000 requests, it adjusts automatically without any configuration.

3. Highly Cost-Effective

Since Lambda charges only when your function executes, there's no cost for idle time. This makes it ideal for workloads with unpredictable volume.

4. Event-Driven Architecture

Lambda works natively with services like:

S3
DynamoDB
CloudWatch
EventBridge
SNS / SQS
API Gateway

This makes it perfect for automation, integrations, and reactive systems.

5. Multi-Language Support

Lambda supports Python, Node.js, Java, Go, .NET, Ruby, and custom runtimes—giving teams flexibility to choose the best language.

What Problem Does AWS Lambda Solve?

Traditionally, even small tasks required running dedicated servers—leading to:

Costly idle infrastructure
Manual scaling
OS patching and maintenance
Complex automation scripts

Lambda solves this by offering:

Serverless compute on demand
Automatic resource management
Event-based execution
Reduced operational workload

It empowers developers to focus purely on logic instead of infrastructure.

Three Real-World Use Cases of AWS Lambda

Below are three practical AWS Lambda use cases (without code), based on your requirement:

1. Automatically Delete Historical Snapshots

Organizations create regular EBS snapshots but often forget to delete old ones, increasing storage cost over time.

How Lambda Helps

A scheduled EventBridge rule triggers your Lambda daily.
Lambda fetches all EBS snapshots.
It identifies snapshots older than a set retention period.
It deletes those snapshots automatically.

Benefits

Saves storage cost
Ensures retention compliance
Eliminates manual cleanup

import boto3

ec2 = boto3.client('ec2')

def lambda_handler(event, context):
    # Describe all snapshots owned by you
    snapshots = ec2.describe_snapshots(OwnerIds=['self'])['Snapshots']

    for snap in snapshots:
        snap_id = snap['SnapshotId']
        print(f"Deleting Snapshot: {snap_id}")
        try:
            ec2.delete_snapshot(SnapshotId=snap_id)
        except Exception as e:
            print(f"Error deleting {snap_id}: {e}")

    return {
        "status": "Completed",
        "deleted_snapshots": len(snapshots)
    }

2. Delete Unused (Available) EBS Volumes

After EC2 instances are terminated, their EBS volumes often remain in the "available" state and keep incurring cost.

How Lambda Helps

A scheduled Lambda function lists all EBS volumes.
It identifies volumes in "available" state.
Lambda deletes these unused volumes.

Benefits

Reduces wasted storage cost
Improves cloud hygiene
Automates cleanup without manual checks

import boto3

ec2 = boto3.client('ec2')

def lambda_handler(event, context):
    # Find volumes that are 'available' (i.e., NOT attached)
    volumes = ec2.describe_volumes(
        Filters=[{'Name': 'status', 'Values': ['available']}]
    )['Volumes']

    for vol in volumes:
        vol_id = vol['VolumeId']
        print(f"Deleting Unattached Volume: {vol_id}")
        try:
            ec2.delete_volume(VolumeId=vol_id)
        except Exception as e:
            print(f"Error deleting {vol_id}: {e}")

    return {
        "status": "Completed",
        "deleted_volumes": len(volumes)
    }

3. Start EC2 Instances That Are in Stopped State

Some environments require EC2 instances to automatically start during working hours or operational windows and often during patching time.

How Lambda Helps

A scheduled trigger (e.g., daily at 9 AM) runs the Lambda function.
Lambda checks for EC2 instances in "stopped" state.
It starts them automatically based on tag filters or instance IDs.

Benefits

Ensures required servers start on time
Reduces manual effort
Supports DevOps automation

import boto3

ec2 = boto3.client('ec2')

def lambda_handler(event, context):
    # Find all instances that are stopped
    response = ec2.describe_instances(
        Filters=[
            {'Name': 'instance-state-name', 'Values': ['stopped']}
        ]
    )

    stopped_instances = []

    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            stopped_instances.append(instance['InstanceId'])

    if stopped_instances:
        print(f"Starting instances: {stopped_instances}")
        ec2.start_instances(InstanceIds=stopped_instances)
    else:
        print("No stopped instances found")

    return {
        "action": "start_instances",
        "instances": stopped_instances
    }

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

Cloud Computing – Complete Overview

Omkar Sharma — Sat, 20 Dec 2025 08:09:19 +0000

What Is Cloud Computing?

Cloud computing is the practice of renting computing resources such as servers, storage, networking, databases, and software from a third-party provider over the internet. Instead of owning and maintaining physical hardware, users access these resources on demand and pay only for what they use.

In simple terms, cloud computing allows you to store data and run applications on remote servers hosted over the internet rather than on local machines or on-premises infrastructure.

Key Features of Cloud Computing

Scalability

Ability to allocate and deallocate resources based on demand.
Elasticity

Automatic scaling of resources up or down as workload changes.
High Availability

Ensures minimal downtime by distributing services across multiple systems.
Agility

Rapid provisioning of resources to respond quickly to business needs.
Fault Tolerance

Capability of systems to continue operating even when components fail.
Disaster Recovery

Ability to recover data and applications after unexpected events.
Consumption-Based Model (Pay-as-You-Go)

Users pay only for the resources they consume.

Cloud Service Models

Infrastructure as a Service (IaaS)

Most responsibility lies with the consumer.
The provider manages networking, storage, servers, and virtualization.
Common use cases:
- Test and development
- Lift-and-shift migration
- Virtual machines
Examples:
- Azure Virtual Machines
- AWS EC2

Platform as a Service (PaaS)

Responsibilities are shared between provider and consumer.
The provider manages OS, runtime, middleware, and infrastructure.
The consumer focuses on application code and data.
Use cases:
- Application development frameworks
Example:
- Heroku

Software as a Service (SaaS)

Most responsibility lies with the provider.
Users access applications directly over the internet.
Examples:
- Gmail
- Outlook
- OneDrive
- Microsoft 365

Shared Responsibility Model

The shared responsibility model defines how security and management responsibilities are divided between the cloud provider and the customer.

The cloud provider is responsible for securing the cloud infrastructure.
The customer is responsible for securing data, access, and configurations, depending on the service model.

Cloud Deployment Models

Private Cloud

Offers greater control and security.
Higher cost and requires skilled technical teams.

Public Cloud

Fully owned and managed by the cloud provider.
No large initial investment.

Hybrid Cloud

Combination of private and public clouds.
Sensitive workloads remain in private clouds while leveraging public cloud flexibility.

Multi-Cloud

Uses multiple cloud providers.
Leverages different services and features from different clouds.

API (Application Programming Interface)

An API is a set of rules that allows software applications to communicate with each other.

In cloud computing, APIs provide a programmatic way to interact with cloud services such as:

Compute
Storage
Databases
Artificial Intelligence services

Scaling in Cloud Computing

Vertical Scaling

Increasing or decreasing the capacity of a resource.
Example: Adding more CPU or RAM to a virtual machine.

Horizontal Scaling

Adding or removing multiple instances of resources.
Commonly used in high-traffic applications.

Virtualization

Virtualization is the process of creating virtual versions of physical resources such as servers, operating systems, storage, and networks.

Key points:

Enables running multiple operating systems on a single physical machine.
Improves resource utilization by logically dividing servers.
Allows OSs like Windows and Linux to run on the same hardware.

Hypervisor

A hypervisor enables virtualization by:

Simulating complete machines with their own operating systems.
Isolating multiple virtual machines on a single physical host.
Allowing multiple OSs to run independently on the same hardware.

Containerization

Containerization is a lightweight alternative to virtualization and is best suited for microservices architectures.

Key characteristics:

Containers package applications with all required dependencies.
They share the host OS kernel.
No separate OS is required for each container.
Solves the “works on my machine” problem.

Containers are ideal for scenarios such as:

Full-stack applications with high backend load
Microservices-based architectures

Note: Containers cannot run a completely different operating system since they rely on the host OS kernel.

Datacenters, Regions, and Availability Zones

Datacenter

A physical facility that houses servers, storage, and networking equipment.

Region

A geographical area containing multiple datacenters to ensure resiliency and reliability for business-critical workloads.

Availability Zones (Azure)

Physically separate datacenters within a region.
Azure regions contain a minimum of three availability zones.
If one zone fails, the others continue operating.

Azure-Specific Concepts

Management Groups

Used to organize subscriptions.
Apply policies, permissions, and restrictions at scale.

Azure Virtual Machines

Provide Infrastructure as a Service (IaaS).

VM Scale Sets

Centrally manage and scale large numbers of identical virtual machines.

Availability Sets

Improve application uptime by distributing VMs across fault and update domains.

Virtual Machines vs Containers

Virtual Machines

Reduce cost compared to physical hardware.
Each VM runs a single operating system.
Heavier than containers due to OS overhead.

Containers

Lightweight and fast.
Allow multiple application instances on a single host.
Package all application dependencies.
Remove OS-level dependency issues.

Summary

Cloud computing enables organizations to build, deploy, and scale applications efficiently by providing computing resources as services. It offers scalability, flexibility, high availability, and cost efficiency while eliminating the need for heavy upfront infrastructure investments.

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

The Only Docker Architecture & Installation Guide You’ll Ever Need

Omkar Sharma — Mon, 22 Sep 2025 17:57:02 +0000

Docker Architecture ?

The above picture, clearly indicates that Docker Deamon is brain of Docker. If Docker Deamon is killed, stops working for some reasons, Docker is brain dead :p (sarcasm intended).

Docker LifeCycle

We can use the above Image as reference to understand the lifecycle of Docker.

There are three important things,

docker build -> builds docker images from Dockerfile
docker run -> runs container from docker images
docker push -> push the container image to public/private regestries to share the docker images.

Understanding the terminology (Inspired from Docker Docs)

Docker daemon

The Docker daemon (dockerd) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with other daemons to manage Docker services.

Docker client

The Docker client (docker) is the primary way that many Docker users interact with Docker. When you use commands such as docker run, the client sends these commands to dockerd, which carries them out. The docker command uses the Docker API. The Docker client can communicate with more than one daemon.

Docker Desktop

Docker Desktop is an easy-to-install application for your Mac, Windows or Linux environment that enables you to build and share containerized applications and microservices. Docker Desktop includes the Docker daemon (dockerd), the Docker client (docker), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper. For more information, see Docker Desktop.

Docker registries

A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker is configured to look for images on Docker Hub by default. You can even run your own private registry.

When you use the docker pull or docker run commands, the required images are pulled from your configured registry. When you use the docker push command, your image is pushed to your configured registry.
Docker objects

When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.

Dockerfile

Dockerfile is a file where you provide the steps to build your Docker Image.

Images

An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image which is based on the ubuntu image, but installs the Apache web server and your application, as well as the configuration details needed to make your application run.

You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.

INSTALL DOCKER

A very detailed instructions to install Docker are provide in the below link

https://docs.docker.com/get-docker/

For Demo,

You can create an Ubuntu EC2 Instance on AWS and run the below commands to install docker.

sudo apt update
sudo apt install docker.io -y

Start Docker and Grant Access

A very common mistake that many beginners do is, After they install docker using the sudo access, they miss the step to Start the Docker daemon and grant acess to the user they want to use to interact with docker and run docker commands.

Always ensure the docker daemon is up and running.

A easy way to verify your Docker installation is by running the below command

docker run hello-world

If the output says:

docker: Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Post "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/create": dial unix /var/run/docker.sock: connect: permission denied.
See 'docker run --help'.

This can mean two things,

Docker deamon is not running.
Your user does not have access to run docker commands.

Start Docker daemon

You use the below command to verify if the docker daemon is actually started and Active

sudo systemctl status docker

If you notice that the docker daemon is not running, you can start the daemon using the below command

sudo systemctl start docker

Grant Access to your user to run docker commands

To grant access to your user to run the docker command, you should add the user to the Docker Linux group. Docker group is create by default when docker is installed.

sudo usermod -aG docker ubuntu

In the above command ubuntu is the name of the user, you can change the username appropriately.

NOTE: : You need to logout and login back for the changes to be reflected.

Docker is Installed, up and running 🥳🥳

Use the same command again, to verify that docker is up and running.

docker run hello-world

Output should look like:

....
....
Hello from Docker!
This message shows that your installation appears to be working correctly.
...
...

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

Why Developers Can’t Ignore Docker Anymore

Omkar Sharma — Mon, 22 Sep 2025 17:25:39 +0000

Problem it Solves: Environment Replication

“My code is working on my machine but not on yours.”

This is one of the most common concerns developers face when shipping code to production.

Reason: Environment replication. The dependencies, libraries, and their versions installed on a developer’s machine may not exist on another machine. It’s not practical to ask people every time to download and configure all the required components.

Here comes Docker — it wraps all the dependencies, libraries, and configurations needed to run the application inside a container.

Difference Between Virtualization and Containers

Containers: Think of them like VMs but without the overhead of a full operating system. They share the host OS kernel, which makes them lightweight and ideal for microservices.
Virtualization: Refers to logically dividing a physical server into multiple virtual machines, each running its own full operating system.

In simple words, you can understand as `containerization is a concept or technology` and `Docker Implements Containerization` just like a hypervisor helps in implementing virtualization.

Containers and virtual machines are both technologies used to isolate applications and their dependencies, but they have some key differences:

1. Resource Utilization: Containers share the host operating system kernel, making them lighter and faster than VMs. VMs have a full-fledged OS and hypervisor, making them more resource-intensive.

2. Portability: Containers are designed to be portable and can run on any system with a compatible host operating system. VMs are less portable as they need a compatible hypervisor to run.

3. Security: VMs provide a higher level of security as each VM has its own operating system and can be isolated from the host and other VMs. Containers provide less isolation, as they share the host operating system.

4. Management: Managing containers is typically easier than managing VMs, as containers are designed to be lightweight and fast-moving.

Why are containers light weight ?

Containers are lightweight because they use a technology called containerization, which allows them to share the host operating system's kernel and libraries, while still providing isolation for the application and its dependencies. This results in a smaller footprint compared to traditional virtual machines, as the containers do not need to include a full operating system. Additionally, Docker containers are designed to be minimal, only including what is necessary for the application to run, further reducing their size.

Let's try to understand this with an example:

Below is the screenshot of official ubuntu base image which you can use for your container. It's just ~ 22 MB, isn't it very small ? on a contrary if you look at official ubuntu VM image it will be close to ~ 2.3 GB. So the container base image is almost 100 times less than VM image.

To provide a better picture of files and folders that containers base images have and files and folders that containers use from host operating system (not 100 percent accurate -> varies from base image to base image). Refer below.

Files and Folders in containers base images

    /bin: contains binary executable files, such as the ls, cp, and ps commands.

    /sbin: contains system binary executable files, such as the init and shutdown commands.

    /etc: contains configuration files for various system services.

    /lib: contains library files that are used by the binary executables.

    /usr: contains user-related files and utilities, such as applications, libraries, and documentation.

    /var: contains variable data, such as log files, spool files, and temporary files.

    /root: is the home directory of the root user.

Files and Folders that containers use from host operating system

    The host's file system: Docker containers can access the host file system using bind mounts, which allow the container to read and write files in the host file system.

    Networking stack: The host's networking stack is used to provide network connectivity to the container. Docker containers can be connected to the host's network directly or through a virtual network.

    System calls: The host's kernel handles system calls from the container, which is how the container accesses the host's resources, such as CPU, memory, and I/O.

    Namespaces: Docker containers use Linux namespaces to create isolated environments for the container's processes. Namespaces provide isolation for resources such as the file system, process ID, and network.

    Control groups (cgroups): Docker containers use cgroups to limit and control the amount of resources, such as CPU, memory, and I/O, that a container can access.

It's important to note that while a container uses resources from the host operating system, it is still isolated from the host and other containers, so changes to the container do not affect the host or other containers.

Note: There are multiple ways to reduce your VM image size as well, but I am just talking about the default for easy comparision and understanding.

so, in a nutshell, container base images are typically smaller compared to VM images because they are designed to be minimalist and only contain the necessary components for running a specific application or service. VMs, on the other hand, emulate an entire operating system, including all its libraries, utilities, and system files, resulting in a much larger size.

I hope it is now very clear why containers are light weight in nature.

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

How to Make a Robust System to Handle Bulk Requests (SQS + SNS + DLQ)

Omkar Sharma — Sat, 26 Jul 2025 19:01:41 +0000

How to Make a Robust System to Handle Bulk Requests

Let’s say you need to send order placed and payment confirmation receipts to millions of users. Challenging, right? You can't just run a loop on the server millions of times — that’s not scalable.

So, we think smart. Let’s create a bulk email worker/server that receives the order and payment confirmation messages, calls the Gmail API, and then sends notifications to users.

Cool? Perfect! That’s how it works…

But here's the challenge:

This is a synchronous process, meaning it depends on the Gmail API. If the Gmail API is down or slow, the worker will wait for the acknowledgement and won’t be able to process other payment events. That’s not scalable.

Enter AWS SQS — A Robust Solution

To solve this, we can use Amazon SQS (Simple Queue Service), which is very robust and decouples the system.

Here’s how it works:

We create a queue of orders and payment confirmations.
Our email worker servers will continuously poll the queue and ask: “Hey, do you have something to send?”
If there are millions of messages, we can scale the email workers horizontally, i.e., spin up more workers to process them in parallel.

But Wait… Another Challenge

Even if you scale your email servers, you’re still dependent on Gmail, which may have rate limits — for example, only 5 emails per second per user/account.

To handle this, you can:

Implement rate limiting logic in your workers.
Use exponential backoff and retry mechanisms.
Queue unsent emails in a Dead-Letter Queue (DLQ) for retry later.

Multi-Channel Notification? Use AWS SNS

In today’s world, you don’t just send emails. You also send WhatsApp messages, SMS, and push notifications. So how do you scale that?

Simple: Use AWS SNS (Simple Notification Service) — a broadcasting service.

Here’s how:

You announce an event (like "payment_successful") using SNS.
Multiple subscribers (email, SMS, WhatsApp, etc.) are attached to this SNS topic.
SNS fan-outs the message to different channels, each connected to its own queue or service.

So if you have:

An SQS queue for email
A webhook for WhatsApp
An SMS gateway for text messages

Each of them gets the notification independently.

What If Delivery Fails?

Good question.

SNS is fire-and-forget by default — no delivery confirmation.

But you can attach dead-letter queues (DLQs) or monitor failures.

So if a mail fails to send, it goes to a discarded queue, and you can retry later.

That’s why sometimes you see receipts 2–3 minutes after making a payment.

Summary

Don’t run loops for millions of tasks — offload to queues.
Use SQS for message handling and decoupling.
Use SNS for multi-channel announcements.
Add DLQs and retry logic to handle external API failures.
Design the system to be asynchronous, scalable, and resilient.

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub

Behind the Scenes of Microservices: Load Balancers & API Gateways Explained

Omkar Sharma — Fri, 25 Jul 2025 20:49:04 +0000

Load Balancing and API Gateways in Microservices

This document explores the use of load balancers and API gateways in a microservice architecture. It addresses the challenges of horizontal scaling, where server IPs change dynamically, and explains how load balancers distribute traffic evenly across healthy servers. Furthermore, it delves into the role of API gateways in routing requests to the appropriate microservice based on the URL or domain, enhancing the overall efficiency and manageability of the system.

Load Balancing in Horizontal Scaling

In horizontal scaling, we increase the capacity of a system by adding more servers to the pool. However, this introduces a challenge: the IP addresses of these servers can change dynamically. Traditional DNS resolution might point to only one IP address, leading to uneven distribution of traffic and potential bottlenecks.

To address this, we employ a load balancer. The load balancer sits in front of the servers and acts as a single point of contact for incoming requests. It then distributes these requests across the available servers based on various load balancing algorithms.

Load Balancing Techniques

Round Robin: Distributes requests sequentially to each server in the pool.
Least Connections: Sends requests to the server with the fewest active connections.
Weighted Round Robin: Assigns weights to servers based on their capacity, distributing requests accordingly.
IP Hash: Uses the client's IP address to determine which server to send the request to, ensuring that requests from the same client are consistently routed to the same server.

The load balancer also monitors the health of the servers. If a server becomes unhealthy, the load balancer automatically removes it from the pool, preventing traffic from being directed to it. Once the server recovers, the load balancer adds it back to the pool.

Load Balancing in a Microservice Architecture

In a microservice architecture, applications are structured as a collection of loosely coupled, independently deployable services. Each service is responsible for a specific business function. For example, consider a large e-commerce platform like Flipkart during a sale:

Orders Service: Handles order placement, tracking, and management.
Payments Service: Processes payments and manages transactions.
API Servers: Provide a public interface for accessing the platform's functionality.
Authentication Servers: Authenticate users and manage their sessions.

Each of these services runs on its own set of servers and can be scaled independently based on its specific needs. To ensure high availability and even distribution of traffic, we place a load balancer in front of each service.

This setup offers several advantages:

Scalability: Each service can be scaled independently to handle varying levels of traffic.
Resilience: If one server fails, the load balancer automatically redirects traffic to the remaining healthy servers.
Isolation: Each service is isolated from the others, preventing failures in one service from affecting the others.
Flexibility: Different services can use different technologies and be deployed independently.

API Gateway

In addition to load balancing individual services, we often use an API gateway to manage external access to the microservices. The API gateway acts as a single entry point for all client requests and provides several key functionalities:

Routing: Directs requests to the appropriate microservice based on the URL or domain.
Authentication and Authorization: Verifies the identity of the client and ensures that they have the necessary permissions to access the requested resource.
Rate Limiting: Prevents abuse of the API by limiting the number of requests that a client can make within a given time period.
Request Transformation: Modifies the request before sending it to the microservice, for example, by adding headers or transforming the data format.
Response Aggregation: Combines responses from multiple microservices into a single response for the client.

Host-Based Routing

Host-based routing directs requests based on the domain name used in the request. For example:

orders.example.com might be routed to the Orders service.
payments.example.com might be routed to the Payments service.

Path-Based Routing

Path-based routing directs requests based on the URL path used in the request. For example:

example.com/orders might be routed to the Orders service.
example.com/payments might be routed to the Payments service.

By using an API gateway, we can simplify the client's interaction with the microservices and provide a consistent and secure interface. It also allows us to evolve the microservices independently without affecting the client.

Conclusion

Load balancers and API gateways are essential components of a well-designed microservice architecture. Load balancers ensure high availability and even distribution of traffic across multiple server instances of each service, while API gateways provide a single entry point for all client requests and handle routing, authentication, and other cross-cutting concerns. Together, they enable us to build scalable, resilient, and maintainable microservice applications.

✍️ Author: Omkar Sharma

📬 Feel free to connect on LinkedIn or explore more on GitHub