AWS EC2: Complete Guide to Virtual Servers on Ubuntu

Step 1: Set Up AWS IAM User for EC2 Access (If not already done)

It's best practice to use an IAM user with specific permissions rather than your AWS root account.

1. Log in to the AWS Management Console: Go to console.aws.amazon.com .
2. Navigate to IAM: Search for "IAM" in the search bar and select it.
3. Create a New User:
   • In the IAM dashboard, click Users in the left navigation pane.
   • Click Add users.
   • Enter a User name (e.g., ec2-admin-user).
   • For AWS credential type, select Access key - Programmatic access. Click Next.
4. Attach Permissions:
   • On the Set permissions page, select Attach policies directly.
   • Search for AmazonEC2FullAccess and select the checkbox. (For production, narrow this down to specific actions and resources).
   • Click Next.
5. Review and Create:
   • Review the user details and permissions.
   • Click Create user.
6. Save Credentials:
   • On the Retrieve credentials page, you will see the Access key ID and Secret access key.
   • Download the .csv file or copy these keys immediately and store them securely. This is your ONLY chance to view the Secret access key.

Step 2: Launch an EC2 Instance (Your Virtual Server)

This is where you create your virtual server. We'll launch an Ubuntu instance, which is excellent for web applications.

1. Navigate to EC2: From the AWS Console, search for "EC2" and select it. In the EC2 Dashboard, click Launch instance (or Instances in the left pane, then Launch instances).
2. Step 1: Choose an Amazon Machine Image (AMI):
   • Search for Ubuntu Server.
   • Select Ubuntu Server 22.04 LTS (HVM), SSD Volume Type (or 20.04 LTS). Ensure it's marked Free tier eligible.
3. Step 2: Choose an Instance Type:
   • Select t2.micro (or t3.micro if available in your region and free tier eligible). This is generally free tier eligible and sufficient for testing.
   • Click Next: Configure Instance Details.
4. Step 3: Configure Instance Details:
   • Network: Keep default VPC.
   • Subnet: Select any available subnet (choosing different Availability Zones for high availability).
   • Auto-assign Public IP: Ensure Enable is selected. This gives your instance a temporary public IP to connect to.
   • Keep other settings as default for now. Click Next: Add Storage.
5. Step 4: Add Storage:
   • The default root volume (8GB General Purpose SSD gp2) is usually fine for Ubuntu. This is where the operating system resides.
   • You can increase the size if needed (e.g., 20GB), but ensure it's still within Free Tier limits if applicable.
   • Click Next: Add Tags.
6. Step 5: Add Tags:
   • Click Add Tag.
   • Key: Name, Value: MyWebServer (or any descriptive name). Tags help you organize your resources.
   • Click Next: Configure Security Group.
7. Step 6: Configure Security Group:
   • Select Create a new security group.
   • Security group name: my-ssh-sg (or similar).
   • Description: SSH access for my web server.
   • Add rule:
     • Type: SSH
     • Protocol: TCP
     • Port Range: 22
     • Source: My IP (AWS will automatically detect your current public IP address). **This is the most secure option for SSH.** If your IP changes frequently, you'll need to update this rule. For broad testing, you *could* select Anywhere (0.0.0.0/0), but **this is NOT recommended for production.**
   • Click Review and Launch.
8. Step 7: Review Instance Launch:
   • Review all your settings. If everything looks good, click Launch.
9. Step 8: Create a New Key Pair:
   • In the pop-up, select Create a new key pair.
   • Key pair name: my-ec2-key (or similar).
   • Click Download Key Pair. **Save this .pem file immediately and securely! This is your private key, and you cannot download it again.**
   • Click Launch Instances.

Step 3: Accessing Your EC2 Instance (Linux/macOS Terminal - SSH)

If you're using a Linux or macOS machine, you'll use the built-in ssh client in your terminal.

1. Locate Your Private Key: Ensure the my-ec2-key.pem file you downloaded is in a secure, known location (e.g., your home directory ~/ or ~/.ssh/).
2. Set Correct Permissions: SSH requires your private key file to have restricted permissions (read-only for the owner).
chmod 400 /path/to/my-ec2-key.pem
Replace /path/to/ with the actual path to your .pem file.
3. Connect via SSH:
   • Open your terminal.
   • Find your instance's Public IPv4 address in the EC2 Console.
   • The default username for Ubuntu AMIs is ubuntu.
   ssh -i /path/to/my-ec2-key.pem ubuntu@YOUR_EC2_PUBLIC_IP
   When you connect for the first time, you might see a warning about the host's authenticity. Type yes and press Enter to continue. If you get a "Permission denied (publickey)" error, double-check chmod 400 and that you're using the correct .pem file and ubuntu username.

Basic Terminal Commands to Test Your Connection:

• pwd: Print working directory.
• ls -l: List directory contents.
• uname -a: Display system information.
• df -h: Show disk space usage.
• free -h: Show memory usage.

Step 4: Accessing Your EC2 Instance (Windows - PuTTY)

On Windows, PuTTY is a popular SSH client. It requires your .pem key to be converted to its own format, .ppk.

1. Download PuTTY and PuTTYgen:
   • If you don't have them, download the putty.exe and puttygen.exe executables from the official PuTTY website: www.putty.org .
   • Save them to a convenient location (e.g., a folder on your Desktop).
2. Convert .pem to .ppk using PuTTYgen:
   • Open puttygen.exe.
   • Click Load. Navigate to where you saved my-ec2-key.pem. You might need to select All Files (*.*) in the file dialog to see it.
   • A pop-up will appear saying the key was successfully imported. Click OK.
   • Click Save private key.
   • PuTTYgen will warn you about saving without a passphrase. For this beginner guide, you can click Yes to proceed without one. **For production environments, always set a strong passphrase!**
   • Save the .ppk file (e.g., my-ec2-key.ppk) in a secure location.
3. Connect with PuTTY:
   • Open putty.exe.
   • Session Category:
     • Host Name (or IP address): ubuntu@YOUR_EC2_PUBLIC_IP (replace YOUR_EC2_PUBLIC_IP with your instance's public IP).
     • Port: 22 (default for SSH).
   • SSH Authentication:
     • In the left pane, navigate to Connection > SSH > Auth.
     • Click Browse and select your my-ec2-key.ppk file.
   • Save Session (Optional, but Recommended):
     • Go back to the Session category.
     • Enter a name in Saved Sessions (e.g., My EC2 Server).
     • Click Save. Now you can just load this session next time.
   • Open Connection: Click Open.
   • If a security alert appears about the host key, click Accept (after verifying the fingerprint if you're cautious).

Step 5: Attaching Additional EBS Storage (Volume)

Your EC2 instance comes with a root volume, but often you'll need more dedicated storage for data, databases, or applications. EBS volumes are highly available, persistent block storage devices.

1. Create an EBS Volume (AWS Console):
   • In the EC2 Dashboard, navigate to Elastic Block Store > Volumes in the left pane.
   • Click Create Volume.
   • Volume Type: gp3 (General Purpose SSD) is a good default.
   • Size: Enter 10 GiB (or your desired size). Ensure it's within Free Tier limits if applicable.
   • Availability Zone: **Crucially, select the SAME Availability Zone as your EC2 instance.** (You can find your instance's AZ on its Description tab in the EC2 Console).
   • Tags: Add a Name tag (e.g., MyDataVolume).
   • Click Create Volume.
2. Attach the Volume to Your Instance (AWS Console):
   • Once the volume is available (may take a moment), select it in the Volumes list.
   • Click Actions > Attach Volume.
   • Instance: Start typing your instance name (MyWebServer) or ID and select it.
   • Device name: Note the suggested device name (e.g., /dev/sdf). This might be slightly different on Ubuntu (e.g., /dev/nvme1n1 for newer instances or /dev/xvdf for older). We'll verify in the next step.
   • Click Attach Volume.
3. Format and Mount the Volume (Linux Terminal):
   • Connect to your EC2 instance via SSH/PuTTY.
   • List Block Devices: Identify the newly attached volume.
     lsblk
     Look for a device with the size you just created (e.g., xvdf or nvme1n1). The root volume is usually xvda or nvme0n1. If it's nvme1n1, the device path will be /dev/nvme1n1. If it's xvdf, it's /dev/xvdf. We'll use /dev/xvdf as an example.
   • Format the Volume (Create a Filesystem):
     sudo mkfs -t ext4 /dev/xvdf
     Be extremely careful! Ensure you specify the correct device (/dev/xvdf or /dev/nvme1n1). Formatting the wrong device will wipe its data!
   • Create a Mount Point: This is the directory where your volume will be accessible.
     sudo mkdir /data
   • Mount the Volume:
     sudo mount /dev/xvdf /data
   • Verify Mount:
     df -h
     You should see /data listed with your new volume's size.
   • Make Mount Persistent (Automount on Reboot):
     • Get the Volume's UUID: This is more reliable than using /dev/xvdf.
       sudo blkid /dev/xvdf
       Copy the UUID= string (e.g., UUID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
     • Edit /etc/fstab: This file tells your system what filesystems to mount at boot.
       sudo nano /etc/fstab
     • Add the following line to the end of /etc/fstab (replace with your actual UUID):

       UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /data ext4 defaults,nofail 0 2

       nofail ensures your instance will still boot even if the volume isn't available (useful for non-critical data).
     • Save (Ctrl+O, Enter) and exit nano (Ctrl+X).
     • Test fstab Entry:
       sudo mount -a
       If no errors, your configuration is correct.

Step 6: Allocating and Associating an Elastic IP (Static Public IP)

By default, when you stop and start an EC2 instance, its public IP address changes. An Elastic IP (EIP) is a static public IP that you can associate with your instance, ensuring its IP address remains the same, even if the instance is stopped or restarted.

1. Allocate a New Elastic IP (AWS Console):
   • In the EC2 Dashboard, navigate to Network & Security > Elastic IPs in the left pane.
   • Click Allocate Elastic IP address.
   • Keep default settings (Amazon's pool of IPv4 addresses).
   • Click Allocate.
2. Associate the Elastic IP with Your Instance (AWS Console):
   • Once allocated, select the new Elastic IP in the list.
   • Click Actions > Associate Elastic IP address.
   • Resource type: Instance.
   • Instance: Start typing your instance name (MyWebServer) or ID and select it.
   • Click Associate.
3. Verify the Change:
   • Go back to EC2 Dashboard > Instances.
   • Select your instance. The Public IPv4 address on its Description tab should now be your newly associated Elastic IP.

Step 7: Configuring Security Groups (Opening Ports for Web Server)

If you plan to run a web server (like Apache or Nginx, which you might install after this guide), you'll need to open ports 80 (HTTP) and 443 (HTTPS) in your Security Group.

1. Edit Your Security Group (AWS Console):
   • In the EC2 Dashboard, navigate to Network & Security > Security Groups in the left pane.
   • Select the security group you created earlier (my-ssh-sg).
   • Click the Inbound Rules tab, then Edit inbound rules.
2. Add HTTP Rule:
   • Click Add rule.
   • Type: HTTP
   • Source: Anywhere-IPv4 (0.0.0.0/0). This allows web access from anywhere.
3. Add HTTPS Rule:
   • Click Add rule.
   • Type: HTTPS
   • Source: Anywhere-IPv4 (0.0.0.0/0).
4. Click Save rules.

Step 8: Terminating Your EC2 Instance (Important for Cost)

When you're finished with your instance, it's crucial to terminate it to avoid incurring charges. Remember the difference between Stop and Terminate.

1. Terminate the Instance (AWS Console):
   • In the EC2 Dashboard, go to Instances.
   • Select your instance (MyWebServer).
   • Click Instance state > Terminate instance.
   • Confirm the termination.
2. Release Elastic IP (if applicable):
   • If you allocated an Elastic IP (Step 6) and no longer need it, go to Elastic IPs.
   • Select the Elastic IP.
   • Click Actions > Release Elastic IP address.
3. Delete EBS Volumes (if applicable):
   • By default, the root EBS volume is deleted with the instance. However, additional volumes you created (like /data in Step 5) are often configured to Persist on termination.
   • To delete them, go to Volumes.
   • Select any volumes you no longer need.
   • Click Actions > Delete Volume.