DEV Community: Mubeen Babar

🚀 Multi-Application CI/CD on AWS (Production-Style)

Mubeen Babar — Thu, 01 Jan 2026 06:36:51 +0000

🎯 Project Goal
Host multiple web applications on AWS where:

Developers push code to GitHub
GitHub Actions automatically:
Tests code
Builds Docker images
Pushes images to AWS ECR
Deploys to AWS ECS (Fargate) or EC2 + Docker
End users access apps via HTTPS (ALB + ACM)
Logs & monitoring via CloudWatch
Supports rolling / blue-green deployment

🏗️ High-Level Architecture

Developer
   |
   v
GitHub Repo (App1, App2, App3)
   |
GitHub Actions (CI/CD)
   |
   |-- Test
   |-- Docker Build
   |-- Push to ECR
   v
AWS ECR (Images)
   |
AWS ECS (Fargate)
   |
Application Load Balancer
   |
   v
End Users (HTTPS)

📁 Repository Structure

multi-app-devops/
├── app1/
│   ├── Dockerfile
│   └── src/
├── app2/
│   ├── Dockerfile
│   └── src/
├── app3/
│   ├── Dockerfile
│   └── src/
└── .github/
    └── workflows/
        └── deploy.yml

Each app is independent but deployed via same pipeline logic.

🔐 STEP 1: AWS ACCOUNT & IAM
Create IAM User (DevOpsUser)
Permissions:

AmazonEC2FullAccess
AmazonECS_FullAccess
AmazonEC2ContainerRegistryFullAccess
CloudWatchFullAccess
IAMReadOnlyAccess

⚠️ Create Access Key (Programmatic)

🌐 STEP 2: Networking (VPC)

Create VPC
2 Public Subnets
Internet Gateway
Route Table
Security Groups:
ALB: 80, 443
ECS: 3000/5000/80 (app ports)

📦 STEP 3: Create ECR Repositories
Create one ECR per app:

app1-ecr
app2-ecr
app3-ecr

Save:

AWS Account ID
Region
Repository URI Example:

123456789012.dkr.ecr.us-east-1.amazonaws.com/app1

🐳 STEP 4: Dockerize Applications
Example Dockerfile (Node.js / Python)

FROM node:18-alpine
WORKDIR /app
COPY package*.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Repeat per app.

⚙️ STEP 5: ECS Cluster (Fargate)

Create ECS Cluster
Create Task Definition per App

Container Image: ECR URI
Port Mapping
CPU & Memory

Create Service

Launch Type: FARGATE
Attach ALB
Desired Tasks: 2 (HA)

🌍 STEP 6: Application Load Balancer
Create ALB
Listener:
HTTP → Redirect HTTPS
HTTPS → Target Groups
Path-based routing:

/app1 → app1-service
/app2 → app2-service
/app3 → app3-service

🔑 STEP 7: GitHub Secrets
In GitHub Repo → Settings → Secrets
AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_REGION AWS_ACCOUNT_ID ECR_REPO_APP1 ECR_REPO_APP2

🔄 STEP 8: GitHub Actions CI/CD Pipeline
.github/workflows/deploy.yml

name: CI-CD Pipeline

on:
  push:
    branches: [ "main" ]

env:
  AWS_REGION: us-east-1

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout Code
      uses: actions/checkout@v4

    - name: Configure AWS Credentials
      uses: aws-actions/configure-aws-credentials@v4
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: ${{ env.AWS_REGION }}

    - name: Login to Amazon ECR
      run: |
        aws ecr get-login-password --region $AWS_REGION \
        | docker login --username AWS --password-stdin \
        ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.$AWS_REGION.amazonaws.com

    - name: Build & Push App1
      run: |
        docker build -t app1 ./app1
        docker tag app1:latest ${{ secrets.ECR_REPO_APP1 }}:latest
        docker push ${{ secrets.ECR_REPO_APP1 }}:latest

    - name: Deploy to ECS
      run: |
        aws ecs update-service \
          --cluster devops-cluster \
          --service app1-service \
          --force-new-deployment

✔ Repeat build steps for app2 & app3.

📊 STEP 9: Monitoring & Logs
Enable CloudWatch Logs in ECS Task Definition
View:

App logs
CPU/Memory
Health checks

🔐 STEP 10: Security & Best Practices
✔ HTTPS using ACM
✔ IAM least privilege
✔ Secrets in GitHub (not code)
✔ Private ECR
✔ Auto-scaling

🧪 STEP 11: Testing Flow

Developer changes code
Push to main
GitHub Action triggers
Docker image rebuilt
Image pushed to ECR
ECS pulls new image
Rolling deployment
End user sees updated app

🔧 Host WordPress on AWS Using LAMP

Mubeen Babar — Mon, 21 Apr 2025 05:54:41 +0000

🖥️ Step 1: Launch EC2 Instance

Go to the EC2 Dashboard.

Click Launch Instance.
Choose Ubuntu Server 22.04 LTS.
Choose an instance type (e.g., t2.micro for free tier).
Create or use an existing key pair (you’ll need it for SSH).
Configure security group:
Allow HTTP (80), HTTPS (443), and SSH (22) from your IP.
Launch instance.

🔗 Step 2: Connect to EC2 via SSH

ssh -i your-key.pem ubuntu@your-ec2-public-ip

📦 Step 3: Install Apache Web Server

sudo apt update
sudo apt install apache2 -y
sudo systemctl enable apache2
sudo systemctl start apache2

Visit http://your-ec2-public-ip to see the Apache2 Ubuntu Default Page.

🐘 Step 4: Install MySQL (Database Server)

sudo apt install mysql-server -y
sudo mysql_secure_installation

Set a strong MySQL root password during the configuration.

✈️ Step 5: Create a WordPress Database and User

Bash

sudo mysql -u root -p

SQL

CREATE DATABASE wordpress;
CREATE USER 'wp_user'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON wordpress.* TO 'wp_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

💻 Step 6: Install PHP and Extensions

Bash

sudo apt install php libapache2-mod-php php-mysql php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip -y
sudo systemctl restart apache2

⬇️ Step 7: Download WordPress

cd /tmp
curl -O https://wordpress.org/latest.tar.gz
tar -xvzf latest.tar.gz

Copy files to Apache root directory

sudo cp -a wordpress/. /var/www/html/

🔐 Step 8: Set Permissions

sudo chown -R www-data:www-data /var/www/html/
sudo chmod -R 755 /var/www/html/

Remove default index.html:

sudo rm /var/www/html/index.html

📝 Step 9: Configure WordPress

cd /var/www/html
sudo cp wp-config-sample.php wp-config.php
sudo nano wp-config.php

Edit database details:

define('DB_NAME', 'wordpress');
define('DB_USER', 'wp_user');
define('DB_PASSWORD', 'your_password');
define('DB_HOST', 'localhost');

Save and exit.

🌐 Step 10: Final Setup via Web UI
Now visit your public IP in the browser:
📍 http://your-ec2-public-ip

You’ll see the WordPress setup page. Choose:

Language
Site Title
Admin Username and Password
Email

Click Install WordPress 🎉

✅ 1. Set Up SSL Using Let’s Encrypt (HTTPS)
SSL secures your website with HTTPS (🔒). It's free with Let’s Encrypt.
Install Certbot:

sudo apt update
sudo apt install certbot python3-certbot-apache -y

Run Certbot for Apache:

sudo certbot --apache

Follow the prompts:

Choose your domain (requires domain pointed to EC2 IP).
Certbot auto-edits Apache config to enable SSL. Test HTTPS: Visit: https://your-domain.com Auto-Renew SSL (runs twice daily):

sudo systemctl status certbot.timer

📌 2. Create an Elastic IP in EC2 (Static IP)
Steps:

Go to EC2 Dashboard > Network & Security > Elastic IPs.
Click Allocate Elastic IP address.
Choose Amazon pool > Allocate.
Select the new Elastic IP > Actions > Associate.
Select your EC2 instance and network interface > Associate. Now your EC2 has a fixed public IP.

Creating a VPC and Launching a Web Application in an Amazon EC2 Instance

Mubeen Babar — Sun, 10 Nov 2024 12:10:26 +0000

Task 1: Create a Virtual Private Cloud

CREATE A VPC, PUBLIC SUBNETS, ROUTE TABLE, AND INTERNET GATEWAY

At the top of the AWS Management Console, in the search bar, search for and choose VPC
Choose Create VPC
On the left side of the Create VPC console, locate the VPC settings section, and select VPC and more in the Resources to create section.
In the Name tag auto-generation section, select Auto-generate, if not already selected.
In the text box under the Auto-generate option, enter the name
In the IPv4 CIDR block section, enter 10.0.0.0/16
In the IPv6 CIDR block section, select the No IPv6 CIDR block option, if not already selected.
Leave the Tenancy section set to Default.
In the Number of Availability Zones (AZs) section, select 2
In the Number of public subnets section, select 2
In the Number of private subnets section, select 0
Expand the Customize subnets CIDR blocks option
In the first text box, enter the following: 10.0.0.0/24. This CIDR range contains all IP addresses starting with 10.0.0.x.
In the second text box, enter the following: 10.0.1.0/24. This CIDR range contains all IP addresses starting with 10.0.1.x.
In the NAT gateways section, select None
In the VPC endpoints section, select None
In the DNS options section, select both Enable DNS hostnames and Enable DNS resolution.

The DNS hostnames attribute determines whether instances launched in the VPC receive public DNS hostnames that correspond to their public IP addresses. The DNS resolution attribute determines whether DNS resolution through the Amazon DNS server is supported for the VPC.

Review the Preview section on the right side of the screen. This preview should include the name of your VPC, the two subnets you created, a public route table, and an Internet gateway.
If the Preview section presents the correct information, select Create VPC.

The Create VPC workflow screen appears. Wait for the workflow to finish. You should receive a message indicating everything created successfully.

Success

Review the details of the workflow. Note that the VPC workflow created your Internet gateway, attached the Internet gateway to your VPC, and associated your subnets to your route table. An example can be found below:

Select View VPC

ADD A PUBLIC ROUTE TO THE ROUTE TABLE

Choose Route tables. Refresh the selection. Select the Main route table for lab-2-vpc

There is currently only one route used for all internal traffic within the VPC. To access the Internet, you must first add a route to the Internet gateway.

Select Edit routes
Select Add route
In the Destination column, locate the text box and enter the following: 0.0.0.0/0
In the Target column, locate the text box and select it. A list of options should present themselves. Select Internet Gateway. The id and name of your Internet Gateway should populate. Select the Internet Gateway ID named lab-2-igw
Select Save changes
You should receive an output message similar to the following: Updated routes for rtb-xxxxxxxxxxxxxxxx successfully
Navigate to the bottom of the VPC console and select the Routes tab, if not already selected.
Note the two routes:

An internal route for VPC traffic

A public route to the Internet by way of the Internet Gateway

The diagram below represents your new custom VPC:

Congratulations! You successfully created a custom VPC, Internet gateway, route table, a public route to the Internet, and two public subnets in two separate availability zones.

Task 2: Create a VPC Security Group

In the left navigation pane, locate the Security section, and choose Security groups.
In the top-right area of your window, choose Create security group.
In the Basic details section, locate the Security group name text box and enter the value Web Security Group
In the Basic details section, locate the Description text box and enter the value Enable HTTP access from anywhere
In the Basic details section, locate the VPC text box, select the X to remove the default VPC, and choose the VPC with name lab-2-vpc. Once select, the lab-2-vpc
In the Inbound rules section, choose Add rule.
In the Type column, select the dropdown and choose HTTP
In the Source column, select the dropdown and choose Anywhere-IPv4
In the Description column, locate the text box and enter Allow web requests from anywhere
Navigate to the bottom of the Create security group window, and choose Create security group.

Congratulations! You successfully created a custom Security Group that allows inbound web traffic from anywhere.

Task 3: Launch Your Amazon EC2 Instance

At the top of the AWS Management Console, in the search bar, search for and choose EC2
In the left navigation pane, in the Instances section, choose Instances.
Choose Launch instances.
In the Name and tags section, locate the Name text box, and enter the value Web Application
In the Application and OS images section, locate the Quick start window, and select Amazon Linux 2023
Under the Quick start window, locate the Amazon Machine Image (AMI) dropdown and select the AMI named Amazon Linux 2023 AMI
Under the Description section, locate the Architecture dropdown and select 64-bit (x86)
In the Instance type section, locate the Instance type dropdown and select t3.micro
In the Key pair (login) section, locate the key pair name dropdown and select Proceed without a key pair (Not recommended)
In the Network settings section, select Edit.
Locate the VPC dropdown and select lab-2-vpc
Locate the Subnet dropdown and select lab-2-subnet-public-1-[az-a] where [az-a] is the first availability zone in your region.
Locate the Auto-assign public IP dropdown and select Enable

Note: This setting assigns a public IP address to the instance so you can access the application in your browser.

In the Firewall (security groups) section, choose Select an existing security group
Locate the Common security groups dropdown and select the security group named Web Security Group
You can leave the Configure storage section set to the default values.
Scroll down to the Advanced Details section, expand, the dropdown, and locate the User data text box.

Note: When you launch an instance in Amazon EC2, you have the option of passing user data to the instance that can be used to perform common automated configuration tasks and even run scripts after the instance starts.
Your instance uses an Amazon Linux 2023 operating system; therefore, you need to provide a shell script that will run when the instance starts. This script installs the required application dependencies and launches the application. Without this user data script, you would need to log in to the EC2 Instance and execute all of the commands yourself.

Copy the following script and paste it into the User data text box. To copy the script, you can use the Clipboard button, located in the top-right corner of the code box below:

#!/bin/bash -ex

# Update yum
yum -y update

#Install nodejs
yum -y install nodejs

# Create a dedicated directory for the application
mkdir -p /var/app

# Get the app from S3
wget https://aws-tc-largeobjects.s3-us-west-2.amazonaws.com/ILT-TF-100-TECESS-5/app/app.zip

# Extract it to the desired folder
unzip app.zip -d /var/app/
cd /var/app/

# Install dependencies
npm install

# Start the app
npm start

This script performs the following tasks:
• Install system updates
• Install a source repository to download the Node.js installer
• Install Node.js
• Download the application code
• Create a dedicated directory for the web application
• Download and extract the application into the specified directory
• Install the application dependencies
• Set the listener port for the application
• Start the web application

In Summary section, for Number of instances text box, enter the value 1, if not already done.
Select Launch instance.
Wait for the instance to launch. You should receive an message indicating the launch completed. See the message below:

Successfully initiated launch of instance (instance-id)

Choose View all instances.

Note: You may need to refresh the Instances page for the instance to appear in the list of instances.
The instance should appear in a Pending or Initializing state, which means it is launching. When the Instance state changes to Running, the instance is booting.

To see the instance details, choose your Web Application instance.

To show more or less information in the Details tab, drag the window divider. You can review the instance details including the instance type, security settings, network settings, etc.

In the Instance window, at the top of the page, locate the Instance state and Status check columns. Wait for the values to indicate the following:

• Instance state: Running
• Status check: 2/2 checks passed

In the Details tab, locate the Public IPv4 address section, and copy the IP address

Note: If you refreshed the Instances window, you may need to choose your Web Application instance again.

Open a new browser tab and paste the IP address you copied in the previous step. You should see the following application screen.

Note: If you use the open address link, your browser might try to browse to the application using
https://, which won’t work. The application can only be accessed using
http:// on port 80

The follow diagram represents the completed lab environment:

Once you access the web application successfully, you can close the browser tab.

Congratulations! You successfully created an EC2 Instance and deployed a web application using a user data script.

Create a Static Website with Amazon Simple Storage Service (Amazon S3) with Public Access

Mubeen Babar — Sat, 24 Aug 2024 23:00:51 +0000

Objectives
By the end of this lab, you will be able to do the following:
• Create an S3 bucket.
• Configure the S3 bucket as a static website and allow public access.
• Add a bucket policy.
• Create and upload the website assets.
• Test the Amazon S3 static website.

1-Start lab

2-Create an S3 bucket

Here you will create a Bucket simply:

At the top of the AWS Management Console, in the search bar, search for and choose S3.
Choose Create bucket.
For Bucket name, Enter a Bucket name (globally unique).
To create the bucket and accept the remaining default values for Object Ownership, Block Public Access settings for this bucket, Bucket Versioning, and Default Encryption, choose Create bucket.

3-Configure the S3 bucket as a static website and allow public access

In this task, you update the bucket’s properties to allow static website hosting. After you allow static website hosting, you also need to update the bucket’s permissions to allow public access to the bucket.

3.1-Configure the S3 bucket as a static website

Choose the text link for the bucket that you just created.
Choose the Properties tab.
Under Static website hosting, choose Edit and then select the following options:
• For the Static website hosting option, select Enable.
• For Hosting type, select Host a static website.
• For Index document, enter index.html.
• For Error document, enter error.html
Choose Save changes.
Return to the Static website hosting section and for later reference, copy the value for the Bucket website endpoint into a text editor.

3.2Allow public access to the bucket

By default, Amazon S3 blocks public access to your account and buckets. If you want to use a bucket to host a static website, you must allow public access to the bucket. Use these steps to edit permissions for the Block public access (bucket settings).

In the page for the bucket you created, choose the Permissions tab.
From the Block public access (bucket settings) section, choose Edit.
Clear Block all public access, and choose Save changes.
In the Edit Block public access (bucket settings) warning window, enter confirm and choose Confirm.

The Amazon S3 console generates the following confirmation message: Successfully edited Block Public Access settings for this bucket.

4-Add a bucket policy to allow public access to content in your bucket

Choose the Permissions tab.
Under Bucket Policy, choose Edit .
To grant public read access for your website, copy the following bucket policy and in the Bucket policy editor, paste the policy.

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "PublicReadGetObject",
"Effect": "Allow",
"Principal": "",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::Bucket-Name/"
]
}
]
}
Update Resource to use your bucket name.

Note: In a bucket policy, the value of Resource is the Amazon Resource Name (ARN) for the bucket. (The Bucket ARN is listed above the Policy editor window.) In the preceding example policy, Bucket-Name is a placeholder for the name of your bucket. To use this bucket policy with your own bucket, you must update this name to match your bucket name. Be sure to include the trailing /* characters because they are important for the functionality of the overall policy.
After you update the policy, choose Save changes

5-Create and upload the website assets and test the website

In this task, you create and upload the website assets to your S3 bucket. Website assets include images, style sheets, scripts, fonts, and other files that contribute to the visual and functional aspects of the website. In this lab, to help simplify the experience, the website assets include an index.html file and an error.html file. After you upload the assets to the S3 bucket, you test the website by opening a web browser to the Amazon S3 URL that you saved earlier.

5.1Create the website assets

Create the index.html file. This file serves as the initial landing page for the website.

Open a text editor.
Copy the following HTML code.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AMAZON S3</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
            margin-top: 50px;
        }
        h1 {
            color: #007bb5; /* LinkedIn color */
        }
        a {
            color: #007bb5;
            text-decoration: none;
            font-size: 18px;
        }
        a:hover {
            text-decoration: underline;
        }
        .success-message {
            margin-top: 20px;
            font-size: 18px;
            color: green;
        }
    </style>
</head>
<body>
    <h1>AMAZON S3</h1>
    <p>Check out my LinkedIn profile: <a href="https://www.linkedin.com/in/mubeen780/" target="_blank">Mubeen's LinkedIn</a></p>
    <p class="success-message">Successfully accessed the website!</p>
</body>
</html>

In your text editor, paste the code.
Save the file as index.html to your desktop.

Next, you create the error.html file. This webpage is returned when a user enters an incorrect URL for this website.

In your text editor, create a new file.
Copy the following HTML code.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Error - Website Access</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
            margin-top: 50px;
        }
        h1 {
            color: #ff4d4d; /* Red color for error */
        }
        p {
            font-size: 18px;
        }
        .error-message {
            color: #ff4d4d;
            font-size: 20px;
            margin-top: 20px;
        }
        .contact-info {
            margin-top: 30px;
        }
        .contact-info a {
            color: #007bb5; /* LinkedIn color */
            text-decoration: none;
            font-size: 18px;
        }
        .contact-info a:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
    <h1>Error</h1>
    <p class="error-message">Unable to access the website. Please try again later.</p>
    <div class="contact-info">
        <p>Contact Mubeen:</p>
        <p><a href="https://www.linkedin.com/in/mubeen780/" target="_blank">LinkedIn Profile</a></p>
    </div>
</body>
</html>

In your text editor, paste the code.
Save the file as error.html to your desktop.

5.2-Upload the website assets to your bucket

Now that you’ve created the website assets, you can upload the assets to your bucket.

Return to the browser tab with the Amazon S3 console and choose the Objects tab.
Choose Upload.
Choose Add files.
Navigate to your desktop, select the index.html file and the error.html file, and choose Open.
Choose Upload.
To return to the root of your bucket, choose Close.

Test the Amazon S3 static website

Now that you’ve uploaded the index.html and error.html files, it’s time to test the Amazon S3 static website.

Copy the URL that you saved earlier, and in a new browser tab, paste the URL.

The following example is what you can expect the landing page of the website to look like.

In the browser’s address bar, go to the end of the URL and add /aboutus.html to it, and press the Enter or Return key.

The following example is what you can expect the website’s error.html page to look like when an incorrect URL is used.

The browser can’t find the path to the /aboutus location, so the error.html page is returned as expected.

By following these steps, you can efficiently host a static website using Amazon S3, leveraging its scalability and cost-effectiveness. Amazon S3 is designed to handle large amounts of data and high traffic with ease, making it ideal for static websites that don’t require server-side processing.

Amazon EC2 Instance

Mubeen Babar — Sat, 03 Aug 2024 19:44:13 +0000

Amazon Elastic Compute Cloud (EC2) is a web service that provides secure, resizable compute capacity in the cloud. It is designed to make web-scale cloud computing easier for developers and businesses by offering virtual servers, known as instances, that can be tailored to meet specific needs. Here is a step-by-step guide to creating an EC2 instance:

Step 1: Access the AWS Console

Log into your AWS account via the https://aws.amazon.com/console/
Navigate to EC2, From the console homepage, click on Services and select EC2 under the "Compute" category.

Step 2: Launch Instance

Click on the Launch Instance button to start the instance creation process. This will open the "Launch Instance."

Give the Name (Should be unique)

Choose an Amazon Machine Image (AMI) Select AMI: AMIs are pre-configured templates for your instances. Choose an appropriate AMI from the list of available options, such as:

Amazon Linux 2 Custom AMIs: You can also use custom AMIs if you need specific software configurations or want to launch an instance from a previous backup.

Step 3: Choose an Instance Type

Select the instance type based on the required CPU, memory, storage, and networking capacity. Common instance types include:

t2.micro: Free tier eligible, suitable for low-traffic applications.

r5.large: Memory-optimized for applications with significant memory requirements.

Specifications upto you how much you need, Each instance type has specific CPU cores, memory size, storage options, and network performance.

Create a key pair for getting the access to the virtual machine. There are two types of key pairs you can download.
1- .PEM (For SSH)
2- .PPK (For Putty)
Here i downloaded .PEM File to access by SSH through my Command Line.

Step 4: Network Settings

Select the Virtual Private Cloud (VPC) where the instance will reside.

Choose the subnet that aligns with your instance's geographical or logical needs.

Auto-assign Public IP, Decide if you need a public IP address to access the instance over the internet.

Step 5: Configure Storage

Volume Type, Specify the type of storage, such as General Purpose SSD (gp2), Provisioned IOPS SSD (io1), or Magnetic.

Size: Define the storage capacity in GiB.

Additional Volumes: Optionally, add more volumes for additional storage requirements.

Step 6: Review and Launch

Review: Double-check all configurations to ensure they meet your requirements.

Launch: Click the Launch button to start the instance creation process.

Step 7: Access the Instance

Connect: Once the instance is running, connect using the preferred method:

SSH: Use the terminal or an SSH client for Linux-based instances.

Public DNS: Use the public DNS name or IP address to connect remotely.

By clicking on Connect which is located on top.

Now Choose the method to connect(SSH)

Open CMD and go to the path where .PEM file is located
Copy the SSH command and paste it in CMD and press Enter.

Here you can see we get access to our Instance/Virtual Machine (Amazon Linux) we created...

By following these steps, you can effectively create and manage EC2 instances , providing the flexibility and scalability required for various applications and workloads.