AWS Detailed Course#

Table of Contents#

1. AWS Well-Architected Framework
2. Containers on AWS: Amazon ECS & AWS Fargate
3. Amazon DynamoDB & Single-Table Design
4. Event-Driven Architecture: EventBridge & Step Functions
5. Caching: Amazon ElastiCache (Redis) & CloudFront
6. High Availability, RTO/RPO & Route 53
7. Database Scaling & Amazon RDS Proxy
8. Cloud Security: PrivateLink, KMS & AWS WAF
9. Infrastructure as Code: AWS CDK vs Terraform
10. Cost Optimization & System Design Deep Dive

1. AWS Well-Architected Framework#

The AWS Well-Architected Framework defines architectural best practices organized across six core pillars:

2. Containers on AWS: Amazon ECS & AWS Fargate#

Amazon Elastic Container Service (ECS) is a fully managed container orchestration service. With AWS Fargate, you do not manage EC2 worker nodes; AWS provisions and scales the underlying compute automatically:

• Task Definition: JSON blueprint specifying Docker image, CPU/memory units (e.g. 0.5 vCPU, 1024 MiB), environment variables, port mappings, and logging to CloudWatch.
• Service: Maintains desired task count (e.g. 5 replicas), integrates with Application Load Balancer (ALB), and manages rolling update deployments.
• Task Execution Role vs Task Role: The Execution Role allows ECS agent to pull images from ECR and write logs; the Task Role grants permissions to the application code running inside the container.

3. Amazon DynamoDB & Single-Table Design#

Amazon DynamoDB is a serverless NoSQL database delivering consistent single-digit millisecond latency at any scale with zero server management.

// DynamoDB Primary Key Concepts:
// 1. Simple Primary Key: Partition Key (PK) -> e.g., userId
// 2. Composite Primary Key: Partition Key (PK) + Sort Key (SK) -> e.g., userId + orderId

// Example: Single-Table Schema for Users and Orders in one table
[
  { "PK": "USER#101", "SK": "METADATA", "name": "Pankaj", "email": "pankaj@corp.com" },
  { "PK": "USER#101", "SK": "ORDER#2026-001", "amount": 89.99, "status": "SHIPPED" },
  { "PK": "USER#101", "SK": "ORDER#2026-002", "amount": 14.50, "status": "PENDING" }
]

// Single Query fetches the user profile AND their recent orders in ONE network request!
// KeyConditionExpression: PK = "USER#101" AND SK begins_with("ORDER#")

4. Event-Driven Architecture: EventBridge & Step Functions#

Building resilient, decoupled microservices relies on events and distributed orchestration:

5. Caching: Amazon ElastiCache (Redis) & CloudFront#

A multi-tiered caching architecture drastically cuts database load and latency:

1. Edge Caching (Amazon CloudFront): Caches HTML, images, and API responses at 600+ edge locations globally. Reduces origin server requests by up to 90%.
2. In-Memory Application Cache (Amazon ElastiCache Redis): Sub-millisecond data store for session states, rate limiting, and frequently read database queries (Cache-Aside pattern).

6. High Availability, RTO/RPO & Route 53#

Disaster recovery (DR) is governed by two metrics:

• RPO (Recovery Point Objective): Acceptable data loss measured in time (e.g. database transactions in the last 5 minutes).
• RTO (Recovery Time Objective): Acceptable downtime before the service is fully restored.
• Amazon Route 53: Cloud DNS supporting latency-based routing, weighted round-robin, and automated DNS failover based on health checks.

7. Database Scaling & Amazon RDS Proxy#

Serverless applications (like Lambda) can spin up thousands of concurrent containers in seconds. Traditional databases like PostgreSQL or MySQL cannot handle 10,000 open connection sockets.

The Solution: Amazon RDS Proxy. Sits between your Lambda functions and RDS database, maintaining an efficient pool of established database connections and multiplexing thousands of serverless requests across a small connection pool.

8. Cloud Security: PrivateLink, KMS & AWS WAF#

• VPC Endpoints (AWS PrivateLink): Allows private EC2 instances or Lambda functions to connect securely to S3, DynamoDB, or Secrets Manager over the internal AWS network without traversing the public Internet or requiring a NAT Gateway!
• AWS Key Management Service (KMS): Securely creates and manages encryption keys used to encrypt S3 buckets, RDS databases, and EBS storage volumes.
• AWS WAF (Web Application Firewall): Protects web applications against common web exploits (SQL injection, Cross-Site Scripting XSS, and rate limiting brute-force attacks).

9. Infrastructure as Code: AWS CDK vs Terraform#

Never configure production cloud resources manually in the AWS web console ("click-ops"). Use Infrastructure as Code (IaC):

// AWS Cloud Development Kit (CDK) in TypeScript
import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class AppStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Creates S3 bucket with encryption and blocking public access
    const bucket = new s3.Bucket(this, 'DocumentBucket', {
      encryption: s3.BucketEncryption.S3_MANAGED,
      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
      removalPolicy: cdk.RemovalPolicy.RETAIN
    });
  }
}

10. Cost Optimization & System Design Deep Dive#

Next Steps: Review quick fundamentals in the AWS Crash Course, explore container orchestration in the Kubernetes Guide, or return to the TechToday Homepage.