# AWS Journey – Week 1 | AWS Cloud Fundamentals & First Deployment 🚀

# ☁️ Introduction to AWS & Public Cloud | Complete Beginner Guide for DevOps Engineers 🚀

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/7bdc81d5-ff42-4e4e-af25-eabe57ef91e6.png align="center")

## 📌 Introduction

Cloud computing has completely changed the way organizations build, deploy, and manage applications. Instead of purchasing expensive physical servers and maintaining data centers, companies can now use cloud platforms like **AWS, Azure, and Google Cloud** to access computing resources whenever required.

In this blog, we will understand:

*   What is Cloud Computing?
    
*   Evolution from Traditional Data Centers to Cloud
    
*   What is Virtualization?
    
*   Public Cloud vs Private Cloud
    
*   Why AWS is Popular?
    
*   Benefits of AWS for DevOps Engineers
    
*   How to Create an AWS Account
    

This blog is part of the **AWS Zero to Hero for DevOps Engineers** journey, where we will learn AWS concepts practically with real-world examples.

* * *

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/f8b50c20-6a9a-4960-96cc-2ae2e587481a.png align="center")

# ☁️ What is Cloud Computing?

**Cloud Computing is the delivery of IT resources like servers, storage, databases, networking, and software over the internet on demand.**

Instead of buying and managing physical hardware, organizations can rent resources from cloud providers and pay only for what they use.

### Traditional Data Center Approach

Earlier, companies followed an **on-premises infrastructure model**:

```plaintext
Company → Buys Servers → Setup Data Center → Maintain Hardware → Deploy Applications
```

Challenges:

*   High hardware cost 💰
    
*   Requires physical space
    
*   Manual maintenance
    
*   Limited scalability
    
*   Hardware failure risks
    

Example:

A company launching a new application needs:

*   Servers
    
*   Storage
    
*   Network devices
    
*   Security systems
    
*   IT administrators
    

Setting up everything can take weeks or months.

* * *

# 🚀 Evolution from Data Centers to Cloud

Cloud computing evolved because organizations needed faster, cheaper, and scalable infrastructure.

## Traditional Infrastructure

```plaintext
Physical Server
      |
      |
Operating System
      |
      |
Application
```

One physical server usually runs one application, causing resource wastage.

* * *

# 🖥️ What is Virtualization?

Virtualization is the technology that allows multiple virtual machines to run on a single physical server.

Example:

One powerful physical server can create:

```plaintext
Physical Server
       |
       |
Hypervisor
       |
 -----------------
 |       |       |
VM-1   VM-2    VM-3
Linux  Linux   Windows
```

Benefits:

✅ Better hardware utilization  
✅ Reduced infrastructure cost  
✅ Easy resource management  
✅ Faster deployment

Virtualization became the foundation of modern cloud computing.

* * *

# ☁️ What is Public Cloud?

A **Public Cloud** is a cloud environment where infrastructure is owned and managed by third-party cloud providers.

Examples:

*   Amazon Web Services (AWS)
    
*   Microsoft Azure
    
*   Google Cloud
    

Cloud providers manage:

*   Physical servers
    
*   Networking equipment
    
*   Data centers
    
*   Hardware maintenance
    
*   Security infrastructure
    

Users only consume required services.

* * *

# 🏢 What is Private Cloud?

A **Private Cloud** is a cloud infrastructure dedicated to a single organization.

Example:

A banking organization creates and manages its own cloud environment.

Architecture:

```plaintext
Organization
      |
Private Cloud
      |
Applications & Data
```

### Advantages:

✅ More control  
✅ Higher customization  
✅ Better compliance management

### Challenges:

❌ Expensive infrastructure  
❌ Requires skilled administrators  
❌ Maintenance responsibility is on the organization

* * *

# 🆚 Public Cloud vs Private Cloud

| Feature | Public Cloud | Private Cloud |
| --- | --- | --- |
| Ownership | Cloud Provider | Organization |
| Cost | Low initial cost | High investment |
| Maintenance | Managed by provider | Managed internally |
| Scalability | Very high | Limited |
| Example | AWS, Azure, GCP | Enterprise Private Cloud |
| Best For | Startups, enterprises | Organizations requiring complete control |

* * *

# 🌟 Why Choose Public Cloud?

Public cloud became popular because it solves many infrastructure problems.

## 1\. Pay-As-You-Go Model 💰

You pay only for the resources you consume.

Example:

Instead of purchasing a server worth ₹5 lakh:

*   Create cloud server
    
*   Use it for required time
    
*   Stop it when not needed
    
*   Pay only usage cost
    

* * *

## 2\. Scalability 🚀

Cloud allows applications to increase or decrease resources according to demand.

Example:

During a festival sale:

```plaintext
Normal Traffic
      |
Increase Users
      |
Automatically Add More Servers
```

After traffic decreases:

```plaintext
Remove Extra Resources
Save Cost
```

* * *

## 3\. No Hardware Maintenance

Cloud providers handle:

*   Server maintenance
    
*   Hardware replacement
    
*   Data center management
    
*   Network infrastructure
    

Developers and DevOps engineers can focus on applications.

* * *

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/f24d7fea-36a4-46ab-ab24-6fef427781b3.png align="center")

# ☁️ Why AWS?

AWS is one of the most widely used cloud platforms globally.

## Reasons AWS is Popular:

### 1\. Cloud Market Leader

AWS was one of the first major cloud providers and has a large ecosystem.

* * *

### 2\. Huge Number of Services

AWS provides services for:

*   Compute
    
*   Storage
    
*   Networking
    
*   Databases
    
*   Security
    
*   Monitoring
    
*   Machine Learning
    
*   Containers
    

Examples:

| Requirement | AWS Service |
| --- | --- |
| Virtual Server | EC2 |
| Storage | S3 |
| Database | RDS |
| Networking | VPC |
| Kubernetes | EKS |
| Monitoring | CloudWatch |

* * *

### 3\. Career Opportunities 🚀

AWS knowledge is highly valuable for:

*   DevOps Engineers
    
*   Cloud Engineers
    
*   Solutions Architects
    
*   SRE Engineers
    

Many organizations use AWS for production workloads.

* * *

# 🔄 Cloud Repatriation Concept

Cloud repatriation means moving workloads back from cloud environments to on-premises infrastructure.

Reasons:

*   Cost optimization
    
*   Compliance requirements
    
*   Specific business needs
    

However, most organizations continue using cloud because of:

✅ Flexibility  
✅ Scalability  
✅ Faster deployment  
✅ Managed services

* * *

# 👨‍💻 Why AWS is Important for DevOps Engineers?

Modern DevOps engineers work heavily with cloud environments.

AWS helps DevOps engineers manage:

### Infrastructure

*   EC2
    
*   VPC
    
*   Load Balancers
    

### Automation

*   CloudFormation
    
*   AWS CLI
    

### Containers

*   EKS
    
*   ECS
    

### CI/CD

*   CodePipeline
    
*   CodeBuild
    
*   CodeDeploy
    

### Monitoring

*   CloudWatch
    

* * *

# 🛠️ Creating an AWS Account

To start learning AWS, we need an AWS account.

## Requirements:

✅ Email address  
✅ Phone number  
✅ Payment card for verification

AWS provides a **Free Tier** that allows beginners to practice many services without immediate charges within free usage limits.

* * *

# Steps to Create AWS Account

## Step 1: Visit AWS Website

Go to AWS official website and select:

**Create AWS Account**

* * *

## Step 2: Enter Account Details

Provide:

*   Email address
    
*   Account name
    
*   Password
    

* * *

## Step 3: Verify Identity

AWS verifies:

*   Email
    
*   Mobile number
    

* * *

## Step 4: Add Payment Information

AWS requires payment details for identity verification.

Note:

Adding a card does not mean automatic charges if you stay within Free Tier limits.

* * *

## Step 5: Select Support Plan

For beginners:

Choose:

**Basic Support Plan (Free)**

* * *

## Step 6: Login to AWS Console

After successful setup:

You can access:

```plaintext
AWS Management Console
        |
        |
AWS Services Dashboard
```

* * *

# 🎯 Real-World Example

Imagine you want to build an e-commerce website.

### Without Cloud:

You need:

*   Buy servers
    
*   Install software
    
*   Configure networking
    
*   Maintain hardware
    

Time: Weeks/Months

* * *

### With AWS:

You can:

1.  Create EC2 server
    
2.  Store images in S3
    
3.  Use RDS database
    
4.  Configure Load Balancer
    
5.  Monitor using CloudWatch
    

Time: Minutes

* * *

# 🔥 Key Takeaways

✅ Cloud computing provides IT resources over the internet.

✅ Virtualization made cloud computing possible.

✅ Public cloud removes hardware management responsibility.

✅ AWS is one of the leading cloud platforms.

✅ DevOps engineers must understand AWS services.

✅ AWS provides scalable, flexible, and cost-effective infrastructure.

* * *

# ☁️ AWS IAM Deep Dive with Practical Implementation

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/d9405754-6db5-4f21-888c-7eafa4f6ed88.png align="center")

## 🔐 Introduction to AWS Identity and Access Management (IAM)

AWS Identity and Access Management (**IAM**) is one of the most important security services in AWS that helps organizations **control who can access AWS resources and what actions they can perform**.

In simple words:

> **IAM answers two important questions:**
> 
> 1.  **Who are you?** → Authentication
>     
> 2.  **What are you allowed to do?** → Authorization
>     

Example:

Imagine an office building:

*   **Authentication** → Security guard checks your ID card.
    
*   **Authorization** → Your ID card decides which rooms you can enter.
    

Similarly, AWS IAM verifies users and provides permissions to access AWS services.

* * *

# 🤔 Why Do We Need IAM in AWS?

When an AWS account is created, it comes with a **Root User** that has complete access to all AWS services.

Using the root user for daily activities is dangerous because:

*   It has unlimited permissions.
    
*   Any mistake can impact the entire AWS account.
    
*   If credentials are compromised, attackers can access everything.
    

Therefore, AWS recommends:

✅ Create separate IAM users  
✅ Assign only required permissions  
✅ Follow the Principle of Least Privilege

* * *

# 🔑 Authentication vs Authorization

Understanding these two concepts is very important for AWS security.

## 🔹 Authentication (Who are you?)

Authentication verifies the identity of a user or application.

Examples:

*   Username and password
    
*   Access Key ID and Secret Access Key
    
*   Multi-Factor Authentication (MFA)
    

Example:

A developer logs into AWS using IAM credentials.

AWS verifies:

```plaintext
Is this user valid?
```

* * *

## 🔹 Authorization (What can you do?)

Authorization decides what actions the authenticated user can perform.

Example:

A developer may have permission to:

✅ Create EC2 instances  
✅ View S3 buckets

But may not have permission to:

❌ Delete databases  
❌ Modify IAM policies

AWS uses policies to define these permissions.

* * *

# 🏗️ AWS IAM Core Components

AWS IAM mainly consists of four important components:

1.  Users
    
2.  Groups
    
3.  Policies
    
4.  Roles
    

* * *

# 👤 1. IAM Users

An IAM User represents an individual person or application that needs access to AWS.

Examples:

*   Developer
    
*   Tester
    
*   Database Administrator
    
*   DevOps Engineer
    

Example:

A company has:

```plaintext
Developers
   |
   |-- Rahul
   |-- Amit
   |-- Priya
```

Each employee can have their own IAM user.

Benefits:

✅ Individual access control  
✅ Activity tracking  
✅ Better security  
✅ Easy permission management

* * *

# 👥 2. IAM Groups

An IAM Group is a collection of IAM users with similar permissions.

Instead of assigning permissions individually to every user, we create groups.

Example:

```plaintext
Development Group

Users:
- Rahul
- Amit
- Priya

Permissions:
- EC2 Access
- S3 Access
```

When a new developer joins:

Instead of creating permissions again:

```plaintext
Create User → Add User to Development Group
```

The user automatically gets required permissions.

### Common Groups:

```plaintext
Developers
QA Team
Administrators
Database Team
Security Team
```

* * *

# 📜 3. IAM Policies

Policies define what actions a user, group, or role can perform.

IAM policies are written in JSON format.

A policy contains:

*   Effect → Allow or Deny
    
*   Action → AWS operation
    
*   Resource → AWS resource
    

Example:

A policy allowing S3 access:

```json
{
 "Effect": "Allow",
 "Action": [
    "s3:*"
 ],
 "Resource": "*"
}
```

Meaning:

```plaintext
Allow
|
|-- All S3 actions
|
|-- On all resources
```

* * *

# 🎭 4. IAM Roles

IAM Roles provide temporary permissions to AWS services or users.

Unlike users:

*   Roles do not have passwords.
    
*   Roles provide temporary credentials.
    
*   Mostly used by applications and AWS services.
    

Example:

A web application running on EC2 needs access to S3.

Bad approach:

```plaintext
Store AWS Access Keys inside application code
```

Security risk ❌

Better approach:

```plaintext
EC2 Instance
       |
       |
IAM Role
       |
       |
S3 Access Permission
```

The application automatically gets permission through the role.

* * *

# 🔄 IAM Workflow

The complete IAM access flow:

```plaintext
User/Application
        |
        |
Authentication
        |
        |
IAM Policy Evaluation
        |
        |
Authorization
        |
        |
AWS Resource Access
```

Example:

Developer wants to create an S3 bucket.

Flow:

```plaintext
Developer Login
        |
        |
IAM verifies identity
        |
        |
Checks attached policies
        |
        |
Allow/Deny request
        |
        |
Create S3 Bucket
```

* * *

# 🛡️ Principle of Least Privilege

One of the most important AWS security principles.

Meaning:

> Give users only the permissions they actually need.

Example:

A developer only needs:

```plaintext
Read + Write access to S3
```

Do not provide:

```plaintext
Administrator Access
```

because unnecessary permissions increase security risks.

* * *

# 🚨 IAM Security Best Practices

## 1\. Never Use Root User Daily

Root account should only be used for:

*   Account setup
    
*   Billing configuration
    
*   Critical operations
    

For daily tasks:

Use IAM users.

* * *

## 2\. Enable MFA

Multi-Factor Authentication adds an extra security layer.

Example:

Password + Mobile OTP

Even if a password is leaked, attackers cannot access the account easily.

* * *

## 3\. Use IAM Roles Instead of Hardcoded Credentials

Avoid:

```plaintext
AWS_ACCESS_KEY=xxxxx
AWS_SECRET_KEY=xxxxx
```

inside application code.

Use:

```plaintext
Application
      |
      |
IAM Role
      |
      |
AWS Services
```

* * *

## 4\. Regularly Review Permissions

Remove:

*   Unused users
    
*   Old access keys
    
*   Unnecessary permissions
    

* * *

# 🧪 Practical Implementation Explained

## Creating IAM User

Steps:

```plaintext
AWS Console
    |
IAM Service
    |
Users
    |
Create User
```

Provide:

*   Username
    
*   Access type
    
*   Permissions
    

* * *

# Example: Developer Access Scenario

Company requirement:

A developer needs access to S3.

## Without IAM:

```plaintext
Share AWS Root Credentials
```

Problem:

❌ No tracking  
❌ Security risk  
❌ Complete account access

* * *

## With IAM:

Create user:

```plaintext
Developer Rahul
```

Attach policy:

```plaintext
AmazonS3FullAccess
```

Now:

Rahul can:

✅ Create buckets  
✅ Upload files  
✅ Manage objects

But cannot:

❌ Delete EC2 instances  
❌ Modify IAM users

* * *

# 🌎 Real-World DevOps Scenario

## Scenario:

A company has multiple teams:

```plaintext
Organization

├── Developers
├── QA Engineers
├── DevOps Team
└── Security Team
```

Each team requires different permissions.

Solution:

```plaintext
IAM Groups

Developer Group
   |
   └── EC2 + S3 Access


QA Group
   |
   └── Testing Environment Access


DevOps Group
   |
   └── Full Infrastructure Access
```

This provides:

✅ Better security  
✅ Easy management  
✅ Clear responsibility

* * *

# 🔥 IAM in DevOps Real World

DevOps engineers use IAM for:

### CI/CD Pipelines

Example:

Jenkins needs permission to deploy applications.

Solution:

```plaintext
Jenkins
   |
IAM Role
   |
AWS Deployment Permissions
```

* * *

### Kubernetes / EKS

Applications running inside Kubernetes need AWS access.

Solution:

```plaintext
Pod
 |
IAM Role
 |
AWS Services
```

* * *

### Infrastructure Automation

Tools like:

*   Terraform
    
*   Ansible
    
*   CloudFormation
    

use IAM permissions to create and manage AWS resources.

* * *

# 📌 Important AWS IAM Interview Questions

## Q1. What is AWS IAM?

**Answer:**

AWS IAM is a security service that helps manage users, permissions, and access control for AWS resources.

It provides authentication and authorization to securely manage AWS services.

* * *

## Q2. Difference between IAM User and IAM Role?

| IAM User | IAM Role |
| --- | --- |
| Permanent identity | Temporary identity |
| Has username/password | No password |
| Used by humans | Used by applications/services |
| Long-term credentials | Temporary credentials |

* * *

## Q3. What is an IAM Policy?

**Answer:**

IAM Policy is a JSON document that defines permissions.

It specifies:

*   Which actions are allowed
    
*   On which resources
    
*   For which users or roles
    

* * *

## Q4. Why should we not use AWS Root User?

**Answer:**

Root user has unlimited permissions.

Using it daily increases security risks.

AWS recommends creating IAM users with limited permissions.

* * *

## Q5. What is the Principle of Least Privilege?

**Answer:**

It means providing only the minimum permissions required to complete a task.

Example:

A developer who only needs S3 access should not receive administrator permissions.

* * *

# 🎯 Key Takeaways

✅ IAM manages AWS access securely  
✅ Authentication verifies identity  
✅ Authorization controls permissions  
✅ Users represent individuals  
✅ Groups simplify permission management  
✅ Policies define access rules  
✅ Roles provide temporary permissions  
✅ Always follow least privilege security practices

* * *

# ☁️ AWS EC2 Deep Dive | Launch Your First Cloud Server & Deploy Jenkins 🚀

* * *

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/dd68f3ea-c462-44bf-8494-24e424fffc45.png align="center")

# 🚀 Introduction to Amazon EC2

Amazon EC2 (**Elastic Compute Cloud**) is one of the most important services in AWS that provides **virtual servers in the cloud**.

In simple words:

> **EC2 allows you to create and manage virtual machines on AWS without purchasing or maintaining physical hardware.**

Instead of buying a physical server:

```plaintext
Traditional Infrastructure:

Company
   |
   |
Physical Server
   |
   |
Application
```

AWS provides:

```plaintext
AWS Cloud:

User
 |
 |
EC2 Instance (Virtual Server)
 |
 |
Application
```

With EC2, you can:

✅ Launch servers within minutes  
✅ Choose CPU, memory, and storage according to requirements  
✅ Scale resources whenever needed  
✅ Pay only for what you use

* * *

# 🤔 Why Do We Need EC2?

Before cloud computing, organizations had to:

*   Buy physical servers
    
*   Setup data centers
    
*   Maintain hardware
    
*   Manage networking
    
*   Handle server failures
    

Problems:

❌ High infrastructure cost  
❌ Long setup time  
❌ Difficult scaling  
❌ Hardware maintenance overhead

AWS EC2 solves these problems:

✅ On-demand servers  
✅ Flexible pricing  
✅ Easy scaling  
✅ Global availability

* * *

# ⚡ What Does "Elastic" Mean in EC2?

The word **Elastic** means the ability to increase or decrease resources based on requirements.

Example:

An e-commerce website during normal days:

```plaintext
Users: 10,000

Required:
2 EC2 Instances
```

During a festival sale:

```plaintext
Users: 1,00,000

Required:
20 EC2 Instances
```

EC2 allows organizations to scale resources according to traffic.

Benefits:

✅ Better performance  
✅ Reduced cost  
✅ High availability

* * *

# 🏗️ EC2 Instance Architecture

An EC2 instance contains:

```plaintext
              EC2 Instance

        +-------------------+
        | Operating System  |
        | Ubuntu / Linux    |
        +-------------------+
        | Application      |
        | Jenkins          |
        +-------------------+
        | CPU              |
        | Memory           |
        | Storage          |
        +-------------------+
```

* * *

# 🧩 Important EC2 Components

## 1\. Amazon Machine Image (AMI)

AMI is a template used to create EC2 instances.

It contains:

*   Operating System
    
*   Software configuration
    
*   Required settings
    

Examples:

```plaintext
Ubuntu AMI
Amazon Linux AMI
Windows Server AMI
```

When launching an EC2 instance:

```plaintext
AMI
 |
 |
Creates
 |
 |
EC2 Instance
```

* * *

# 2\. Instance Type

Instance type defines the hardware configuration of an EC2 machine.

It decides:

*   CPU power
    
*   Memory
    
*   Network performance
    
*   Storage capability
    

Example:

```plaintext
t2.micro

CPU:
1 vCPU

Memory:
1 GB RAM
```

* * *

# 🖥️ EC2 Instance Types

AWS provides different instance families.

* * *

# 1\. General Purpose Instances

Balanced CPU, memory, and networking.

Used for:

*   Web servers
    
*   Development environments
    
*   Testing
    

Examples:

```plaintext
t2.micro
t3.medium
```

Beginner projects usually use:

```plaintext
t2.micro
```

because it is suitable for learning.

* * *

# 2\. Compute Optimized Instances

Designed for CPU-intensive workloads.

Used for:

*   Gaming servers
    
*   Scientific calculations
    
*   Batch processing
    

Example:

```plaintext
C Series
```

* * *

# 3\. Memory Optimized Instances

Designed for applications requiring high memory.

Used for:

*   Databases
    
*   Big data applications
    
*   Cache systems
    

Example:

```plaintext
R Series
```

* * *

# 4\. Storage Optimized Instances

Designed for high-speed storage.

Used for:

*   Data processing
    
*   Large databases
    
*   Analytics workloads
    

* * *

# 5\. Accelerated Computing Instances

Uses GPUs for heavy processing.

Used for:

*   Machine learning
    
*   AI workloads
    
*   Video processing
    

* * *

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/93eb4f1b-e8f4-497d-8832-5ad79ba7bc37.png align="center")

# 🌎 AWS Regions and Availability Zones

## What is an AWS Region?

A Region is a geographical location where AWS has data centers.

Examples:

```plaintext
Asia Pacific (Mumbai)

US East (North Virginia)

Europe (Ireland)
```

* * *

## What is an Availability Zone?

Availability Zone (AZ) is an isolated data center inside a region.

Example:

```plaintext
Mumbai Region

 |
 |
 +--- Availability Zone A
 |
 +--- Availability Zone B
 |
 +--- Availability Zone C
```

Benefits:

✅ High availability  
✅ Disaster recovery  
✅ Low latency

* * *

# 🔐 EC2 Security

Security is managed using:

## Security Groups

A Security Group acts like a virtual firewall.

It controls:

*   Incoming traffic
    
*   Outgoing traffic
    

Example:

Default:

```plaintext
SSH Port 22
Blocked
```

Allow:

```plaintext
Port 22 → SSH Access

Port 8080 → Jenkins Access

Port 80 → Website Access
```

* * *

# 🔑 Key Pair in EC2

AWS uses key pairs for secure authentication.

A key pair contains:

```plaintext
Public Key
+
Private Key (.pem file)
```

Example:

```plaintext
jenkins-key.pem
```

Used for SSH login.

* * *

# 🔗 Connecting to EC2 Using SSH

Command:

```bash
ssh -i jenkins-key.pem ubuntu@<public-ip>
```

Before connecting:

Change permission:

```bash
chmod 600 jenkins-key.pem
```

Why?

Because AWS requires private keys to be accessible only by the owner.

* * *

# 🚀 Practical Project: Deploy Jenkins on AWS EC2

![](https://cdn.hashnode.com/uploads/covers/66fecde7cb0abd844c1a2f3c/911aee46-e2f6-4f19-a18e-a378ccd77f09.png align="center")

Now let's deploy Jenkins on an EC2 instance.

Architecture:

```plaintext
Developer

    |
    |

AWS EC2 Instance

    |
    |

Ubuntu Server

    |
    |

Jenkins Application

    |
    |

CI/CD Pipeline
```

* * *

# Step 1: Launch EC2 Instance

Configuration:

```plaintext
AMI:
Ubuntu

Instance Type:
t2.micro

Storage:
Default

Security Group:
SSH - Port 22
Custom TCP - Port 8080
```

* * *

# Step 2: Connect to EC2

Using SSH:

```bash
ssh -i key.pem ubuntu@public-ip
```

Successful login:

```plaintext
ubuntu@ip-172-xx-xx
```

Now we are inside our cloud server.

* * *

# Step 3: Update System Packages

Run:

```bash
sudo apt update
```

Why?

To get the latest package information.

* * *

# Step 4: Install Java

Jenkins requires Java.

Install:

```bash
sudo apt install openjdk-17-jdk
```

Verify:

```bash
java -version
```

Output:

```plaintext
openjdk version 17
```

* * *

# Step 5: Install Jenkins

Add Jenkins repository:

```bash
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo tee \
/usr/share/keyrings/jenkins-keyring.asc
```

Install Jenkins:

```bash
sudo apt install jenkins
```

Start Jenkins:

```bash
sudo systemctl start jenkins
```

Enable on startup:

```bash
sudo systemctl enable jenkins
```

Check status:

```bash
sudo systemctl status jenkins
```

* * *

# Step 6: Configure Security Group

Jenkins runs on:

```plaintext
Port 8080
```

Allow inbound traffic:

```plaintext
Custom TCP

Port:
8080

Source:
0.0.0.0/0
```

Now Jenkins can be accessed externally.

* * *

# Step 7: Access Jenkins Dashboard

Open browser:

```plaintext
http://<EC2-Public-IP>:8080
```

Example:

```plaintext
http://13.xx.xx.xx:8080
```

Jenkins login page appears.

* * *

# 🔑 Get Jenkins Initial Password

Run:

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

Copy password and complete setup.

* * *

# 🌍 Real-World DevOps Scenario

## Scenario:

A company wants to automate application deployment.

Previously:

```plaintext
Developer

Manual Deployment

Production Server
```

Problems:

❌ Slow deployment  
❌ Human errors  
❌ No automation

Solution:

```plaintext
Developer

     |
     |

GitHub

     |
     |

Jenkins on EC2

     |
     |

Build + Test + Deploy

     |
     |

Production
```

Benefits:

✅ Automated deployments  
✅ Faster releases  
✅ Better reliability

* * *

# 🏢 How Companies Use EC2?

EC2 is commonly used for:

### Web Applications

Example:

```plaintext
Frontend
Backend API
Database
```

* * *

### CI/CD Servers

Tools:

*   Jenkins
    
*   GitLab Runner
    
*   GitHub Actions Runner
    

* * *

### Development Servers

Developers create temporary environments for testing.

* * *

### Monitoring Tools

Running:

*   Prometheus
    
*   Grafana
    
*   ELK Stack
    

* * *

# 📌 Important EC2 Commands

Check server information:

```bash
uname -a
```

Check disk:

```bash
df -h
```

Check memory:

```bash
free -h
```

Check running services:

```bash
systemctl status
```

Install packages:

```bash
sudo apt install <package>
```

* * *

# 🎯 EC2 Interview Questions

## Q1. What is Amazon EC2?

**Answer:**

Amazon EC2 is a cloud computing service that provides scalable virtual servers in AWS.

It allows users to run applications without managing physical infrastructure.

* * *

## Q2. What is the difference between Region and Availability Zone?

**Answer:**

Region is a geographical AWS location.

Availability Zone is an isolated data center inside a region.

Example:

```plaintext
Mumbai Region

AZ-A
AZ-B
AZ-C
```

* * *

## Q3. What is Security Group in EC2?

**Answer:**

Security Group is a virtual firewall that controls inbound and outbound traffic for EC2 instances.

* * *

## Q4. Why do we use Key Pair in EC2?

**Answer:**

Key pairs provide secure SSH authentication without using passwords.

* * *

## Q5. How do you access Jenkins deployed on EC2?

**Answer:**

Jenkins runs on port 8080.

We allow port 8080 in Security Group and access:

```plaintext
http://EC2-Public-IP:8080
```

* * *

# 🚀 Key Takeaways

✅ EC2 provides virtual servers in AWS  
✅ Elasticity allows scaling resources  
✅ Instance types decide performance  
✅ Regions and AZs provide availability  
✅ Security Groups protect servers  
✅ Key pairs provide secure access  
✅ Jenkins can be deployed easily on EC2  
✅ EC2 is one of the most important AWS services for DevOps engineers

* * *

* * *

# 🚀 Continue Your Learning Journey

Thank you for taking the time to read this article.

Technology is evolving rapidly, and continuous learning is one of the most valuable investments you can make in your career. Whether you're exploring **DevOps, Cloud Computing, Artificial Intelligence, Cybersecurity, Software Development, Data Science, or Career Growth**, the resources below can help you deepen your knowledge and stay ahead in the industry.

* * *

# 🎓 Recommended Learning Platforms

## 🚀 Coursera

Learn from world-renowned universities and industry leaders including Google, IBM, Stanford, Microsoft, Meta, and many more.

✔ Professional Certificates ✔ Career-focused Learning Paths ✔ AI & Machine Learning Programs ✔ Cloud & DevOps Certifications ✔ Business & Leadership Courses

🔗 https://imp.i384100.net/k0KvbV

* * *

## 💻 Udemy

One of the largest online learning platforms with practical, hands-on courses covering:

✔ DevOps & Kubernetes ✔ Docker & Cloud Computing ✔ AWS, Azure & GCP ✔ Programming & Development ✔ Cybersecurity & Ethical Hacking

🔗 https://trk.udemy.com/MAL2MY

* * *

## 📊 DataCamp

A great platform for anyone interested in:

✔ Python Programming ✔ SQL & Databases ✔ Data Analytics ✔ Machine Learning ✔ Artificial Intelligence

Interactive learning paths and hands-on projects make it ideal for beginners and professionals alike.

🔗 https://datacamp.pxf.io/nX4kER

* * *

## 🎓 edX

Access high-quality courses and certifications from leading institutions such as:

✔ Harvard University ✔ MIT ✔ Berkeley ✔ Microsoft

Perfect for learners seeking university-level education online.

🔗 https://edx.sjv.io/POvVeN

* * *

## 🎨 Domestika

Enhance your creative skills with courses on:

✔ Graphic Design ✔ Video Editing ✔ Animation ✔ Digital Marketing ✔ Content Creation

🔗 https://domestika.sjv.io/dynKAW

* * *

# 🛠️ Recommended Tools & Resources

## 🔥 AppSumo

Discover exclusive lifetime deals on:

✔ AI Tools ✔ Productivity Software ✔ Developer Utilities ✔ Marketing Platforms ✔ Business Applications

A must-have resource for developers, creators, freelancers, and entrepreneurs looking to save money while accessing premium tools.

🔗 https://appsumo.8odi.net/L04a33

* * *

## 🛒 Shopify

Looking to start an online business or launch an eCommerce store?

Shopify provides everything you need to build, manage, and scale an online business.

✔ Online Store Builder ✔ Payment Integration ✔ Inventory Management ✔ Marketing Tools

🔗 https://shopify.pxf.io/Vxv09k

* * *

## 🌐 WordPress, WooCommerce & Jetpack

Create professional websites, blogs, and online stores with one of the most trusted web ecosystems in the world.

Ideal for:

✔ Personal Blogs ✔ Portfolio Websites ✔ Business Websites ✔ eCommerce Stores

🔗 https://automattic.pxf.io/Z6vR5W

* * *

# 🌍 Language Learning Resources

## 🗣️ Preply

Learn English and other languages through personalized one-on-one tutoring sessions with experts from around the world.

🔗 https://preply.sjv.io/o4gBDY

* * *

## 📚 British Council English Online

Improve your professional communication skills and English fluency through structured learning programs.

🔗 https://englishonline.sjv.io/9VOGa4

* * *

## 🧠 Rosetta Stone

One of the most recognized language-learning platforms for immersive language acquisition.

🔗 https://aff.rosettastone.com/X4OyqG

* * *

# 🧪 Science & Educational Resources

## 🔬 MEL Science

Interactive science kits and educational experiences designed to make STEM learning engaging and practical.

🔗 https://imp.i328067.net/bk2beg

* * *

## 📖 Carson Dellosa Education

Educational materials and learning resources for students, teachers, and lifelong learners.

🔗 https://carsondellosaeducation.sjv.io/E0JbjW

* * *

# ❤️ Support My Work

Creating detailed technical content, tutorials, guides, and learning resources takes significant time and effort.

If you find my articles helpful and would like to support my work, you can do so through the following platforms:

## ⭐ Become a GitHub Sponsor

Support my open-source contributions, technical content, and community projects.

🔗 https://github.com/sponsors/hritikranjan1

* * *

## ☕ Buy Me a Chai

Enjoying my content? Consider buying me a chai and supporting future tutorials, guides, and educational resources.

🔗 https://www.chai4.me/hritikranjan

* * *

# 👨‍💻 Connect With Me

**Hritik Ranjan**

💡 AI Enthusiast ☁️ DevOps Learner 🔐 Cybersecurity Advocate 💻 Software Developer

### Connect & Follow

🔗 GitHub: https://github.com/hritikranjan1

🔗 LinkedIn: https://linkedin.com/in/hritikranjan1

* * *

## 📢 Found This Article Helpful?

If this article added value to your learning journey:

✅ Share it with your network  
✅ Bookmark it for future reference  
✅ Follow for more DevOps, AI, Cloud, Cybersecurity, and Software Engineering content

Thank you for reading and being part of this learning journey.

**Keep Learning. Keep Building. Keep Growing. 🚀**