In a shared AWS environment, it is important to clearly identify EC2 instances and their owning teams. This project implements a Python-based EC2 Random Name Generator that creates unique, standardized EC2 instance names to improve visibility and organization across departments.

The script allows users to specify how many EC2 instance names they need and to provide their department name, which is included as part of the EC2 naming convention. Each name also contains a randomly generated combination of letters and numbers to ensure uniqueness.

As an advanced feature, the script below restricts usage to approved departments only: Marketing, Accounting, and FinOps. User input is handled in a case-insensitive manner so variations such as “accounting” or “Accounting” are treated the same. The trailing spaces are also taken care of using strip(). If a user enters an unapproved department, the script displays a message indicating that they should try it again.

For added structure and reusability, the logic is encapsulated within a function, which is executed to verify correct behavior.

The completed code is pushed to GitHub using GitHub desktop and commiting the changed files.

Media Inc. implemented a secure AWS solution to manage its “MediaCatalog” DynamoDB table, which stores metadata for its latest movie releases. To ensure data integrity, the company deployed a t3.micro EC2 instance configured with a specific IAM role that follows the principle of least privilege, granting only read-only access. By using the AWS CLI on the instance without long-term access keys, authorized users can efficiently scan the catalog for performance analysis while the system automatically blocks unauthorized write attempts. This architecture validates that the security permissions are correctly configured, protecting the media database from tampering while providing necessary visibility for business decisions.

SOLUTION

I created a DynamoDB table and added data to it. Next, I launched an EC2 instance with an IAM policy granting read access to DynamoDB and tested the setup. For every step, I provided instructions for performing the tasks using both the AWS Console and the CLI.

STEP 1: CREATE DynamoDB TABLE

Search for DynamoDB-> Create table.

Give a name and partition key. The partition key is like the primary key in SQL. It is a unique identifier. The rest of the options to default -> Create table.

In CLI, table is created using create-table and verified using describe-table command.

STEP 2 : INSERT DATA INTO THE TABLE

To populate the table, click on the table -> Explore table items -> Under table -> Create item.

The attributes need to be created. Choose Add new attribute -> give name of attribute and choose datatype. Add relevant values.

Values can also be added in JSON format once the JSON view button is selected. This makes it easier to make multiple entries by just editing the values.

Similarly, I created 10 entries for the table.

In CLI, I created a .json file using nano and wrote all the 10 entries in json format while referencing the table. Once created, I used the batch-write-item command to write all the entries in the file to the table. The put command only adds one entry at a time.

STEP 3: CREATE AN EC2 INSTANCE WITH DYNAMODB READ ACCESS

Search for EC2 -> Launch instances.

Give a name, choose AMI and instance type. I also created a key-pair (An already existing key-pair can also be used).

An IAM profile needs to be created to give DynamoDB read access privileges to the EC2 instance.

Advanced details -> IAM instance profile -> Create new IAM profile.

Roles -> Create role.

Select the entity type as AWS service and use case as EC2 -> Next.

Search for DynamoDBReadOnlyAccess -> Next.

Give a name to the role -> Create.

Go back to the EC2 instance and refresh beside the IAM instance profile -> select the new role -> Launch instance.

The EC2 instance on the console can be connected by EC2 connect and on the CLI using SSH.

In CLI, we need to create an instance profile and attach the role to the profile. Create a key-value pair if needed for the EC2 instance, create a security group for the instance and launch an instance using them. I used the default security group and already created key pair.

STEP 4: TEST

Scan command is run to verify entries. Put-item command is run to add an entry to the table which fails proving that the role provided works!

Adventure Works, a global travel agency specializing in adventure tours and luxury packages, plans to launch a new Joomla website to serve as a central hub for all travel services. The site is designed using a two-tier architecture, with EC2 hosting the Joomla web server and RDS managing the MySQL database, ensuring scalability, security, and high availability. Joomla is chosen for its flexibility, ease of use, and rich support for extensions, allowing Adventure Works to efficiently manage content, engage users, and integrate additional features like booking systems and e-commerce.

STEP 1: Create a VPC

Search for VPC -> Your VPCs -> Create VPC

Give a name and CIDR block for the VPC.

Keep the rest of the options to default -> Create VPC .

STEP 2: Create Subnets

VPC -> Subnets-> Create subnet.

Choose newly created VPC, give subnet name, availability zone, subnet CIDR block and Create Subnet.

Similarly create one more public and 2 more private subnets. Auto assign public IPs for all subnets.

STEP 3: Create Internet Gateway

The public subnets need to be attached to an internet gateway.

VPC -> Internet Gateway-> Create internet gateway.

Give a name -> Create internet gateway.

Actions -> Attach to a VPC.

Choose VPC -> Attach internet gateway.

STEP 4: Create Route table

VPC -> Route tables -> Create route table.

Give a name, choose the newly created VPC -> Create route table.

Select route table -> Edit routes -> Select the public subnets -> Save associations.

Similarly create a private route table and choose the private subnets.

Attach the internet gateway to the public route table.

VPC -> Route tables-> public route table-> Add route

Choose destination as 0.0.0.0/0 (anywhere) and target as the internet gateway -> Save changes.

STEP 5: CREATE EC2 INSTANCE FOR JOOMLA

Search for EC2-> Launch instance.

Give a name and choose Ubuntu as the AMI.

Choose or create a key pair, edit the network settings to include the newly created VPC, subnet and create a new security group.

Give a name and add a rule to allow http traffic.

STEP 6: CREATE RDS SUBNET, SG and DB

Aurora and RDS -> Subnet groups -> Create DB subnet group.

Give a name, choose the new VPC and choose the subnets and availability zones. I put it in the private subnets -> Create.

Create Security group.

Ec2 -> Security groups -> Create security group.

Give a name, VPC, add an inbound rule for mySQL (port 3306) -> Create security group.

Create DB

Aurora and RDS -> Databases -> Create database.

Choose Full configuration as Easy create does not allow to choose VPC info. Select MySQL as the Engine type.

Give a name for the DB and give a username and password.

Select the newly created VPC, the subnet created for the DB and the security group.

Rest of the options to default -> Create database.

It takes a few minutes for the database to get created.

STEP 7: CONFIGURE JOOMLA

EC2 -> Instances -> Choose the created EC2 instance -> Connect.

Connect using EC2 instance connect.

Run the following commands:

1. Update Package List:

sudo apt update

2. Install Apache, PHP, and Required Modules:

sudo apt install -y apache2 php libapache2-mod-php php-mysql php-xml php-gd unzip

3. Start and Enable Apache:

sudo systemctl start apache2

sudo systemctl enable apache2

4. Download Joomla:

cd /var/www/html

sudo curl -L -o joomla.zip https://github.com/joomla/joomla-cms/releases/download/3.9.28/Joomla_3.9.28-Stable-Full_Package.zip

5. Extract Joomla

sudo unzip joomla.zip

6. Set the correct permissions:

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

sudo chmod -R 755 /var/www/html

7. Remove the default Apache index.html file:

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

8. Edit the Apache Configuration File:

sudo nano /etc/apache2/mods-enabled/dir.conf

9. Adjust the Directory Index Setting:

Make sure the `index.php` comes before `index.html`.

The line should look like this:

DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm

10. Save and Close the File:

Save the changes and exit the editor (Ctrl+O, Enter, Ctrl+X).

11. Restart Apache:

sudo systemctl restart apache2

Copy DB end point and DB name from RDS.

Get the public IP of the EC2 instance.

Complete the Joomla configuration by giving the name, email, username, password -> Next.

Give the Host Name as RDS endpoint, username and password -> Next.

It asks you to delete a particular file. Go to the EC2 instance and search for the file within /var/www/html/installation and delete the file.

Once done we can proceed to the next page -> Install.

After installation, refresh the page and we should be able to the Joomla login page.

Test if it works with the credentials created.

USE CASE

Aurora Digital, a growing online retailer specializing in luxury home goods, aimed to migrate its digital operations to AWS to improve scalability, reliability, security, and cost-efficiency. To address the challenges of increasing traffic during peak sales events and to ensure uninterrupted service, a cloud-based infrastructure was designed using AWS CloudFormation. The solution includes a VPC with three public subnets across different availability zones, an Auto Scaling Group of t3.micro instances with Apache installed and a custom web page, and an Application Load Balancer to distribute traffic evenly. Security is enforced through two security groups: one for the ALB allowing inbound HTTP traffic from anywhere, and one for the web servers restricting access only to the ALB, preventing direct access via public IPs. CloudFormation automates the provisioning of all these resources, ensuring consistency, repeatability, and version control, while enabling Aurora Digital to scale resources automatically, maintain high uptime, secure customer data, and optimize operational costs. The environment allows users to access the website through the ALB DNS, verifying a fully functional, secure, and highly available cloud deployment.

STEPS

STEP 1: Create the template file.

For this task, I utilized VS Code, and the script is provided below:

This first creates a VPC with the CIDR block 10.10.0.0/16 and enables DNS support and hostnames for instances. Within the VPC, three public subnets are created, each in a different availability zone (us-east-1a, 1b, and 1c), and configured to automatically assign public IPs to instances. An Internet Gateway is attached to the VPC, and a route table is created with a default route to the Internet Gateway, which is associated with all three public subnets to ensure internet connectivity. Two security groups are defined: one for the Application Load Balancer (ALB) that allows inbound HTTP traffic from anywhere, and one for the web servers that only allows HTTP traffic from the ALB, preventing direct access to EC2 instances. An internet-facing ALB is deployed across all public subnets with a listener on port 80, forwarding traffic to a target group that monitors instance health via HTTP. The template defines a Launch Template for EC2 instances that specifies t2.micro instances, the latest Amazon Linux 2 AMI, attaches the web server security group, and runs user data to install and start Apache with a basic web page. Finally, an Auto Scaling Group is created across the three public subnets using the Launch Template, with a minimum of 2 and a maximum of 5 instances, automatically registering instances with the ALB target group and performing health checks to maintain high availability. The template outputs the DNS name of the ALB so we can access the website via a browser.

STEP 2: Create a stack in CloudFormation.

Search for Cloud Formation in the AWS console.

Click on create stack -> With new resources.

Upload the created YAML file from the previous step. The template can be provided in either YAML or JSON format.

Upload a template file -> Choose file -> Next.

Give the stack a name and click Next.

Leave the remaining options as default and click Submit at the end.

Once deployed it can be verified using the URL in the Outputs section.

Summary:
Aurora Digital, a growing online retailer of luxury home goods, is transitioning its digital operations to AWS to handle increasing traffic, especially during major sales events, while maintaining performance, security, and cost-efficiency. The project focuses on implementing a scalable, reliable, and secure cloud infrastructure that can automatically adjust resources, reduce downtime, protect customer data, and optimize operational costs.

AWS CloudFormation is chosen to automate infrastructure deployment, ensure environment consistency, enable version control, and allow template reusability for faster, error-free deployments.

Key Requirements:

• Deploy an EC2 instance with an Apache Webserver using CloudFormation.
• Use User Data to install Apache automatically.
• Configure a Security Group with the necessary permissions.

STEP 1: Create the template file.

For this task, I utilized VS Code, and the script is provided below:

This script uses a parameter to select the VPC, which will be prompted when creating the CloudFormation stack. Alternatively, a VPC can be created directly using parameters defined in the resources section. The script provisions an EC2 instance with User Data to install Apache and sets up a security group that allows HTTP traffic.

In case the AMI id is hardcoded, it only works for a specific zone and fails for the rest. Hence, I used “{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}” to get the latest AMI ID from AWS SSM Parameter Store (provided by default) at stack creation, ensuring your EC2 instance always uses the most up-to-date image without hardcoding the AMI.

The outputs section specifies the values that will be returned once the stack is successfully deployed.

STEP 2: Create a stack in CloudFormation.

Search for Cloud Formation in the AWS console.

Click on create stack -> With new resources.

Upload the created YAML file from the previous step. The template can be provided in either YAML or JSON format.

Upload a template file -> Choose file -> Next.

Give the stack a name and choose the VPC (VPC was in the parameters of the template).

Leave the remaining options as default and click Submit at the end.

STEP 3: Testing the stack created.

Once the stack is created, it takes a few minutes to create it. The progress can be seen in the Events tab.

In the template script, I specified outputs for the Instance ID and public IP, and simply appended ‘http’ to form the URL.”

Once the URL is clicked, it works as expected.

After successfully testing a server on EC2, Level-Up Bank plans to migrate its network to AWS to improve scalability, reliability, and security. The bank creates a custom VPC (10.10.0.0/16) with three public subnets spread across multiple Availability Zones to ensure high availability. An Auto Scaling Group of t2.micro EC2 instances with Apache installed is deployed across these subnets, automatically adjusting capacity between 2 and 5 instances based on demand. An Application Load Balancer distributes incoming traffic to the instances, secured by dedicated security groups that control internet access and allow traffic only through the load balancer. This architecture enables the bank to host web applications efficiently while benefiting from AWS’s elasticity and cost-effective, pay-as-you-go model.

STEPS

STEP1 : CREATE A VPC

Search for VPC -> Click on Create VPC

Give it a name and the IPv4 CIDR, leave the rest to default and click on Create VPC.

STEP 2: CREATE AN INTERNET GATEWAY

Search for Internet Gateways in VPC -> Create Internet Gateway

Give a name and click Create internet gateway.

Click on Attach to a VPC -> select the VPC created -> Attach internet gateway button

STEP 3: CREATE PUBLIC SUBNETS

Search for Subnets -> Create subnet.

Select the created VPC, give a name for the subnet, select the Availability Zone and give a subnet CIDR block.

Leave the rest to default and click on Create subnet.

Similarly create 2 more subnets in different availability zones.

STEP 4: CREATE ROUTE TABLES

Search for Route tables and click Create route table.

Give name and select created VPC -> Create route table button.

Once created, click edit routes.

Add a route from created Internet Gateway to the internet (0.0.0.0/0) -> Save changes.

Go to Subnet associations -> Edit subnet associations button -> select created public subnets -> Save associations button.

Edit subnet settings -> enable auto-assign public IPv4 address -> Save changes.

Do this for all the subnets.

STEP 5: CREATE LAUNCH TEMPLATE

Search for EC2 -> Launch Templates -> Create launch template.

Give a name and description.

For launch template contents, a newly created AMI can also be used. Here I used the Linux AMI.

Choose instance type.

In Network settings, select the subnet and Create security group, give a name and select the created, add a Inbound Security Group hot HTTP port to include traffic from the internet.

Go to the advanced section -> User data. Add script as follows and click Create launch template.

#!/bin/bash

yum update -y

yum install -y httpd

systemctl start httpd

systemctl enable httpd

echo “ALB Health Check OK” > /var/www/html/index.html

STEP 6: CREATE AUTO SCALING GROUP

Search for Auto Scaling Groups under EC2 -> Create Auto Scaling group.

Give a name, choose the created Launch template and click next.

Choose the created VPC in the network, choose the Availability Zones and click Next.

Here, we are going to create a new load balancer. Choose option Attach to a new load balancer, application load balancer. It gives a name by default but can be changed as per choice. The scheme should be internet facing.

Choose the availability zones and create a target group and give it a name.

Choose turn on Elastic Load Balancing health checks and click Next.

We need a minimum of 2 instances and a maximum of 5, so changed the desired capacity to 2 and scaling min and max accordingly.

Leave the rest of the options to default and click next.Go to final page and review and click on create auto scaling group.

The security group of the load balancer is that of the ec2 instance and does not allow external traffic. So, we need to create a new security group.

Give a name, select the VPC and add an inbound rule to allow http from anywhere.

Now, edit the load balancer security group to add the newly created security group.

Once this is done, the EC2 instances are created but it does not allow to access the EC2 instances and shows the following :

To fix this, an IAM role needs to be created with AmazonSSMManagedInstanceCore.

Go to IAM -> Roles -> Create Role.

Choose entity type as AWS service and Use case as EC2 -> Click Next.

Search for AmazonSSMManagedInstanceCore in permissions -> Click Next.

Give a name -> Click Next.

Now this role needs to be attached to the Launch Templates to make it take effect, and the new version of the Launch Template needs to be included in the Auto Scaling group.

Go to Lauch Template -> Select the template -> Actions -> Modify Template.

Advanced details -> IAM instance profile -> choose the created SSM profile -> Create template button.

Next, the auto-scaling group needs to be updated to reflect the new verion of the launch template.

Auto Scaling Groups -> Select the group -> Actions -> Edit.

Under Launch templates, in version, choose latest and click update.

Once done, the EC2 instance should be accessible.

To check the DNS, go to Load Balancers, choose our application load balancer and copy the DNS info.

To test it open it on the browser.

NOTES:

For any reason if the EC2 instances are not healthy, after making the required changes to fix it, the EC2 instances need to be terminated and within a few minutes the Auto scaling group will deploy new ones.

USE CASE : AUTOMATIC SCALING

In case we need to deploy new instances when the CPU utilization increases by a certain threshold, we need to have automatic scaling.

Auto Scaling groups -> select the group -> Automatic Scaling -> Create dynamic scaling policy.

Choose target tracking scaling and provide the metric. Here I want it to scale when the CPU utilization goes beyond 50% utilized and provided the same metric and click create.

OVERVIEW

The Level-Up Bank is migrating its website and online banking platform to AWS to improve scalability, reliability, and security. It begins by creating a t2.micro EC2 instance and a user-data script that updates packages, installs Apache, and starts the web service. The bank verifies the setup by accessing the instance’s public IP and confirming the Apache default page. Using AWS services like RDS and S3, the bank can securely host databases and files while easily scaling instances up or down. Compared to an on-premises server, AWS reduces costs, enhances security through encryption and access controls, and provides flexibility to deploy new instances and test features quickly. With proper security groups and a public IP, the bank ensures its online services are accessible and reliable, creating a strong foundation for a secure, scalable online banking platform.

STEPS

STEP 1: Get Access Key from AWS Console to use it in AWS CLI

Top right username -> Security Credentials

Click on create access key button and create an access key.

Copy the Access key and Secret access key as this will be used to connect to AWS CLI.

STEP 2: Connect to your user via CLI

Open the editor of your choice and verify that AWS is installed.

Run AWS configure command and provide necessary details

STEP 3: CREATE EC2 INSTANCE

For an EC2 instance, we need security group, subnet, key pair information. In this scenario we also need to create a script which runs when EC2 instance starts.

Create new key pair using :

aws ec2 create-key-pair \

— key-name mykeyweek5\

— output text > mykeyweek5.pem

Verify if the key pair is created using grep.

Create a script to update all packages, installs and starts Apache.

Verify contents of file.

To get subnet information, goto AWS Console -> Search for VPC -> Subnets. Copy the Subnet ID.

Launch an EC2 instance. We also need to create a Security Group which I forgot so added it later. The name of the EC2 instance is specified in the tag-specifications.

Verify the status of EC2 instance using the following:

aws ec2 describe-instances \

— query “Reservations[*].Instances[*].{Name:Tags[?Key==’Name’]|[0].Value,ID:InstanceId,State:State.Name,IP:PublicIpAddress}” \

— output table

Parameters to be displayed can be changed as per requirements.

Check if public IP works as intended. Fails because a Security Group is missing.Can use curl command or directly open the link in a web browser.

Create a security group and allow HTTP and SSH access using the following:

To create a security group with name MySGTestWeek5:

aws ec2 create-security-group \

— group-name MySGTestWeek5 \

— description “Allow HTTP and SSH access” \

— vpc-id vpc-0ef0c7a809eac71c8

To get the security group ID:

aws ec2 describe-security-groups \

— query “SecurityGroups[*].[GroupName,GroupId,VpcId]” \

— output table

To allow HTTP access from anywhere:

aws ec2 authorize-security-group-ingress \

— group-id sg-0c640014f9f46153f \

— protocol tcp \

— port 80 \

— cidr 0.0.0.0/0

To allow SSH from EC2 IP:

aws ec2 authorize-security-group-ingress \

— group-id sg-0c640014f9f46153f \

— protocol tcp \

— port 22 \

— cidr 13.221.127.125/32

Attach the newly created Security Group to the existing EC2 instance.

Before attaching the new Security Group, check the existing Security groups attached to the instance using:

aws ec2 describe-instances \

— instance-ids i-00cd78941a81b9b50 \

— query “Reservations[*].Instances[*].SecurityGroups[*].GroupId” \

— output text

Now modify the instance to add the new Security Group using:

aws ec2 modify-instance-attribute \

— instance-id i-00cd78941a81b9b50 \

— groups sg-0a336849ecab7cb5c sg-0c640014f9f46153f

(include the old and the new security group ids)

Verify if the new security group is added.

STEP 4: Verify if instance has webserver

Run curl on the public IP of the instance.

It can also be verified using the web browser.

OVERVIEW

Level Up Corporation operates multiple Linux EC2 instances but struggles with efficient remote management due to the lack of a secure and direct administration method. To address this, the company plans to implement secure remote access tools — SSH for Linux to enable encrypted, reliable management from any location. This improvement will enhance productivity, reduce downtime, strengthen data security, lower operational costs, simplify troubleshooting, and support future scaling as infrastructure grows.

OBJECTIVES

For the Linux environment, the EC2 instance will be configured to use AWS Systems Manager (SSM) instead of SSH. This requires enabling the SSM Agent and appropriate IAM permissions, allowing secure remote access without open SSH ports, thereby adding an extra layer of security.

PREREQUISTES

· Have a Linux EC2 instance already set up.

STEPS

STEP 1. Create IAM role for SSM

· Search for IAM in the AWS console -> Click Create role

· Choose AWS service as Trusted entity type and Use case as EC2 -> Click Next.

· Search for AmazonSSMManagedInstanceCore in the Permissions policies -> Click Next.

· Give a name to the IAM role -> Create Role.

STEP 2: Attach IAM role to created EC2 instance.

· Search for EC2 in the AWS console and go to the already created Linux EC2 instance.

· Click Actions -> Security -> Modify IAM role.

· Give the name of the IAM role created in the previous step -> Update IAM role.

STEP 3: Connect to the EC2 instance via SSM.

· Go to the instance -> Connect -> Session Manager tab.

· This showed that the SSM Agent is not online.

· Checked the status of SSM agent via terminal using : sudo systemctl status amazon-ssm-agent and this showed running.

· Checked the connectivity to the internet and that seemed fine as well.

· Restarted the SSM agent using sudo systemctl restart amazon-ssm-agent.

· Check in the Connect section if Session Manager and now it shows the Connect option.

· Click Connect

· This opens up into an SSM session!

OVERVIEW

Level Up Corporation currently operates multiple Linux and Windows EC2 instances on AWS but struggles with efficient remote management due to the lack of a secure and reliable access method. To resolve this, the company plans to implement RDP for Windows servers, enabling the IT team to securely connect and administer systems from any location. This solution will significantly improve operational efficiency, reduce downtime, enhance data security through encrypted communication, and support future scalability as the infrastructure grows. By streamlining remote administration and troubleshooting, Level Up can boost productivity, lower operational costs, and ensure more resilient and secure server management.

STEPS

STEP 1: Launch EC2 instance.

o Login to your AWS account and search for EC2.

o Click on Launch an instance button.

o Give a name to the instance and choose Windows under Application and OS images.

o Create a key pair by providing the key-pair name and the rest can be used as default. The private key gets downloaded onto your local system.

o Click on Launch instance button

STEP 2. Verify Security Group

o The instance is now created.

o On the instance go to Security tab -> Inbound rules.

o Rule for TCP is created by default, verify it.

STEP 3 : Connect to the instance via RDP

o On the instance click Connect button -> RDP client tab

o Follow the instructions provided and download the RDP file.

o We also need to get the password. For that upload the private key file previously downloaded -> Click on Decrypt Password.

o Once the password is generated, it shows up on the screen ready to copy.

o On mac, we cannot open RDP files by default.

o Go to App store and download Windows App

Open the Windows app -> Connections -> Import from RDP file -> Upload the downloaded RDP file.

o Now the RDP session is ready to use. Click on the 3 dots -> Connect -> Enter password.

o The RDP session opens up!

OVERVIEW

Level Up Corporation currently operates multiple Linux and Windows EC2 instances on AWS but struggles with efficient remote management due to the lack of a secure and reliable access method. To resolve this, the company plans to implement SSH for Linux servers, enabling the IT team to securely connect and administer systems from any location. This solution will significantly improve operational efficiency, reduce downtime, enhance data security through encrypted communication, and support future scalability as the infrastructure grows. By streamlining remote administration and troubleshooting, Level Up can boost productivity, lower operational costs, and ensure more resilient and secure server management.

STEPS

STEP 1: Launch EC2 instance.

o Login to your AWS account and search for EC2.

o Click on Launch an instance button.

o Give a name to the instance and choose Amazon Linux under Application and OS images.

o Create a key pair by providing the key-pair name and the rest can be used as default . The private key gets downloaded onto your local system.

o The test-key gets downloaded on to your local system.

o Click on Launch instance button

STEP 2. Verify Security Group

o The instance is now created.

o On the instance go to Security tab -> Inbound rules.

o A rule for SSH is created by default, verify it.

STEP 3 : Connect to the instance via SSH

o On the instance click Connect button -> SSH client tab

o Follow the instructions provided in the terminal.

o On mac open Terminal and on windows, PowerShell can be used.

o pwd command shows the current directory you’re in. This is to verify which directly you are currently in and to move to the correct directory where the private key exists.