DEV Community: mahpara jabbar

Auto Scaling with an Application Load Balancer

mahpara jabbar — Sun, 22 Sep 2024 07:45:39 +0000

This lab teaches how to set up an Auto Scaling infrastructure in AWS, including creating an AMI, configuring a load balancer, and implementing an Auto Scaling group. It demonstrates dynamic resource scaling based on demand to ensure application availability and efficient traffic distribution. The lab also tests scaling by increasing load and verifying load balancer functionality.

Summary:

Step 1: Create an AMI from Web Server 1
Step 2: Create a Load Balancer
Step 3: Create a Launch Template
Step 4: Create an Auto Scaling Group
Step 5: Verify Load Balancer Functionality
Step 6: Test Auto Scaling
Step 7: Terminate Web Server 1

Step 1: Create an AMI from Web Server 1

Go to EC2 Dashboard:

Search for EC2 in the AWS Management Console.

Select Instance:

In the Instances section, find Web Server 1 (ensure it's in the Running state).

Create Image:

Select Web Server 1.
Choose Actions > Image and templates > Create image.
Set Image name: Web Server AMI.
Optional: Add Image description: Lab AMI for Web Server.
Click Create image.

Note AMI ID:

Copy the AMI ID for use when launching the Auto Scaling group later.

Step 2: Create a Load Balancer

Navigate to Load Balancers:

In the EC2 Dashboard, go to Load Balancers under the Load Balancing section.

Create Load Balancer:

Click Create load balancer.
Choose Application Load Balancer.
Set Load balancer name: LabELB.

Network Configuration:

Select Lab VPC.
Map to Public Subnet 1 and Public Subnet 2 for availability zones.

Security Group:

Remove the default security group.
Select Web Security Group (preconfigured for HTTP access).

Create Target Group:

Click Create target group (opens a new tab).
Choose Instances as the target type.
Set Target group name: lab-target-group.
Click Next and Create target group.

Assign Target Group to Load Balancer:

Return to the Load Balancer tab and Refresh the target groups.
Select lab-target-group for the Forward to action.

Create Load Balancer:

Click Create load balancer and copy the DNS name.

Step 3: Create a Launch Template

Access Launch Templates:

In the EC2 Dashboard, go to Launch Templates.

Create Launch Template:

Set Launch template name: lab-app-launch-template.
Add a Description: A web server for the load test app.
Check the box for Auto Scaling guidance.

AMI and Instance Type:

Choose the My AMIs tab and select Web Server AMI.
Set the Instance type to t3.micro.

Security Group:

Select Web Security Group.

Create Template:

Click Create launch template.

Step 4: Create an Auto Scaling Group

Create Auto Scaling Group:

Select lab-app-launch-template from the launch template list.
Choose Actions > Create Auto Scaling group.
Set Auto Scaling group name: Lab Auto Scaling Group.

Network Configuration:

Select Lab VPC.
Assign Private Subnet 1 and Private Subnet 2.

Attach Load Balancer:

Choose Attach to an existing load balancer.
Select lab-target-group | HTTP.

Health Check:

Set Health check type to ELB.

Group Size and Scaling Policy:

Set Desired capacity: 2.
Set Minimum capacity: 2.
Set Maximum capacity: 4.
Enable Target tracking scaling policy for Average CPU utilization and set the target to 50%.

Tags:

Add a Tag:
Key: Name,
Value: Lab Instance.

Create Auto Scaling Group:

Finish by clicking Create Auto Scaling group.

Step 5: Verify Load Balancer Functionality

Check Instances:

Go to Instances in the EC2 Dashboard.
Ensure two Lab Instances are running.

Check Target Health:

In Load Balancing > Target Groups, find lab-target-group.
Verify that both Lab Instances show a Healthy status.

Access Application:

Use the load balancer DNS name to check if the Load Test app is running.

Step 6: Test Auto Scaling

Access CloudWatch:

In the AWS Console, search for CloudWatch.

Check Alarms:

In Alarms, locate the AlarmHigh (CPU utilization > 50%).
Ensure the state is OK.

Generate Load:

Open the Load Test tab from the web application.
Trigger high CPU load by selecting Load Test.

Monitor Scaling:

In CloudWatch, check the AlarmHigh status, which should change to In alarm.
Auto Scaling should add instances as CPU load increases.

Migrating to Amazon RDS

mahpara jabbar — Tue, 17 Sep 2024 10:16:50 +0000

A lab on migrating to Amazon RDS typically involves transferring an existing on-premises or cloud-hosted database to Amazon's Relational Database Service (RDS). The goal is to reduce the operational burden of managing databases by leveraging AWS's managed service for automated backups, patching, monitoring, and scaling.

Objective:

Create an Amazon RDS MariaDB instance by using the AWS CLI.
Migrate data from a MariaDB database on an EC2 instance to an Amazon RDS MariaDB instance.
Monitor the Amazon RDS instance by using Amazon CloudWatch metrics.

Summary:

Creating an Amazon RDS instance by using the AWS CLI
Migrating application data to the Amazon RDS instance
Configuring the website to use the Amazon RDS instance
Monitoring the Amazon RDS database

The application database runs in an Amazon Elastic Compute Cloud (Amazon EC2) Linux, Apache, MySQL, and PHP (LAMP) instance along with the application code. The instance has a T3 small instance type and runs in a public subnet so that internet clients can access the website. A CLI Host instance resides in the same subnet to facilitate the instance's administration by using the AWS Command Line Interface (AWS CLI).

Creating an Amazon RDS instance by using the AWS CLI:

Configure the AWS CLI.
Create the following prerequisite components required to build the Amazon RDS instance:
A security group firewall for the Amazon RDS instance
Two private subnets and a database subnet group
Create the Amazon RDS MariaDB instance.
On the AWS Management Console, in the Search bar, enter and choose EC2 to open the EC2 Management Console.
In the navigation pane, choose Instances.
From the list of instances, select the CLI Host instance.
Choose Connect.
On the EC2 Instance Connect tab, choose Connect.
To set up the AWS CLI profile with credentials, in the EC2 Instance Connect terminal, run the following command: ‘aws configure’
Enter the user's access key and secret access key.
Create Security Group: Set up CafeDatabaseSG to protect the RDS instance.
Add Inbound Rule: Allow only MySQL requests (TCP protocol, port 3306) from instances in CafeSecurityGroup.
Create Private Subnets: Establish two private subnets (CafeDB Private Subnet 1 and CafeDB Private Subnet 2).
Create Database Subnet Group: Define a CafeDB Subnet Group for RDS, associating it with the private subnets.
Create CafeDatabaseSG Security Group: Run command: aws ec2 create-security-group \ --group-name CafeDatabaseSG \ --description "Security group for Cafe database" \ --vpc-id

Output: Note the GroupId for future use.

Create Inbound Rule for CafeDatabaseSG:
Run command:
aws ec2 authorize-security-group-ingress \
--group-id \
--protocol tcp --port 3306 \
--source-group
Verify Inbound Rule:
Run command:
aws ec2 describe-security-groups \
--query "SecurityGroups[*].[GroupName,GroupId,IpPermissions]" \
--filters "Name=group-name,Values='CafeDatabaseSG'"
Create CafeDB Private Subnet 1
Run command:
aws ec2 create-subnet \
--vpc-id \
--cidr-block 10.200.2.0/23 \
--availability-zone

Output: Note the SubnetId for future use.

Create CafeDB Private Subnet 2
Run command:
aws ec2 create-subnet \
--vpc-id \
--cidr-block 10.200.10.0/23 \
--availability-zone
Output: Note the SubnetId for future use.
Create DB Subnet Group
Run command:
aws rds create-db-subnet-group \
--db-subnet-group-name "CafeDB Subnet Group" \
--db-subnet-group-description "DB subnet group for Cafe" \
--subnet-ids \
--tags "Key=Name,Value= CafeDatabaseSubnetGroup"
Create the CafeDBInstance

Run the following command to create the MariaDB instance with the specified configuration:
Run command:
aws rds create-db-instance \
--db-instance-identifier CafeDBInstance \
--engine mariadb \
--engine-version 10.5.13 \
--db-instance-class db.t3.micro \
--allocated-storage 20 \
--availability-zone \
--db-subnet-group-name "CafeDB Subnet Group" \
--vpc-security-group-ids \
--no-publicly-accessible \
--master-username root --master-user-password 'Re:Start!9'

Key settings:

DB instance identifier: CafeDBInstance
Engine: MariaDB (version 10.5.13)
Instance class: db.t3.micro
Allocated storage: 20 GB
Security group: CafeDatabaseSG
Username: root
Password: Re:Start!9
The creation of the database instance may take up to 10 minutes.
Monitor the Status of the DB Instance

After running the creation command, monitor the status of the database by running the following command:
Run command:

aws rds describe-db-instances \
--db-instance-identifier CafeDBInstance \
--query "DBInstances[*].[Endpoint.Address,AvailabilityZone,PreferredBackupWindow,BackupRetentionPeriod,DBInstanceStatus]"

What to watch: The command will return information such as the endpoint address, availability zone, backup window, retention period, and the status of the instance.
Initially, the status will show as creating and then progress through modifying, backing-up, and finally to available.

Continue running the status command every few minutes until the status of the database shows available. Run command: aws rds describe-db-instances \ --db-instance-identifier CafeDBInstance \ --query "DBInstances[*].[DBInstanceStatus]"

Migrating application data to the Amazon RDS instance:

Connect to the EC2 Instance (CafeInstance)
In the terminal, run the following command to create a backup of the local cafe_db database:
Run Command:
mysqldump --user=root --password='Re:Start!9' \
--databases cafe_db --add-drop-database > cafedb-backup.sql
Review the Backup File
You can review the contents of the backup using the less command:
Run Command:
less cafedb-backup.sql

Use arrow keys or Page Up/Down to navigate and q to quit.

Restore the Backup to the Amazon RDS Database
Run the following command to restore the backup to the RDS instance. Replace with your actual RDS instance endpoint:
Run Command
mysql --user=root --password='Re:Start!9' \
--host= \
< cafedb-backup.sql
Verify the Data Migration
Open an interactive MySQL session to the RDS instance:
Run Command:
mysql --user=root --password='Re:Start!9' \
--host= \
cafe_db

Once inside the MySQL session, verify the data in the product table by running the following SQL query:
sql
Run Command:
select * from product;

Ensure that the returned data matches the original database.

Exit the MySQL Session After verifying the data, exit the MySQL session by entering: Run Command exit

Note: Keep the SSH window open for future tasks.

Configuring the website to use the Amazon RDS instance

Open AWS Systems Manager
In the AWS Management Console, search for Systems Manager in the search bar.
Navigate to Systems Manager.
Access Parameter Store
In the left navigation pane, choose Parameter Store.
Edit the /cafe/dbUrl Parameter
From the My parameters list, select /cafe/dbUrl.
Choose Edit to modify the parameter value.
Update the Database URL
In the Parameter details page, replace the existing value with the RDS Instance Database Endpoint Address.
The format should be like:
Run Command:

cafedbinstance.xxxxxxx.us-west-2.rds.amazonaws.com

Click Save changes to update the parameter.

Test the Website

Open a new browser window and paste the CafeInstanceURL that you saved earlier (e.g., http://ec2-xx-xx-xx-xx.compute-1.amazonaws.com).
The café website’s homepage should load.

Verify the Database Connection Go to the Order History tab on the website. Check the number of orders displayed. It should match the number from the local database before the migration.

Monitoring the Amazon RDS database

Open the Amazon RDS Console
In the AWS Management Console, search for RDS.
Go to the RDS Management Console.
Select the Database
In the left navigation pane, choose Databases.
From the list, select cafedbinstance.
You will now see detailed information about the database.
View Monitoring Metrics
Click on the Monitoring tab.
This tab displays key metrics, including:

CPUUtilization
DatabaseConnections
FreeStorageSpace
FreeableMemory
WriteIOPS
ReadIOPS

Monitor DatabaseConnections Metric
Look for the DatabaseConnections graph. If needed, go to page 2 or 3 of the metrics charts.
This graph tracks the number of active database connections.
Connect to the RDS Database
In the CafeInstance terminal window, run the following command to open a MySQL session:
Run Command
mysql --user=root --password='Re:Start!9' \
--host= \
cafe_db

Replace with your RDS instance endpoint.

Run an SQL Query Inside the MySQL session, run the following SQL query to retrieve data from the product table: sql Run Command: select * from product;

The query should return the data from the product table.

Check the DatabaseConnections Graph
In the RDS console, click the DatabaseConnections graph.
You should now see 1 active connection from the interactive SQL session.
If the graph does not update, wait 1 minute and click Refresh.
Close the MySQL Session
In the CafeInstance terminal window, exit the MySQL session:

Run Command
exit

Monitor the Connections After Disconnecting
Wait for 1 minute, then refresh the DatabaseConnections graph in the RDS console.
The number of connections should now show as 0.
Explore Other Metrics
You can explore additional metrics such as CPUUtilization, FreeStorageSpace, WriteIOPS, and ReadIOPS by reviewing their graphs on the Monitoring tab.

CloudWatch CPU Utilization Monitoring with SNS Alert

mahpara jabbar — Wed, 04 Sep 2024 10:14:02 +0000

This lab focuses on setting up a CloudWatch alarm to monitor CPU utilization on an EC2 instance, configuring an SNS topic to receive email alerts when CPU utilization exceeds a defined threshold, and creating a CloudWatch dashboard for real-time monitoring. Additionally, it involves installing the stress tool on the EC2 instance to simulate high CPU usage for testing the alarm and notification system.

Summary

Launch EC2 Instance.
Create SNS Topic and Subscription.
Create a CloudWatch Alarm.
Create a CloudWatch Dashboard.
Connect to EC2 and Install Stress Tool.

Launch EC2 Instance:

Launch an EC2 instance with the following specifications:

Instance Type: t2.nano
Network: Assign a public IP.
Security Group: Allow SSH (port 22) from your IP.

Create SNS Topic and Subscription:

Go to the SNS (Simple Notification Service) section in the AWS Management Console.
Click on Topics > Create Topic.
Choose Standard as the type.
Provide a Name for the topic (e.g., EC2-CPU-Alerts).
Click Create Topic.

In the newly created topic, click on Create Subscription.
Set the protocol to Email.
Enter your email address and click Create Subscription.
Confirm the subscription by checking your email and clicking on the verification link.

Create a CloudWatch Alarm:

Go to the CloudWatch section in the AWS Management Console.
Select Alarms from the sidebar, then click Create Alarm.
Click Select Metric.
Navigate to EC2 > Per-Instance Metrics > CPUUtilization.
Choose the Instance ID of your EC2 instance.
Set the Statistic to Average and the Period to 1 minute.
Set the Threshold Type to Static and enter 60 as the value (for greater than 60% CPU utilization).
Click Next.
Under Actions, choose Select an existing SNS topic and pick the topic you created earlier.
Click Next.
Provide an Alarm Name (e.g., High-CPU-Utilization-Alarm).
Click Create Alarm.

Create a CloudWatch Dashboard:

In the CloudWatch console, navigate to Dashboards.
Click Create Dashboard.
Provide a Name for the dashboard (e.g., EC2-Monitoring-Dashboard).
Click Add Widget.
Choose Line and click Configure.
Select the same metric used in your alarm (EC2 CPU Utilization).
Click Create Widget.
Save the dashboard.

Connect to EC2 and Install Stress Tool:

Connect your EC2 instance.
Run the following commands to update the instance and install the stress tool:
sudo yum update -y
sudo yum install stress -y
Use the stress tool to generate CPU load:
stress --cpu 1 --timeout 300

CPU utilization crosses the threshold:

Alarm Generated:

This lab should give you a hands-on understanding of setting up CloudWatch alarms with SNS and monitoring an EC2 instance's CPU utilization.

VPC Flow Logs Setup

mahpara jabbar — Tue, 20 Aug 2024 11:08:37 +0000

In the VPC Flow Logs Setup lab, we will configure VPC Flow Logs in AWS to monitor and analyze network traffic within a Virtual Private Cloud (VPC). we will create a VPC with public and private subnets, launch EC2 instances, and enable Flow Logs to capture traffic data, which is then sent to CloudWatch Logs for analysis. This lab provides hands-on experience in using VPC Flow Logs for security monitoring, troubleshooting, and gaining insights into network activity in AWS.

Summary:

Create a VPC
Create a VPC
Create an Internet Gateway
Configure Route Tables
Launch EC2 Instances
Enable VPC Flow Logs
Analyze Flow Logs

Create a VPC

Login to AWS Management Console.
Navigate to VPC under the Networking & Content Delivery section.
Click on Create VPC.
Name tag: vpc-flowlog-lab
IPv4 CIDR block: 10.0.0.0/24
Leave the rest of the settings as default and click Create VPC.

Create Subnets
In your VPC, create two subnets:

Public Subnet:

Name tag: PublicSubnet
Availability Zone: Choose any available one
IPv4 CIDR block: 10.0.0.0/25

Private Subnet:

Name tag: PrivateSubnet
Availability Zone: Same as the public subnet
IPv4 CIDR block: 10.0.0.128/25

Create an Internet Gateway

Navigate to Internet Gateways.
Click Create internet gateway.
Name tag: vpc-flowlog-igw
Attach this Internet Gateway to your VPC.

Configure Route Tables

Public Route Table:

Name tag: PublicRouteTable
Associate it with the Public Subnet.
Edit routes: Add a route with the destination 0.0.0.0/0 and the target as the Internet Gateway.

Private Route Table:

Name tag: PrivateRouteTable
Associate it with the Private Subnet.
No need to add any routes to the Internet Gateway.

Launch EC2 Instances

Public EC2 Instance:

Launch an EC2 instance in the Public Subnet.
Instance Type: t2.micro
Security Group: Allow inbound SSH (22) and HTTP (80) traffic.

Private EC2 Instance:

Launch another EC2 instance in the Private Subnet.
Instance Type: t2.micro
Security Group: Allow inbound SSH (22) only from the Public EC2 instance's private IP.

Enable VPC Flow Logs

Navigate to the VPC Dashboard.
Select Flow Logs under Your VPCs.
Click Create flow log.
Filter: Choose All to capture all traffic (you can also choose Reject or Accept depending on your needs).
Destination: Choose Send to CloudWatch Logs.
Log Group Name: Create a new log group (e.g., vpc-flowlog-lab-logs).
IAM Role: If you don’t have a role, create one with the necessary permissions (the IAM role should allow VPC Flow Logs to publish to CloudWatch Logs).
Click Create flow log.

Analyze Flow Logs

Navigate to CloudWatch Logs.
Find your Log Group and click on it.
View the log streams to see the VPC traffic information.
You can filter and analyze the logs to see traffic details, such as source/destination IPs, traffic accept/reject status, etc.

Test Traffic Between Instances

SSH into the public instance.
From the public instance, try to ping the private instance using its private IP.
Observe the Flow Logs in CloudWatch to see the traffic being logged.

"S3 VPC Endpoint "

mahpara jabbar — Mon, 19 Aug 2024 11:31:26 +0000

In this VPC endpoint lab, you'll set up a Virtual Private Cloud (VPC) with both public and private subnets in AWS. The goal is to configure a VPC endpoint to securely access Amazon S3 from instances within the private subnet, without routing the traffic through the internet. The public subnet will allow instances to access the internet directly.

Summary:

Create a VPC with public and private subnets.
Set up a VPC endpoint for Amazon S3 to allow private subnet instances to access S3 securely.
Configure the route tables and security settings to ensure proper connectivity.
Test the setup by accessing S3 from both public and private subnet instances.

1. Set Up Your VPC

Create a VPC:

Go to the VPC Dashboard.
Click Create VPC.
Set a CIDR block (e.g., 10.0.0.0/24).

2. Create Subnets:

Public Subnet:

Create a subnet with CIDR block 10.0.0.0/25.

Private Subnet:

Create another subnet with CIDR block 10.0.0.128/25.

3. Internet Gateway:

Create an Internet Gateway (IGW) and attach it to your VPC.

4. Route Tables:

Public Route Table:

Create a route table.
Add a route to the IGW (destination 0.0.0.0/0).
Associate this route table with the public subnet.

Private Route Table:

Create a route table.
Do not add an internet route; keep the local route (destination 10.0.0.0/16).
Associate this route table with the private subnet.

5. VPC Endpoints:

Go to VPC Endpoints and click Create Endpoint.
Choose the Amazon S3 service.
Select the Private Route Table to associate with the endpoint.
Policy: Leave the default policy, which allows full access to S3, or customize it as needed.

6. Create an IAM Role:

Go to the IAM Dashboard > Roles.
Create a new role for s3.

Attach Role to EC2 Instances:

When launching instances in the private subnet, attach the IAM role you created to these instances.
This role will allow instances to access S3 using the endpoint.

7. Launch and Configure EC2 Instances:

Launch EC2 Instances:

Public Subnet: Launch an EC2 instance (e.g., for management or administration). Assign a public IP if needed.
Private Subnet: Launch another EC2 instance. Ensure it has the IAM role attached.

8. Configure Security Groups:

Public Instance: Configure security group rules to allow SSH (port 22) if you need to connect remotely.
Private Instance: Configure security group rules to allow access from the public instance or other necessary resources.

9. Testing the Configuration

Connect to Instances:

SSH into the public instance and access the private instance using its private IP.

Test S3 Access:

Use the AWS CLI to test S3 access from the private instance with the command aws s3 ls.

Creating a VPC with Public and Private Subnets

mahpara jabbar — Sun, 11 Aug 2024 11:28:18 +0000

Creating a VPC with Public and Private Subnets is a fundamental AWS networking lab that helps to understand how to isolate resources within a Virtual Private Cloud (VPC) and manage their access to the internet.

Summary:

Create a VPC
Create Subnets
Create and Attach an Internet Gateway
Create Route Tables
Launch an EC2 Instance in the Public Subnet
Access the EC2 Instance

Step 1: Create a VPC

Search VPC
Click on Create VPC.
Provide a Lab-vpc for VPC.
Select an IPv4 CIDR block (e.g., 10.0.0.0/24).
Click Create VPC.

Step 2: Create Subnets

Create a Public Subnet:

Select Subnets on the left panel and click Create subnet.
Select the VPC you created earlier.
Provide a Public-subnet for the subnet.
Specify an Availability Zone (us-east-1a)
Set the IPv4 CIDR block ( 10.0.0.0/25).
Click Create Subnet.

Create a Private Subnet:

Repeat the steps to create another subnet within the same VPC.
Name this subnet (Private-Subnet.)
IPv4 CIDR block (e.g., 10.0.0.128/25).
Click Create Subnet.

Step 3: Create and Attach an Internet Gateway

Create an Internet Gateway (IGW):

In the VPC Dashboard, click on Internet Gateways and then Create Internet Gateway.
Provide a VPC-Internet-gateway for the IGW.
Click Create Internet Gateway.

Attach the Internet Gateway to Your VPC:

After creation, select the newly created IGW.
Click Actions and choose Attach to VPC.
Select the VPC you created and click Attach Internet Gateway.

Step 4: Create Route Tables

Create a Public Route Table:

Go to Route Tables on the left panel and click Create route table.
Name it Public-Route-Table.
Select the VPC which created earlier.
Click Create.

Add a Route for the Internet Gateway:

Select the Public-Route-Table.
Under Routes, click Edit routes.

Add a new route:

Destination: 0.0.0.0/0
Target: Select your Internet Gateway (IGW) from the dropdown.
Click Save routes.

Associate Public Subnet with the Public Route Table:

Under the Subnet associations tab, click Edit subnet associations.
Select your Public-Subnet and click Save associations.
Repeat this process for private subnets.

Step 5: Launch an EC2 Instance in the Public Subnet

Launch a New EC2 Instance:

Click on Launch Instance.
Select an Amazon Linux 2.
Choose an instance type (t2.micro)
Under Network, choose the VPC you created.
Under Subnet, select Public-Subnet.
Ensure Auto-assign Public IP is enabled.
Configure the security group to allow HTTP traffic.
Click advance details and add website code in the user data.
Review and launch the instance.

Step 6: Access the EC2 Instance

Copy the Public IPv4 address and paste it on new tab.
click on the Ip and remove 's' from https to http.

Mastering the Basics: Essential Linux Commands

mahpara jabbar — Thu, 08 Aug 2024 11:20:36 +0000

Introduction:
As the backbone of many servers and systems worldwide, Linux is a crucial skill for anyone in the tech industry. When I started my journey into Linux, I realized how powerful and versatile it is, especially when combined with my networking and cloud computing knowledge.
What is Linux?
Linux is an open-source operating system that powers everything from personal computers to large-scale enterprise servers. Learning Linux is not just about mastering another OS; it's about gaining control and flexibility in managing systems efficiently.
Essential Commands for Beginners:

ls - List directory contents

Example: ls -la lists all files, including hidden ones, with detailed information.

cd - Change directory

Example: cd /var/logs navigates to the logs directory.

pwd - Print Working Directory

Example: Running pwd in the terminal will display the full path of the current directory, such as /home/user/documents.

rm - Remove (delete) a file

Example: rm file.txt deletes file.txt.

mkdir - Make a new directory

Example: mkdir new_folder creates a directory named new_folder.

rmdir - Remove an empty directory

Example: rmdir old_folder removes old_folder if it is empty.

rm -r - Remove a directory and its contents recursively

Example: rm -r old_folder deletes old_folder and everything inside it.

cp - Copy Files or Directories

Example: cp source.txt destination.txt copies source.txt to destination.txt.

mv - Move or Rename Files or Directories Example: mv oldname.txt newname.txt renames oldname.txt to newname.txt

Tools in Linux:

cat - File Viewing Utility
touch - File Management Utility
vi/vim - Text Editors
nano - Simple Text Editor

cat - File Viewing Utility:

It displays the contents of a file in the terminal, but it can do much more.

Command: cat filename.txt

Example: cat notes.txt shows everything written inside notes.txt.

Command:cat file1.txt >> file2.txt

Example: cat footer.txt >> report.txt adds the content of footer.txt to the end of report.txt.

Command: cat > newfile.txt

Example: cat > message.txt opens input mode where you can type a message to be saved in message.txt.

Command: cat file1.txt file2.txt

Example: cat header.txt body.txt prints both files' content one after the other.

Command: tac filename

Example: tac file1 will reverse the order of the file.

touch - File Management Utility:

Used to create new empty files or update the timestamps of existing files (last accessed or modified). Creating a placeholder file or refreshing the timestamp of a file to mark it as recently modified.

Command: touch filename.txt

Example:touch notes.txt creates a new empty file called notes.txt.

Command: touch file1.txt file2.txt file3.txt

Example:touch project1.txt project2.txt project3.txt creates three empty files.

vi/vim - Text Editors:

vi and vim (Vi IMproved) are powerful text editors in Linux that can seem complex at first, but they offer great flexibility once get the hang of their basic commands.

Opening a File

Command: vi filename.txt or vim filename.txt

Switching Modes

i (Insert Mode): Press i to enter Insert mode, where you can start typing text.
Esc (Normal Mode): Press Esc to return to Normal mode, where you can use commands.

Inserting and Editing Text

i: Insert text before the cursor.
a: Insert text after the cursor.
o: Open a new line below the current line and enter Insert mode.
x: Delete the character under the cursor.
dd: Delete the entire current line.
u: Undo the last change.
Ctrl + r: Redo the undone change.

Saving and Exiting

w: Save the current file.
q: Quit the editor. If there are unsaved changes, it will warn you.
wq: Save and quit.

Copy, Cut, and Paste

p: Paste the copied or cut text after the cursor.
dd: Cut (delete) the current line.

nano - Simple Text Editor:

nano is a simple and user-friendly text editor in Linux.

Opening a File

Command: nano filename.txt

Saving and Exiting

Ctrl + O (Write Out): Save the current file. Press Enter to confirm the filename.
Ctrl + X (Exit): Exit the editor. If there are unsaved changes, it will prompt you to save before exiting.

EC2 Instance Data Persistence and Migration

mahpara jabbar — Tue, 06 Aug 2024 10:38:12 +0000

This EC2 lab involves creating an EC2 instance with multiple volumes, accessing it via RDP, adding data to the volumes, creating an image of the instance, copying the image to a different region, and then verifying the persistence of data.
Summary:

Create an EC2 Instance
- Take the RDP of the Instance
- Add Files and Folders
- Create an Image of the Instance
- Copy the Image to a Different Region
- Create an Instance from the Copied Image in the New Region
- RDP into the New Instance
- Check Data Persistence

Step 1: Creating an EC2 instance:

Select Microsoft Windows Server.
Select t2.micro as the instance type.
Root volume (C-drive): Default size 30 GB.
Additional volume (D-drive): 20GB.
Launching the instance.

Step 2:Taking the RDP of this Instance:

Select your instance, and click on Connect.
Choose the RDP client tab, and note the public DNS.
Decrypt the password using your PEM file
Use an RDP client (like Microsoft Remote Desktop) to connect
Use Administrator as the username and the decrypted password.

Step 3: Adding Files and Folders:

Access the C-drive and D-drive within the RDP session.
Create folders and add files on both drives.

Step 4: Creating an Image of the Instance:

Name the image and add a description.
Include both volumes in the image.
Wait for the image (AMI) creation to complete.

Step 5: Copy the Image to a Different Region:

Choose the destination region.
Name the copied AMI and add a description.
Wait for the copy process to complete.

Step 6: Create an Instance from the Copied Image in that Region:

Switching to the destination region(Ohio).
Go to the AMIs section and select the copied AMI.
Ensuring the instance type and storage configuration are appropriate then Click on Launch.

Step 7: RDP into the New Instance:
Connecting it to the new instance using the same RDP process as before.

Step 8: Check Data Persistence
Verify the files and folders created in the C-drive and D-drive are present and unchanged.