Microservices Architecture

CHOOSE MONOLITH WHEN:
├── Small team (< 10 developers)
├── Simple domain with clear boundaries
├── Startup MVP or rapid prototyping
├── Limited operational expertise
└── Predictable, stable requirements

CHOOSE MICROSERVICES WHEN:
├── Large organization with multiple teams
├── Different services have different scaling needs
├── Need for technology flexibility
├── Frequent, independent deployments required
├── High availability requirements
└── Complex domain with clear bounded contexts

ECS ARCHITECTURE:

CLUSTER
├── Logical grouping of tasks and services
└── Can span multiple Availability Zones

TASK DEFINITION
├── Blueprint for your application
├── Specifies container images
├── Defines CPU, memory, networking
├── IAM roles for containers
└── Similar to a Docker Compose file

SERVICE
├── Runs and maintains desired task count
├── Integrates with load balancers
├── Supports rolling deployments
├── Auto Scaling capabilities
└── Health check monitoring

TASK
├── Running instance of task definition
├── One or more containers
├── Ephemeral (can be replaced)
└── Runs on EC2 or Fargate

EKS ARCHITECTURE:

CONTROL PLANE (AWS Managed)
├── Kubernetes API server
├── etcd (cluster state storage)
├── Controller manager
└── Scheduler

DATA PLANE (You manage or Fargate)
├── Worker Nodes (EC2 instances)
├── Node Groups (managed scaling)
└── Fargate Profiles (serverless)

KUBERNETES RESOURCES:
POD
├── Smallest deployable unit
├── Contains one or more containers
└── Shared networking and storage

DEPLOYMENT
├── Manages replica sets
├── Rolling updates
└── Rollback capabilities

SERVICE
├── Stable network endpoint
├── Load balancing across pods
└── Service discovery (DNS)

CLIENT-SIDE DISCOVERY:
├── Service queries registry directly
├── Client chooses instance to call
├── Examples: Consul, Eureka
└── More complex client logic

SERVER-SIDE DISCOVERY (AWS Recommended):
├── Request goes to load balancer/DNS
├── Router queries registry and forwards
├── Examples: ALB, Route 53, Cloud Map
└── Simpler client, transparent discovery

AWS CLOUD MAP:
├── Define namespace (e.g., production.local)
├── Register service (e.g., orders.production.local)
├── Health checks update DNS records
├── Auto-removes unhealthy instances
└── API and DNS query support

ECS SERVICE DISCOVERY:
├── Automatic registration with Cloud Map
├── DNS A or SRV records
├── Integrates with Route 53
└── Health check integration

{
  "Namespace": {
    "Name": "production.local",
    "Type": "DNS_PRIVATE",
    "Vpc": "vpc-123456"
  },
  "Service": {
    "Name": "order-service",
    "DnsConfig": {
      "RoutingPolicy": "MULTIVALUE",
      "DnsRecords": [
        { "Type": "A", "TTL": 60 }
      ]
    },
    "HealthCheckCustomConfig": {
      "FailureThreshold": 3
    }
  }
}

REST API (Most Common):
├── HTTP/HTTPS protocols
├── Stateless requests
├── JSON/XML payloads
└── Good for: CRUD operations, web APIs

gRPC:
├── High-performance RPC framework
├── Protocol Buffers for serialization
├── HTTP/2 with bidirectional streaming
└── Good for: Low-latency service-to-service

API GATEWAY PATTERN:
Internet → API Gateway → Microservices
├── Single entry point for clients
├── Request routing by path/header
├── Authentication & authorization
├── Rate limiting & throttling
├── Request/response transformation
└── Caching

MESSAGE QUEUES (SQS):
├── Point-to-point communication
├── Guaranteed delivery
├── Message persistence
├── Dead-letter queues for failures
└── Good for: Work distribution, decoupling

PUBLISH/SUBSCRIBE (SNS):
├── One-to-many messaging
├── Multiple subscriber types
├── Fan-out pattern
└── Good for: Notifications, broadcasting

EVENT STREAMING (Kinesis/EventBridge):
├── Real-time data streams
├── Event sourcing patterns
├── Multiple consumers
└── Good for: Analytics, real-time processing

API GATEWAY PATTERN:

                    ┌──────────────────┐
                    │   API Gateway    │
                    │   ─────────────  │
Mobile ───────────→ │ • Authentication │
Web App ──────────→ │ • Rate Limiting  │ ──→ Microservices
Partners ─────────→ │ • Routing        │
                    │ • Transformation │
                    │ • Caching        │
                    └──────────────────┘

AMAZON API GATEWAY FEATURES:
├── REST APIs (full-featured)
│   ├── Request/response transformation
│   ├── SDK generation
│   └── API caching
│
├── HTTP APIs (simpler, faster, cheaper)
│   ├── Lower latency
│   ├── Native OpenID Connect/OAuth 2.0
│   └── 71% cheaper than REST APIs
│
└── WebSocket APIs
    ├── Real-time bidirectional
    ├── Chat, gaming, trading
    └── Connection state management

SAGA PATTERN (Order Processing Example):

SUCCESS PATH:
1. Create Order      → Order Service
2. Reserve Inventory → Inventory Service
3. Process Payment   → Payment Service
4. Ship Order        → Shipping Service
✓ Complete

COMPENSATING TRANSACTIONS (on failure):
If Payment fails:
├── 3. Payment Failed     → Trigger compensation
├── 2. Release Inventory  → Inventory Service
├── 1. Cancel Order       → Order Service
└── Return error to user

AWS STEP FUNCTIONS FOR SAGA:
├── Visual workflow designer
├── Error handling & retries
├── Timeout management
├── Parallel execution
├── State machine definition
└── Integration with Lambda, ECS, SQS

IMAGE OPTIMIZATION:
├── Use minimal base images (Alpine, distroless)
├── Multi-stage builds to reduce size
├── Scan images for vulnerabilities (ECR scanning)
└── Tag images with git SHA, not just 'latest'

RESOURCE MANAGEMENT:
├── Set CPU and memory limits
├── Use appropriate instance types (Fargate vCPU/memory)
├── Implement health checks
└── Configure graceful shutdown

SECURITY:
├── Run as non-root user
├── Use IAM roles for tasks (not embedded credentials)
├── Enable secrets management (Secrets Manager)
├── Network isolation with security groups
└── Enable encryption in transit

DEPLOYMENT:
├── Blue/green or canary deployments
├── Rolling updates with health checks
├── Automated rollback on failures
└── Immutable infrastructure

CHOOSE SYNCHRONOUS (API Gateway, ALB):
├── Real-time response required
├── Simple request-response
├── User-facing operations
└── Query operations

CHOOSE ASYNCHRONOUS (SQS, SNS, EventBridge):
├── Can tolerate latency
├── Need fault tolerance
├── Background processing
├── Event broadcasting
├── Workload decoupling
└── Fan-out scenarios

{
  "family": "order-service",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::123456789012:role/orderServiceRole",
  "containerDefinitions": [
    {
      "name": "order-api",
      "image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/order-service:v1.2.3",
      "portMappings": [
        { "containerPort": 8080, "protocol": "tcp" }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/order-service",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "healthCheck": {
        "command": ["CMD-SHELL", "curl -f http://localhost:8080/health || exit 1"],
        "interval": 30,
        "timeout": 5,
        "retries": 3
      },
      "secrets": [
        {
          "name": "DB_PASSWORD",
          "valueFrom": "arn:aws:secretsmanager:us-east-1:123456789012:secret:db-password"
        }
      ]
    }
  ]
}