AWS (Amazon Web Services)¶

Cloud platform that runs half the internet. 200+ services (you'll use maybe 10). 33+ regions globally. Industry standard for cloud infrastructure. Pricing is a mystery, bills are scary, but it works.

Quick Hits¶

# EC2 - Virtual machines (you'll use this)
aws ec2 run-instances \
  --image-id ami-xxx \
  --instance-type t3.micro \
  --key-name my-key # (1)!

# S3 - Object storage (everyone uses this)
aws s3 cp file.txt s3://bucket-name/
aws s3 sync ./local s3://bucket/path --delete # (2)!

# Lambda - Serverless functions (scales like crazy)
aws lambda invoke \
  --function-name my-function \
  --payload '{"key":"value"}' \
  output.txt # (3)!

# RDS - Managed databases (don't run your own DB)
aws rds describe-db-instances
aws rds create-db-snapshot --db-instance-identifier prod-db # (4)!

# IAM - Identity management (painful but critical)
aws iam create-user --user-name dev-user
aws sts get-caller-identity  # "Who the fuck am I?"
aws iam list-attached-user-policies --user-name dev-user # (5)!

# CloudWatch - Logs and monitoring (set billing alarms!)
aws logs tail /aws/lambda/my-function --follow
aws cloudwatch put-metric-alarm \
  --alarm-name BillingAlarm \
  --alarm-description "Alert when bill exceeds $100" \
  --metric-name EstimatedCharges \
  --threshold 100 # (6)!

# ECS/EKS - Container orchestration
aws ecs list-clusters
aws eks list-clusters
aws eks update-kubeconfig --name my-cluster # (7)!

import boto3
from botocore.exceptions import ClientError

# S3 upload with proper error handling
def upload_to_s3(file_path, bucket, key):
    """Upload file to S3 with private ACL."""
    s3 = boto3.client('s3')
    try:
        s3.upload_file(
            file_path,
            bucket,
            key,
            ExtraArgs={'ACL': 'private'}  # Don't leak shit # (1)!
        )
        return True
    except ClientError as e:
        print(f"Upload failed: {e}")
        return False

# Lambda handler pattern (use this)
def lambda_handler(event, context):
    """Standard Lambda handler with proper error handling."""
    try:
        # Parse event (API Gateway, SQS, etc.)
        body = json.loads(event.get('body', '{}'))

        # Do work
        result = process_data(body)

        # Return proper response
        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'  # Adjust for prod # (2)!
            },
            'body': json.dumps(result)
        }
    except Exception as e:
        print(f"Error: {e}")  # Goes to CloudWatch # (3)!
        return {'statusCode': 500, 'body': 'Internal error'}

# DynamoDB pattern (NoSQL done right)
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Users')

# Query (efficient) - use this
response = table.query(
    KeyConditionExpression='user_id = :uid',
    ExpressionAttributeValues={':uid': '12345'}
) # (4)!

# Scan (expensive) - avoid in prod
response = table.scan(Limit=100)  # Will cost $$$$ at scale # (5)!

# CloudFormation/SAM pattern (infrastructure as code)
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: python3.12  # Use latest runtime # (1)!
      Handler: app.lambda_handler
      Timeout: 30  # Seconds - adjust based on workload
      MemorySize: 512  # MB - more memory = faster CPU # (2)!
      Environment:
        Variables:
          TABLE_NAME: !Ref MyTable
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref MyTable  # Least privilege # (3)!

  MyTable:
    Type: AWS::DynamoDB::Table
    Properties:
      BillingMode: PAY_PER_REQUEST  # No capacity planning # (4)!
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      StreamSpecification:  # For DynamoDB Streams
        StreamViewType: NEW_AND_OLD_IMAGES # (5)!

Learning Paths¶

Free Resources¶

• AWS Skill Builder - Official training, tons of free courses (start here)
• AWS Free Tier - 12 months free for core services (stay within limits!)
• freeCodeCamp AWS Course - 10+ hour deep dive, quality content
• AWS Workshops - Hands-on labs, various topics
• A Cloud Guru Free Tier - Quality video courses
• AWS Getting Started Guides - Official tutorials
• AWS re:Post - Official Q&A platform (replaced forums in 2024)

Interactive Labs¶

• AWS Sandbox Accounts - Official hands-on tutorials in real AWS
• Qwiklabs AWS - Temporary accounts for safe experimentation
• Instruqt AWS Labs - Browser-based scenarios
• LocalStack - Run AWS locally for development (Pro version worth it)
• AWS CloudShell - Browser-based shell with AWS CLI pre-installed

Certifications Worth It¶

• Cloud Practitioner - $100, easiest, good starting point if totally new
• Solutions Architect Associate - $150, most popular, worth it for resume (this one matters)
• Developer Associate - $150, worth it if you code on AWS daily
• SysOps Administrator Associate - $150, operations-focused
• Skip unless senior/employer pays: Professional certs ($300), Specialty certs ($300) - overkill for most

Reality check:

• Solutions Architect Associate is the sweet spot (most job postings ask for this)
• Study 2-3 months with hands-on practice, exams are scenario-based
• Use Tutorials Dojo practice exams ($15, best investment)
• Join r/AWSCertifications for study tips

Projects to Build¶

Architecture Patterns¶

Common AWS architecture patterns for real-world applications.

Three-Tier Web Application¶

Classic pattern: presentation, application, data layers with high availability.

graph TB
    subgraph "Internet"
        Users[Users]
    end

    subgraph "AWS Cloud"
        subgraph "Availability Zone 1"
            ALB1[Application<br/>Load Balancer]
            EC2_1[EC2 Instance<br/>App Server]
            RDS_Primary[(RDS Primary<br/>PostgreSQL)]
        end

        subgraph "Availability Zone 2"
            EC2_2[EC2 Instance<br/>App Server]
            RDS_Standby[(RDS Standby<br/>Read Replica)]
        end

        S3[S3 Bucket<br/>Static Assets]
        CloudFront[CloudFront CDN]
    end

    Users -->|HTTPS| CloudFront
    CloudFront -->|Static| S3
    CloudFront -->|Dynamic| ALB1
    ALB1 --> EC2_1
    ALB1 --> EC2_2
    EC2_1 -->|Read/Write| RDS_Primary
    EC2_2 -->|Read/Write| RDS_Primary
    RDS_Primary -.->|Replicate| RDS_Standby

    style Users fill:#e1f5ff
    style CloudFront fill:#ff9900
    style S3 fill:#569a31
    style ALB1 fill:#ff9900
    style EC2_1 fill:#ff9900
    style EC2_2 fill:#ff9900
    style RDS_Primary fill:#527fff
    style RDS_Standby fill:#527fff

Components:

• CloudFront: Global CDN, caches static assets at edge locations
• S3: Object storage for images, CSS, JavaScript
• ALB: Distributes traffic across EC2 instances in multiple AZs
• EC2: Application servers running in Auto Scaling group
• RDS: Managed PostgreSQL with multi-AZ failover

Real talk: This pattern handles 10k-100k requests/day. Add auto-scaling for growth.

Serverless Microservices¶

Event-driven architecture with Lambda, API Gateway, and DynamoDB.

graph LR
    Client[Mobile/Web<br/>Client] -->|HTTPS| APIGW[API Gateway<br/>REST API]
    APIGW -->|Invoke| Auth[Lambda<br/>Auth Function]
    APIGW -->|Invoke| Users[Lambda<br/>Users Service]
    APIGW -->|Invoke| Orders[Lambda<br/>Orders Service]

    Auth -->|Read/Write| Cognito[Cognito<br/>User Pool]
    Users -->|Read/Write| UserDB[(DynamoDB<br/>Users Table)]
    Orders -->|Read/Write| OrderDB[(DynamoDB<br/>Orders Table)]

    Orders -->|Publish| SNS[SNS Topic<br/>Order Events]
    SNS -->|Subscribe| Email[Lambda<br/>Email Service]
    SNS -->|Subscribe| SQS[SQS Queue]
    SQS -->|Process| Worker[Lambda<br/>Worker Function]

    style Client fill:#e1f5ff
    style APIGW fill:#ff9900
    style Auth fill:#ff9900
    style Users fill:#ff9900
    style Orders fill:#ff9900
    style Email fill:#ff9900
    style Worker fill:#ff9900
    style Cognito fill:#dd344c
    style UserDB fill:#527fff
    style OrderDB fill:#527fff
    style SNS fill:#ff9900
    style SQS fill:#ff9900

Components:

• API Gateway: RESTful API with authentication, rate limiting, caching
• Lambda: Stateless functions, auto-scale, pay-per-invocation
• DynamoDB: NoSQL database with single-digit millisecond latency
• SNS/SQS: Async messaging for decoupled microservices
• Cognito: User authentication and authorization

Real talk: Scales to millions of requests, costs pennies at low traffic. Cold starts are 100-500ms.

Data Pipeline Architecture¶

ETL pattern for processing large datasets with S3, Glue, and Athena.

graph TB
    Sources[Data Sources<br/>Logs, APIs, Databases] -->|Stream| Kinesis[Kinesis Data<br/>Streams]
    Sources -->|Batch| S3_Raw[S3 Raw Bucket<br/>Landing Zone]

    Kinesis -->|Real-time| Firehose[Kinesis Data<br/>Firehose]
    Firehose --> S3_Raw

    S3_Raw -->|Trigger| Glue[AWS Glue<br/>ETL Jobs]
    Glue -->|Transform| S3_Processed[S3 Processed<br/>Parquet Format]

    S3_Processed -->|Catalog| GlueCatalog[Glue Data<br/>Catalog]
    GlueCatalog -->|Query| Athena[Athena<br/>SQL Queries]
    GlueCatalog -->|Visualize| QuickSight[QuickSight<br/>Dashboards]

    S3_Processed -->|Train| SageMaker[SageMaker<br/>ML Models]

    style Sources fill:#e1f5ff
    style Kinesis fill:#ff9900
    style Firehose fill:#ff9900
    style S3_Raw fill:#569a31
    style Glue fill:#ff9900
    style S3_Processed fill:#569a31
    style GlueCatalog fill:#ff9900
    style Athena fill:#ff9900
    style QuickSight fill:#ff9900
    style SageMaker fill:#ff9900

Components:

• Kinesis: Real-time data streaming (alternative to Kafka)
• S3: Data lake storage (raw and processed data)
• Glue: Serverless ETL, converts JSON/CSV to optimized Parquet
• Athena: Query S3 data with SQL, pay per query ($5/TB scanned)
• QuickSight: BI dashboards, ML-powered insights

Real talk: Processes terabytes for cents. Use Parquet format (10x cheaper queries than JSON).

Well-Architected Framework¶

AWS's five pillars for building reliable, secure, efficient systems.

Security¶

Design Principles:

• Identity and Access Management - Use IAM roles, never embed credentials
• Detective Controls - Enable CloudTrail, GuardDuty, Config
• Infrastructure Protection - VPC isolation, security groups, NACLs
• Data Protection - Encrypt at rest (KMS) and in transit (TLS)
• Incident Response - Automated remediation with Lambda

Reliability¶

Design Principles:

• Multi-AZ Deployment - RDS, ALB, EC2 across 2+ availability zones
• Auto Scaling - Respond to demand changes automatically
• Backup and Recovery - Automated snapshots, cross-region replication
• Change Management - Infrastructure as code (CloudFormation/Terraform)
• Failure Isolation - Bulkheads prevent cascading failures

Performance Efficiency¶

Design Principles:

• Selection - Choose right compute (EC2 vs Lambda vs Fargate)
• Review - Continuously evaluate new services
• Monitoring - CloudWatch metrics, X-Ray tracing
• Trade-offs - Consistency vs latency, normalization vs denormalization

graph TD
    Start{Compute Need?} -->|Containers| Container{Orchestration?}
    Start -->|VMs| VM{Persistent?}
    Start -->|Functions| Lambda[Lambda<br/>Event-driven]

    Container -->|Yes| EKS[EKS<br/>Kubernetes]
    Container -->|No| ECS[ECS/Fargate<br/>Simpler]

    VM -->|Yes| EC2[EC2<br/>Full Control]
    VM -->|No| Batch[AWS Batch<br/>Job Scheduling]

    style Start fill:#e1f5ff
    style Lambda fill:#ff9900
    style EKS fill:#ff9900
    style ECS fill:#ff9900
    style EC2 fill:#ff9900
    style Batch fill:#ff9900

Cost Optimization¶

Design Principles:

• Right Sizing - Match instance size to workload (don't over-provision)
• Elasticity - Auto-scale down during off-peak hours
• Pricing Models - Reserved Instances (72% off), Spot (90% off)
• Managed Services - RDS cheaper than self-managed EC2 databases
• Cost Allocation - Tag everything for chargeback/showback

Operational Excellence¶

Design Principles:

• Operations as Code - Infrastructure as code, runbooks as code
• Frequent, Small Changes - Reduce blast radius of failures
• Refine Operations - Learn from failures, improve processes
• Anticipate Failure - Chaos engineering, game days
• Learn from Failures - Post-mortems without blame

Community Pulse¶

Who to Follow¶

Twitter/X:

• @awscloud - Official updates, new service launches
• @QuinnyPig - Corey Quinn, AWS cost optimization, hilarious roasts
• @ben11kehoe - Serverless expert, AWS Community Builder
• @nathankpeck - AWS Principal Dev Advocate, ECS/containers expert
• @jeremy_daly - Serverless champion, great technical insights
• @neiltheblue - Solutions Architect, hands-on tutorials
• @esh - AWS Chief Evangelist (Jeff Barr)

YouTube/Streamers:

• AWS Online Tech Talks - Deep dives, re:Invent sessions
• FooBar Serverless - Serverless tutorials
• Be A Better Dev - Practical AWS projects
• TechWorld with Nana - DevOps + AWS tutorials
• AWS Events - Conference talks, workshops

Active Communities¶

• r/aws - 250k+ members, active daily, mix of beginner + advanced (best community)
• AWS Community Discord - Official, helpful, core team present
• Dev.to #aws - Quality tutorials, case studies, community posts
• AWS Community Builders - Official program, great networking
• AWS re:Post - Official Q&A (replaces old forums)
• ServerlessLand Community - Serverless-focused, active Slack/Discord

Podcasts & Newsletters¶

Podcasts:

• AWS Podcast - Official, weekly, new features + customer stories
• Screaming in the Cloud - Corey Quinn, hilarious, critical of AWS (in good way)
• AWS TechChat - Technical deep dives
• AWS Morning Brief - Short daily AWS news

Newsletters:

• Last Week in AWS - Weekly, irreverent, critical analysis (subscribe now)
• Off-by-none - Serverless newsletter, Jeremy Daly, quality content
• AWS Week in Review - Official blog, weekly updates
• AWS Open Source News - Open source projects on AWS

Events & Conferences¶

• AWS re:Invent - Las Vegas, late November, 50k+ attendees, $2k+ (worth it once in career)
• AWS Summit - Free, regional (20+ cities), good for networking
• AWS Community Day - Free, community-organized, worldwide, quality talks
• ServerlessDays - Free/cheap, serverless-focused, technical talks

Worth Checking¶

Last Updated: 2026-01-31 | Vibe Check: Mainstream - AWS is the default cloud. Not the coolest kid anymore (Vercel/Railway have better DX), but runs most production workloads. If you're doing cloud professionally, you're learning AWS.

Tags: aws, cloud