DEV Community: Vijaya Laxmi Kadham

🐾 PawTrack: A Daily Activity & Wellness Tracker for Your Dog

Vijaya Laxmi Kadham — Sun, 16 Aug 2026 13:08:10 +0000

This is a submission for Weekend Challenge: Dog Days Edition

What I Built

For the Dog Days Edition challenge, I built PawTrack, a simple daily companion for dog owners.

The idea was to turn everyday dog-care activities into something easy and fun to track.

PawTrack lets users record:

🚶 Walk time
🍖 Meals
💧 Water
🎾 Play time
🧠 Training time
😊 Daily mood

Based on these activities, PawTrack calculates a Paw Score from 0–100 and gives the owner a simple message about how their dog's day went.

For example:

⭐ Superstar Pup!

🐶 Great Day!

🐾 Good Start!

🌱 Getting There!

🦴 Let's Get Moving!

The application also keeps a rolling 15-day activity history, allowing users to look back at their dog's recent activity.

I wanted to keep the project simple enough to use immediately while still making it feel like a real small application rather than just a static webpage.

Demo

🐾 Live Demo: Try PawTrack Live

The application includes two main pages:

🐶 Daily Tracker

Users can:

Create a dog profile
Record daily activities
Select their dog's mood
See a live Paw Score
Save the day's activity

📊 PawTrack Dashboard

The dashboard provides an overview of recent activity, including:

Average Paw Score
Best Score
Days Tracked
Latest Score
Average walk time
Average meals
Average water
Average play time
Average training time
15-day activity history

The dashboard can be accessed directly from the main PawTrack page.

📸 Screenshots

🐾 Daily Tracker

📊 Dashboard

Code

🐙 GitHub Repository: View PawTrack on GitHub

The project is completely open and built using basic web technologies.

How I Built It

I intentionally kept the technical architecture simple.

The application was built using:

HTML5 – page structure
CSS3 – responsive UI and styling
JavaScript – Paw Score calculation, validation, mood selection, and dashboard logic
localStorage – storing the dog profile, daily activities, mood, score, and activity history
Git & GitHub – source control and project hosting
GitHub Pages – deployment

🏗️ Application Flow

                    🐶 Dog Profile
                          │
                          ▼
                 🏃 Daily Activities
                          │
                          ▼
                    😊 Dog Mood
                          │
                          ▼
                   🐾 Paw Score
                          │
                          ▼
                    💾 localStorage
                          │
                          ▼
                📈 15-Day Activity History
                          │
                          ▼
                   📊 Dashboard

🐾 Paw Score

The Paw Score is calculated from five daily activities:

Activity	Maximum Points
🚶 Walk	25
🍖 Meals	20
💧 Water	20
🎾 Play	15
🧠 Training	20
Total	100

The score updates live as activities are entered, giving the user immediate feedback before saving the day's activity.

When the user saves the day's activities, the record is added to the activity history.

📈 15-Day History

Rather than requiring a database or backend, PawTrack uses browser localStorage.

Each saved day contains:

📅 Date
😊 Mood
🚶 Walk
🍖 Meals
💧 Water
🎾 Play
🧠 Training
🐾 Paw Score

The application keeps the 15 most recent records. When a new record pushes the history beyond 15 entries, the oldest record is automatically removed.

This allowed me to create a useful history feature without introducing unnecessary backend complexity for a weekend project.

🔒 Why localStorage?

I chose localStorage because PawTrack is designed as a lightweight browser-based application.

This means:

No backend server is required
No database is required
No user account is required
Data stays in the user's browser
The application can be deployed as a static website

What I Learned

This challenge was a great opportunity to build something small from start to finish within a limited amount of time.

I worked on:

Structuring a complete web application
Building an interactive UI with HTML and CSS
Writing JavaScript for application logic
Validating user input
Using localStorage for persistent browser data
Creating a rolling activity history
Building a separate dashboard
Connecting multiple pages together
Deploying the application with GitHub Pages

One of the biggest lessons was that a project doesn't need a complicated backend or many external services to be useful.

Sometimes a focused idea, a simple implementation, and a good user experience are enough to turn a small weekend project into something enjoyable to use.

Prize Categories

I am not submitting PawTrack for a specific prize category.

The project is being submitted for the overall challenge.

I chose to focus on building a complete, functional, and easy-to-use dog activity tracker rather than adding a prize-category technology just for the sake of using it.

🐾 Final Thoughts

PawTrack started with a simple question:

What if taking care of your dog's daily activities could feel a little more fun?

The result is a small application that turns everyday activities into a simple Paw Score and gives dog owners a quick way to look back at their dog's recent routine.

Track • Play • Train • Celebrate 🐶

AWS CloudWatch For Beginners – Monitoring, Metrics, Alarms & with Default Metrics Demo

Vijaya Laxmi Kadham — Sun, 16 Aug 2026 09:48:41 +0000

Introduction

Amazon CloudWatch is an Amazon monitoring and observability service that helps us to collect, visualize, monitor and respond to information generated by AWS Resources, applications and services.

In simple terms:

CloudWatch helps us understand what is happening inside our AWS environment and alerts us when something requires attention.

For example, imagine we have an EC2 instance running an application.

If the server's CPU becomes very high, we don't have to wait until the users start complaining.

Instead:

EC2 Instance
     |
     | CPU Utilization
     ↓
CloudWatch
     |
     | Threshold exceeded
     ↓
CloudWatch Alarm
     |
     ↓
Amazon SNS
     |
     ↓
Email Notification

CloudWatch can monitor AWS provided metrics as well as that we publish ourselves as custom metrics.

What Problem does CloudWatch Solve?

Without monitoring, we might have to manually log into servers and check their health.

For example:

Server
  ↓
Is CPU high?
  ↓
Is memory high?
  ↓
Are requests increasing?
  ↓
Are errors occurring?

This doesn't scale well.

CloudWatch provides a centralized place to monitor AWS resources and applications.

Without CloudWatch

EC2
 ↓
No monitoring
 ↓
Problem occurs
 ↓
Users report problem
 ↓
Engineer investigates

With CloudWatch

EC2
 ↓
CloudWatch Metrics
 ↓
Threshold exceeded
 ↓
CloudWatch Alarm
 ↓
SNS Notification
 ↓
Engineer gets alert

This allows problems to be detected earlier.

Major CloudWatch Features

**1. Metrics*: Metrics are numerical measurements collected over time.

For example:

CPUUtilization = 72%

NetworkIn = 10 MB

A metric is essentially a time series of values.

For an EC2 instance, CloudWatch can provide metrics such as CPU utilization, network traffic and status checks.

2. Alarms: CloudWatch alarms monitor metrics and compare them against conditions that we define.

For example:

CPUUtilization >= 50%

If the condition is met, the alarm can enter the ALARM state and trigger an action such as an SNS notification. AWS supports alarms based on individual metrics and other CloudWatch data sources.

3. Logs: CloudWatch log allows application and AWS resources to send log information to CloudWatch.

Think of a:

Log Group = Folder of related logs

and

Logstream = Individual stream of log events inside that group.

For example:

CloudWatch Logs
     |
     └── /application/my-app
            |
            ├── Instance-1
            ├── Instance-2
            └── Instance-3

The current CloudWatch console may show this functionality under Log -> Log Management, rather than the exact "Log Groups" menu.

CloudWatch Metrics Concepts

Before doing the hands-on, it is important to understand a few terms.

Metric: A metric is the measurement we want to monitor.

Example:

CPUUtilization

Data Point: A data point is an individual value recorded for a metric at a particular time.

For example:

10:00 → 15%
10:05 → 18%
10:10 → 42%
10:15 → 63%

These values form a time series.

Namespace: A namespace groups related metrics.

For EC2, the namespace is:

AWS/EC2

For example:

AWS/EC2
   |
   ├── CPUUtilization
   ├── NetworkIn
   ├── NetworkOut
   └── StatusCheckFailed

Dimension

A dimension helps identify what a metric belongs to.

For example:

Metric:
CPUUtilization

Dimension:
InstanceId = i-0123456789abcdef

This is why CloudWatch may display your EC2 instance ID rather than the friendly EC2 Name tag.

Statistic: Statistics tell CloudWatch how to summarize metric values.

Common statistics include:

Average
Minimum
Maximum
Sum
Sample count

For CPU utilization, Average is usually an intuitive choice for a basic monitoring alarm.

Period

The period defines the amount of time represented by each data point used for evaluation.

For example:

Period = 5 minutes

means CloudWatch evaluates the metric over five-minute periods.

CloudWatch Architecture for the Project

Our project will Have 2 demonstrations.

Demo 1 - AWS Default Metric

We will monitor

EC2 CPUUtilization

Architecture:

                AWS
                 |
        +--------+--------+
        |                 |
       EC2            CloudWatch
        |                 |
        | CPU metric      |
        +---------------->|
                          |
                    CPUUtilization
                          |
                          ↓
                   CloudWatch Alarm
                          |
                          ↓
                         SNS
                          |
                          ↓
                    Email Alert

Demo - Monitor EC2 CPU Utilization

Objective

In this demo we will:

Create an EC2 instance
View its default CloudWatch metrics
Understand CPU Utilization
Create a CloudWatch alarm.
Configure the SNS email notification.
Generate controlled CPU activity on the EC2 instance.
Trigger the alarm. Receive the alarm.
Receive an email notification

Step 1: Create the EC2 Instance

Go to:

AWS Console -> EC2 -> Instances -> launch Instance

Use a name such as:

cloudwatch-demo

Configure the required keypair and networking.

Also make sure we have public IP enabled for IPv4 so that we can SSH directly to the instance.

Then click on Launch Instance

Wait until all the checks are completed and it is in running state.

step 2 - Open CloudWatch

Go to:
AWS Console → CloudWatch

On the left hand side select Metrics -> Classic Metrics

Step 3 - Find EC2 Metrics

Inside:

CloudWatch → Metrics → Classic metrics

look for EC2

Then select the EC2 metric category such as per-instance metrics(Because for now I have only one EC2 instance, usually in production we should select the overall Instance metrics).

Select your instance by checking the Instance Id.

Select CPUUtilization

Understanding CPU Utilization

It represents the percentage of compute capacity being used by the EC2 Instance.

For example:

CPUUtilization = 10%

means the instance is lightly loaded.

Whereas:

CPUUtilization = 90%

indiciates that the instance is under significantly heavier CPU load.

A high CPU value isn't automatically a problem.

For example:

CPU = 90%

could be perfectly normal if we intentionally have a batch job running.

That's why monitoring usually involves:

Metric
+
Threshold
+
Time period

rather than simply saying:

CPU is high, therefore something is wrong.

Step 4 - Create the CloudWatch Alarm

From the CPU metric, choose Create Alarm

Select Metric: CPUUtilization

Use static: Average

for a learning exmaple, we can use:

Period: 1 minute

and

Threshold: >=50%

The logic becomes:

IF 
Average CPUUtilization >= 50%

THEN

Alarm -> ALARM state

Click on Next

Step 5 – Configure SNS Notification

For the alarm action, choose:

Alarm State Trigger = In Alarm

Then configure an SNS notification.

Create a new topic:

cloudwatch-demo-alerts

Click on Create Topic -> Click on Next

AWS will send an SNS subscription confirmation email.

Check:

Inbox
Spam
Junk
Promotions/Other folders

Then click:

Confirm subscription

Why is this required?

SNS needs to verify that the email address actually wants to receive notifications.

Step 6 – Name the Alarm

Use a descriptive name:

cloudwatch-demo-high-cpu

Description:

# ALERT
Hello Team,

CPU Utilization is **25% or more**

**PLEASE CHECK AND ACT ON IT**

Then Click on Next -> Create Alarm.

Now we need to test whether our alarm actually works.

For that purpose we have a CPU-spike script in python language it will spike the CPU for a certain amount of time then it will bring back to the normal stage.

Before going to the next step, we will first enable to monitor in the EC2 instance.

Go to AWS Console -> EC2 -> Select the EC2 you created.

Here scroll down you will find the Monitoring tab click on it.

Select the Managed Detailed Monitoring option -> Click on ENABLE -> Confirm.

Step 7 - Connect to the EC2 Instance

The architecture is:

Company Laptop 
| 
| 
SSH 
↓ 
AWS EC2 Instance 
| 
| 
Python workload 
↓ 
CPU utilization increases 
| ↓ CloudWatch 
| 
↓ CloudWatch Alarm 
| 
↓ 
SNS 
| 
↓ 
Email Notification

Connect to the EC2 instance using SSH:

ssh -i your-key.pem ubuntu@YOUR_PUBLIC_IP

Replace:

your-key.pem with the name/path of your key pair
YOUR_PUBLIC_IP with the public IPv4 address of your EC2 instance

Step 8 – Check Python

Before creating our program, verify that Python 3 is available.

Run:

python3 --version

You should see something similar to:

Python 3.x.x

If Python 3 is available, we can continue or install the python3.

Step 9 – Create the Python File

Create a new file called:

cpu_load_demo.py

Create the file:

vim cpu_load_demo.py

This opens the Vim editor.

When Vim opens, press:i

The i key puts Vim into Insert Mode, which allows us to type or paste the Python code.

Add the following code:

import time

DURATION = 120

print("Starting CPU load test...")
print("CPU workload will run for 2 minutes.")

start_time = time.time()

try:
    while time.time() - start_time < DURATION:
        result = 0

        for number in range(1, 1_000_000):
            result += number * number

    print("CPU load test completed.")

except KeyboardInterrupt:
    print("\nCPU load test stopped manually.")

Understanding the Python Code

1. Import the Time Module

import time

The time module allows the program to keep track of how long it has been running.

2. Set the Duration

DURATION = 120

The value 120 represents:

120 seconds = 2 minutes

This means the CPU test is designed to stop automatically after approximately two minutes.

3. Record the Starting Time

start_time = time.time()

This records the time when the program starts.

The program can then compare the current time against the starting time.

4. Run the CPU Workload

while time.time() - start_time < DURATION:

This keeps the program running while the elapsed time is less than 120 seconds.

In simple terms:

Start
  ↓
Has 2 minutes passed?
  ↓
No → Continue CPU workload
  ↓
Check again

Once two minutes have passed:

2 minutes reached
↓
Stop CPU workload

5. Perform Calculations

for number in range(1, 1_000_000):
result += number * number

This repeatedly performs calculations.

The purpose isn't to perform a useful business calculation.

The purpose of this learning exercise is to create temporary CPU activity so that we can observe the change in the EC2 CPUUtilization metric in CloudWatch.

6. Handle Manual Interruption

except KeyboardInterrupt:
print("\nCPU load test stopped manually.")

If we press:

Ctrl + C

the program can stop gracefully.

Step 10 - Save the File in Vim

After entering the code, press:

Esc

This exits Insert Mode.

Then type:

:wq

and press:

Enter
Vim commands used
i → Enter Insert Mode
Esc → Exit Insert Mode
:wq → Save and quit

The terminal should return after the file is saved.

Run ls

You should see: cpu_load_demo.py

Step 11 - Run the CPU Load Test

Now execute the Python program:

python3 cpu_load_demo.py

You should see:

Starting CPU load test...
CPU workload will run for 2 minutes.

The Python program is now generating CPU activity on the EC2 instance.

NOTE: MAKE SURE YOU ARE RUNNING THIS FILE INSIDE THE EC2 INSTANCE AND NOT IN YOUR COMPUTER.

Important: The CPU activity is happening on the AWS EC2 instance. It is not consuming the CPU of the company laptop or your personal laptop.

Step 12 - Check CloudWatch CPUUtilization

Now return to the AWS Console:

Go to CloudWatch -> Metrics -> Classic Metrics -> EC2 -> Per-Instance Metrics

Select the CPUUtilization metric for the EC2 instance.

You should eventually see the CPU utilization increases on the CloudWatch graph.

You can also check the Monitoring in EC2.

Go the EC2 Instance -> Click on Monitoring tab

Step 13 - Check the SNS Email

The alarm enters in the ALARM state, and Amazon SNS should sned the notification to the email address that was subscribed to the SNS topic.

Check your:

Inbox
Spam/Junk folder
Promotions/other folder

The notification confirms that the CloudWatch alarm changed state.

You will get the message like below:

This demonstrates how CloudWatch can automatically notify an administrator when a monitored resource exceeds a configured threshold.

NOTE: I TRIED TO MAKE IT FOR 50% OR MORE BUT MY EC2 CPU CONSUMPTION WASN'T GOING THAT HIGH, SO I EDITED THE CPUUtilization TO >=25% IN ALARMS.

Complete Project Workflow

                    AWS CLOUD
                        |
                        v
                +---------------+
                |      EC2      |
                | cloudwatch-   |
                |     demo      |
                +-------+-------+
                        |
                        | CPUUtilization
                        v
                +---------------+
                |  CloudWatch   |
                |    Metrics    |
                +-------+-------+
                        |
                        | CPU >= 25%
                        v
                +---------------+
                |  CloudWatch   |
                |     Alarm     |
                +-------+-------+
                        |
                        | ALARM State
                        v
                +---------------+
                |      SNS      |
                |     Topic     |
                +-------+-------+
                        |
                        | Email
                        v
                +---------------+
                | Email Alert   |
                | Notification  |
                +---------------+


              CPU LOAD TESTING FLOW

                EC2 Instance
                     |
                     v
            cpu_load_demo.py
                     |
                     | Runs for ~2 minutes
                     v
              CPU Usage Rises
                     |
                     v
             CloudWatch Metric
                     |
                     v
              Alarm Threshold
                  >= 25%
                     |
                     v
              Alarm = ALARM
                     |
                     v
                    SNS
                     |
                     v
              Email Received
                     |
                     v
            Python Script Stops
                     |
                     v
              CPU Decreases
                     |
                     v
              Alarm = OK

Final Flow

EC2
 ↓
CPUUtilization
 ↓
CloudWatch Metrics
 ↓
CloudWatch Alarm (>= 25%)
 ↓
SNS
 ↓
Email Notification

In this article, we learned how to monitor an AWS-provided metric using Amazon CloudWatch.

We monitored:

EC2 → CPUUtilization → CloudWatch Alarm → SNS → Email

What's Next?

In the next article we will learn about the AWS Lambda Functions and with the Cloud Optimization hands-on Demo to understand it better.

Preparing for AWS CI/CD Hands-On Project - Prerequisites

Vijaya Laxmi Kadham — Fri, 31 Jul 2026 22:42:55 +0000

Introduction

In the previous article, we learned how AWS CodePipeline automates the software delivery process.

Before we start building our AWS CI/CD pipeline, we need one more important tool: Docker.

Modern applications are rarely deployed directly from the source code. Instead, they are packaged into Docker images, making them portable and consistent across different environments.

In this article, we will prepare everything required for our CI/CD project by creating a Docker account and understanding how Docker images work.

Why Do We Need Docker?

Imagine you are developing an application on your laptop.

It works perfectly on your machine.

But when another developer runs the same application, it suddenly fails because:

A different Python version is installed.
Some libraries are missing.
The operating system is different.

This is a very common problem.

Docker solves it by packaging everything the application needs into a single unit called a Docker image.

Instead of saying:

It works on my machine.

You can simply share the Docker image, and it works the same everywhere.

What is Docker Hub?

Docker Hub is similar to GitHub, but instead of storing source code, it stores Docker images.

You can:

Upload Docker images.
Download images.
Share images.
Use images in your CI/CD pipelines.

Think of it like this:

GitHub	Docker Hub
Stores source code	Stores Docker images
Git repositories	Docker repositories

Create a Docker Hub Account

Open your browser.
Visit https://hub.docker.com/
Click Sign Up.
Create a free account.
Verify your email address.
Sign in to Docker Hub.

Congratulations! Your Docker Hub account is ready.

Till now we have learned that AWS CodePipeline automates the software delivery process and how Docker helps package applications into portable Docker images.

But one important question still remains.

When a developer pushes code to GitHub:

Who actually builds the application?
Who compiles the code?
Who runs the tests?
Who creates the Docker image?

The answer is AWS CodeBuild.

What is AWS CodeBuild?

AWS CodeBuild is a fully managed build service that automatically builds and tests your application whenever new code is pushed.

Instead of manually running the build commands on your laptop, CodeBuild creates a temporary build environment in AWS and performs all required tasks.

Think of CodeBuild as a robot builder.

You simply tell it what to do, and it performs the work automatically.

Where Does CodeBuild Fit?

Let's look at the complete flow.

Developer
   ⬇️
Push Code
   ⬇️
GitHub
   ⬇️
AWS CodePipeline
   ⬇️
AWS CodeBuild
   ⬇️
Docker Hub / Amazon ECR
   ⬇️
AWS CodeDeploy
   ⬇️
EC2 / ECS / EKS

Notice something important.

CodePipeline doesn't build your application.

It simply coordinates the workflow.

The actual build work is done by CodeBuild.

What Happens Inside CodeBuild?

Whenever CodeBuild starts, it performs a series of automated steps.

A typical workflow looks like this:

Download Source Code
        ⬇️
Install Dependencies
        ⬇️
Compile / Build Application
        ⬇️
Run Unit Tests
        ⬇️
Run Code Quality Checks
        ⬇️
Build Docker Image
        ⬇️
Push Docker Image

Each project may have different steps depending on the application.

What is a Build Environment?

CodeBuild doesn't use your local computer.

Instead, AWS creates a temporary build server whenever a build starts.

This temporary environment includes:

Operating system
CPU and memory
Required programming language
Build tools
Runtime

Once the build completes, AWS automatically removes the environment.

This means you don't need to manage build servers yourself.

What is a `buildspec.yml` File?

One of the most important parts of CodeBuild is the buildspec.yml file.

Think of it as an instruction manual for CodeBuild.

It tells AWS exactly what commands should be executed during the build.

For example, it may contain instructions such as:

Install dependencies.
Run tests.
Build the application.
Build the Docker image.
Push the image to Docker Hub.

Without a buildspec.yml file, CodeBuild wouldn't know what to do.

We will create and understand this file in our upcoming hands-on article.

Real-World Example

Imagine a company developing an online banking application.

A developer fixes a bug and pushes the code to GitHub.

Immediately:

GitHub notifies AWS CodePipeline.
CodePipeline starts the workflow.
CodeBuild downloads the latest code.
It builds the application.
It runs automated tests.
It creates a Docker image.
The Docker image is uploaded to Docker Hub.
CodeDeploy deploys the new version.

All of this happens automatically without manual intervention.

Why Use AWS CodeBuild?

AWS CodeBuild offers several advantages.

Fully Managed

AWS manages the build infrastructure for you.

Automatic Scaling

Multiple builds can run simultaneously without requiring manual setup.

Pay Only for What You Use

You are billed only for the build time used.

Easy Integration

CodeBuild integrates seamlessly with:

GitHub
AWS CodePipeline
Docker Hub
Amazon ECR
CodeDeploy
Amazon S3

No Build Server Maintenance

There is no need to install or update build servers.

AWS handles everything behind the scenes.

What's Next?

In the next article, we will start our hands-on implementation of the entire CI/CD process.

We will divide it into 3 to 4 articles to make it easier to understand and keep the content clean and well organized.

AWS CodePipeline Explained for Beginners | Understanding CI/CD on AWS

Vijaya Laxmi Kadham — Fri, 31 Jul 2026 22:40:31 +0000

Introduction

In the previous article, we learned about AWS CodeCommit, AWS's managed Git repository service.

Although CodeCommit can store source code, simply storing code is not enough.

Every time developers make changes to an application, someone still needs to:

Build the application
Test it
Package it
Deploy it

Imagine a company with 200 developers.

If every deployment had to be done manually, software releases would become slow and error-prone.

This is why CI/CD pipelines are important.

In this article, we will learn:

What CI/CD is
How a traditional CI/CD pipeline works
What AWS CodePipeline is
How CodePipeline works with other AWS services
Why AWS provides its own CI/CD service

By the end of this article, we will understand where CodePipeline fits into the software delivery process.

What is CI/CD?

CI/CD stands for:

Continuous Integration (CI)
Continuous Delivery / Continuous Deployment (CD)

Think of CI/CD as an automated assembly line for software.

Instead of manually building and deploying the application every time code changes, the pipeline performs those tasks automatically.

Without CI/CD, the process might look like this:

Developer
      ↓
Writes Code
      ↓
Builds Application
      ↓
Tests It
      ↓
Deploys It

Every step is done manually.

With CI/CD, the process becomes:

Developer
      ↓
Push Code
      ↓
Pipeline Runs Automatically
      ↓
Application is Deployed

This saves time, reduces mistakes, and provides faster feedback.

How Does CI/CD Usually Work?

Before understanding AWS CodePipeline, let's see how CI/CD is commonly implemented in many organizations.

A typical setup looks like this:

Developer
    ⬇️
GitHub / GitLab
    ⬇️
Jenkins
    ⬇️
Docker Registry
    ⬇️
Kubernetes / EC2

What Happens Here?

A developer pushes code to GitHub.
GitHub notifies Jenkins using a webhook.
Jenkins starts the pipeline.
Jenkins builds and tests the application.
Jenkins creates a Docker image.
The image is stored in a container registry.
The application is deployed to Kubernetes or EC2.

This process is completely automated.

What is a Jenkins Pipeline?

A Jenkins pipeline is a series of automated steps that Jenkins executes whenever new code is pushed.

A pipeline may include stages such as:

Checkout source code
Compile the application
Run unit tests
Perform code quality checks
Scan for security vulnerabilities
Build a Docker image
Push the image to a container registry
Deploy the application

Each stage runs automatically in the defined order.

What is Continuous Integration (CI)?

Continuous Integration focuses on validating code changes as early as possible.

Whenever developers push new code, the CI system automatically:

Downloads the latest code
Builds the application
Runs automated tests
Checks code quality
Detects bugs early

The goal is to identify problems before the application reaches production.

A simple CI flow looks like this:

Developer
    ⬇️
Push Code
    ⬇️
Checkout Code
    ⬇️
Build
    ⬇️
Run Tests
    ⬇️
Scan Code
    ⬇️
Build Docker Image
    ⬇️
Push Image

What is Continuous Delivery (CD)?

Once CI completes successfully, the application is ready to be deployed.

Continuous Delivery (CD) automates the deployment process.

Instead of manually copying files to servers, the deployment tool automatically releases the new version.

Typical deployment targets include:

Amazon EC2
Amazon ECS
Kubernetes (AWS EKS)
AWS Lambda

How Does AWS Solve This Problem?

Instead of using separate third-party tools, AWS provides its own managed CI/CD services.

These services work together to build a complete CI/CD pipeline.

Service	Purpose
AWS CodeCommit	Stores source code
AWS CodePipeline	Orchestrates the workflow
AWS CodeBuild	Builds and tests the application
AWS CodeDeploy	Deploys the application

Together, these services automate the software delivery process.

Note: In our next hands-on article, we will use GitHub instead of AWS CodeCommit.

What is AWS CodePipeline?

AWS CodePipeline is a fully managed service that automates the entire software release process.

Instead of manually performing every deployment step, CodePipeline coordinates each stage automatically.

Think of CodePipeline as the project manager of your entire CI/CD workflow.

It decides:

When to start the pipeline
Which stage runs next
Whether the stages should continue
Whether the deployment succeeds or fails

CodePipeline itself doesn't build or deploy applications.

Instead, it connects different AWS services together.

How AWS CodePipeline Works

A typical AWS CodePipeline looks like this:

Developer
    ⬇️
GitHub
(Source Code)
    ⬇️
AWS CodePipeline
    ⬇️
AWS CodeBuild
    ⬇️
AWS CodeDeploy
    ⬇️
EC2 / ECS / EKS / Lambda

Each AWS service has a specific responsibility.

What Happens Inside CodeBuild?

CodeBuild performs CI tasks.

Typical stages include:

Checkout the source code
Build the application
Run unit tests
Perform code quality checks
Scan for vulnerabilities
Build Docker images
Push images to Amazon ECR

Once these steps complete successfully, CodePipeline moves to the deployment stage.

What Does CodeDeploy Do?

CodeDeploy handles the Continuous Delivery (CD) process.

It automatically deploys the latest version of the application to:

Amazon EC2
Amazon ECS
AWS Lambda
On-premises servers

This removes the need for manual deployments.

Real-World Example

Imagine an online shopping application.

A developer fixes code in the checkout page and pushes the changes to GitHub.

Immediately:

CodePipeline detects the changes.
CodeBuild compiles the application.
Automated tests run.
If everything passes, CodeDeploy deploys the new version.
Customers receive the updated application without any manual intervention.

The entire process happens automatically.

Jenkins vs AWS CodePipeline

Feature	Jenkins	AWS CodePipeline
Installation Required	Yes	No
Server Management	Yes	No
Scaling	Manual	Automatic
AWS Integration	Plugins Required	Native
Maintenance	User Managed	AWS Managed

Jenkins offers greater flexibility, while CodePipeline provides a simpler, fully managed experience within AWS.

AWS CI/CD Explained for Beginners | Understanding AWS CodeCommit, CodePipeline, CodeBuild & CodeDeploy

Vijaya Laxmi Kadham — Fri, 31 Jul 2026 22:38:03 +0000

Introduction

Over the past few articles, we have learned how to create AWS infrastructure manually using services like:

Amazon EC2
Amazon S3
VPC
Route 53
CloudFormation

But once an application is developed, another question arises.

How do we automatically deploy a new version of our application whenever developers make changes?

Imagine a company with 100 developers.

Every day developers:

Fix bugs
Add new features
Improve the application

If an operations engineer had to manually deploy every change, it would:

Take a lot of time
Be error-prone
Slow down software delivery

This is where CI/CD comes into the picture.

What We Will Learn

In this article, we will cover:

What is CI/CD
Why CI/CD is so important
Common CI/CD tools used in the industry
AWS Developer Tools
What is AWS CodeCommit
Advantages and Disadvantages of CodeCommit
Hands-on: Creating your first CodeCommit repository

What is CI/CD?

CI/CD stands for:

Continuous Integration (CI)
Continuous Delivery / Continuous Deployment (CD)

These practices help development teams deliver software faster, more reliably, and with fewer manual steps.

Instead of manually copying application files to servers every time there is a change, CI/CD automates the entire process.

Think of it like an assembly line in a factory.

As soon as one step is completed, the product automatically moves to the next step until it's ready for the customer.

Software delivery works in a similar way.

Why Do We Need CI/CD?

Imagine you are developing an online shopping application.

Every day, developers:

Fix bugs
Add new features
Improve performance

If every update had to be deployed manually, someone would need to:

Copy the latest code
Build the application
Test it
Deploy it to servers

Doing this manually every day becomes repetitive and increases the chances of mistakes.

CI/CD automates these repetitive tasks so that software can be delivered quickly and consistently.

Common CI/CD Tools Used in the Industry

Before AWS introduced its own developer tools, companies were already using several popular CI/CD platforms.

Some of the most common ones are:

GitHub Actions
Jenkins
GitLab CI/CD
Azure DevOps

These tools work with almost every cloud provider and are widely used in the industry.

For example:

GitHub Actions integrates directly with GitHub repositories.
Jenkins is highly customizable using plugins.
GitLab CI/CD is built into GitLab.
Azure DevOps provides a complete DevOps platform.

Many organizations continue to use these tools even when deploying applications to AWS.

Then Why Does AWS Provide Its Own CI/CD Services?

AWS wanted to provide a fully managed CI/CD solution that integrates seamlessly with other AWS services.

Instead of installing, configuring, updating, and maintaining your own CI/CD tools, AWS manages everything for you.

This reduces operational overhead and allows you to focus on building applications rather than managing infrastructure.

AWS provides four main services for building CI/CD pipelines:

AWS CodeCommit
AWS CodeBuild
AWS CodeDeploy
AWS CodePipeline

Together these services can automate the complete software delivery process.

Understanding AWS CI/CD Workflow

A typical AWS CI/CD pipeline looks like this:

Developer
   ⬇️
AWS CodeCommit
(Source Code)
   ⬇️
AWS CodeBuild
(Build & Test)
   ⬇️
AWS CodeDeploy
(Deploy Application)
   ⬇️
EC2 / ECS / Lambda

AWS CodePipeline sits on top of these services and automates the entire workflow.

Overview of AWS Developer Tools

AWS CodeCommit

AWS CodeCommit is a fully managed Git repository service.

It provides a secure place to store source code, similar to GitHub or GitLab.

Developers can:

Push code
Pull code
Create branches
Merge changes
Track commit history

without managing their own Git servers.

AWS CodeBuild

CodeBuild automatically compiles source code, installs dependencies, runs tests, and prepares application artifacts.

Instead of building applications on your machine, AWS performs the build process for you.

AWS CodeDeploy

CodeDeploy automates application deployments.

It can deploy applications to:

Amazon EC2
AWS Lambda
Amazon ECS
On-premises servers

This helps reduce manual deployment effort.

AWS CodePipeline

CodePipeline connects all the services together.

Whenever developers push code, CodePipeline automatically triggers the next stage such as building, testing, and deployment.

It acts as the automation engine for the entire CI/CD process.

Today's Focus: AWS CodeCommit

In today's article, we will focus on the first service in the pipeline: AWS CodeCommit.

Think of CodeCommit as AWS's version of GitHub.

Just like GitHub stores Git repositories, CodeCommit stores Git repositories inside your AWS account.

Why Did AWS Create CodeCommit?

Many organizations prefer to keep their code inside AWS rather than using third-party platforms.

AWS created CodeCommit so customers could have:

Fully managed Git repositories
High availability
Automatic scaling
Tight integration with AWS services
No Git server maintenance

Instead of installing and managing your own Git server, AWS takes care of everything behind the scenes.

Advantages of AWS CodeCommit

Some benefits include:

Fully managed by AWS
No Git server administration
Highly available
Automatically scalable
Secure integration with AWS IAM
Data encrypted at rest and in transit

Limitations of AWS CodeCommit

Although CodeCommit is a good managed Git service, it has some limitations.

Compared to GitHub, it offers:

Fewer collaboration features
Smaller ecosystem
Fewer third-party integrations
Less community adoption

Because of this, many organizations prefer GitHub or GitLab as their source code repositories while still using AWS CodeBuild, CodeDeploy, and CodePipeline.

Important Note

We are learning CodeCommit to understand the AWS Developer Tools ecosystem and how it fits into a CI/CD pipeline.

In future articles, we will use GitHub as the source repository because it's the most commonly used platform in the industry.

Hands-on: Create Your First CodeCommit Repository

Open the AWS Console.
Search for CodeCommit.
Click Create Repository.

Enter a repository name.
(Optional) Add a description.
Click Create Repository.

Explore the repository dashboard, including:
- Commits
- Branches
- Pull Requests
- Settings
Upload a file through the AWS Console.
Later, clone the repository using Git and push files from your local machine.

Why We Will Use GitHub in Future Articles

Although AWS provides CodeCommit, most organizations today use GitHub or GitLab as their source code repositories because they offer richer collaboration features, better integrations, and a larger ecosystem.

For that reason, our upcoming CI/CD articles will continue using:

GitHub
AWS CodeBuild
AWS CodeDeploy
AWS CodePipeline

This reflects a common real-world setup used by many development teams.

Conclusion

In this article, we learned the fundamentals of CI/CD and explored the AWS Developer Tools ecosystem.

We also understood where AWS CodeCommit fits into the CI/CD pipeline, its advantages, and its limitations compared to modern Git hosting platforms.

In the next article, we will move beyond source code management and learn how AWS CodePipeline automates the entire software delivery process by connecting source code, build, testing, and deployment into a single workflow.

AWS CI/CD Explained for Beginners | PART 1 | Understanding AWS CodeCommit

Vijaya Laxmi Kadham — Fri, 31 Jul 2026 22:37:42 +0000

AWS CI/CD Explained for Beginners | Understanding AWS CodeCommit, CodePipeline, CodeBuild & CodeDeploy

Introduction

Over the past few articles, we have learned how to create AWS infrastructure manually using services like:

Amazon EC2
Amazon S3
VPC
Route 53
CloudFormation

But once an application is developed, another question arises.

How do we automatically deploy a new version of our application whenever developers make changes?

Imagine a company with 100 developers.

Every day developers:

Fix bugs
Add new features
Improve the application

If an operations engineer had to manually deploy every change, it would:

Take a lot of time
Be error prone
Slow down software delivery

This is where CI/CD comes into the picture.

What We Will Learn

In this article, we will cover:

What is CI/CD
Why CI/CD is so important
Common CI/CD tools used in the industry
AWS Developer Tools
What is AWS CodeCommit
Advantages and Disadvantages of CodeCommit
Hands-on: Creating your first CodeCommit repository

What is CI/CD?

CI/CD stands for:

Continuous Integration (CI)
Continuous Delivery / Continuous Deployment (CD)

These practices help development teams deliver software faster, more reliably, and with fewer manual steps.

Instead of manually copying application files to servers every time there is a change, CI/CD automates the entire process.

Think of it like an assembly line in a factory.

As soon as one step is completed, the product automatically moves to the next step until it's ready for the customer.

Software delivery works in a similar way.

Why Do We Need CI/CD?

Imagine you are developing an online shopping application.

Every day, developers:

Fix bugs
Add new features
Improve performance

If every update had to be deployed manually, someone would need to:

Copy the latest code
Build the application
Test it
Deploy it to servers

Doing this manually every day becomes repetitive and increases the chances of mistakes.

CI/CD automates these repetitive tasks so that software can be delivered quickly and consistently.

Common CI/CD Tools Used in the Industry

Before AWS introduced its own developer tools, companies were already using several popular CI/CD platforms.

Some of the most common ones are:

GitHub Actions
Jenkins
GitLab CI/CD
Azure DevOps

These tools work with almost every cloud provider and are widely used in the industry.

For example:

GitHub Actions integrates directly with GitHub repositories.
Jenkins is highly customizable using plugins.
GitLab CI/CD is built into GitLab.
Azure DevOps provides a complete DevOps platform.

Many organizations continue to use these tools even when deploying applications to AWS.

Then Why Does AWS Provide Its Own CI/CD Services?

AWS wanted to provide a fully managed CI/CD solution that integrates seamlessly with other AWS services.

Instead of installing, configuring, updating and maintaining your own CI/CD tools, AWS manages everything for you.

This reduces operational overhead and allows you to focus on building applications rather than managing infrastructure.

AWS provides four main services for building CI/CD pipelines:

AWS CodeCommit
AWS CodeBuild
AWS CodeDeploy
AWS CodePipeline

Together these services can automate the complete software delivery process.

Understanding AWS CI/CD Workflow

A typical AWS CI/CD pipeline looks like this:

Developer
    │
    ▼
AWS CodeCommit
(Source Code)
    │
    ▼
AWS CodeBuild
(Build & Test)
    │
    ▼
AWS CodeDeploy
(Deploy Application)
    │
    ▼
EC2 / ECS / Lambda

AWS CodePipeline sits on top of these services and automates the entire workflow.

Overview of AWS Developer Tools

AWS CodeCommit

AWS CodeCommit is a fully managed Git repository service.

It provides a secure place to store source code, similar to GitHub or GitLab.

Developers can:

Push Code
Pull Code
Create branches
Merge Changes
Track Commit History

without managing their own Git servers.

AWS CodeBuild

CodeBuild automatically compiles source code, installs dependencies, runs tests and prepares application artifacts.

Instead of building applications on your machine, AWS performs the build process for you.

AWS CodeDeploy

CodeDeploy automates application deployments.

It can deploy applications to:

Amazon EC2
AWS Lambda
Amazon ECS
On-premises servers

This helps reduce manual deployment effort.

AWS CodePipeline

CodePipeline connects all the services together.

Whenever developers push code, CodePipeline automatically triggers the next stage such as building, testing and deployment.

It acts as the automation engine for the entire CI/CD process.

Today's Focus: AWS CodeCommit

In today's article, we will focus on the first service in the pipeline: AWS CodeCommit.

Think of CodeCommit as AWS's version of GitHub.

Just like GitHub stores Git repositories, CodeCommit stores Git repositories inside your AWS account.

Why did AWS Create CodeCommit?

Many organizations prefer to keep their code inside AWS rather than using third-party platforms.

AWS created CodeCommit so customers could have:

Fully managed Git repositories
High availability
Automatic scaling
Tight integration with AWS services
No Git server maintenance

Instead of installing and managing your own Git server, AWS takes care of everything behind the scenes.

Advantages of AWS CodeCommit

Some benefits include:

Fully managed by AWS
No Git server administration
Highly available
Automatically scalable
Secure integration with AWS IAM
Data encrypted at rest and in transit

Limitations of AWS CodeCommit

Although CodeCommit is a good managed Git service, it has some limitations.

Compared to GitHub, it offers:

Fewer collaboration features
Smaller ecosystem
Fewer third-party integrations
Less community adoption

Because of this, many organizations prefer GitHub or GitLab as their source code repositories while still using AWS CodeBuild, CodeDeploy and CodePipeline.

Important Note

We are learning CodeCommit to understand the AWS Developer Tools ecosystem and how it fits into a CI/CD pipeline.

In future articles, we will use GitHub as the source repository because it's the most commonly used platform in the industry.

Hands-on: Create Your First CodeCommit Repository

Open the AWS Console.
Search for CodeCommit.
Click Create Repository.

Enter a repository name.
(Optional) Add a Description.
Click Create Repository.

After the repository is created, explore the repository dashboard, including:

Commits
Branches
Pull Requests
Settings

Upload a file through the AWS Console.

Later, clone the repository using Git, and push files from your local machine.

Conclusion

In this article, we learned the fundamentals of CI/CD and explored the AWS Developer Tools ecosystem.

We also understood where AWS CodeCommit fits into the CI/CD pipeline, its advantages, and its limitations compared to modern Git hosting platforms.

Key Takeaways

✅ Understand what CI/CD is and why it is important.
✅ Learn the common CI/CD tools used in the industry.
✅ Explore the AWS Developer Tools ecosystem.
✅ Understand the role of AWS CodeCommit in a CI/CD pipeline.
✅ Learn the advantages and limitations of AWS CodeCommit.
✅ Create your first CodeCommit repository.
✅ Prepare for building complete CI/CD pipelines using AWS services.

What's Next?

In the next article, we will learn about AWS CodePipeline and understand how it automates the complete software delivery lifecycle by connecting source code, build, testing and deployment into a single CI/CD workflow.

We will also see how CodePipeline integrates with services like GitHub, AWS CodeBuild, and AWS CodeDeploy to automate deployments from source code to production.

AWS CloudFormation Hands-on | Build Your First Infrastructure Using YAML

Vijaya Laxmi Kadham — Thu, 09 Jul 2026 20:19:49 +0000

Introduction

In the previous article, we learned what Infrastructure as Code (IaC) is and why AWS CloudFormation is used to automate infrastructure creation.

Instead of manually creating AWS resources through the AWS Management Console every time, CloudFormation allows us to define our infrastructure in a template and let AWS create everything for us.

Now it's time to put those concepts into practice.

In this hands-on guide, we will write our first CloudFormation template, deploy it as a CloudFormation Stack, verify that AWS creates the resources automatically, update the infrastructure, and finally clean everything up.

By the end of this article, you will have a solid understanding of the basic CloudFormation workflow.

What We will Build

In this lab, we will create:

One Amazon S3 Bucket
A CloudFormation Stack
Update the Stack
Delete the Stack

Although we are creating only an S3 bucket, the same process is used to create much larger infrastructure such as VPCs, EC2 instances, Load Balancers and Auto Scaling Groups.

Prerequisites

Before starting, make sure you have:

An AWS account
IAM User with Administrator Access
Basic understanding of S3
Basic understanding of CloudFormation (covered in the previous article)

Step 1: Open CloudFormation

In the search bar, search for:

CloudFormation

Open the CloudFormation service.

You will see the CloudFormation dashboard.

Step 2: Understand What We Need

Before creating anything, let's understand how CloudFormation works.

CloudFormation doesn't create resources directly from button clicks.

Instead, it reads a Template.

Think of the template as a blueprint.

You Write Template
        ↓
CloudFormation Reads It
        ↓
AWS Creates Resources

Our first task is to create this template.

Step 3: Create a YAML Template

Open any text editor.

Examples:

VS Code
Notepad++
Sublime Text

Create a new file named:

s3-bucket.yaml

Paste the following template:

AWSTemplateFormatVersion: '2010-09-09'

Description: Creates an S3 Bucket using AWS CloudFormation

Resources:

  MyS3Bucket:

    Type: AWS::S3::Bucket

    Properties:

      BucketName: my-demo-cloudformation-bucket

Note: S3 bucket names must be globally unique. Replace my-demo-cloudformation-bucket with your own unique bucket name.

Save the file.

Step 4: Understanding the Template

Let's understand every part of this template.

1. AWSTemplateFormatVersion

AWSTemplateFormatVersion: '2010-09-09'

This specifies the version of the CloudFormation template format.

You don't usually need to change this value.

2. Description

Description:

This simply describes what the template does.

Think of it like comments for humans.

3. Resources

Resources:

This is the most important section.

Everything AWS creates is defined under Resources.

For example:

EC2
VPC
IAM
S3
Lambda

All are created inside this section.

4. Logical Resource Name

MyS3Bucket

This is the logical name inside CloudFormation.

AWS uses this name internally.

It doesn't become the actual bucket name.

5. Resource Type

Type: AWS::S3::Bucket

This tells AWS what service to create.

Different services have different resource types.

Examples:

AWS Service	Resource Type
S3	AWS::S3::Bucket
EC2	AWS::EC2::Instance
VPC	AWS::EC2::VPC

6. Properties

Properties define how the resource should be configured.

Example:

BucketName:

Here we provide the actual bucket name.

Step 5: Create the Stack

Return to AWS CloudFormation.

Click on Create Stack → Select Choose an existing template.

Click on Choose file and upload:

s3-bucket.yaml

Click on Next.

Step 6: Stack Details

Provide a Stack Name, for example:

demo-s3-stack

Click on Next.

You can leave all the options as default for this lab.

Click Next.

Step 7: Review

Review the Configuration.

Click on Submit.

CloudFormation now starts creating the resources.

Step 8: Watch the Events

This is one of the most useful tabs.

Open Events.

You will notice CloudFormation showing each action.

Example:

CREATE_IN_PROGRESS

CREATE_COMPLETE

Instead of guessing what AWS is doing, you can monitor every step here.

Step 9: Verify the Resource

Open:

AWS S3
    ↓
Buckets

You should now see the bucket that CloudFormation created.

Notice something interesting.

We never manually clicked Create Bucket.

CloudFormation created it automatically.

This is the power of Infrastructure as Code (IaC).

Step 10: Update the Stack

Infrastructure changes over time.

Instead of deleting everything and recreating it, CloudFormation allows us to update existing resources.

Let's update our bucket by enabling versioning.

Modify the template.

AWSTemplateFormatVersion: '2010-09-09'

Description: Creates an S3 Bucket using AWS CloudFormation

Resources:

  MyS3Bucket:

    Type: AWS::S3::Bucket

    Properties:

      BucketName: my-demo-cloudformation-bucket-12345

      VersioningConfiguration:

        Status: Enabled

Save the file.

Step 11: Update CloudFormation

Go back to CloudFormation.

Select your Stack.

Click Update, choose:

Replace Current Template

Upload the modified YAML file.

Click:

Next → Next → Submit

Step 12: Verify Versioning

Go back to the S3 Bucket.

Open Properties and scroll down.

You should now see Bucket Versioning enabled.

Notice that CloudFormation updated the existing resource rather than creating a new bucket.

Step 13: Delete the Stack

CloudFormation also makes cleanup easy.

Instead of deleting every resource manually,

simply select the stack.

Click Delete.

CloudFormation automatically deletes all the resources that belong to that Stack.

This is one of the biggest advantages of Infrastructure as Code.

Understanding the CloudFormation Workflow

Write YAML Template
        ↓
Upload Template
        ↓
Create Stack
        ↓
AWS Creates Resources
        ↓
Update Template
        ↓
Update Stack
        ↓
Delete Stack

Best Practices

Store your CloudFormation templates in Git.
Use meaningful stack names.
Add descriptions to templates.
Start with small templates before building large infrastructures.
Delete unused stacks to avoid unnecessary AWS charges.

Key Takeaways

CloudFormation uses templates to define infrastructure.
A Stack is a collection of AWS resources created from a template.
You can create, update and delete infrastructure using the same template.
CloudFormation reduces manual work and helps maintain consistency across environments.
Infrastructure as Code is a fundamental skill for DevOps and Cloud Engineers.

Conclusion

In this hands-on lab, we created our first AWS CloudFormation template using YAML and used it to deploy an S3 bucket without manually creating resources through the AWS Console.

We also learned how CloudFormation manages infrastructure through Stacks, how to update existing resources by modifying the template and how to clean up everything by deleting the stack.

Although this example used a simple S3 bucket, the same workflow is used in real-world environments to provision complex infrastructure consisting of VPCs, EC2 instances, Load Balancers, Auto Scaling Groups, RDS databases, and much more.

🎉 Congratulations! You have successfully:

Written your first CloudFormation template
Created an AWS resource using Infrastructure as Code
Updated an existing CloudFormation Stack
Deleted a Stack and cleaned up resources

You now understand the complete CloudFormation workflow:

Write Template
      ↓
Create Stack
      ↓
AWS Creates Resources
      ↓
Update Template
      ↓
Update Stack
      ↓
Delete Stack

This workflow is the foundation for deploying production infrastructure on AWS using Infrastructure as Code.

AWS CloudFormation Explained for Beginners | Infrastructure as Code (IaC) Made Simple

Vijaya Laxmi Kadham — Wed, 08 Jul 2026 19:54:05 +0000

AWS CloudFormation Explained for Beginners | Infrastructure as Code (IaC) Made Simple

Introduction

In the previous article, we learned how to use the AWS CLI to interact with AWS services from the command line.

The AWS CLI is great for performing quick tasks such as:

Listing S3 buckets
Launching an EC2 Instance
Creating a VPC

However, imagine that you need to build an entire production environment consisting of:

A VPC
Public and Private Subnets
Internet Gateway
NAT Gateway
Route Tables
Security Groups
EC2 Instances
Load Balancer
Auto Scaling Group

Creating all these resources manually every time would be slow, repetitive and prone to mistakes.

This is where Infrastructure as Code (IaC) comes in.

AWS provides a service called CloudFormation that allows us to create infrastructure using code instead of clicking through the AWS Console.

In this article, we will understand the basics of CloudFormation and why it is one of the most important services for AWS and DevOps engineers.

What We Will Learn

In this article, we will learn:

What is Infrastructure as Code (IaC)?
Why CloudFormation is needed
Problems with manual infrastructure
What is CloudFormation?
Templates
Stacks
Stack Updates
Stack Deletion
Benefits
Real-world examples

Imagine this Scenario

Suppose you work for an online learning platform.

Every new customer gets their own AWS environment.

Each environment needs:

1 VPC
2 Public Subnets
2 Private Subnets
Internet Gateway
NAT Gateway
Security Groups
EC2 Instances
Load Balancer

Now imagine creating this manually for:

Customer A
Customer B
Customer C
Customer D

Every single week.

It would become repetitive and time-consuming.

Even worse, one small mistake could cause production issues.

The Problem with Manual Infrastructure

Creating infrastructure manually has several drawbacks.

Time consuming
Human errors
Difficult to recreate
Hard to maintain
No version control

Think of writing a long document.

Would you rather rewrite the document every time, or simply save it and reuse it whenever needed?

Infrastructure works the same way.

Instead of rebuilding everything manually, we write the infrastructure once and reuse it whenever required.

What is Infrastructure as Code (IaC)?

Infrastructure as Code means defining your infrastructure using code instead of manually creating resources through the AWS Console.

Instead of clicking buttons every time, we write instructions inside a file.

AWS reads those instructions and creates the required resources automatically.

Think of it like following a recipe.

Rather than preparing a dish from memory every time, you write the recipe once and anyone can recreate the same dish by following those instructions.

CloudFormation works in a similar way.

You write the infrastructure once, and AWS builds it whenever needed.

What is AWS CloudFormation?

AWS CloudFormation is a service that allows you to create, update and manage AWS infrastructure using code.

Instead of manually creating resources, you write a template describing what you want.

AWS reads the template and creates all the required resources for you.

Developer
     │
Writes Template
     │
     ▼
CloudFormation
     │
Creates Resources
     │
 ┌───────────────┐
 │ VPC           │
 │ Subnets       │
 │ EC2           │
 │ S3            │
 │ IAM           │
 │ Load Balancer │
 └───────────────┘

What is a CloudFormation Template?

A Template is simply a blueprint of your infrastructure.

It contains instructions describing:

What resources should be created
Configuration
Dependencies

Think of it as a house blueprint.

The blueprint doesn't build the house.

It simply describes how the house should be built.

CloudFormation uses the blueprint to create the infrastructure.

What is a Stack?

When CloudFormation reads your template and creates the resources, AWS groups all those resources into something called a Stack.

Think of a Stack as a project folder.

Instead of managing resources individually, AWS manages them together.

For example, your Stack may contain:

VPC
EC2
Security Group
S3 Bucket

Deleting the Stack deletes all those resources together.

Real-World Example

Imagine a company with separate environments:

Development
Testing
Production

Instead of creating infrastructure manually three times, the DevOps engineer writes one CloudFormation template.

Then they deploy it three times:

Dev Stack
Test Stack
Production Stack

Same code.

Different environments, much easier.

Why Companies Use CloudFormation

Companies use CloudFormation because it provides:

Automation
Consistency
Version Control
Faster Deployments
Easy Recovery
Repeatability

CloudFormation vs Manual AWS Console

Manual AWS Console	CloudFormation
Click every resource	Write once
Slow	Fast
Human mistakes	Consistent
Hard to repeat	Easily reusable
No version control	Git friendly

CloudFormation Supports Almost Every AWS Service

Examples include:

EC2
VPC
IAM
S3
Route 53
Lambda
DynamoDB
RDS
CloudFront

A Simple Flow

Write Template
       │
       ▼
Upload to CloudFormation
       │
       ▼
Create Stack
       │
       ▼
AWS Creates Resources

Conclusion

In this article, we learned the theory behind AWS CloudFormation and Infrastructure as Code.

We explored why manually creating AWS resources becomes difficult as environments grow and how CloudFormation solves this problem by allowing us to define infrastructure using code.

What's Next?

In the next article, we will put these concepts into practice by creating our first CloudFormation template, launching resources using a Stack and understanding how CloudFormation manages infrastructure automatically.

AWS CLI for Beginners | Automating AWS without using the Console

Vijaya Laxmi Kadham — Mon, 29 Jun 2026 09:03:40 +0000

Introduction

Until now, we have been creating resources such as:

VPCs
EC2 Instances
S3 Buckets

using AWS Console.

While the AWS Console is easy for beginners, it becomes difficult when we need to create many resources repeatedly.

Imagine manually creating:

20 VPCs
20 S3 buckets
15 EC2 Instances

Doing this from the UI every time would be slow and inefficient.

This is where AWS CLI becomes useful.

What we will Learn

In this article, we will learn:

What AWS CLI is
Why AWS CLI is useful
How AWS CLI communicates with AWS
Installing AWS CLI
Configuring AWS CLI
Running our first AWS CLI command
Finding AWS CLI documentation

Why Do We Need AWS CLI?

AWS provides APIs(Application Programming Interfaces) for all its services.

These APIs allow us to:

Create resources
Update resources
Delete resources
Manage infrastructure programmatically

Instead of clicking on buttons in AWS Console, we can send commands directly to AWS.

Think of it like this:

AWS Console
    ↓
Manual Operations

AWS CLI
    ↓
Command Based Operations

Real Life Example

Suppose your company asks you to create:

50 S3 buckets
20 EC2 Instances
Multiple VPCs

Doing this manually from the AWS Console would take time.

Using AWS CLI we can automate these operations through commands and scripts.

What is AWS CLI?

AWS CLI stands for:

AWS Command Line Interface

It is tool that allows us to manage AWS services directly from terminal.

AWS CLI acts as a bridge between users and AWS APIs.

User
  ↓
AWS CLI
  ↓
AWS API
  ↓
AWS Services

The AWS CLI itself is developed by AWS and internally sends API requests to AWS services.

The good part is:

We don't need programming knowledge to start using AWS CLI
We only need to understand commands and documentation.

AWS CLI vs AWS Console

AWS Console	AWS CLI
Manual	Command Line Interface
Beginner fridenly	Automation friendly
Slower for repetitive tasks	Faster
Requires clicking	Requires commands
Suitable for learning	Suitable for automation

AWS CLI vs Terraform vs Cloud Formation

Many beginners ask:

If AWS CLI can create resources, why do we need Terraform or CloudFormation?

The answer is simple.

AWS CLI is best for:

Quick actions
testing
Small automation tasks
Learning AWS services

CloudFormation is best for:

Reusable infrastructure
AWs native infrastructure as a Code

Terraform is best for:

Large production environments
Multi-cloud infrastructure
Infrastructure as Code

AWS CDK is best for:

Developers who prefer programming languages.

Hands-On: Installing AWS CLI

Method 1: Install AWS CLI using Git Bash

Step 1: Install Git Bash

Open your browser and search:

Git Bash Download

Download and install Git Bash.

After installation, open:

Git Bash

Step 2: Install AWS CLI

In your browser search for:

AWS CLI

Open the official AWS Documentation.

Navigate to:

User Guide → Get Started → Install/Update

Select the Linux CLI installer and copy the path and paste it in the Git Bash terminal.

Then you will see AWS CLI is installing.

After installation, verify:

aws --version

You will see something like this in the terminal:

aws-cli/2.x Python/3.x Windows

Step 3: Configure AWS CLI

Why Does AWS CLI Need Configuration?

AWS CLI needs to know:

Which AWS account to use
Which region to use
Which credentials belong to us

This is done using:

aws configure

Provide:

AWS Access Key ID
AWS Secret Access Key
Default Region
Output Format (json)

You will get the Access Key ID from your AWS account.

Go to your AWS Console.

Click on the account name on the right-side corner → Select Security Credentials.

Scroll to Access Keys → Click on Create Access Key.

AWS generates:

Access Key ID
Secret Access Key

Save these credentials securely.

NEVER SHARE YOUR SECRET ACCESS KEY

Example:

AWS Access Key ID: AKIAxxxxxxxx
AWS Secret Access Key: ********
Default Region Name: ap-south-1
Default Output Format: json

Why JSON?

AWS returns responses in JSON format because it is easy for applications and scripts to process.

Method 2: Using AWS CloudShell (What I Used)

Since I was using a managed laptop where installing software was restricted, I used AWS CloudShell.

CloudShell already comes with AWS CLI pre-installed, making it convenient for learning and experimentation.

Step 1: Open AWS Console

In the search bar type:

CloudShell

and wait for the terminal to open.

Step 2: Verify AWS CLI

aws --version

You will get an output like this:

aws-cli/2.x

Note: CloudShell automatically uses the credentials of the currently logged-in IAM user.

Therefore, unlike local installation, there is no need to run:

aws configure

Running our First AWS CLI Command

Now let's check whether AWS CLI can access our resources.

Run:

aws s3 ls

means:

List all S3 buckets available in my AWS account

Example output will be like this:

2025-11-02  my-learning-notes-example
2025-11-03  demo-cli-bucket

Exploring AWS CLI Documentation

AWS provides documentation for every service.

For example, search:

AWS CLI S3 reference

Here you will see a bunch of available commands and how to use them in detail.

For example:

List Buckets

aws s3 ls

Create Bucket

aws s3 mb s3://mydemo-s3-bucket-for-cli

One of the best ways to become comfortable with AWS CLI is by exploring the official documentation and trying commands on your own.

AWS provides CLI references for almost every service.

For example, if you want to learn EC2 commands, search:

AWS CLI EC2 Reference

Spend some time browsing the documentation and try commands in your environment.

Key Takeaways

In this article, we learned:

✅ What AWS CLI is
✅ Why AWS CLI is useful
✅ How AWS APIs work
✅ Installing AWS CLI
✅ Creating Access Keys
✅ Configuring AWS CLI
✅ Running our first commands
✅ Exploring AWS CLI documentation

Conclusion

AWS CLI makes managing AWS resources faster and easier.

Instead of repeatedly performing manual tasks through the AWS Console, we can interact with AWS services directly from the terminal.

AWS CLI is excellent for quick actions and small automation tasks.

However, as infrastructure grows larger, managing resources using individual commands becomes difficult.

This is where Infrastructure as Code (IaC) tools become extremely useful.

What's Next?

In the next article, we will begin exploring Infrastructure as Code (IaC) and understand:

What is AWS CloudFormation (CFT)?
CloudFormation vs Terraform
Tips and Tricks for Writing CloudFormation Templates
Why production teams prefer Infrastructure as Code

From this point onward, we will start moving from individual commands to managing complete infrastructure using code. 🚀

AWS S3 Hands-On Project | Buckets, Versioning, Permissions and Static Website Hosting

Vijaya Laxmi Kadham — Sat, 20 Jun 2026 12:53:51 +0000

Introduction

In the previous article, we learned the theory behind Amazon S3.

Now it is time to see Amazon S3 in action.

In this hands-on project, we will:

Create an S3 bucket
Upload files
Understand Objects inside S3
Enable Bucket Versioning
Create IAM User
Control access using Bucket Policies
Host a Static Website using S3

By the end of this article, we will understand some of the most commonly used Amazon S3 features.

Step 1: Create an S3 Bucket

Search for S3.

Open the dashboard.

Click on Create Bucket.

Provide:

Bucket Name

Give your bucket a name, for example:

my-learning-notes-example

Bucket names must be globally unique.

For now, leave all the remaining settings as default.

Click on Create Bucket.

Step 2: Explore the Bucket

Open the bucket you just created.

Initially, you will notice:

Objects (0)

because the bucket is empty.

Think of a bucket as a folder that stores files.

Step 3: Upload Your First Object

Click on:

Upload

Then click:

Add files

Choose any file.

Click:

Upload

After the upload finishes, you will see the file inside the bucket.

In Amazon S3, every uploaded file is called an Object.

Now if you look inside the bucket, you will notice that Objects are no longer zero because we have uploaded a file.

Step 4: Explore Object Options

Click on the uploaded Object.

Explore the options:

Open

Select the file and click Open.

It will display the contents of the file.

Download

Select the file and click Download.

The file will be downloaded to your system.

Delete

If you select Delete, AWS will ask for confirmation before deleting the object.

This helps you understand how S3 manages objects.

Step 5: Enable Bucket Versioning

Suppose you upload:

demo-learning-s3.txt

Later, you modify the file and upload it again.

Without versioning, the old file gets overwritten.

Versioning allows you to preserve previous versions.

Go to:

Bucket → Properties

Scroll to:

Bucket Versioning

Click:

Edit

Choose:

Enable

Click:

Save Changes

Now if you check the bucket properties, you can see that versioning is enabled.

Step 6: Upload a New Version

Modify your file.

Before

AWS S3 Notes version 1

After

AWS S3 Notes version 2

Upload the file again using the same filename.

Now open the Object.

Click:

Versions

You will see multiple versions.

This is similar to maintaining history in Git.

Step 7: Create an IAM User

In AWS Console, search for:

IAM

Go to:

IAM → Users → Create User

Give a name:

demo-s3-user

Assign a password.

Click:

Create User

Step 8: Verify Permissions

Open an Incognito browser.

Try accessing the Amazon S3 bucket.

Also try creating a bucket.

Initially, you will receive permission errors.

This happens because the user has no S3 permissions.

Step 9: Grant S3 Permissions

Open:

IAM → Users → demo-s3-user

Click:

Add Permissions

Attach:

AmazonS3FullAccess

Click:

Save

Now refresh the IAM user session.

The demo-s3-user can now access S3.

Step 10: Explore Bucket Permissions

Open:

S3 → Bucket → Permissions

You will notice:

Bucket Policies
Block Public Access
Access Control

These settings provide an additional security layer.

Even if IAM permissions are accidentally misconfigured, Bucket Policies can still protect your bucket.

Step 11: Enable Static Website Hosting

Create a simple index.html file.

Upload this file to your bucket.

Now go to:

Bucket → Properties

Scroll to:

Static Website Hosting

Click:

Edit

Enable:

Static Website Hosting

Set:

Index Document: index.html

Click:

Save Changes

AWS will generate a website endpoint.

Try accessing the website endpoint URL.

You will notice that you still cannot access it even if you have S3 Full Access.

This happens because there are still S3 permissions blocking public access.

Step 12: Remove Public Access Block

Go to:

Permissions

Locate:

Block Public Access

Click:

Edit

Disable public access.

Confirm the warning.

When you try to access the URL again, you may still receive:

403 Forbidden

Although Static Website Hosting is enabled, the files inside the bucket are still private.

AWS requires explicit permission before users on the internet can read objects inside an S3 bucket.

To solve this, we need to create a Bucket Policy.

Step 13: Add Bucket Policy for Public Read

Go to:

Permissions → Bucket Policy → Edit

Click:

Add New Statement

Initially, AWS provides a template similar to:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "Statement1",
      "Principal": {},
      "Effect": "Allow",
      "Action": [],
      "Resource": []
    }
  ]
}

We need to fill these values.

Understanding the Fields

Sid

Used to identify the policy statement.

"Sid": "PublicReadGetObject"

Principal

Defines who the rule applies to.

"Principal": "*"

The * means anyone on the internet.

Effect

Specifies whether AWS should allow or deny the action.

"Effect": "Allow"

Action

Defines which permission we are granting.

"Action": "s3:GetObject"

This allows users to read objects inside the bucket.

Resource

Specifies which bucket objects the rule applies to.

Example:

"Resource": "arn:aws:s3:::YOUR_BUCKET_NAME/*"

Replace YOUR_BUCKET_NAME with your actual bucket name.

The /* means apply the rule to all objects inside the bucket.

My bucket name is:

my-learning-notes-example

Therefore, the policy becomes:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "Statement1",
      "Principal": "*",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::my-learning-notes-example/*"
    }
  ]
}

Click:

Save Changes

Note: Replace my-learning-notes-example with your own bucket name.

Step 14: Access the Website

Go back to:

Bucket → Properties

Scroll down to:

Static Website Hosting

Copy the:

Bucket Website Endpoint URL

Paste it into your browser.

Now, instead of receiving the 403 Forbidden error, your webpage should load successfully.

Congratulations 🎉

You have successfully hosted your first static website using Amazon S3.

Key Takeaways

In this hands-on project, we learned how to:

✅ Create an S3 bucket
✅ Upload objects
✅ Understand bucket and object concepts
✅ Enable versioning
✅ Create IAM users
✅ Understand permissions
✅ Explore bucket policies
✅ Host a static website

What's Next?

In the next article, we will explore another important AWS service and continue building our cloud learning journey.

AWS S3 Basics for Beginners

Vijaya Laxmi Kadham — Sat, 20 Jun 2026 12:24:59 +0000

Introduction

In the previous articles, we explored AWS networking concepts like:

VPC
Subnets
Internet Gateway
Security Groups
Route 53

Now, let's move to one of the most popular AWS services:

Amazon S3 (Simple Storage Service)

Amazon S3 is one of the easiest AWS services to learn and one of the most widely used services in real-world applications.

Almost every application stores some kind of data:

Images
Videos
Documents
Log files
Backups
Static websites

Amazon S3 helps us store and retrieve these files securely from anywhere in the world.

In this article, we will understand:

What Amazon S3 is
Buckets and Objects
Benefits of S3
Storage Classes
Versioning
Basic security concepts
Static website hosting overview

Why Do We Need Storage?

Imagine you are running an online photo-sharing application.

Users upload:

Profile pictures
Photos
Videos

Where should these files be stored?

Keeping them directly inside application servers is not a good idea because:

Storage is limited.
Scaling becomes difficult.
Replacing servers may cause data loss.

This is where Amazon S3 helps.

What is Amazon S3?

Amazon S3 stands for:

Simple Storage Service

It is a cloud-based object storage service provided by AWS.

S3 allows us to:

Store data
Retrieve data
Manage data

from anywhere using the internet.

Amazon S3 is designed to be:

Highly available
Durable
Scalable
Secure
Cost-effective

Real-World Example

Think of Amazon S3 as a digital warehouse.

Suppose you own an e-commerce company.

Inside your warehouse, you store:

Product images
Invoices
Customer documents
Videos

Similarly, Amazon S3 stores digital files safely in the cloud.

Buckets and Objects

Amazon S3 stores data using two concepts:

Bucket

A bucket is a container used to store files.

Think of a bucket like a folder.

Examples:

company-documents
customer-images
application-logs

Bucket names must be globally unique.

Object

Anything stored inside a bucket is called an Object.

Examples:

invoice.pdf
profile.jpg
backup.zip
video.mp4

Objects can contain:

Images
Videos
HTML files
CSV files
JSON files
Log files

Almost any file type can be stored in S3.

Real-Life Example

Cupboard (Bucket)
    ↓
Files and Documents (Objects)

Similarly:

S3 Bucket
    ↓
Objects

Benefits of Amazon S3

1. High Durability

Amazon S3 is famous for its durability.

AWS provides:

99.999999999%

durability.

This is often called:

Eleven 9's of Durability

AWS automatically keeps multiple copies of your data to prevent data loss.

2. High Availability

S3 is designed to remain accessible even if some infrastructure components fail.

Applications can continue accessing files without interruption.

3. Scalability

You don't need to estimate storage in advance.

Whether you store:

10 files
10 million files

Amazon S3 automatically scales.

4. Security

AWS provides multiple security mechanisms:

IAM Policies
Bucket Policies
Encryption
Access Control

These help protect sensitive data.

5. Cost Effective

You only pay for:

Storage used
Requests made

There is no need to purchase storage hardware.

6. High Performance

Amazon S3 supports:

Parallel uploads
Multipart uploads

This improves performance for large files.

S3 Storage Classes

Not every file needs the same level of access.

AWS provides different storage classes.

S3 Standard

Used for frequently accessed files.

Examples:

Website images
Application assets

S3 Standard-IA

IA stands for:

Infrequent Access

Used for files accessed occasionally.

Examples:

Monthly reports
Older documents

One Zone-IA

Stores data in a single Availability Zone.

Cheaper but less resilient.

Suitable for:

Backup copies
Temporary files

S3 Glacier

Used for long-term archival storage.

Examples:

Old backups
Compliance records

Retrieval is slower but storage cost is very low.

What is Versioning?

Suppose today you upload:

report.csv

Tomorrow, you modify the same file and upload it again.

What if you later discover that yesterday's version was correct?

Versioning helps solve this problem.

When versioning is enabled:

Old versions are preserved.
New uploads create new versions.
Previous files can be restored.

Real-Life Example

Think about Git.

Every commit stores history.

Similarly, S3 Versioning stores file history.

Static Website Hosting

Amazon S3 can also host static websites.

Examples:

Portfolio websites
Documentation sites
Landing pages

Files like:

index.html
style.css
logo.png

can be served directly from S3.

Because static websites do not require servers, S3 hosting is:

Simple
Fast
Low cost

Understanding S3 Security

AWS provides multiple layers of security.

Examples:

IAM Policies

Control what users can do.

Bucket Policies

Control who can access a bucket.

Encryption

Protects stored data.

Even if IAM permissions are accidentally configured incorrectly, bucket policies can provide an additional security layer.

Common Use Cases of Amazon S3

Amazon S3 is used for:

Image storage
Video storage
Backup and recovery
Application logs
Static website hosting
Data archival
Data lakes
Big data workloads

Official AWS Documentation

If you'd like to explore S3 in more detail, AWS provides excellent documentation.

Amazon S3 Documentation

https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html

Amazon S3 Overview

https://aws.amazon.com/s3/

Conclusion

Amazon S3 is one of the most important AWS services and is widely used in almost every cloud application.

In this article, we learned:

What Amazon S3 is
Buckets and Objects
Benefits of S3
Storage Classes
Versioning
Security concepts
Static website hosting overview

In the next article, we will perform hands-on exercises and:

Create S3 buckets
Upload files
Enable versioning
Configure permissions
Create IAM users
Host a static website using Amazon S3

AWS S3 Basics for Beginners

Vijaya Laxmi Kadham — Wed, 17 Jun 2026 12:27:17 +0000

Introduction

In the previous articles, we explored AWS networking concepts like:

VPC
Subnets
Internet Gateway
Security Groups
Route 53

Now, let's move to one of the most popular AWS services:

Amazon S3 (Simple Storage Service)

Amazon S3 is one of the easiest AWS services to learn and one of the most widely used services in real-world applications.

Almost every application stores some kind of data:

Images
Videos
Documents
Log files
Backups
Static websites

Amazon S3 helps us store and retrieve these files securely from anywhere in the world.

In this article, we will understand:

What Amazon S3 is
Buckets and Objects
Benefits of S3
Storage Classes
Versioning
Basic security concepts
Static website hosting overview

Why Do We Need Storage?

Imagine you are running an online photo-sharing application.

Users upload:

Profile pictures
Photos
Videos

Where should these files be stored?

Keeping them directly inside application servers is not a good idea because:

Storage is limited.
Scaling becomes difficult.
Replacing servers may cause data loss.

This is where Amazon S3 helps.

What is Amazon S3?

Amazon S3 stands for:

Simple Storage Service

It is a cloud-based object storage service provided by AWS.

S3 allows us to:

Store data
Retrieve data
Manage data

from anywhere using the internet.

Amazon S3 is designed to be:

Highly available
Durable
Scalable
Secure
Cost-effective

Real-World Example

Think of Amazon S3 as a digital warehouse.

Suppose you own an e-commerce company.

Inside your warehouse, you store:

Product images
Invoices
Customer documents
Videos

Similarly, Amazon S3 stores digital files safely in the cloud.

Buckets and Objects

Amazon S3 stores data using two concepts:

Bucket

A bucket is a container used to store files.

Think of a bucket like a folder.

Examples:

company-documents
customer-images
application-logs

Bucket names must be globally unique.

Object

Anything stored inside a bucket is called an Object.

Examples:

invoice.pdf
profile.jpg
backup.zip
video.mp4

Objects can contain:

Images
Videos
HTML files
CSV files
JSON files
Log files

Almost any file type can be stored in S3.

Real-Life Example

Cupboard (Bucket)
    ↓
Files and Documents (Objects)

Similarly:

S3 Bucket
    ↓
Objects

Benefits of Amazon S3

1. High Durability

Amazon S3 is famous for its durability.

AWS provides:

99.999999999%

durability.

This is often called:

Eleven 9's of Durability

AWS automatically keeps multiple copies of your data to prevent data loss.

2. High Availability

S3 is designed to remain accessible even if some infrastructure components fail.

Applications can continue accessing files without interruption.

3. Scalability

You don't need to estimate storage in advance.

Whether you store:

10 files
10 million files

Amazon S3 automatically scales.

4. Security

AWS provides multiple security mechanisms:

IAM Policies
Bucket Policies
Encryption
Access Control

These help protect sensitive data.

5. Cost Effective

You only pay for:

Storage used
Requests made

There is no need to purchase storage hardware.

6. High Performance

Amazon S3 supports:

Parallel uploads
Multipart uploads

This improves performance for large files.

S3 Storage Classes

Not every file needs the same level of access.

AWS provides different storage classes.

S3 Standard

Used for frequently accessed files.

Examples:

Website images
Application assets

S3 Standard-IA

IA stands for:

Infrequent Access

Used for files accessed occasionally.

Examples:

Monthly reports
Older documents

One Zone-IA

Stores data in a single Availability Zone.

Cheaper but less resilient.

Suitable for:

Backup copies
Temporary files

S3 Glacier

Used for long-term archival storage.

Examples:

Old backups
Compliance records

Retrieval is slower but storage cost is very low.

What is Versioning?

Suppose today you upload:

report.csv

Tomorrow, you modify the same file and upload it again.

What if you later discover that yesterday's version was correct?

Versioning helps solve this problem.

When versioning is enabled:

Old versions are preserved.
New uploads create new versions.
Previous files can be restored.

Real-Life Example

Think about Git.

Every commit stores history.

Similarly, S3 Versioning stores file history.

Static Website Hosting

Amazon S3 can also host static websites.

Examples:

Portfolio websites
Documentation sites
Landing pages

Files like:

index.html
style.css
logo.png

can be served directly from S3.

Because static websites do not require servers, S3 hosting is:

Simple
Fast
Low cost

Understanding S3 Security

AWS provides multiple layers of security.

Examples:

IAM Policies

Control what users can do.

Bucket Policies

Control who can access a bucket.

Encryption

Protects stored data.

Even if IAM permissions are accidentally configured incorrectly, bucket policies can provide an additional security layer.

Common Use Cases of Amazon S3

Amazon S3 is used for:

Image storage
Video storage
Backup and recovery
Application logs
Static website hosting
Data archival
Data lakes
Big data workloads

Official AWS Documentation

If you'd like to explore S3 in more detail, AWS provides excellent documentation.

Amazon S3 Documentation

https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html

Amazon S3 Overview

https://aws.amazon.com/s3/

Conclusion

Amazon S3 is one of the most important AWS services and is widely used in almost every cloud application.

In this article, we learned:

What Amazon S3 is
Buckets and Objects
Benefits of S3
Storage Classes
Versioning
Security concepts
Static website hosting overview

In the next article, we will perform hands-on exercises and:

Create S3 buckets
Upload files
Enable versioning
Configure permissions
Create IAM users
Host a static website using Amazon S3

DEV Community: Vijaya Laxmi Kadham

🐾 PawTrack: A Daily Activity & Wellness Tracker for Your Dog

What I Built

Demo

🐶 Daily Tracker

📊 PawTrack Dashboard

📸 Screenshots

🐾 Daily Tracker

📊 Dashboard

Code

How I Built It

🏗️ Application Flow

🐾 Paw Score

📈 15-Day History

🔒 Why localStorage?

What I Learned

Prize Categories

🐾 Final Thoughts

AWS CloudWatch For Beginners – Monitoring, Metrics, Alarms & with Default Metrics Demo

Introduction

What Problem does CloudWatch Solve?

Major CloudWatch Features

CloudWatch Metrics Concepts

CloudWatch Architecture for the Project

Demo 1 - AWS Default Metric

Demo - Monitor EC2 CPU Utilization

Objective

Step 1: Create the EC2 Instance

step 2 - Open CloudWatch

Step 3 - Find EC2 Metrics

Understanding CPU Utilization

Step 4 - Create the CloudWatch Alarm

Step 5 – Configure SNS Notification

Step 6 – Name the Alarm

Step 7 - Connect to the EC2 Instance

Step 8 – Check Python

Step 9 – Create the Python File

Understanding the Python Code

1. Import the Time Module

2. Set the Duration

3. Record the Starting Time

4. Run the CPU Workload

5. Perform Calculations

6. Handle Manual Interruption

Step 10 - Save the File in Vim

Step 11 - Run the CPU Load Test

Step 12 - Check CloudWatch CPUUtilization

Step 13 - Check the SNS Email

Complete Project Workflow

Final Flow

What's Next?

Preparing for AWS CI/CD Hands-On Project - Prerequisites

Introduction

Why Do We Need Docker?

What is Docker Hub?

Create a Docker Hub Account

What is AWS CodeBuild?

Where Does CodeBuild Fit?

What Happens Inside CodeBuild?

What is a Build Environment?

What is a buildspec.yml File?

Real-World Example

Why Use AWS CodeBuild?

Fully Managed

Automatic Scaling

Pay Only for What You Use

Easy Integration

No Build Server Maintenance

What's Next?

AWS CodePipeline Explained for Beginners | Understanding CI/CD on AWS

Introduction

What is CI/CD?

How Does CI/CD Usually Work?

What Happens Here?

What is a Jenkins Pipeline?

What is Continuous Integration (CI)?

What is Continuous Delivery (CD)?

How Does AWS Solve This Problem?

What is AWS CodePipeline?

How AWS CodePipeline Works

What is a `buildspec.yml` File?