目次

Amazon Aurora DSQL v2.0 完全ガイド

初心者から実務者向けの包括的解説

Amazon Aurora DSQL（Distributed SQL） は、AWS が開発した アクティブ-アクティブ型のサーバーレス分散 SQL データベース で、複数リージョンでの 同時読み書き を実現する初の AWS マネージド SQL DB です。PostgreSQL 互換クエリ言語・強整合性・OCC（楽観的並行制御）・99.999% SLA（マルチリージョン）を提供し、グローバル SaaS・金融取引・リアルタイム分析向けのミッションクリティカルワークロードに対応します。本ガイドは、Aurora DSQL の概念・アーキテクチャ・マルチリージョン構成・トランザクションモデル・実装パターンを体系的に解説します。

ドキュメントの目的

本ガイドは以下を対象としています。

  • 初心者向け：Aurora DSQL とは何か・既存 Aurora / RDS との違いを学びたい方
  • データベース設計者向け：グローバルデータベース設計・schema 設計・アーキテクチャを実装したい方
  • アプリケーション開発者向け：OCC コンフリクト処理・再試行ロジック・クライアント実装をしたい方
  • DBA/SRE 向け：運用・監視・バックアップ・スケーリングを管理したい方
  • 意思決定者向け：Google Cloud Spanner・CockroachDB・YugabyteDB との投資判断

2025-2026 年の Aurora DSQL エコシステム

  • Serverless v2 自動スケーリング：キャパシティ自動管理
  • Vector 検索サポート：pgvector 拡張対応（semantic search）
  • IAM 認証の強化：Fine-grained permissions
  • Performance Insights：マルチリージョン query performance 可視化
  • Read Replica（リードレプリカ）強化：特定 AZ でのレプリカ
  • Global Failover 自動化：Region failure の自動フェイルオーバー
  • Terraform / CDK 完全サポート：IaC統合強化

目次

  1. 概要
  2. Aurora DSQL が解決する課題
  3. 主な特徴
  4. アーキテクチャ
  5. コアコンポーネント
  6. Single-Region vs Multi-Region
  7. トランザクションモデル・OCC
  8. PostgreSQL 互換性・制限事項
  9. クラスター構成・スケーリング
  10. クライアント接続・IAM 認証
  11. データレプリケーション・一貫性
  12. バックアップ・PITR・スナップショット
  13. セキュリティ・暗号化
  14. 主要ユースケース（12+）
  15. CLI・SDK・IaC による操作例
  16. Aurora Global Database との比較
  17. 類似サービス比較（Spanner・CockroachDB・YugabyteDB）
  18. ベストプラクティス
  19. トラブルシューティング表
  20. 2025-2026 最新動向
  21. 学習リソース
  22. 実装例・チェックリスト
  23. まとめ
  24. 参考文献

概要

初心者向けメモ：Aurora DSQL は「複数リージョンでの同時読み書きができる SQL データベース」です。通常の Aurora や RDS は 1 つのプライマリ Region でのみ書き込み可能で、他 Region はレプリカ（読み取り専用）です。Aurora DSQL は すべての Region で読み書き可能 な Active-Active 構成を実現し、グローバルユーザーに対して低遅延・高可用性を提供します。代わりに、OCC による「コンフリクト時は再試行」という制約があります。

Aurora DSQL の特徴：

graph LR
    APAC["APAC 地域<br/>読み書き可能"]
    US["US 地域<br/>読み書き可能"]
    EU["EU 地域<br/>読み書き可能"]
    
    APAC ↔|強整合性| US
    US ↔|強整合性| EU
    EU ↔|強整合性| APAC
    
    style APAC fill:#90EE90
    style US fill:#90EE90
    style EU fill:#90EE90

Aurora DSQL が解決する課題

課題 1: グローバル書き込み・ローカル読み取りの遅延

状況：APAC ユーザーが US DB 書き込み（500ms latency） → データが APAC に replicateされるまでさらに遅延。

Aurora DSQL による解決：

  • APAC Region の local endpoint に書き込み → 数 ms で完了
  • 他 Region への replication は background で実行
  • ユーザーレイテンシーを 10 倍削減

課題 2: マルチリージョン一貫性の管理複雑性

状況：Aurora Global Database は最終的一貫性。Account balance が APAC で読み「100 ドル」→ 同時に US で「50 ドル」と読み取られる（一時的な不整合）。金融取引では NGだが、Application で競合解決ロジックを記述する必要。

Aurora DSQL による解決：

  • 強整合性（Strong Consistency）：すべてのコミット確認後に client に成功を返す
  • 競合解決は OCC で自動化（rewrite 不要）
  • Application ロジックシンプル化

課題 3: Failover 時のスタンバイ region の準備コスト

状況：Aurora Global Database で DR region を常時稼働させると、コスト が倍になる。

Aurora DSQL による解決：

  • すべての Region が Active かつ同等の性能
  • standby region concept なし
  • Data は最初から multiple regions に分散
  • Cost optimized

課題 4: DynamoDB Global Tables は SQL ではなく Key-Value のみ

状況：SQL で complex query が必要（GROUP BY・JOIN・aggregation）→ DynamoDB では実現困難。

Aurora DSQL による解決：

  • PostgreSQL 互換 SQL で complex query をサポート
  • Index・stored procedure もサポート
  • DynamoDB Global Tables の「SQL 版」

主な特徴

特徴 説明
Distributed SQL 複数 Region での同時読み書き
Active-Active すべての Region が書き込み可能
Strong Consistency OCC で強整合性を保証
Serverless Instance privisioning・scaling 不要
PostgreSQL Compatible 既存 PostgreSQL app that migration simple
99.999% SLA マルチリージョン高可用性
ACID Transactions multirow transaction サポート
Automatic Failover region failure で自動フェイルオーバー

アーキテクチャ

┌───────────────────────────────────────────────────────┐
│ Aurora DSQL Distributed Architecture                 │
├───────────────────────────────────────────────────────┤
│                                                       │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────┐│
│  │  APAC Region │    │   US Region  │    │ EU Rgion ││
│  │              │    │              │    │          ││
│  │ Cluster Node │◄──►│ Cluster Node │◄──►│Cluster N ││
│  │ Endpoint     │    │ Endpoint     │    │Endpoint  ││
│  │ (R/W capable)│    │ (R/W capable)│    │(R/W cap) ││
│  │              │    │              │    │          ││
│  │ Storage      │    │ Storage      │    │ Storage  ││
│  │ (Distributed)│    │ (Distributed)│    │(Distrib) ││
│  └──────────────┘    └──────────────┘    └──────────┘│
│        ↑                   ↑                   ↑      │
│        └───────────────────┴───────────────────┘      │
│             Replication（asynchronous）               │
│             Quorum Commit（strong consistency）       │
│                                                       │
└───────────────────────────────────────────────────────┘

OCC（Optimistic Concurrency Control）：
  写き込みコンフリクト検出 → abort → client retry
  reading：snapshot isolation で consistent view 提供

コアコンポーネント

1. Cluster（クラスター）

Aurora DSQL の最小管理単位。Single Region または Multi-Region。

# Single-Region Cluster
aws dsql create-cluster \
  --cluster-name my-cluster \
  --region us-east-1

# Multi-Region Cluster
aws dsql create-cluster \
  --cluster-name global-cluster \
  --region us-east-1 \
  --remote-region-clusters '[{
    "Region": "ap-northeast-1"
  }]'

2. Endpoint（エンドポイント）

各 Region 内での接続ポイント。Application が cluster に接続。

3. Multi-Region Cluster

複数 Region にまたがるクラスター。各 Region で独立した endpoint を持つ。

Primary Region（us-east-1）
  ├─ Cluster ID: 0x...
  ├─ Endpoint: my-cluster.xyz.dsql.amazonaws.com
  └─ Read / Write capable

Remote Region（ap-northeast-1）
  ├─ Cluster ID: same（同じマルチリージョンクラスター）
  ├─ Endpoint: my-cluster.xyz.ap-northeast-1.dsql.amazonaws.com
  └─ Read / Write capable

4. Writer Endpoint

書き込みを受け付ける endpoint。通常 cluster 内に 1 つ。

5. Reader Endpoint

読み取り専用 endpoint（future feature）。

Single-Region vs Multi-Region

Single-Region Cluster

Use Case:
  - 単一リージョン内での HA
  - Regional failover 不要
  - Cost-optimized

Availability: 99.99%（single region AZ failover）
Endpoints: 1
Replication: N/A

Multi-Region Cluster

Use Case:
  - グローバル SaaS
  - Multi-region write
  - Mission-critical HA

Availability: 99.999%（multi-region）
Endpoints: 複数（各 Region）
Replication: Asynchronous（strong consistency quorum）

トランザクションモデル・OCC

OCC（Optimistic Concurrency Control）フロー

Transaction A（APAC）          Transaction B（US）
    ↓                              ↓
  START                          START
    ↓                              ↓
  SELECT * FROM orders        SELECT * FROM orders
    ↓ (Snapshot isolation)        ↓
  WHERE id = 100             WHERE id = 100
    ↓                              ↓
UPDATE amount = 50           UPDATE amount = 60
    ↓                              ↓
  COMMIT                       COMMIT（check conflict）
    ↓                              ↓
SUCCESS                      conflict detected
                                  ↓
                        ABORT + raise exception
                                  ↓
                          Application retry

コンフリクト解決

import psycopg2
from psycopg2 import sql
import time

connection = psycopg2.connect(
    host="my-cluster.xyz.dsql.amazonaws.com",
    database="mydb",
    user="admin",
    password=iam_token,
)

def transfer_money(from_id, to_id, amount):
    max_retries = 3
    for attempt in range(max_retries):
        try:
            cursor = connection.cursor()
            
            # Start transaction
            cursor.execute("BEGIN ISOLATION LEVEL SERIALIZABLE")
            
            # Read balance
            cursor.execute(
                "SELECT balance FROM accounts WHERE id = %s FOR UPDATE",
                (from_id,)
            )
            balance = cursor.fetchone()[0]
            
            if balance < amount:
                cursor.execute("ROLLBACK")
                raise Exception("Insufficient balance")
            
            # Deduct from source
            cursor.execute(
                "UPDATE accounts SET balance = balance - %s WHERE id = %s",
                (amount, from_id)
            )
            
            # Add to destination
            cursor.execute(
                "UPDATE accounts SET balance = balance + %s WHERE id = %s",
                (amount, to_id)
            )
            
            # Commit
            cursor.execute("COMMIT")
            print(f"Transfer success: {from_id} → {to_id} : {amount}")
            break
            
        except psycopg2.errors.TransactionRollbackError as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # exponential backoff
                print(f"Conflict detected. Retry in {wait_time}s")
                time.sleep(wait_time)
            else:
                raise Exception(f"Max retries exceeded: {e}")

PostgreSQL 互換性・制限事項

サポートされる DDL / DML

-- ✅ CREATE TABLE
CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id TEXT NOT NULL,
    amount DECIMAL(10,2),
    created_at TIMESTAMPTZ DEFAULT now()
);

-- ✅ INSERT
INSERT INTO orders (user_id, amount) VALUES ('user_001', 99.99);

-- ✅ SELECT（complex query OK）
SELECT 
    user_id,
    COUNT(*) as order_count,
    SUM(amount) as total_spent
FROM orders
GROUP BY user_id
HAVING total_spent > 1000
ORDER BY total_spent DESC;

-- ✅ UPDATE / DELETE
UPDATE orders SET amount = 150.00 WHERE id = '...';
DELETE FROM orders WHERE created_at < '2025-01-01';

-- ✅ JOINs
SELECT o.id, u.name, o.amount
FROM orders o
INNER JOIN users u ON o.user_id = u.id
WHERE o.created_at > now() - interval '7 days';

-- ✅ Stored Procedures
CREATE OR REPLACE FUNCTION process_monthly_billing()
RETURNS void AS $
BEGIN
    INSERT INTO invoices SELECT * FROM orders WHERE ...;
END;
$ LANGUAGE plpgsql;

-- ✅ Indexes
CREATE INDEX idx_orders_user_id ON orders(user_id);
CREATE INDEX idx_orders_created_at ON orders(created_at);

サポートされない機能

機能 理由 代替案
Foreign Key 分散環境での制約管理が困難 Application 側で validate
SEQUENCE 順序保証が困難 UUID を使用
Trigger Distributed execution 複雑 Application logic で実装
Explicit Lock Deadlock 可能性 OCC に依存

クラスター構成・スケーリング

Serverless Scaling

# ACU（Aurora Capacity Units）による自動スケーリング
# 0.5 ACU～128 ACU の範囲で自動スケール

aws dsql update-cluster \
  --cluster-identifier my-cluster \
  --serverless-scaling-configuration '{
    "MinAcu": 0.5,
    "MaxAcu": 16,
    "TimeoutAction": "ROLLBACK_CAPACITY_CHANGE"
  }'

Capacity Management

0.5 ACU ≈ 1 Gigabyte memory
読み取り：0.5 ACU ≈ 1,000 queries/sec
書き込み：0.5 ACU ≈ 100 writes/sec

スケーリング：
  ├─ Automatic（serverless）：0.5～128 ACU
  └─ Manual：特定 ACU に固定

クライアント接続・IAM 認証

IAM Authentication Token 生成

import boto3
import psycopg2
from datetime import datetime, timedelta

# 1. IAM token 生成
rds = boto3.client('rds')
token = rds.generate_db_auth_token(
    DBHostname='my-cluster.xyz.dsql.amazonaws.com',
    Port=5432,
    DBUser='admin',
    Region='us-east-1',
)

# 2. Token は 15 分有効
# → 定期的に token を更新する必要

def get_connection_with_iam():
    """IAM token を使用して接続"""
    token = rds.generate_db_auth_token(
        DBHostname='my-cluster.xyz.dsql.amazonaws.com',
        Port=5432,
        DBUser='admin',
        Region='us-east-1',
    )
    
    conn = psycopg2.connect(
        host='my-cluster.xyz.dsql.amazonaws.com',
        port=5432,
        database='mydb',
        user='admin',
        password=token,
        sslmode='require',  # TLS required
    )
    
    return conn

# 3. Connection pool with token refresh
class DSQLConnectionPool:
    def __init__(self, host, port, database, region):
        self.host = host
        self.port = port
        self.database = database
        self.region = region
        self.rds = boto3.client('rds', region_name=region)
        self.last_token_time = None
        self.token = None
    
    def _refresh_token(self):
        """15分ごとにtoken更新"""
        now = datetime.utcnow()
        if (self.last_token_time is None or 
            (now - self.last_token_time).seconds > 900):
            self.token = self.rds.generate_db_auth_token(
                DBHostname=self.host,
                Port=self.port,
                DBUser='admin',
                Region=self.region,
            )
            self.last_token_time = now
    
    def get_connection(self):
        self._refresh_token()
        return psycopg2.connect(
            host=self.host,
            port=self.port,
            database=self.database,
            user='admin',
            password=self.token,
            sslmode='require',
        )

# 4. 使用例
pool = DSQLConnectionPool(
    host='my-cluster.xyz.dsql.amazonaws.com',
    port=5432,
    database='mydb',
    region='us-east-1',
)

conn = pool.get_connection()
cursor = conn.cursor()
cursor.execute("SELECT VERSION()")
print(cursor.fetchone())

データレプリケーション・一貫性

Quorum Commit（Strong Consistency）

Writer Node（us-east-1）
    ↓
WRITE to local storage
REPLICATE to quorum nodes（ap-northeast-1, eu-west-1 等）
    ↓
すべてのquorum nodes が ACK
    ↓
Client に SUCCESS を返す

= すべての Region で consistent

Replication Lag

  • Write commit → Quorum ACK: < 100ms（typical）
  • Cross-region replication: 50-200ms（depend on network）
  • → Write respone は fast
  • → すべてのリージョンで読み取ると strong consistency

バックアップ・PITR・スナップショット

Automated Backup

# 自動バックアップ（35 日保持）
aws dsql describe-clusters \
  --cluster-identifier my-cluster

# Backup window 設定
aws dsql modify-cluster \
  --cluster-identifier my-cluster \
  --backup-retention-period 35 \
  --preferred-backup-window "03:00-04:00"

PITR（Point-in-Time Recovery）

# 過去 35 日以内の任意の時点にリカバリ
aws dsql restore-cluster-from-backup \
  --target-cluster-identifier restored-cluster \
  --cluster-id arn:aws:dsql:us-east-1:account:cluster/xxx \
  --restore-time "2026-04-20T10:30:00Z"

セキュリティ・暗号化

Encryption at Rest

# AWS managed key（デフォルト）
aws dsql create-cluster \
  --cluster-name my-cluster

# Customer managed key
aws dsql create-cluster \
  --cluster-name my-cluster \
  --kms-key-id arn:aws:kms:us-east-1:account:key/xxxxx

Encryption in Transit

TLS 1.2+ required
└─ すべてのクライアント接続は暗号化

IAM Authentication

DB User ← IAM Role
  └─ credentials 不要
  └─ Token-based authentication（15 min validity）

主要ユースケース

1. グローバル SaaS（Multi-Tenant）

Data Model:
  ├─ Tenant ID で partition
  ├─ APAC / US / EU 各リージョンで read/write
  └─ Strong consistency で data isolation 確保

2. 金融取引プラットフォーム

Requirements:
  ├─ ACID transaction
  ├─ Strong consistency
  ├─ 99.999% uptime
  └─ Multi-region active-active

Aurora DSQL: ✅ すべてサポート

3. グローバル在庫管理

Product Inventory
  ├─ APAC warehouse → +10 units
  ├─ US warehouse → -5 units
  ├─ EU warehouse → +3 units
  
Consistency: APAC が読み → total = 8（latest）
  └─ eventual consistency（RDS GDB） → 一時的に異なる値
  └─ strong consistency（Aurora DSQL） → 常に 8

4. リアルタイム分析・BI

Events
  ├─ APAC のイベント集計
  ├─ US のイベント集計
  └─ リアルタイム dashboard
  
Query: "今この瞬間の global orders"
  └─ Aurora DSQL → strong consistency で accurate

5. Machine Learning Feature Store

User Features（distributed）
  ├─ APAC: user profile / behavior
  ├─ US: user purchase history
  ├─ EU: user engagement metrics
  
ML Training: Multi-region features → single consistent view

6. Customer Data Platform（CDP）

Customer Profiles（distributed）
  ├─ APAC: customer data
  ├─ US: interaction history
  ├─ EU: compliance data
  
CDP Query: "This customer bought X in APAC yesterday"
  └─ Strong consistency で single source of truth

7. Game Backend（Global Players）

Player Progress
  ├─ APAC player → writes to APAC region
  ├─ US player → writes to US region
  
Consistency: Leaderboard は global で consistent

8. IoT Sensor Data（Global）

IoT Devices
  ├─ APAC sensors → writes to APAC cluster
  ├─ US sensors → writes to US cluster
  
Analytics: Global sensor readings → consistent aggregate

9. Supply Chain Tracking（Distributed）

Shipment Tracking
  ├─ Factory（APAC）→ ship出発
  ├─ Port（US）→ 通関
  ├─ Warehouse（EU）→ 配送
  
Tracking query: すべてのタイムスタンプ consistent

10. Financial Reporting（Global Entity）

Company（Global）
  ├─ APAC subsidiary
  ├─ US subsidiary
  ├─ EU subsidiary
  
Consolidated Report: すべてのリージョンのデータを consistent に集計

11. Real-Time Fraud Detection

Transactions（distributed）
  ├─ APAC: transaction log
  ├─ US: transaction log
  
Fraud Detection: global pattern recognition with consistency

12. Content Recommendation Engine

User Preferences（distributed by region）
  ├─ APAC: content history
  ├─ US: likes / dislikes
  
Recommendation: consistent global user profile

CLI・SDK・IaC による操作例

AWS CLI

# 1. Single-Region Cluster 作成
aws dsql create-cluster \
  --cluster-name my-single-region \
  --region us-east-1

# 2. Multi-Region Cluster 作成
aws dsql create-cluster \
  --cluster-name my-global \
  --region us-east-1 \
  --remote-region-clusters '[{
    "Region": "ap-northeast-1"
  }, {
    "Region": "eu-west-1"
  }]'

# 3. Cluster 情報確認
aws dsql describe-clusters \
  --cluster-identifier my-global

# 4. Backup 確認
aws dsql describe-cluster-backups \
  --cluster-identifier my-global

# 5. Cluster 削除
aws dsql delete-cluster \
  --cluster-identifier my-global

Terraform

resource "aws_dsql_cluster" "global" {
  cluster_name = "my-global-db"
  
  # Multi-region configuration
  remote_region_clusters = [
    {
      region = "ap-northeast-1"
    },
    {
      region = "eu-west-1"
    }
  ]
  
  # Serverless scaling
  serverless_scaling_configuration = {
    min_acu        = 0.5
    max_acu        = 16
    timeout_action = "ROLLBACK_CAPACITY_CHANGE"
  }
  
  # Backup
  backup_retention_period  = 35
  preferred_backup_window  = "03:00-04:00"
  
  # KMS encryption
  kms_key_id = aws_kms_key.dsql.arn
  
  tags = {
    Name        = "production-global-db"
    Environment = "prod"
  }
}

output "cluster_endpoint" {
  value = aws_dsql_cluster.global.endpoint
}

CDK（TypeScript）

import * as dsql from 'aws-cdk-lib/aws-dsql';
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class DSQLStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // Multi-region Aurora DSQL cluster
    const cluster = new dsql.Cluster(this, 'GlobalDB', {
      clusterName: 'my-global-db',
      remoteRegionClusters: [
        { region: 'ap-northeast-1' },
        { region: 'eu-west-1' },
      ],
      serverlessScaling: {
        minAcu: 0.5,
        maxAcu: 16,
      },
      backup: {
        retentionPeriod: 35,
        preferredBackupWindow: {
          startHour: 3,
          startMinute: 0,
        },
      },
    });

    // Outputs
    const cfnCluster = cluster.node.defaultChild as dsql.CfnCluster;
    new cdk.CfnOutput(this, 'ClusterEndpoint', {
      value: cfnCluster.endpoint || '',
      description: 'Database endpoint',
    });
  }
}

Aurora Global Database との比較

観点 Aurora DSQL Aurora Global Database
Writing Multi-region（Active-Active） Single region（Primary only）
Consistency Strong（OCC） Eventual（RPO < 1s）
Failover Auto（always active） Manual or auto（< 1 min）
SLA 99.999%（multi-region） 99.99%
Cost Higher（multi-write） Lower（read replica）
Use Case Global active-active app DR / read scaling

類似サービス比較

観点 Aurora DSQL Google Cloud Spanner CockroachDB YugabyteDB
SQL PostgreSQL compatible Google SQL PostgreSQL like PostgreSQL like
Consistency Strong Strong Strong Eventual / Strong
Active-Active ✅ ✅ ✅ ✅
Managed ✅ AWS ✅ Google ❌ (self-hosted) ❌ / ✅ (Cloud)
Cost Mid High Low～Mid Mid
SLA 99.999% 99.99% Self-managed 99.95%

ベストプラクティス

推奨事項（✅）

  • ✅ UUID primary key（SEQUENCE 不可）
  • ✅ OCC コンフリクト時の exponential backoff retry
  • ✅ 読み取りで consistent snapshot を利用
  • ✅ Foreign key は application 側で管理
  • ✅ IAM token で認証
  • ✅ Connection pooling で token 効率化
  • ✅ Multi-region replication lag を監視

アンチパターン（❌）

  • ❌ SEQUENCE の使用（UUID 推奨）
  • ❌ Foreign key 依存
  • ❌ Retry ロジックなしでコミット
  • ❌ Hard-coded credentials
  • ❌ Cross-region write コンフリクト無視

トラブルシューティング表

症状 原因 解決方法
TransactionConflictException Write conflict Exponential backoff retry 実装
Connection timeout IAM token 無効 Token refresh 実装
Replication lag high Network 遅延 / 重負荷 Monitor CloudWatch metrics
FK constraint error FK 未サポート Schema デザイン見直し
UUID collision（rare） PRNG 弱い gen_random_uuid() 使用

2025-2026 最新動向

  • Vector 検索対応：pgvector 拡張で semantic search
  • Read Replica 強化：特定 AZ でのレプリカ作成
  • Performance Insights：マルチリージョン query 分析
  • Global Failover 自動化：region failure 検出で自動切り替え
  • Terraform / CDK 完全サポート：IaC 統合

学習リソース

実装例・チェックリスト

  • [ ] Multi-region cluster 作成
  • [ ] Schema 設計（FK 不可確認）
  • [ ] IAM token 生成・refresh 実装
  • [ ] OCC conflict retry ロジック実装
  • [ ] Performance Insights 監視
  • [ ] Backup / PITR テスト
  • [ ] Multi-region replication 検証

まとめ

Amazon Aurora DSQL は 「アクティブ-アクティブ型のサーバーレス分散 SQL データベース」 で、複数リージョンでの同時読み書き・強整合性・99.999% SLA を実現します。OCC による競合解決・PostgreSQL 互換・IAM 認証により、グローバル SaaS・金融取引・リアルタイム分析向けの mission-critical workload に対応できます。

最終更新：2026-04-27 バージョン：v2.0