S3, DynamoDB, Kinesis, SNS, SQS
API Gateway, CloudFront (Lambda@Edge)
CloudWatch Events/EventBridge, Cognito
CloudWatch Logs

S3 (이미지 업로드) → Lambda (썸네일 생성) → S3 (썸네일 저장)
                                          → DynamoDB (메타데이터)

EventBridge (매 1시간) → Lambda (작업 수행)

Client → SDK/CLI → Lambda → Response (즉시 반환)
Client → API Gateway → Lambda → Response

S3 (새 파일) → Event Queue → Lambda → 처리
                   │
                   └─→ 실패 시 재시도 (최대 3회)
                           └─→ DLQ (SNS/SQS)

Kinesis/DynamoDB Streams/SQS
           │
    Event Source Mapping (Poll)
           │
           ▼
    Lambda (배치로 동기 호출)

Client → ALB → Target Group → Lambda
              (HTTP→JSON)     (JSON→HTTP)

URL: http://example.com/path?name=foo&name=bar
 
→ Lambda Event:
{
  "queryStringParameters": {
    "name": ["foo", "bar"]
  }
}

S3 (새 파일) → Lambda → DynamoDB/RDS (메타데이터 저장)

def lambda_handler(event, context):
    print(event)  # 입력 데이터
    print(context.aws_request_id)  # 요청 ID
    print(context.function_name)  # 함수 이름

Lambda (기본) → AWS 소유 VPC에서 실행
                    │
                    ├─→ Public Internet ✅
                    └─→ Private VPC (RDS, ElastiCache) ❌

┌─────────────────── VPC ───────────────────┐
│                                            │
│   Private Subnet                           │
│   ┌─────────────────────────────────────┐ │
│   │                                     │ │
│   │  Lambda ──(ENI)──→ RDS             │ │
│   │                                     │ │
│   └─────────────────────────────────────┘ │
│                                            │
└────────────────────────────────────────────┘
 
필요 설정:
• VPC ID
• Subnet IDs
• Security Group IDs
• AWSLambdaVPCAccessExecutionRole

┌─────────────────── VPC ───────────────────┐
│                                            │
│   Private Subnet          Public Subnet    │
│   ┌──────────────┐       ┌──────────────┐ │
│   │   Lambda     │──────▶│ NAT Gateway  │ │
│   └──────────────┘       └──────┬───────┘ │
│                                  │         │
│                           ┌──────▼───────┐ │
│                           │ IGW          │ │
│                           └──────┬───────┘ │
└──────────────────────────────────┼─────────┘
                                   │
                                   ▼
                            Public Internet
 
• VPC 내 Lambda는 인터넷 접근 불가 (기본)
• Public Subnet에 배포해도 Public IP 없음
• Private Subnet + NAT Gateway 필요
• VPC Endpoint로 AWS 서비스 접근 (NAT 없이)

Lambda (Private) → NAT Gateway (Public) → IGW → Internet → 외부 API

# DynamoDB 접근 예시
Lambda → VPC Endpoint Gateway → DynamoDB (Private 액세스)

# ❌ BAD - 매 호출마다 연결 생성
def lambda_handler(event, context):
    db = connect_to_database()  # 매번 새로 연결 → 비효율적
    # ...
 
# ✅ GOOD - 핸들러 외부에서 연결 생성 (재사용)
db = connect_to_database()  # 한 번만 초기화
 
def lambda_handler(event, context):
    # db 재사용 → 성능 향상
    # ...

# 핸들러 내부 초기화 (BAD)
호출 1: DB 연결 → 처리 → 종료
호출 2: DB 연결 → 처리 → 종료  ← 매번 연결 오버헤드
호출 3: DB 연결 → 처리 → 종료
 
# 핸들러 외부 초기화 (GOOD)
초기화: DB 연결 (1회)
호출 1: 처리 → 종료
호출 2: 처리 → 종료  ← 연결 재사용
호출 3: 처리 → 종료

Without Layers:
┌─────────────────────────────┐
│ function.py                 │
│ + heavy_library (30MB)      │
│ = 30.02MB 패키지            │
└─────────────────────────────┘
 
With Layers:
┌───────────────────┐    ┌─────────────────────┐
│ function.py (20KB)│───▶│ Layer: library (30MB)│
└───────────────────┘    └─────────────────────┘
                              ↑
                         여러 함수에서 공유

1. EFS 파일 시스템 생성
2. EFS Access Point 생성
3. Lambda를 Private Subnet에 배포
4. Lambda 초기화 시 EFS를 로컬 디렉토리에 마운트

낮은 트래픽: 동시 실행 2개
높은 트래픽: 동시 실행 최대 1,000개 (리전당 기본 제한)

# 시나리오: 3개의 애플리케이션이 Lambda 사용
App 1: ALB → Lambda (대규모 프로모션 중, 트래픽 폭주)
App 2: API Gateway → Lambda (소규모 사용자)
App 3: SDK/CLI → Lambda
 
# 문제 발생
App 1이 동시성 1,000개 모두 소진
   ↓
App 2, App 3도 Throttle 발생!

S3 (대량 파일 업로드) → Lambda (동시성 제한 도달)
                              ↓
                        Throttle 발생
                              ↓
                    내부 이벤트 대기열로 반환
                              ↓
                    최대 6시간 동안 재시도
                    (지수 백오프: 1초 ~ 5분 간격)

ALB/API Gateway (많은 사용자) ──┐
                                │
SDK/CLI (소수 사용자) ──────────┼──▶ Lambda (1000 동시 실행)
                                │
                           THROTTLE!

┌─────────────────────────────────────────┐
│                                         │
│  ┌─────────────┐  ┌─────────────┐      │
│  │ Unreserved  │  │  Reserved   │      │
│  │ Concurrency │  │ Concurrency │      │
│  │             │  │             │      │
│  │             │  │ ┌─────────┐ │      │
│  │             │  │ │Provisioned│      │
│  │             │  │ │Concurrency│      │
│  │             │  │ └─────────┘ │      │
│  └─────────────┘  └─────────────┘      │
│                                         │
│        Account Concurrency Limit        │
└─────────────────────────────────────────┘

# Lambda Runtime API 구현 이미지 사용
FROM amazon/aws-lambda-nodejs:12
 
COPY app.js package*.json ./
RUN npm install
 
CMD ["app.lambdaHandler"]

# 시나리오: S3에 코드를 업데이트했지만...
S3에 새 코드 업로드 (같은 파일명)
        ↓
CloudFormation 템플릿의 S3Bucket, S3Key 동일
        ↓
❌ CloudFormation이 변경 감지 못함 → 업데이트 안 됨!
 
# 해결책: S3ObjectVersion 사용
버저닝 활성화 → 파일 덮어쓰기 → 새 버전 ID 생성
        ↓
S3ObjectVersion 값 변경
        ↓
✅ CloudFormation이 변경 감지 → Lambda 함수 업데이트!

┌─────────────────────────────────────────────────────────────────┐
│                        계정 1 (소스)                              │
│  ┌─────────────┐                                                 │
│  │  S3 Bucket  │ ← Lambda 코드 저장                              │
│  │ (코드 저장) │                                                 │
│  │             │                                                 │
│  │ ┌─────────┐ │                                                 │
│  │ │ Bucket  │ │ ← 계정 2, 3에 GetObject 권한 부여               │
│  │ │ Policy  │ │                                                 │
│  │ └─────────┘ │                                                 │
│  └──────┬──────┘                                                 │
└─────────┼───────────────────────────────────────────────────────┘
          │
          ▼
┌─────────────────────────────────────────────────────────────────┐
│                        계정 2 (타겟)                              │
│  ┌─────────────────┐      ┌─────────────────┐                    │
│  │ CloudFormation  │─────▶│ Lambda Function │                    │
│  │ + Execution Role│      │   (배포됨)       │                    │
│  └─────────────────┘      └─────────────────┘                    │
│         │                                                        │
│         └─ S3 버킷 접근 권한 (계정 1의 버킷 정책 + 실행 역할)      │
└─────────────────────────────────────────────────────────────────┘

Code:
  ZipFile: |
    def handler(event, context):
        return "Hello"

Code:
  S3Bucket: my-bucket
  S3Key: code.zip
  S3ObjectVersion: abc123 # 버전 관리 시

$LATEST (mutable) ← 개발 중
    │
    ├─→ V1 (immutable)
    ├─→ V2 (immutable)
    └─→ V3 (immutable)

$LATEST ← DEV Alias
V2 ← TEST Alias
V1 (95%) + V2 (5%) ← PROD Alias (Canary)

version: 0.0
Resources:
  - MyFunction:
      Type: AWS::Lambda::Function
      Properties:
        Name: MyFunction
        Alias: PROD
        CurrentVersion: 1
        TargetVersion: 2

# ✅ 핸들러 외부에서 초기화 (재사용)
import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('MyTable')
 
def lambda_handler(event, context):
    # table 재사용
    return table.get_item(...)