Client → API Gateway → Lambda → DynamoDB
         (REST API)    (PROXY)   (CRUD)

Client → API Gateway → Kinesis Data Streams → Kinesis Data Firehose → S3
         (requests)     (send records)                                (.json 저장)

Client → API Gateway → (백엔드 없음) → 미리 정의된 응답 반환

{
  "message": "Hello, this is a mock response!",
  "status": "success"
}

Client → API Gateway + Mapping Templates → SQS Queue

클라이언트: { "name": "홍길동" }
      ↓ (Mapping Template으로 변환)
백엔드: <user><name>홍길동</name></user>

Client Request → API Gateway → Lambda (그대로 전달)
                                  │
                                  ├─ 요청/응답 로직은 Lambda가 처리
                                  └─ Mapping Template 없음

def lambda_handler(event, context):
    # event에 모든 정보가 담겨 옴
    print(event['headers'])        # HTTP 헤더
    print(event['queryStringParameters'])  # ?name=value
    print(event['body'])           # POST 본문
 
    return {
        'statusCode': 200,
        'body': '{"message": "success"}'
    }

Client → API Gateway → HTTP Backend (그대로 전달)

기존: Client ──→ Express Server
변경: Client ──→ API Gateway (인증, 제한) ──→ Express Server

API Gateway 변경 → 바로 적용 ❌
                → "Deployment" 필요 ✅ → Stage에 배포

v1 Stage ← v1 Client (https://api.example.com/v1)
v2 Stage ← v2 Client (https://api.example.com/v2)

개발 중: https://api.example.com/dev/users
테스트: https://api.example.com/test/users
실서비스: https://api.example.com/prod/users

${stageVariables.variableName}

dev Stage:
  lambdaAlias = "DEV"
 
prod Stage:
  lambdaAlias = "PROD"

Lambda ARN: arn:aws:lambda:...:myFunction:${stageVariables.lambdaAlias}

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  Prod Stage ──→ PROD Alias ──→ V1 (95%) + V2 (5%)         │
│  Test Stage ──→ TEST Alias ──→ V2 (100%)                  │
│  Dev Stage  ──→ DEV Alias  ──→ $LATEST (100%)             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Client ─┬──(95%)──→ Prod Stage v1 (기존 안정 버전)
        │
        └──(5%)───→ Prod Stage Canary v2 (새 버전)

#set($inputRoot = $input.path('$'))
{
  "user_name": "$inputRoot.name",
  "user_age": $inputRoot.age
}

GET http://example.com/users?name=홍길동&age=25

{
  "userName": "$input.params('name')",
  "userAge": $input.params('age')
}

{
  "userName": "홍길동",
  "userAge": 25
}

Client (REST, JSON) → API Gateway + Mapping Template → SOAP API (XML)

openapi: 3.0.0
info:
  title: 사용자 API
  version: 1.0.0
paths:
  /users:
    get:
      summary: 사용자 목록 조회
      responses:
        "200":
          description: 성공
    post:
      summary: 사용자 생성
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                name:
                  type: string
                email:
                  type: string

잘못된 요청 → API Gateway → Lambda (실행됨, 비용 발생) → 에러 반환

잘못된 요청 → API Gateway (검증 실패, 400 에러) → Lambda 실행 안 됨!

paths:
  /users:
    post:
      parameters:
        - name: Authorization
          in: header
          required: true # 필수!
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - name
                - email # 필수 필드!
              properties:
                name:
                  type: string
                  minLength: 1
                email:
                  type: string
                  format: email

첫 번째 요청:
Client → API Gateway → (캐시 없음) → Lambda → 응답 → 캐시에 저장
 
두 번째 같은 요청:
Client → API Gateway → (캐시 있음!) → 캐시된 응답 반환 (Lambda 호출 안 함!)

x-api-key: WBjHxNtoAb4WPKBC7cGm64CBibIb24b4jt8jJHo9

1단계: API 생성 → 메서드에 "API Key 필요" 설정 → Stage 배포
2단계: API Keys 생성 (고객에게 배포)
3단계: Usage Plan 생성 (Throttle, Quota 설정)
4단계: Usage Plan에 API Stages + API Keys 연결

curl -X GET "https://api.example.com/prod/users" \
  -H "x-api-key: WBjHxNtoAb4WPKBC7cGm64CBibIb24b4jt8jJHo9"

[INFO] Request: GET /users?page=1
[INFO] Headers: { "x-api-key": "***", "Content-Type": "application/json" }
[INFO] Response: 200, Body: {"users": [...]}
[ERROR] Request: POST /users - 500 Internal Server Error

Client → API Gateway (10ms) → Lambda (200ms) → DynamoDB (50ms)
                                    │
                                    └─→ 어디가 병목인지 한눈에!

Client → API Gateway → "429 Too Many Requests"
                       "잠시 후 다시 시도하세요"

Account (10,000 RPS)
    │
    ├─ Stage limit (예: prod는 5,000 RPS)
    │      │
    │      └─ Method limit (예: POST /orders는 1,000 RPS)
    │
    └─ Usage Plan (고객별)
           │
           ├─ Free 고객: 10 RPS
           └─ Pro 고객: 100 RPS

# 잘못된 응답 (502 발생!)
def lambda_handler(event, context):
    return "Hello"
 
# 올바른 응답
def lambda_handler(event, context):
    return {
        'statusCode': 200,
        'headers': {'Content-Type': 'application/json'},
        'body': '{"message": "Hello"}'
    }

1. 브라우저: "api.mysite.com으로 요청해도 될까요?" (OPTIONS 요청)
2. API Gateway: "www.mysite.com은 허용됩니다" (CORS 헤더 응답)
3. 브라우저: "허가받았으니 실제 요청 보냄" (GET/POST 요청)

def lambda_handler(event, context):
    return {
        'statusCode': 200,
        'headers': {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Headers': 'Content-Type',
        },
        'body': '{"message": "success"}'
    }

Client (AWS 내부) → API Gateway → Backend
   │
   └─ IAM 자격 증명 + Signature v4 서명

{
  "Effect": "Allow",
  "Principal": "*",
  "Action": "execute-api:Invoke",
  "Resource": "arn:aws:execute-api:...",
  "Condition": {
    "IpAddress": {
      "aws:SourceIp": "203.0.113.0/24"
    }
  }
}

1. 사용자 → Cognito 로그인 → 토큰 받음
2. 사용자 → API Gateway (토큰 포함) → Cognito 토큰 검증 → Backend

1. 사용자 → API Gateway (토큰 포함)
2. API Gateway → Lambda Authorizer 호출
3. Lambda → 토큰 검증 (회사 자체 인증 서버 확인)
4. Lambda → IAM Policy 반환 ("이 사용자는 /users만 접근 가능")
5. API Gateway → Backend 호출 또는 거부

┌─────────────────────────────────────────────────────────────┐
│                        CHAT APPLICATION                      │
│                                                              │
│  [유저A] ←──────────(WebSocket)──────────→ API Gateway      │
│  [유저B] ←──────────(WebSocket)──────────→     │            │
│                                                 │            │
│                       ┌─────────────────────────┘            │
│                       │                                      │
│         onConnect ────┼──── sendMessage ──── onDisconnect   │
│              │        │          │                │          │
│              ▼        │          ▼                ▼          │
│           Lambda      │       Lambda           Lambda        │
│              │        │          │                │          │
│              └────────┴──────────┴────────────────┘          │
│                              │                               │
│                              ▼                               │
│                         DynamoDB                             │
│                    (connectionId 저장)                       │
└─────────────────────────────────────────────────────────────┘

유저A 접속 → connectionId: "abc123" 생성 → DynamoDB에 저장

유저A: "안녕하세요!"
  → Lambda: DynamoDB에서 모든 connectionId 조회
  → Lambda: 유저B의 connectionId("xyz789")로 메시지 전송
유저B: "안녕하세요!" 수신

유저A 나감 → connectionId: "abc123" 삭제

import boto3
 
# API Gateway Management API 사용
client = boto3.client('apigatewaymanagementapi',
                      endpoint_url='https://abcdef.execute-api.us-west-1.amazonaws.com/dev')
 
# 특정 클라이언트에게 메시지 전송
client.post_to_connection(
    ConnectionId='abc123',
    Data=b'{"message": "Hello from server!"}'
)

                          Route 53
                    (api.mycompany.com)
                             │
                       API Gateway
                             │
            ┌────────────────┼────────────────┐
            │                │                │
       /users            /products        /orders
            │                │                │
            ▼                ▼                ▼
     Lambda (사용자)   ECS (상품)     EC2 (주문)
            │                │                │
            ▼                ▼                ▼
        DynamoDB          RDS             RDS