Getting Started: Your First AWS Project

# First, enable billing alerts in the Billing Console
# Go to: Billing > Billing Preferences > check "Receive Billing Alerts"

# Then create a CloudWatch billing alarm
aws cloudwatch put-metric-alarm \
  --alarm-name "billing-alarm-10-usd" \
  --alarm-description "Alert when estimated charges exceed $10" \
  --namespace "AWS/Billing" \
  --metric-name "EstimatedCharges" \
  --dimensions Name=Currency,Value=USD \
  --statistic Maximum \
  --period 21600 \
  --evaluation-periods 1 \
  --threshold 10 \
  --comparison-operator GreaterThanThreshold \
  --alarm-actions "arn:aws:sns:us-east-1:YOUR_ACCOUNT_ID:billing-alerts" \
  --region us-east-1

# Note: Billing metrics are only available in us-east-1

# macOS (using Homebrew)
brew install awscli

# Windows (download the MSI installer)
# https://awscli.amazonaws.com/AWSCLIV2.msi

# Linux
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Verify installation
aws --version
# aws-cli/2.x.x Python/3.x.x ...

# Configure credentials (after creating an IAM user)
aws configure
# AWS Access Key ID: AKIA...
# AWS Secret Access Key: ****
# Default region name: us-east-1
# Default output format: json

# Create an IAM user for your day-to-day work
aws iam create-user --user-name admin-user

# Attach the AdministratorAccess managed policy
# (For learning purposes - restrict in production)
aws iam attach-user-policy \
  --user-name admin-user \
  --policy-arn arn:aws:iam::aws:policy/AdministratorAccess

# Create access keys for CLI access
aws iam create-access-key --user-name admin-user
# Save the AccessKeyId and SecretAccessKey securely!

# Enable console access
aws iam create-login-profile \
  --user-name admin-user \
  --password "YourStr0ngP@ssword!" \
  --password-reset-required

# IMPORTANT: Enable MFA on the IAM user too
# Go to IAM > Users > admin-user > Security credentials > Assign MFA device

# Find the latest Amazon Linux 2023 AMI
AMI_ID=$(aws ec2 describe-images \
  --owners amazon \
  --filters "Name=name,Values=al2023-ami-2023*-x86_64" \
             "Name=state,Values=available" \
  --query 'sort_by(Images, &CreationDate)[-1].ImageId' \
  --output text)

echo "Using AMI: $AMI_ID"

# Create a key pair for SSH access
aws ec2 create-key-pair \
  --key-name my-first-keypair \
  --query 'KeyMaterial' \
  --output text > my-first-keypair.pem

chmod 400 my-first-keypair.pem

# Create a security group allowing SSH and HTTP
SG_ID=$(aws ec2 create-security-group \
  --group-name my-first-sg \
  --description "Allow SSH and HTTP" \
  --query 'GroupId' \
  --output text)

aws ec2 authorize-security-group-ingress \
  --group-id $SG_ID \
  --protocol tcp --port 22 --cidr 0.0.0.0/0

aws ec2 authorize-security-group-ingress \
  --group-id $SG_ID \
  --protocol tcp --port 80 --cidr 0.0.0.0/0

# Launch the instance (Free Tier eligible)
INSTANCE_ID=$(aws ec2 run-instances \
  --image-id $AMI_ID \
  --instance-type t2.micro \
  --key-name my-first-keypair \
  --security-group-ids $SG_ID \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=my-first-instance}]' \
  --query 'Instances[0].InstanceId' \
  --output text)

echo "Instance launched: $INSTANCE_ID"

# Wait for the instance to be running
aws ec2 wait instance-running --instance-ids $INSTANCE_ID

# Get the public IP address
PUBLIC_IP=$(aws ec2 describe-instances \
  --instance-ids $INSTANCE_ID \
  --query 'Reservations[0].Instances[0].PublicIpAddress' \
  --output text)

echo "Connect with: ssh -i my-first-keypair.pem ec2-user@$PUBLIC_IP"

# Connect via SSH
ssh -i my-first-keypair.pem ec2-user@YOUR_PUBLIC_IP

# Once connected, you're inside a Linux virtual server!
# Try some commands:
uname -a                   # See the kernel version
cat /etc/os-release        # See the OS info
free -h                    # Check available memory
df -h                      # Check disk space
curl http://169.254.169.254/latest/meta-data/instance-type  # Instance metadata

# Create a bucket (name must be globally unique)
aws s3 mb s3://my-first-bucket-janedoe-2025

# Upload a file
echo "Hello from AWS S3!" > hello.txt
aws s3 cp hello.txt s3://my-first-bucket-janedoe-2025/hello.txt

# List objects in the bucket
aws s3 ls s3://my-first-bucket-janedoe-2025/

# Download a file
aws s3 cp s3://my-first-bucket-janedoe-2025/hello.txt downloaded.txt

# Upload a directory
mkdir my-website
echo "<html><body><h1>Hello AWS!</h1></body></html>" > my-website/index.html
echo "<html><body><h1>Error</h1></body></html>" > my-website/error.html
aws s3 sync my-website/ s3://my-first-bucket-janedoe-2025/website/

# Generate a pre-signed URL (temporary access without making the bucket public)
aws s3 presign s3://my-first-bucket-janedoe-2025/hello.txt --expires-in 3600

# View your default VPC
aws ec2 describe-vpcs \
  --filters "Name=isDefault,Values=true" \
  --query 'Vpcs[0].{VpcId:VpcId, CidrBlock:CidrBlock}' \
  --output table

# List subnets in the default VPC
aws ec2 describe-subnets \
  --filters "Name=vpc-id,Values=YOUR_VPC_ID" \
  --query 'Subnets[].{SubnetId:SubnetId, AZ:AvailabilityZone, CIDR:CidrBlock}' \
  --output table

# View the route table
aws ec2 describe-route-tables \
  --filters "Name=vpc-id,Values=YOUR_VPC_ID" \
  --query 'RouteTables[0].Routes[].{Dest:DestinationCidrBlock, Target:GatewayId}' \
  --output table

# SSH into your EC2 instance first
ssh -i my-first-keypair.pem ec2-user@YOUR_PUBLIC_IP

# Update the system
sudo dnf update -y

# Install Nginx web server
sudo dnf install -y nginx

# Start Nginx and enable it to start on boot
sudo systemctl start nginx
sudo systemctl enable nginx

# Create a custom index page
sudo tee /usr/share/nginx/html/index.html > /dev/null << 'HTMLEOF'
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>My First AWS App</title>
  <style>
    body { font-family: system-ui, sans-serif; max-width: 800px; margin: 40px auto; padding: 0 20px; }
    h1 { color: #232F3E; }
    .info { background: #f0f4f8; padding: 20px; border-radius: 8px; margin: 20px 0; }
    code { background: #e8ecf0; padding: 2px 6px; border-radius: 4px; }
  </style>
</head>
<body>
  <h1>Hello from AWS EC2!</h1>
  <div class="info">
    <p>This page is served from an EC2 instance running in the AWS cloud.</p>
    <p>Instance type: <code>t2.micro</code> (Free Tier eligible)</p>
    <p>Web server: <code>Nginx</code></p>
  </div>
  <p>Congratulations on deploying your first AWS web application!</p>
</body>
</html>
HTMLEOF

# Verify Nginx is running
sudo systemctl status nginx

# Test locally
curl http://localhost

# View CPU utilization for your instance (last 1 hour)
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=YOUR_INSTANCE_ID \
  --start-time $(date -u -v-1H '+%Y-%m-%dT%H:%M:%S') \
  --end-time $(date -u '+%Y-%m-%dT%H:%M:%S') \
  --period 300 \
  --statistics Average \
  --output table

# List all running EC2 instances
aws ec2 describe-instances \
  --filters "Name=instance-state-name,Values=running" \
  --query 'Reservations[].Instances[].{ID:InstanceId, Type:InstanceType, Name:Tags[?Key==`Name`].Value|[0], State:State.Name, PublicIP:PublicIpAddress}' \
  --output table

# Check your S3 bucket size
aws s3 ls s3://my-first-bucket-janedoe-2025 --recursive --summarize \
  | tail -2

# View your estimated AWS charges
aws ce get-cost-and-usage \
  --time-period Start=$(date -u -v-7d '+%Y-%m-%d'),End=$(date -u '+%Y-%m-%d') \
  --granularity DAILY \
  --metrics "BlendedCost" \
  --output table

# 1. Terminate EC2 instances
aws ec2 terminate-instances --instance-ids YOUR_INSTANCE_ID
aws ec2 wait instance-terminated --instance-ids YOUR_INSTANCE_ID

# 2. Delete the key pair
aws ec2 delete-key-pair --key-name my-first-keypair
rm my-first-keypair.pem

# 3. Delete the security group (wait for instance termination first)
aws ec2 delete-security-group --group-id YOUR_SG_ID

# 4. Empty and delete S3 bucket
aws s3 rm s3://my-first-bucket-janedoe-2025 --recursive
aws s3 rb s3://my-first-bucket-janedoe-2025

# 5. Delete the IAM user (if no longer needed)
aws iam delete-access-key --user-name admin-user --access-key-id YOUR_KEY_ID
aws iam delete-login-profile --user-name admin-user
aws iam detach-user-policy \
  --user-name admin-user \
  --policy-arn arn:aws:iam::aws:policy/AdministratorAccess
aws iam delete-user --user-name admin-user

# 6. Check for any remaining resources
echo "=== Running EC2 Instances ==="
aws ec2 describe-instances \
  --filters "Name=instance-state-name,Values=running" \
  --query 'Reservations[].Instances[].InstanceId' --output text

echo "=== S3 Buckets ==="
aws s3 ls

echo "=== EBS Volumes (not attached) ==="
aws ec2 describe-volumes \
  --filters "Name=status,Values=available" \
  --query 'Volumes[].{ID:VolumeId, Size:Size}' --output table

echo "=== Elastic IPs ==="
aws ec2 describe-addresses \
  --query 'Addresses[].{IP:PublicIp, Allocation:AllocationId}' --output table

echo "=== NAT Gateways (expensive!) ==="
aws ec2 describe-nat-gateways \
  --filter "Name=state,Values=available" \
  --query 'NatGateways[].NatGatewayId' --output text

# Check your Free Tier usage via CLI
aws ce get-cost-and-usage \
  --time-period Start=$(date -u -v-30d '+%Y-%m-%d'),End=$(date -u '+%Y-%m-%d') \
  --granularity MONTHLY \
  --metrics "UsageQuantity" "BlendedCost" \
  --group-by Type=DIMENSION,Key=SERVICE \
  --output table

# List all resources in your account (multi-service scan)
echo "=== Lambda Functions ==="
aws lambda list-functions --query 'Functions[].FunctionName' --output text 2>/dev/null

echo "=== RDS Instances ==="
aws rds describe-db-instances \
  --query 'DBInstances[].{ID:DBInstanceIdentifier,Class:DBInstanceClass,Status:DBInstanceStatus}' \
  --output table 2>/dev/null

echo "=== CloudFormation Stacks ==="
aws cloudformation list-stacks \
  --stack-status-filter CREATE_COMPLETE UPDATE_COMPLETE \
  --query 'StackSummaries[].StackName' --output text 2>/dev/null