Amazon VPC Lattice 完全ガイド v2.0

マイクロサービスメッシュ・Zero Trust IAM認証・クロスVPC統合

概要

Amazon VPC Lattice は、マイクロサービス間の通信をポリシーベースで安全に管理する AWS ネイティブサービスメッシュプラットフォーム です（2023年 GA）。VPC・AWS アカウント・実行環境（ECS/EKS/Lambda/EC2）の境界を越えたサービス間通信を統一的に制御し、IAM 認証・TLS 暗号化・トラフィックルーティングをアプリケーション変更なしに実現します。2025 年以降、EKS ネイティブ統合（Gateway API Controller）と Kubernetes CNI Plugin 統合が加速しています。

初心者向けメモ

VPC Lattice は「サービス間の通信を IAM ポリシーで安全に管理」するサービスです。従来はセキュリティグループでネットワーク境界を制御していましたが、VPC Lattice は「どのサービスが何のリソースにアクセスできるか」を IAM で細かく制御できます。サイドカープロキシ不要で Istio や App Mesh のような高度なサービスメッシュ機能を実現でき、EKS・ECS・Lambda を統一的に管理できます。

VPC Lattice が解決する課題

主な特徴

アーキテクチャ

図1：VPC Lattice サービスメッシュ全体図

graph TB
    Client["Client VPC"]
    ServiceNet["Service Network<br/>Logical Boundary"]
    
    Service1["Service 1<br/>Ordering<br/>ECS"]
    Service2["Service 2<br/>Payment<br/>Lambda"]
    Service3["Service 3<br/>Inventory<br/>EKS Pod"]
    Service4["Service 4<br/>Notification<br/>EC2"]
    
    TG1["Target Group 1<br/>Order Instances"]
    TG2["Target Group 2<br/>Payment Functions"]
    TG3["Target Group 3<br/>Inventory Pods"]
    TG4["Target Group 4<br/>Notification Servers"]
    
    IAMPolicy["IAM Auth Policy<br/>Service → Service<br/>Zero Trust"]
    
    Client -->|VPC Assoc<br/>Service Discovery| ServiceNet
    ServiceNet -->|Service Registry<br/>DNS| Service1
    ServiceNet -->|Service Registry<br/>DNS| Service2
    ServiceNet -->|Service Registry<br/>DNS| Service3
    ServiceNet -->|Service Registry<br/>DNS| Service4
    
    Service1 -->|Auto TLS<br/>SigV4 Auth| TG1
    Service2 -->|Auto TLS<br/>SigV4 Auth| TG2
    Service3 -->|Auto TLS<br/>SigV4 Auth| TG3
    Service4 -->|Auto TLS<br/>SigV4 Auth| TG4
    
    ServiceNet -->|IAM Authentication| IAMPolicy
    
    style ServiceNet fill:#e8f4f8
    style Service1 fill:#d4e9f7
    style Service2 fill:#c0ddf5
    style Service3 fill:#acd1f2
    style Service4 fill:#f0dff8
    style IAMPolicy fill:#f0e8f8

図2：Cross-VPC / Cross-Account Integration と EKS Native

graph LR
    subgraph Acct1["Account 1<br/>Service Owner"]
        VPC1["VPC-1<br/>Service 1<br/>ECS"]
        VPC2["VPC-2<br/>Service 2<br/>Lambda"]
        EKS1["EKS Cluster<br/>Service 3<br/>Pods"]
    end
    
    subgraph ServiceNetwork["Service Network<br/>Cross-Account Shared"]
        SN["Service Network<br/>via Resource Access Manager"]
    end
    
    subgraph Acct2["Account 2<br/>Client Owner"]
        VPC3["VPC-3<br/>Client App<br/>ECS/EC2"]
        EKS2["EKS Cluster<br/>Client Pods"]
    end
    
    VPC1 -->|Service 1 Register| SN
    VPC2 -->|Service 2 Register| SN
    EKS1 -->|Gateway API<br/>Service Register| SN
    VPC3 -->|VPC Associate| SN
    EKS2 -->|Gateway API<br/>Service Discovery| SN
    VPC3 -->|Service Discovery<br/>DNS| VPC1
    VPC3 -->|Service Discovery<br/>DNS| VPC2
    EKS2 -.->|Pod-to-Service<br/>Cross-Account| VPC1

    style SN fill:#fff4e8
    style Acct1 fill:#e8f4f8
    style Acct2 fill:#f8e8e8
    style EKS1 fill:#fff0cc
    style EKS2 fill:#fff0cc

コアコンポーネント

1. Service Network（サービスネットワーク）

定義：マイクロサービス群の論理的な集約
役割：
  - DNS ベースのサービス発見
  - VPC 間ルーティング
  - IAM 認可ポリシー適用
  - TLS 終端（Auto TLS）
  - Listener / Rule 管理
  
構成要素：
  - Service 1..N（複数サービス登録可能）
  - Resource Configuration（RDS / 外部リソース）
  - VPC Association（複数 VPC に対応）
  - Auth Policy（IAM ベース）
  
スケール：
  - リージョンのスコープ内
  - 複数リージョン展開は複数 Service Network

2. Service（サービス）

定義：独立して配置されるワークロードユニット
実行環境：
  - ECS / EKS（コンテナ）
  - Lambda（サーバーレス）
  - EC2（仮想マシン）
  - ALB（ロードバランサー）
  - IP アドレス（オンプレミス / VPC）
  
構成：
  - Listener（プロトコル・ポート指定）
  - Rule（ルーティングロジック）
  - Target Group（バックエンド）
  
属性：
  - Service Name（DNS: service-name.service-network.vpc-lattice.local）
  - Protocol（HTTP / HTTPS / gRPC）
  - Port
  - Auth Type（AWS_IAM / NONE）

3. Target Group（ターゲットグループ）

タイプ：
  - EC2 Instance
  - IP Address（オンプレ / VPC 内外部サーバー）
  - Lambda Function
  - ALB
  - ECS Task
  - Kubernetes Pod（EKS・Gateway API）

特徴：
  - ALB と互換性のある概念
  - Health Check サポート（HTTP / TCP）
  - Weighted Distribution（重み付け 0-100）
  - Stickiness 設定（オプション）
  
Health Check：
  - Protocol: HTTP / HTTPS / TCP
  - Path（HTTP/HTTPS の場合）
  - Port
  - Interval（デフォルト 30秒）
  - Timeout（デフォルト 5秒）

4. IAM Auth Policy（認証・認可・Zero Trust）

概念：Zero Trust Authentication
形式：IAM Policy + SigV4 署名
レベル：
  1. Service Network レベル（粗粒度）
  2. Service レベル（細粒度）
  3. リクエスト単位（HTTP ヘッダー検査・Source IP）

例：
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:role/OrderService"
      },
      "Action": "vpc-lattice:Invoke",
      "Resource": "arn:aws:vpc-lattice:*:*:service/svc-*"
    },
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:role/PaymentService"
      },
      "Action": "vpc-lattice:Invoke",
      "Resource": "arn:aws:vpc-lattice:*:*:service/payment-svc",
      "Condition": {
        "IpAddress": {
          "aws:SourceIp": "10.0.0.0/8"
        }
      }
    }
  ]
}

5. Service Discovery（DNS）

仕組み：
  - Route 53 Private Hosted Zone（自動作成）
  - Service 名 → VPC Lattice Endpoint に自動解決
  - Client が DNS クエリ → Lattice Service IP 取得
  
形式：
  - Service Name: payment-service.my-network.vpc-lattice.local
  - 複数 AZ 自動分散
  - Availability Zone Affinity 対応
  
解決先：
  - VPC Lattice Internal Load Balancer IP
  - Target Group 内の Healthy Target に自動ルーティング

6. Resource Configuration（リソース構成）

対応リソース：
  - RDS Database（特定のインスタンスではなく、DNS Endpoint）
  - EC2 Instance（IP アドレス）
  - IP Address（外部サービス）
  - Domain Name（DNS エンドポイント・オンプレミス）
  
用途：
  - VPC 内マイクロサービス外のリソースを Service Network に統合
  - VPC 外のリソースへのアクセス管理
  - ハイブリッド・マルチクラウドシナリオ

7. Gateway API Controller（EKS・2025+）

概念：Kubernetes ネイティブ VPC Lattice 統合
実装：AWS Gateway API Controller
対応リソース：
  - Gateway（Service Network マッピング）
  - HTTPRoute（Listener Rule）
  - TCPRoute（TCP トラフィック）
  - TLSRoute（TLS トラフィック）
  
利点：
  - Kubernetes manifest でのネイティブ定義
  - kubectl でのライフサイクル管理
  - Service / Deployment との統合
  - Pod-to-Service 通信の自動最適化

主要ユースケース（12+）

1. マイクロサービス間通信の一元管理：複数の独立したサービスを Service Network で統合
2. マルチアカウント SaaS プラットフォーム：各テナント用 VPC を Service Network 経由で接続
3. Zero Trust マイクロサービスセキュリティ：IAM ポリシーで「どのサービスが何を呼べるか」を細かく制御
4. カナリアリリース・段階的デプロイ：ターゲットグループ重み付けで新バージョンに段階的に切替
5. ECS ↔ Lambda クロス実行環境通信：異なるコンテナ化・サーバーレス環境を統一的に管理
6. EKS ネイティブ統合：Kubernetes Pod から Service Network を透過的に利用（Gateway API）
7. ハイブリッド遠隔リソース：オンプレ / Site-to-Site VPN 経由のリソースを統合
8. 内部 API プラットフォーム：Cross-account でセルフサービス型 API レジストリ
9. 複数リージョン統合：各リージョンの Service Network を Transit Gateway 経由で統合
10. AI/ML パイプライン：モデル推論・特徴エンジニアリング・トレーニング間の通信管理
11. マイクロサービス Observability：CloudWatch Logs で全トラフィック可視化
12. Payment / Gateway Service：決済ゲートウェイのセキュアな中央集約
13. EKS Cross-Cluster 通信：複数 EKS クラスター間の Pod-to-Pod 通信（2025+）
14. 生成 AI アプリケーション：LLM 推論・RAG パイプライン間の Zero Trust 通信

設定・操作の具体例

AWS CLI 例1：Service Network 作成

aws vpc-lattice create-service-network \
  --name "my-service-network" \
  --auth-type AWS_IAM \
  --tags "Environment=Production,Team=Platform,CostCenter=Engineering"

# 出力例
# {
#   "arn": "arn:aws:vpc-lattice:us-east-1:123456789012:service-network/sn-1234567890abcdef0",
#   "id": "sn-1234567890abcdef0",
#   "name": "my-service-network",
#   "createdAt": "2025-04-26T10:00:00Z"
# }

AWS CLI 例2：Service 作成・Listener + Rule

# Service 作成
aws vpc-lattice create-service \
  --name "order-service" \
  --protocol HTTP \
  --port 8080 \
  --auth-type AWS_IAM \
  --service-network-identifier snk-12345678 \
  --tags "Owner=OrderTeam,CostCenter=Sales"

# Target Group 作成
aws vpc-lattice create-target-group \
  --name "order-targets" \
  --protocol HTTP \
  --port 8080 \
  --vpc-identifier vpc-12345678 \
  --target-type EC2_INSTANCE \
  --health-check-protocol HTTP \
  --health-check-path "/health" \
  --health-check-interval-seconds 30

# Listener 作成
aws vpc-lattice create-listener \
  --service-identifier svc-12345678 \
  --protocol HTTP \
  --port 8080 \
  --default-actions '[{
    "Type": "forward",
    "TargetGroupArn": "arn:aws:vpc-lattice:us-east-1:123456789012:targetgroup/order-targets/tg-1234567890abcdef0"
  }]'

# Rule 作成（Path-based）
aws vpc-lattice create-rule \
  --listener-identifier listener-12345678 \
  --priority 10 \
  --match '{"httpMatch": {"pathMatch": {"match": "EXACT", "values": ["/api/v2/*"]}}}' \
  --action '{
    "type": "forward",
    "targetGroupArn": "arn:aws:vpc-lattice:us-east-1:123456789012:targetgroup/order-targets/tg-1234567890abcdef0"
  }'

AWS CLI 例3：Target Group 登録・IAM Policy

# Target 登録
aws vpc-lattice register-targets \
  --target-group-identifier tg-1234567890abcdef0 \
  --targets Id=i-1234567890abcdef0,Port=8080 Id=i-0987654321fedcba0,Port=8080

# IAM Auth Policy 設定
aws vpc-lattice put-auth-policy \
  --resource-arn "arn:aws:vpc-lattice:us-east-1:123456789012:service/order-service" \
  --policy '{
    "Version": "2012-10-17",
    "Statement": [{
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:role/PaymentService"
      },
      "Action": "vpc-lattice:Invoke",
      "Resource": "*"
    }]
  }'

CloudFormation 例：Service + IAM Policy + VPC Association

Resources:
  MyServiceNetwork:
    Type: AWS::VpcLattice::ServiceNetwork
    Properties:
      Name: my-service-network
      AuthType: AWS_IAM
      Tags:
        - Key: Environment
          Value: Production

  MyService:
    Type: AWS::VpcLattice::Service
    Properties:
      Name: my-service
      Protocol: HTTPS
      Port: 443
      ServiceNetworkIdentifier: !Ref MyServiceNetwork
      AuthType: AWS_IAM

  MyTargetGroup:
    Type: AWS::VpcLattice::TargetGroup
    Properties:
      Name: my-targets
      Protocol: HTTPS
      Port: 8443
      VpcIdentifier: !Ref MyVpc
      TargetType: EC2_INSTANCE
      HealthCheck:
        Enabled: true
        HealthyThresholdCount: 2
        UnhealthyThresholdCount: 3
        TimeoutSeconds: 5
        IntervalSeconds: 30
        Path: /health
        Protocol: HTTPS

  MyListener:
    Type: AWS::VpcLattice::Listener
    Properties:
      ServiceIdentifier: !Ref MyService
      Protocol: HTTPS
      Port: 443
      DefaultActions:
        - Type: forward
          TargetGroupArn: !GetAtt MyTargetGroup.Arn

  MyServiceAuthPolicy:
    Type: AWS::VpcLattice::AuthPolicy
    Properties:
      ResourceIdentifier: !Ref MyService
      Policy:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              AWS: !Sub "arn:aws:iam::${AWS::AccountId}:role/AppRole"
            Action: vpc-lattice:Invoke
            Resource: "*"

  VpcAssociation:
    Type: AWS::VpcLattice::ServiceNetworkVpcAssociation
    Properties:
      ServiceNetworkIdentifier: !Ref MyServiceNetwork
      VpcIdentifier: !Ref MyVpc
      SecurityGroupIds:
        - !Ref ServiceNetworkSG

  ServiceNetworkSG:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: VPC Lattice Service Network SG
      VpcId: !Ref MyVpc
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 443
          ToPort: 443
          CidrIp: 10.0.0.0/8

Terraform 例：EKS 統合・Gateway API

# VPC Lattice Service Network
resource "aws_vpc_lattice_service_network" "example" {
  name       = "my-service-network"
  auth_type  = "AWS_IAM"
}

# Service
resource "aws_vpc_lattice_service" "api" {
  name                       = "api-service"
  protocol                   = "HTTPS"
  service_network_identifier = aws_vpc_lattice_service_network.example.id
  auth_type                  = "AWS_IAM"
}

# Target Group（EKS Pod 用）
resource "aws_vpc_lattice_target_group" "kubernetes_pods" {
  name           = "k8s-pods"
  protocol       = "HTTPS"
  port           = 8443
  vpc_identifier = aws_vpc.main.id
  target_type   = "KUBERNETES_POD"
  
  health_check {
    enabled             = true
    healthy_threshold   = 2
    unhealthy_threshold = 3
    timeout             = 5
    interval            = 30
    path                = "/health"
    protocol            = "HTTPS"
  }
}

# Listener
resource "aws_vpc_lattice_listener" "api" {
  service_identifier = aws_vpc_lattice_service.api.id
  protocol           = "HTTPS"
  port               = 443
  
  default_action {
    type              = "forward"
    target_group_arn  = aws_vpc_lattice_target_group.kubernetes_pods.arn
  }
}

# VPC Association
resource "aws_vpc_lattice_service_network_vpc_association" "example" {
  service_network_identifier = aws_vpc_lattice_service_network.example.id
  vpc_identifier             = aws_vpc.main.id
  security_group_ids         = [aws_security_group.lattice.id]
}

# IAM Auth Policy
resource "aws_vpc_lattice_auth_policy" "example" {
  resource_arn = aws_vpc_lattice_service.api.arn
  
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Principal = {
          AWS = "arn:aws:iam::${data.aws_caller_identity.current.account_id}:role/EKSPodRole"
        }
        Action   = "vpc-lattice:Invoke"
        Resource = "*"
      }
    ]
  })
}

Kubernetes（EKS）+ Gateway API 例

apiVersion: networking.k8s.io/v1beta1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: vpc-lattice
  listeners:
  - name: http
    protocol: HTTP
    port: 80
    allowedRoutes:
      namespaces:
        from: All

---
apiVersion: networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
  name: order-service-route
spec:
  parentRefs:
  - group: networking.k8s.io
    kind: Gateway
    name: my-gateway
  hostnames:
  - "order-service.my-network.vpc-lattice.local"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /api/v2
    backendRefs:
    - name: order-service
      port: 8080
      weight: 80
    - name: order-service-canary
      port: 8080
      weight: 20

---
apiVersion: v1
kind: Service
metadata:
  name: order-service
  annotations:
    vpc-lattice.amazonaws.com/service-network: "my-service-network"
spec:
  type: ClusterIP
  selector:
    app: order
  ports:
  - name: http
    protocol: TCP
    port: 8080
    targetPort: 8080

Python Example（Boto3）：Service Network Monitor

import boto3
import json

lattice_client = boto3.client('vpc-lattice')
cloudwatch = boto3.client('cloudwatch')

def monitor_lattice_services():
    # List all Service Networks
    networks = lattice_client.list_service_networks()
    
    for network in networks['items']:
        network_id = network['id']
        print(f"Service Network: {network['name']} ({network_id})")
        
        # List Services
        services = lattice_client.list_services(
            serviceNetworkIdentifier=network_id
        )
        
        for service in services['items']:
            service_id = service['id']
            print(f"  Service: {service['name']} ({service_id})")
            
            # Get Auth Policy
            try:
                auth_policy = lattice_client.get_auth_policy(
                    resourceArn=service['arn']
                )
                policy = json.loads(auth_policy['policy'])
                print(f"    Auth Type: {service['authType']}")
                print(f"    Auth Policy Principals: {len(policy.get('Statement', []))}")
            except:
                print("    No Auth Policy")
            
            # Get Target Groups
            target_groups = lattice_client.list_target_groups(
                serviceNetworkIdentifier=network_id
            )
            for tg in target_groups['items']:
                print(f"    Target Group: {tg['name']}")
                
                # CloudWatch metrics
                metrics = cloudwatch.get_metric_statistics(
                    Namespace='AWS/VpcLattice',
                    MetricName='TargetHealthCount',
                    Dimensions=[
                        {'Name': 'TargetGroup', 'Value': tg['id']},
                        {'Name': 'TargetHealth', 'Value': 'Healthy'}
                    ],
                    StartTime='2025-04-26T00:00:00Z',
                    EndTime='2025-04-26T23:59:59Z',
                    Period=300,
                    Statistics=['Sum']
                )
                print(f"      Healthy Targets: {metrics['Datapoints']}")

類似サービス比較表

ベストプラクティス

✅ すべき施策

1. Service Network per Logical Boundary：環境（本番・開発）やテナント単位で分離
2. IAM Auth Policy の細粒度制御：最小権限の原則で「必要な呼び出しだけ」許可
3. Weighted Target Group：カナリアリリースで段階的デプロイ（0% → 10% → 50% → 100%）
4. Health Check 有効化：Target の生存確認で自動フェイルオーバー
5. CloudWatch Logs 有効化：全トラフィック可視化・トラブルシューティング
6. VPC Lattice Service Discovery DNS：明示的な IP 不要でサービス名で呼び出し
7. Cross-Account 設計：Resource Access Manager で安全に他 Account に共有
8. Service Mesh 段階導入：1 サービス → 複数サービス → 全体へ徐々に拡大
9. EKS Gateway API 活用：Kubernetes ネイティブなネットワークポリシー定義（2025+）
10. Observability 統合：CloudWatch + X-Ray で分散トレース可視化

❌ 避けるべき施策

1. すべてのサービスに Public VIF：セキュリティリスク、IAM ポリシー不要なら VPC Lattice 不要
2. 固定 IP 依存：サービス名（DNS）を活用・負荷分散効率化
3. 過度な複雑な IAM ポリシー：Service Network / Service レベルの 2 段階に留める
4. Health Check なし：不健全なターゲットへのリクエスト送信のリスク
5. マイクロサービス単位での Service Network：1 つの Service Network で複数サービス統合
6. Observability なし：トラフィック把握・トラブル時に現況不明
7. App Mesh との混在：新規は VPC Lattice へ統一
8. Auth Policy なし：Zero Trust 実装の機会喪失
9. 複数リージョン構成での Service Network 統合忘れ：リージョン間通信困難
10. EKS マニフェスト無視：Gateway API による Kubernetes ネイティブ管理をスキップ

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

2025-2026 最新動向

• Kubernetes CNI Plugin 統合：EKS で Lattice Controller の標準化・Pod 直接統合
• Gateway API Controller GA 拡大：HTTPRoute / TCPRoute / TLSRoute サポート拡張
• 生成 AI 推論パイプライン最適化：LLM 推論・埋め込みモデル間のルーティング強化
• Regional Mesh Gateway：エッジ拠点でのメッシュ処理・Wavelength Zone 対応検討
• Advanced Observability：Service Map による依存関係の可視化強化・自動異常検知
• Serverless Lattice：Lambda+ECS のシームレスなメッシュ統合・Cold Start 最適化
• Multi-Cloud Extended：AWS 外リソースの統合（Hybrid）試験的サポート開始
• Cross-Region Service Network Peering：リージョン間 Service Network 直結検討中

学習リソース

公式ドキュメント（8+）

• Amazon VPC Lattice User Guide
• VPC Lattice API Reference
• VPC Lattice Pricing
• AWS Gateway API Controller（EKS）
• VPC Lattice + ECS Integration
• VPC Lattice + Lambda
• AWS Networking Blog - Lattice Posts
• Application Networking with Amazon VPC Lattice and Amazon EKS（2025）

関連オープンスタンダード・OSS（5+）

• Kubernetes Service Mesh Interface（SMI）
• Envoy Proxy（Service Mesh 基盤）
• CloudEvents Specification（イベント駆動アーキテクチャ）
• OpenTelemetry（Observability）
• CNCF Service Mesh Landscape

実装例・チェックリスト

小規模実装例（単一 VPC・単一リージョン）

• Service Network 1 個
• Service 3-5 個（API / Web / DB）
• Target Group ごと 2-3 Target
• Auth Policy なし（同一 VPC 内信頼前提）
• 開発検証環境向け

中規模実装例（複数 VPC・マルチアカウント）

• Service Network 1-2 個
• Service 10+ 個
• Cross-Account Service Network 共有（Resource Access Manager）
• IAM Auth Policy で細粒度制御
• Canary Deploy 対応

大規模実装例（EKS / ECS / Lambda 統合・グローバル）

• Service Network per 環境（本番・Staging・開発）
• Service 100+ 個（ECS Task + EKS Pod + Lambda）
• Gateway API Controller で Kubernetes ネイティブ管理
• 完全な Zero Trust（IAM Auth Policy 必須）
• CloudWatch + X-Ray 完全統合
• 複数リージョン Transit Gateway 経由統合

実装チェックリスト

• [ ] Service Network 作成・命名規則決定
• [ ] IAM ロール・ポリシー設計（Principal 定義）
• [ ] Service 一覧化・Service 毎の責務整理
• [ ] Target Group デザイン（EC2/Lambda/ALB/EKS Pod）
• [ ] Health Check 設定（パス・間隔・閾値）
• [ ] Weighted Routing 設計（Canary 配分）
• [ ] VPC Association（複数 VPC 対応）
• [ ] Auth Policy 作成・テスト
• [ ] CloudWatch Logs 有効化
• [ ] Service Discovery DNS テスト
• [ ] Cross-Account 設定（Resource Access Manager）
• [ ] EKS / ECS 統合テスト
• [ ] Gateway API Controller インストール（EKS）
• [ ] Failover テスト（Target Down 時）
• [ ] 監視・アラート設定（CloudWatch メトリクス）
• [ ] X-Ray トレース可視化設定

まとめ

Amazon VPC Lattice は、AWS ネイティブの軽量で強力なサービスメッシュプラットフォームです。Istio や App Mesh のようなサイドカープロキシ複雑性を排除しながら、IAM による Zero Trust セキュリティ・Cross-Account / Cross-VPC 統合・ECS/EKS/Lambda シームレス対応を実現します。2025 年の EKS Gateway API Controller や CNI Plugin 統合により、Kubernetes ネイティブなネットワーク管理が標準化され、マイクロサービスアーキテクチャで「シンプルさ」と「セキュリティ」を両立させる中核のコンポーネントになります。

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