Cloud Platforms

# Create bucket
$ aws s3 mb s3://my-app-bucket

# Upload file
$ aws s3 cp image.jpg s3://my-app-bucket/images/

# Upload directory
$ aws s3 sync ./dist s3://my-app-bucket/website/

# Download file
$ aws s3 cp s3://my-app-bucket/data.csv ./

# List objects
$ aws s3 ls s3://my-app-bucket/

# Delete object
$ aws s3 rm s3://my-app-bucket/old-file.txt

# Make bucket public (careful!)
$ aws s3api put-bucket-policy --bucket my-app-bucket --policy file://policy.json

# Enable versioning
$ aws s3api put-bucket-versioning \
  --bucket my-app-bucket \
  --versioning-configuration Status=Enabled

# Create volume
$ aws ec2 create-volume \
  --availability-zone us-east-1a \
  --size 100 \
  --volume-type gp3 \
  --iops 3000 \
  --throughput 125

# Attach to instance
$ aws ec2 attach-volume \
  --volume-id vol-1234567890abcdef0 \
  --instance-id i-1234567890abcdef0 \
  --device /dev/sdf

# Create snapshot (backup)
$ aws ec2 create-snapshot \
  --volume-id vol-1234567890abcdef0 \
  --description "Backup before upgrade"

# Restore from snapshot
$ aws ec2 create-volume \
  --snapshot-id snap-1234567890abcdef0 \
  --availability-zone us-east-1a

# Via AWS CLI
$ aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type t3.micro \
  --key-name my-key \
  --security-group-ids sg-1234567890 \
  --subnet-id subnet-1234567890 \
  --user-data file://install.sh \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=web-server}]'

# List instances
$ aws ec2 describe-instances \
  --filters "Name=tag:Environment,Values=production"

# Stop instance
$ aws ec2 stop-instances --instance-ids i-1234567890abcdef0

# Terminate instance
$ aws ec2 terminate-instances --instance-ids i-1234567890abcdef0

import json
import boto3
from datetime import datetime

s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('users')

def lambda_handler(event, context):
    """
    Lambda handler function
    event: trigger data (API Gateway, S3 event, etc.)
    context: runtime information
    """

    # Example 1: API Gateway event
    if event.get('httpMethod'):
        body = json.loads(event['body'])

        # Process request
        user_id = body.get('user_id')
        user = table.get_item(Key={'id': user_id})

        return {
            'statusCode': 200,
            'headers': {'Content-Type': 'application/json'},
            'body': json.dumps(user.get('Item', {}))
        }

    # Example 2: S3 event (file uploaded)
    if event.get('Records'):
        for record in event['Records']:
            if record['eventName'].startswith('ObjectCreated'):
                bucket = record['s3']['bucket']['name']
                key = record['s3']['object']['key']

                # Process uploaded file
                print(f"Processing {key} from {bucket}")

                # Get file
                obj = s3.get_object(Bucket=bucket, Key=key)
                data = obj['Body'].read()

                # Do something with data...

        return {'statusCode': 200}

    # Example 3: Scheduled event (CloudWatch Events/EventBridge)
    if event.get('source') == 'aws.events':
        # Daily cleanup job
        print(f"Running cleanup at {datetime.now()}")
        # Cleanup logic...
        return {'statusCode': 200}

    return {
        'statusCode': 400,
        'body': json.dumps({'error': 'Unknown event type'})
    }

$ aws rds create-db-instance \
  --db-instance-identifier myapp-db \
  --db-instance-class db.t4g.micro \
  --engine postgres \
  --engine-version 15.3 \
  --master-username admin \
  --master-user-password MySecurePassword123! \
  --allocated-storage 20 \
  --storage-type gp3 \
  --backup-retention-period 7 \
  --preferred-backup-window "03:00-04:00" \
  --multi-az \  # High availability
  --publicly-accessible false \
  --vpc-security-group-ids sg-1234567890 \
  --db-subnet-group-name my-db-subnet-group \
  --storage-encrypted \
  --enable-cloudwatch-logs-exports '["postgresql"]'

# Create read replica
$ aws rds create-db-instance-read-replica \
  --db-instance-identifier myapp-db-replica \
  --source-db-instance-identifier myapp-db \
  --db-instance-class db.t4g.micro

# Create snapshot
$ aws rds create-db-snapshot \
  --db-instance-identifier myapp-db \
  --db-snapshot-identifier myapp-db-snapshot-2024-01-20

import boto3
from boto3.dynamodb.conditions import Key, Attr
from decimal import Decimal

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('users')

# Put item
table.put_item(
    Item={
        'user_id': '12345',
        'name': 'John Doe',
        'email': 'john@example.com',
        'age': 30,
        'tags': ['premium', 'verified'],
        'created_at': '2024-01-20T10:30:00Z'
    }
)

# Get item
response = table.get_item(
    Key={'user_id': '12345'}
)
user = response.get('Item')

# Update item
table.update_item(
    Key={'user_id': '12345'},
    UpdateExpression='SET age = :age, tags = list_append(tags, :tag)',
    ExpressionAttributeValues={
        ':age': 31,
        ':tag': ['active']
    }
)

# Query (requires partition key)
response = table.query(
    KeyConditionExpression=Key('user_id').eq('12345')
)

# Scan (expensive, avoid in production)
response = table.scan(
    FilterExpression=Attr('age').gt(25) & Attr('tags').contains('premium')
)

# Batch write
with table.batch_writer() as batch:
    for i in range(100):
        batch.put_item(
            Item={
                'user_id': f'user-{i}',
                'name': f'User {i}',
                'score': Decimal(str(i * 10))
            }
        )

# Delete item
table.delete_item(
    Key={'user_id': '12345'}
)

$ aws elbv2 create-load-balancer \
  --name my-alb \
  --subnets subnet-12345 subnet-67890 \
  --security-groups sg-12345 \
  --scheme internet-facing \
  --type application

# Create target group
$ aws elbv2 create-target-group \
  --name my-targets \
  --protocol HTTP \
  --port 80 \
  --vpc-id vpc-12345 \
  --health-check-path /health \
  --health-check-interval-seconds 30

# Register targets
$ aws elbv2 register-targets \
  --target-group-arn arn:aws:... \
  --targets Id=i-12345 Id=i-67890

# Create listener
$ aws elbv2 create-listener \
  --load-balancer-arn arn:aws:... \
  --protocol HTTP \
  --port 80 \
  --default-actions Type=forward,TargetGroupArn=arn:aws:...