DynamoDB
    │
    └─ Table
           │
           ├─ Item (행) - 최대 400KB
           │      │
           │      ├─ Attribute (열)
           │      ├─ Attribute
           │      └─ Attribute
           │
           └─ Item
                  └─ ...

┌────────────────────────────────────────────────────┐
│  User_ID (PK)  │  First_Name  │  Last_Name  │ Age │
├────────────────┼──────────────┼─────────────┼─────┤
│  7791a3d6-...  │     John     │   William   │  46 │
│  873e0634-...  │    Katie     │    Lucas    │  31 │
│  a80f73a1-...  │    Oliver    │     -       │  24 │
└────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│  User_ID (PK)  │  Game_ID (SK)  │  Score  │    Result      │
├────────────────┼────────────────┼─────────┼────────────────┤
│  7791a3d6-...  │      4421      │   92    │      Win       │
│  873e0634-...  │      4521      │   77    │      Win       │
│  873e0634-...  │      1894      │   14    │     Lose       │
└─────────────────────────────────────────────────────────────┘
                       ↑
              같은 PK, 다른 SK (조합이 고유)

영화 DB에서 최적의 Partition Key는?
 
❌ movie_language → 값이 적음, 영어에 편중
❌ producer_name → 카디널리티 낮음
❌ leader_actor_name → 카디널리티 중간
✅ movie_id → 가장 높은 카디널리티!

10 × (2KB / 1KB) = 20 WCU

6 × (5KB / 1KB) = 30 WCU  ← 4.5 → 5로 올림

(120/60) × (2KB / 1KB) = 4 WCU

Application → DynamoDB
                 │
           ┌─────┼─────┐
           │     │     │
        Server1 Server2 Server3
           │           │
         write    ────→ replication (지연 가능)
           │           │
         read ←────    read (Eventually: 오래된 데이터 가능)

10 × (4KB / 4KB) = 10 RCU

(16/2) × (12KB / 4KB) = 24 RCU

10 × (8KB / 4KB) = 20 RCU  ← 6 → 8로 올림

Application
    │
    ▼
Hash Function
    │
    ├─→ Partition 1 (ID_13, ID_27, ...)
    ├─→ Partition 2 (ID_45, ID_89, ...)
    └─→ Partition 3 (...)

# 조건: 가격 > 500일 때만 150 할인 적용
aws dynamodb update-item \
  --table-name ProductCatalog \
  --key '{"id": {"N": "456"}}' \
  --update-expression "SET Price = Price - :discount" \
  --condition-expression "Price > :limit" \
  --expression-attribute-values file://values.json
 
# values.json
{
  ":discount": {"N": "150"},
  ":limit": {"N": "500"}
}
 
# 결과:
# 가격 650 → 500 (조건 충족, 업데이트 성공)
# 가격 500 → 변경 없음 (조건 불충족, 업데이트 실패)

# 가격이 없는 불완전한 항목 정리
aws dynamodb delete-item \
  --table-name ProductCatalog \
  --key '{"id": {"N": "789"}}' \
  --condition-expression "attribute_not_exists(Price)"

# 별점 1개 리뷰가 존재하는 제품만 삭제
aws dynamodb delete-item \
  --table-name ProductCatalog \
  --key '{"id": {"N": "123"}}' \
  --condition-expression "attribute_exists(ProductReview.OneStar)"

# Partition Key만 있는 경우
--condition-expression "attribute_not_exists(pk)"
 
# Partition Key + Sort Key 조합인 경우
--condition-expression "attribute_not_exists(pk) AND attribute_not_exists(sk)"

# ProductCategory가 cat1/cat2이거나 가격이 500~600 사이일 때 삭제
aws dynamodb delete-item \
  --table-name ProductCatalog \
  --key '{"id": {"N": "456"}}' \
  --condition-expression "ProductCategory IN (:cat1, :cat2) OR Price BETWEEN :lo AND :hi" \
  --expression-attribute-values file://values.json
 
# values.json
{
  ":cat1": {"S": "Electronics"},
  ":cat2": {"S": "Books"},
  ":lo": {"N": "500"},
  ":hi": {"N": "600"}
}
 
# 예시: ProductCategory=Electronics, Price=650
# → 첫 번째 조건(IN) 통과, 삭제 실행
 
# 예시: ProductCategory=Toys, Price=650
# → 두 조건 모두 불충족, 삭제 안 됨

# 안전하지 않은 URL(http://)로 시작하는 이미지 삭제
aws dynamodb delete-item \
  --table-name ProductCatalog \
  --key '{"id": {"N": "123"}}' \
  --condition-expression "begins_with(ImageUrl, :prefix)" \
  --expression-attribute-values '{":prefix": {"S": "http://"}}'

# Partition Key: 반드시 = (등호) 연산자만 사용 가능
partition_key = "value"
 
# Sort Key: 다양한 연산자 사용 가능 (선택)
sort_key = "value"           # 정확히 일치
sort_key < "value"           # 미만
sort_key > "value"           # 초과
sort_key BETWEEN a AND b     # 범위
sort_key begins_with("prefix") # 접두사

# 반환 조건 (둘 중 하나 먼저 도달 시)
1. Limit 매개변수에 지정한 항목 수
2. 최대 1MB 데이터 용량
 
# 더 많은 데이터 필요 시
→ 페이지네이션으로 추가 요청

# 방법 1: Limit 적용
Scan에 Limit 문 적용 → 결과 크기 제한 → 잠시 중지 후 재개
 
# 방법 2: 병렬 스캔 (Parallel Scan)
여러 작업자가 동시에 데이터 세그먼트를 스캔
→ 처리량과 RCU 증가
→ 빠른 Scan 완료
→ Limit 등 조건으로 영향 제한 가능

SELECT * FROM Users WHERE User_ID = '7791a3d6-...'

┌─────────────────────────────────────────────────────────────────────────┐
│  User_ID (PK)  │  Game_ID (SK)  │  Score  │  Game_TS (LSI)            │
├────────────────┼────────────────┼─────────┼───────────────────────────┤
│  7791a3d6-...  │      4421      │   92    │  2021-03-15T17:43:08      │
│  873e0634-...  │      1894      │   77    │  2021-02-11T04:11:31      │
└─────────────────────────────────────────────────────────────────────────┘
                                                    ↑
                                             Alternative Sort Key

# 기본 테이블 구성
Partition Key: User_ID
Sort Key: Game_ID
 
# 가능한 쿼리
✅ User_ID + Game_ID 로 쿼리 가능
 
# 불가능한 쿼리 (LSI 없이)
❌ User_ID + Game_TS 로 쿼리 불가
   → Scan 후 클라이언트에서 필터링 필요 (비효율적)
 
# LSI 생성 후
✅ User_ID + Game_TS 로 쿼리 가능
   → "2020~2021년 사이 특정 사용자가 플레이한 모든 게임" 조회 가능

TABLE (User_ID로 쿼리)           GSI (Game_ID로 쿼리)
┌────────────────────────┐      ┌────────────────────────┐
│ User_ID │ Game_ID │... │      │ Game_ID │ Game_TS │... │
├─────────┼─────────┼────┤      ├─────────┼─────────┼────┤
│ 7791... │  4421   │    │      │  4421   │ 2021... │    │
│ 873e... │  1894   │    │      │  1894   │ 2021... │    │
└────────────────────────┘      └────────────────────────┘
        ↑                              ↑
  User_ID로만 쿼리 가능         Game_ID로 쿼리 가능!

# 기본 테이블 구성
Partition Key: User_ID
Sort Key: Game_ID
 
# 불가능한 쿼리 (GSI 없이)
❌ Game_ID로 쿼리 불가
   → "이 게임을 플레이한 모든 유저" 조회 불가
   → Scan 후 클라이언트에서 필터링 필요
 
# GSI 생성 후
GSI Partition Key: Game_ID
GSI Sort Key: Game_TS
Projected Attributes: User_ID
 
✅ Game_ID로 쿼리 가능!
   → "특정 게임을 플레이한 모든 유저와 플레이 시간" 조회 가능

# 상황
메인 테이블 WCU: 충분함 ✅
GSI WCU: 부족함 ❌
 
# 결과
GSI 쓰기 Throttle 발생
       ↓
메인 테이블 쓰기도 Throttle! ❌

# 언제 LSI를 사용할까?
- 동일한 Partition Key 내에서 다른 정렬 기준이 필요할 때
- 테이블 설계 시점에 쿼리 패턴을 알고 있을 때
- 예: "특정 유저의 게임 기록을 시간순으로 조회"
 
# 언제 GSI를 사용할까?
- 완전히 다른 Partition Key로 쿼리해야 할 때
- 테이블 생성 후 새로운 쿼리 패턴이 필요할 때
- 예: "특정 게임을 플레이한 모든 유저 조회"

DynamoDB Table
User_ID: 7791...
Name: Michael
Version: 1
 
Client 1: UPDATE Name = 'John' WHERE Version = 1 ✅ → Version = 2
Client 2: UPDATE Name = 'Lisa' WHERE Version = 1 ❌ (Version이 이미 2)

# Hot Key 문제
특정 키(항목)를 너무 많이 읽음
        ↓
RCU 스로틀 발생!
        ↓
# DAX로 해결
DAX 클러스터가 인기 데이터를 캐시
        ↓
DynamoDB 대신 캐시에서 반환 → 스로틀 방지

┌─────────────┐      ┌─────────────────┐      ┌─────────────────┐
│ Application │─────▶│   DAX Cluster   │─────▶│ DynamoDB Table  │
└─────────────┘      │  (인메모리 캐시) │      └─────────────────┘
                     │                 │
                     │  ┌───────────┐  │
                     │  │  Node 1   │  │  ← 프로비저닝 필요
                     │  │  Node 2   │  │  ← 최대 10개 노드
                     │  │  Node 3   │  │  ← Multi-AZ 권장
                     │  └───────────┘  │
                     │                 │
                     │  TTL: 5분 (기본)│
                     └─────────────────┘

Application
    │
    ├─→ DAX → DynamoDB
    │   (개별 객체 캐시, Query/Scan 캐시)
    │   → 간단한 유형의 쿼리: 객체, 쿼리, 스캔
    │
    └─→ ElastiCache
        (집계 결과 저장)
        → 복잡한 계산 결과: SUM, 필터링, 통계 등

# DAX 사용
- DynamoDB 데이터를 그대로 캐싱
- GetItem, Query, Scan 결과 캐싱
- Hot Key 문제 해결
 
# ElastiCache 사용
- 애플리케이션에서 계산한 결과 저장 (통계, 랭킹, 집계 등)
- 계산 비용이 많이 드는 작업의 결과 캐싱
- DAX를 다시 쿼리하고 클라이언트에서 다시 집계하지 않아도 됨

# DynamoDB Streams 활용 시나리오
 
1. 환영 이메일 발송
   신규 사용자 생성 → Stream → Lambda → SES 이메일 발송
 
2. 실시간 분석
   주문 데이터 변경 → Stream → Kinesis Data Analytics → 실시간 대시보드
 
3. 파생 테이블 생성
   원본 테이블 변경 → Stream → Lambda → 다른 DynamoDB 테이블 업데이트
 
4. 검색 인덱싱
   상품 데이터 변경 → Stream → Lambda → OpenSearch/ElasticSearch 인덱싱
 
5. Global Tables 복제
   리전 A 변경 → Stream → 리전 B로 자동 복제 (내부적으로 Streams 사용)

┌─────────────────┐
│ DynamoDB Table  │
│ (Items 변경)    │
└────────┬────────┘
         │ create/update/delete
         ▼
┌─────────────────┐     ┌────────────────────────┐
│DynamoDB Streams │────▶│ Kinesis Data Streams   │ (선택적 연동)
│ (24시간 보존)   │     │ (더 긴 보존 기간 필요 시)│
└────────┬────────┘     └───────────┬────────────┘
         │                          │
         ▼                          ▼
┌─────────────────────────────────────────────────┐
│               처리 옵션                          │
├─────────────────────────────────────────────────┤
│ • AWS Lambda (가장 일반적)                       │
│ • KCL (Kinesis Client Library) 애플리케이션     │
│ • Kinesis Data Firehose                         │
└─────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────┐
│               대상 서비스                        │
├─────────────────────────────────────────────────┤
│ • Amazon OpenSearch (검색 인덱싱)               │
│ • Amazon SNS (알림 발송)                        │
│ • 다른 DynamoDB Table (파생 테이블)             │
│ • Amazon Redshift (데이터 웨어하우스)           │
│ • Amazon S3 (아카이브 저장)                     │
└─────────────────────────────────────────────────┘

# 예시: 사용자 이름 변경 시 각 유형별 Stream 레코드
 
KEYS_ONLY:
{ "User_ID": "123" }
 
NEW_IMAGE:
{ "User_ID": "123", "Name": "John", "Email": "john@..." }
 
OLD_IMAGE:
{ "User_ID": "123", "Name": "Mike", "Email": "mike@..." }
 
NEW_AND_OLD_IMAGES:
{
  "OldImage": { "User_ID": "123", "Name": "Mike", "Email": "mike@..." },
  "NewImage": { "User_ID": "123", "Name": "John", "Email": "john@..." }
}

┌─────────────────┐     ┌─────────────────────┐     ┌─────────────────┐
│ DynamoDB Table  │────▶│  DynamoDB Streams   │────▶│  AWS Lambda     │
│ (항목 변경)     │     │  (Event Source)     │     │  (처리 함수)    │
└─────────────────┘     └─────────────────────┘     └─────────────────┘
                                   │
                                   │ Event Source Mapping
                                   │ (Lambda가 Stream을 폴링)
                                   ▼
                        ┌─────────────────────┐
                        │ 동기 호출 (Invoke)  │
                        │ • 배치 처리 가능    │
                        │ • 재시도 자동 처리  │
                        └─────────────────────┘

# 24시간 이상 데이터 보존이 필요한 경우
 
DynamoDB Streams (24시간)
         │
         ▼
Kinesis Data Streams (최대 365일 보존 가능)
         │
         ├─→ Kinesis Data Firehose → S3 (영구 보관)
         └─→ Lambda → 장기 분석/처리

# 특정 속성만 가져오기
aws dynamodb get-item \
  --table-name Users \
  --key '{"User_ID": {"S": "123"}}' \
  --projection-expression "Name, Email"
 
# Name과 Email 속성만 반환 (다른 속성은 제외)

# 특정 조건에 맞는 아이템만 반환
aws dynamodb scan \
  --table-name Users \
  --filter-expression "Age > :min_age" \
  --expression-attribute-values '{":min_age": {"N": "30"}}'

# 문제 상황: 10,000개 아이템을 한 번에 요청 → 시간 초과 발생!
 
# 해결: --page-size로 분할 요청
aws dynamodb scan \
  --table-name LargeTable \
  --page-size 100
 
# 내부 동작:
# - 100개씩 100번의 API 호출 (백그라운드)
# - 사용자에게는 전체 10,000개 결과 반환
# - 각 호출이 작아서 시간 초과 방지

# 처음 25개만 가져오기
aws dynamodb scan \
  --table-name Users \
  --max-items 25
 
# 결과에 NextToken이 포함됨
# {
#   "Items": [...],
#   "NextToken": "eyJFeGNsdXNpdm..."
# }
 
# 다음 25개 가져오기 (--starting-token 사용)
aws dynamodb scan \
  --table-name Users \
  --max-items 25 \
  --starting-token "eyJFeGNsdXNpdm..."

# 예시: 10,000개 테이블
 
# --page-size 100
→ 100번의 API 호출 (백그라운드)
→ 10,000개 전체 결과 반환
 
# --max-items 100
→ 100개만 반환
→ NextToken으로 다음 100개 요청 가능

┌─────────────────────────────────────────────────────────────────┐
│ AccountBalance 테이블                                            │
├─────────────┬──────────┬─────────────────────────────────────────┤
│ Account_ID  │ Balance  │ Last_Tx_ts                              │
├─────────────┼──────────┼─────────────────────────────────────────┤
│ ACC-001     │ $5,000   │ 2024-01-15T10:30:00                     │
│ ACC-002     │ $3,000   │ 2024-01-15T09:15:00                     │
└─────────────────────────────────────────────────────────────────┘
 
┌─────────────────────────────────────────────────────────────────┐
│ BankTransactions 테이블                                          │
├──────────┬─────────────────┬──────────┬──────────┬──────────────┤
│ Tx_ID    │ Tx_ts           │ From_Acc │ To_Acc   │ Amount       │
├──────────┼─────────────────┼──────────┼──────────┼──────────────┤
│ TX-001   │ 2024-01-15...   │ ACC-001  │ ACC-002  │ $500         │
└─────────────────────────────────────────────────────────────────┘

Application
    │
    │ 하나의 트랜잭션으로 처리
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│                    TransactWriteItems                        │
├─────────────────────────────────────────────────────────────┤
│ 1. UpdateItem (AccountBalance)                               │
│    → ACC-001 잔액에서 $500 차감                              │
│    → ACC-002 잔액에 $500 추가                                │
│                                                              │
│ 2. PutItem (BankTransactions)                                │
│    → 새 거래 기록 추가                                       │
└─────────────────────────────────────────────────────────────┘
    │
    ▼
결과: 두 테이블 모두 업데이트 성공 ✅
  OR 모두 롤백 (실패 시) ❌

3 × (5KB / 1KB) × 2 = 30 WCU
 
# 계산 과정:
# - 초당 3번 쓰기
# - 아이템 크기 5KB (1 WCU = 1KB)
# - 트랜잭션이므로 ×2

5 × (8KB / 4KB) × 2 = 20 RCU
 
# 계산 과정:
# - 초당 5번 읽기
# - 아이템 크기 5KB → 8KB로 올림 (4KB 단위)
# - 트랜잭션이므로 ×2

투표 앱에서 Candidate_ID를 PK로 사용:
- Candidate_A → Partition 1 (과부하!)
- Candidate_B → Partition 2 (과부하!)

┌──────────────────────────────────────────┐
│  Candidate_ID + Suffix  │  Vote_ts  │... │
├─────────────────────────┼───────────┼────┤
│  Candidate_A-11         │ 1631...   │    │
│  Candidate_A-20         │ 1631...   │    │
│  Candidate_B-17         │ 1631...   │    │
│  Candidate_B-80         │ 1631...   │    │
└──────────────────────────────────────────┘

Application
    │
    │ 1. 이미지 업로드
    ▼
┌─────────────────┐
│  Amazon S3      │ → 객체 키(URL) 반환
│  (이미지 저장)   │
└─────────────────┘
    │
    │ 2. 메타데이터 저장
    ▼
┌─────────────────────────────────────────────────────────────┐
│ DynamoDB (Products 테이블)                                   │
├─────────────┬──────────────┬────────────────────────────────┤
│ Product_ID  │ Product_Name │ Image_URL                      │
├─────────────┼──────────────┼────────────────────────────────┤
│ PROD-001    │ 노트북        │ s3://bucket/images/laptop.jpg  │
│ PROD-002    │ 키보드        │ s3://bucket/images/keyboard.jpg│
└─────────────────────────────────────────────────────────────┘

Application (클라이언트)
    │
    │ 1. 메타데이터 조회
    ▼
┌─────────────────┐
│   DynamoDB      │ → Product_ID, Product_Name, Image_URL 반환
└─────────────────┘
    │
    │ 2. Image_URL로 이미지 요청
    ▼
┌─────────────────┐
│   Amazon S3     │ → 이미지 바이너리 반환
└─────────────────┘
    │
    │ 3. 큰 객체 재구성
    ▼
Application (클라이언트에 이미지 표시)

┌─────────────┐
│ Application │
└──────┬──────┘
       │ 1. 파일 업로드
       ▼
┌─────────────────┐     ┌─────────────────┐
│   Amazon S3     │────▶│ S3 Event        │
│ (객체 저장)     │     │ Notification    │
└─────────────────┘     └────────┬────────┘
                                 │ 2. Lambda 트리거
                                 ▼
                        ┌─────────────────┐
                        │  AWS Lambda     │
                        │ (메타데이터 추출)│
                        └────────┬────────┘
                                 │ 3. 메타데이터 저장
                                 ▼
┌─────────────────────────────────────────────────────────────┐
│ DynamoDB (S3_Objects_Metadata 테이블)                        │
├─────────────┬──────────┬──────────┬─────────┬───────────────┤
│ Object_Key  │ Size     │ Created  │ Owner   │ Content_Type  │
├─────────────┼──────────┼──────────┼─────────┼───────────────┤
│ img/a.jpg   │ 2.5MB    │ 2024-01  │ user_1  │ image/jpeg    │
│ doc/b.pdf   │ 15MB     │ 2024-01  │ user_2  │ application/pdf│
└─────────────────────────────────────────────────────────────┘

# DynamoDB 테이블 상단에 애플리케이션을 만들면 다양한 쿼리 가능:
 
1. 특정 타임스탬프의 객체 찾기
   → "2024년 1월에 업로드된 모든 파일"
 
2. 고객이 사용한 총 스토리지 계산
   → "user_1이 사용한 총 용량은?"
 
3. 속성별 객체 목록화
   → "image/jpeg 타입의 모든 파일"
 
4. 특정 조건의 S3 객체 검색
   → "10MB 이상인 PDF 파일"

Application
    │
    │ 1. 조건으로 쿼리
    │    (예: "2024년 1월 업로드된 이미지")
    ▼
┌─────────────────┐
│   DynamoDB      │ → 조건에 맞는 Object_Key 목록 반환
└─────────────────┘
    │
    │ 2. 필요한 객체 검색
    ▼
┌─────────────────┐
│   Amazon S3     │ → 실제 파일 반환
└─────────────────┘

# 모든 아이템을 스캔하고 하나씩 삭제
┌─────────────────────────────────────────────────────────────┐
│                     DynamoDB Table                          │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐              │
│  │Item 1│ │Item 2│ │Item 3│ │Item 4│ │Item 5│ ... (N개)    │
│  └──────┘ └──────┘ └──────┘ └──────┘ └──────┘              │
└─────────────────────────────────────────────────────────────┘
      │          │         │         │         │
      ▼          ▼         ▼         ▼         ▼
   Scan으로    Scan으로   Scan으로   Scan으로   Scan으로
   읽기(RCU)  읽기(RCU)  읽기(RCU)  읽기(RCU)  읽기(RCU)
      │          │         │         │         │
      ▼          ▼         ▼         ▼         ▼
 DeleteItem  DeleteItem DeleteItem DeleteItem DeleteItem
   (WCU)       (WCU)      (WCU)      (WCU)      (WCU)

# 테이블을 삭제하고 동일한 설정으로 재생성
┌─────────────────────────────────────────────────────────────┐
│                     DynamoDB Table                          │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐              │
│  │Item 1│ │Item 2│ │Item 3│ │ .... │ │Item N│              │
│  └──────┘ └──────┘ └──────┘ └──────┘ └──────┘              │
└─────────────────────────────────────────────────────────────┘
                           │
                    DeleteTable API
                           │
                           ▼
                   (테이블 전체 삭제)
                           │
                    CreateTable API
                    (동일한 설정으로)
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                  새로운 빈 DynamoDB Table                    │
│                       (비어있음)                             │
└─────────────────────────────────────────────────────────────┘

┌──────────────────┐
│  Source Table    │
│   (DynamoDB)     │
└────────┬─────────┘
         │
         │ 1. 데이터 읽기
         ▼
┌──────────────────┐
│  Amazon EMR      │ ← AWS Data Pipeline이 관리
│   (클러스터)      │
└────────┬─────────┘
         │
         │ 2. S3에 임시 저장
         ▼
┌──────────────────┐
│  Amazon S3       │ (중간 저장소)
│   (임시 파일)     │
└────────┬─────────┘
         │
         │ 3. S3에서 읽기
         ▼
┌──────────────────┐
│  Amazon EMR      │
│   (클러스터)      │
└────────┬─────────┘
         │
         │ 4. 데이터 쓰기
         ▼
┌──────────────────┐
│  Target Table    │
│   (DynamoDB)     │
└──────────────────┘

┌──────────────────┐
│  Source Table    │
│   (DynamoDB)     │
└────────┬─────────┘
         │
         │ 1. Create Backup
         ▼
┌──────────────────┐
│     Backup       │ (AWS 관리)
│   (자동 저장)     │
└────────┬─────────┘
         │
         │ 2. Restore to New Table
         ▼
┌──────────────────┐
│  Target Table    │
│   (DynamoDB)     │
│   (새 이름 가능)  │
└──────────────────┘

┌──────────────────┐
│  Source Table    │
│   (DynamoDB)     │
└────────┬─────────┘
         │
         │ 1. Scan (읽기)
         ▼
┌──────────────────┐
│  Your Code       │ (Lambda, EC2, 로컬 등)
│  - Scan          │
│  - Write         │
└────────┬─────────┘
         │
         │ 2. PutItem / BatchWriteItem
         ▼
┌──────────────────┐
│  Target Table    │
│   (DynamoDB)     │
└──────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│                     테이블 복사 방법 선택 가이드                       │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  간단한 복사가 필요한가?                                             │
│       │                                                             │
│       ├── Yes → Backup and Restore ⭐ (권장)                        │
│       │                                                             │
│       └── No (데이터 변환 필요)                                      │
│             │                                                       │
│             ├── 대용량 + 인프라 있음 → AWS Data Pipeline             │
│             │                                                       │
│             └── 커스텀 로직 필요 → Scan + PutItem/BatchWriteItem     │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

{
  "Condition": {
    "ForAllValues:StringEquals": {
      "dynamodb:LeadingKeys": ["${cognito-identity.amazonaws.com:sub}"]
    }
  }
}