AWS ECS・Fargateでコンテナアプリを本番運用するための設計手順｜タスク定義・ALB連携・マルチAZ配置の構成パターン入門

この記事のポイント

・FargateはサーバーレスでEC2管理が不要。本番用途では最初の選択肢になる
・タスク定義でCPU・メモリ・コンテナ定義・ログ設定を一元管理する
・ECSサービス＋ALBでマルチAZに分散配置してヘルスチェックを自動化する
・maximumPercent=200／minimumHealthyPercent=100でゼロダウンタイムデプロイを実現する
・force_new_deployment=trueを設定するとタスク定義更新時にサービスの再デプロイが自動でトリガーされる
・Auto ScalingはCPU使用率70%をトリガーにするターゲットトラッキングが基本
・実行ロール（起動権限）とタスクロール（アプリ権限）を分離して最小権限を実現する
・デプロイ失敗時はcircuit breakerで自動ロールバックしサービス停止を防ぐ
・TerraformでIaC管理する場合はjsonencodeかテンプレートファイルでコンテナ定義を管理し、lifecycle.ignore_changesでCI/CDと共存する
・ECSはVPC・ALBと別のState（ディレクトリ）に分割して変更頻度の違いを吸収するのが本番設計の鉄則

# ECSクラスターを作成する（Container Insights有効化）
aws ecs create-cluster   --cluster-name myapp-cluster   --settings "name=containerInsights,value=enabled"   --region ap-northeast-1

# 既存クラスターにContainer Insightsを後から有効化する
aws ecs update-cluster-settings   --cluster myapp-cluster   --settings "name=containerInsights,value=enabled"   --region ap-northeast-1

resource "aws_ecs_cluster" "main" {
  name = "myapp-cluster"

  setting {
    name  = "containerInsights"
    value = "enabled"
  }

  tags = {
    Environment = var.environment
  }
}

# タスク定義のJSON（コンテナ定義部分の抜粋）
{
  "family": "myapp-task",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [
    {
      "name": "myapp",
      "image": "123456789012.dkr.ecr.ap-northeast-1.amazonaws.com/myapp:latest",
      "portMappings": [
        {
          "containerPort": 8080,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {"name": "APP_ENV", "value": "production"},
        {"name": "LOG_LEVEL", "value": "info"}
      ],
      "secrets": [
        {
          "name": "DB_PASSWORD",
          "valueFrom": "arn:aws:secretsmanager:ap-northeast-1:123456789012:secret:myapp/db-password"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/myapp",
          "awslogs-region": "ap-northeast-1",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

# CloudWatch Logsのロググループを作成する
aws logs create-log-group   --log-group-name /ecs/myapp   --region ap-northeast-1

# ロググループの保持期間を30日に設定する（必ず設定すること）
aws logs put-retention-policy   --log-group-name /ecs/myapp   --retention-in-days 30

# タスク定義のコンテナヘルスチェック設定（JSON抜粋）
{
  "healthCheck": {
    "command": [
      "CMD-SHELL",
      "curl -f http://localhost:8080/health || exit 1"
    ],
    "interval": 30,
    "timeout": 5,
    "retries": 3,
    "startPeriod": 60
  }
}

# startPeriodは起動直後のヘルスチェック猶予時間（秒）
# アプリの起動に時間がかかる場合は大きめに設定する
# 例: Javaアプリで起動に45秒かかるなら startPeriod を 60～90 に設定する

# 既存のタスク定義をJSONファイルとして書き出す（初回）
aws ecs describe-task-definition   --task-definition myapp-task   --query 'taskDefinition'   --output json > task-definition.json

# JSONファイルを編集した後、新しいリビジョンとして登録する
aws ecs register-task-definition   --cli-input-json file://task-definition.json

# Gitで変更を管理する
git add task-definition.json
git commit -m "Update myapp-task: increase memory from 1024 to 2048"

resource "aws_ecs_task_definition" "app" {
  family                   = "myapp-task"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = "512"
  memory                   = "1024"
  execution_role_arn       = aws_iam_role.ecs_task_execution.arn
  task_role_arn            = aws_iam_role.ecs_task.arn

  container_definitions = jsonencode([
    {
      name      = "myapp"
      image     = "123456789012.dkr.ecr.ap-northeast-1.amazonaws.com/myapp:latest"
      essential = true
      portMappings = [
        {
          containerPort = 8080
          protocol      = "tcp"
        }
      ]
      environment = [
        { name = "APP_ENV",   value = var.environment },
        { name = "LOG_LEVEL", value = "info" }
      ]
      logConfiguration = {
        logDriver = "awslogs"
        options = {
          "awslogs-group"         = "/ecs/myapp"
          "awslogs-region"        = "ap-northeast-1"
          "awslogs-stream-prefix" = "ecs"
        }
      }
    }
  ])
}

# container_def.json.tpl （コンテナ定義テンプレートファイル）
[
  {
    "name": "${container_name}",
    "image": "${image_uri}",
    "essential": true,
    "portMappings": [
      {
        "containerPort": ${container_port},
        "protocol": "tcp"
      }
    ],
    "environment": [
      { "name": "APP_ENV", "value": "${app_env}" }
    ],
    "secrets": [
      {
        "name": "DB_PASSWORD",
        "valueFrom": "${ssm_db_password_arn}"
      }
    ],
    "logConfiguration": {
      "logDriver": "awslogs",
      "options": {
        "awslogs-group": "${log_group}",
        "awslogs-region": "${region}",
        "awslogs-stream-prefix": "ecs"
      }
    }
  }
]

# task.tf （templatefileを使ったタスク定義）
resource "aws_ecs_task_definition" "app" {
  family                   = "${var.env}-${var.app_name}"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = var.task_cpu
  memory                   = var.task_memory
  execution_role_arn       = aws_iam_role.ecs_task_execution.arn
  task_role_arn            = aws_iam_role.ecs_task.arn

  container_definitions = templatefile("${path.module}/container_def.json.tpl", {
    container_name      = var.app_name
    image_uri           = "${var.ecr_repository_url}:${var.image_tag}"
    container_port      = var.container_port
    app_env             = var.env
    ssm_db_password_arn = var.ssm_db_password_arn
    log_group           = aws_cloudwatch_log_group.app.name
    region              = var.region
  })
}

terraform/
├── environments/
│   ├── prd/
│   │   ├── vpc/           # VPC・サブネット（変更頻度: 低）
│   │   ├── alb/           # ALB・Target Group（変更頻度: 低）
│   │   └── ecs/           # Cluster・Task Def・Service（変更頻度: 高）
│   └── stg/
│       └── ...（同じ構造）
└── modules/
    ├── vpc/
    ├── alb/
    └── ecs-service/

# ALB用セキュリティグループ（インターネットからの80/443を受け入れる）
aws ec2 create-security-group   --group-name myapp-alb-sg   --description "Security group for ALB"   --vpc-id vpc-0123456789abcdef0

# ALB SGにインターネットからのHTTPS（443）を許可する
aws ec2 authorize-security-group-ingress   --group-id sg-alb-xxxxxxxx   --protocol tcp --port 443   --cidr 0.0.0.0/0

# ECSタスク用セキュリティグループ（ALBのSGからのみコンテナポートを受け入れる）
aws ec2 create-security-group   --group-name myapp-ecs-sg   --description "Security group for ECS Fargate tasks"   --vpc-id vpc-0123456789abcdef0

# ECSタスクSGへの許可：ソースをALBのSGに限定する（0.0.0.0/0は絶対に使わない）
aws ec2 authorize-security-group-ingress   --group-id sg-ecs-xxxxxxxx   --protocol tcp --port 8080   --source-group sg-alb-xxxxxxxx

# ターゲットグループを作成する（FargateはIPターゲット）
aws elbv2 create-target-group   --name myapp-tg   --protocol HTTP   --port 8080   --vpc-id vpc-0123456789abcdef0   --target-type ip   --health-check-path /health   --health-check-interval-seconds 30   --healthy-threshold-count 2   --unhealthy-threshold-count 3

# 出力例
{
    "TargetGroups": [
        {
            "TargetGroupArn": "arn:aws:elasticloadbalancing:ap-northeast-1:123456789012:targetgroup/myapp-tg/abc123def456",
            "TargetGroupName": "myapp-tg",
            "Protocol": "HTTP",
            "Port": 8080,
            "HealthCheckPath": "/health",
            ...
        }
    ]
}

# alb.tf （ALB・リスナー・ターゲットグループのTerraform定義）
resource "aws_lb" "main" {
  name               = "${var.env}-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb.id]
  subnets            = var.public_subnet_ids

  # 本番環境では誤削除防止のため必ずtrueに設定する
  enable_deletion_protection = var.environment == "prod" ? true : false

  tags = { Env = var.environment }
}

resource "aws_lb_listener" "http" {
  load_balancer_arn = aws_lb.main.arn
  port              = 80
  protocol          = "HTTP"

  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.app.arn
  }
}

resource "aws_lb_target_group" "app" {
  name        = "${var.env}-${var.app_name}-tg"
  port        = var.container_port
  protocol    = "HTTP"
  target_type = "ip"     # Fargateはawsvpcモードなので "ip" 固定
  vpc_id      = var.vpc_id

  health_check {
    path                = var.health_check_path
    matcher             = "200"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 3
  }

  # デプロイ時に古いタスクの登録解除を速くする（デフォルト300秒）
  deregistration_delay = 30

  tags = { Env = var.environment }
}

# ECSサービスを作成する（ALBと連携・マルチAZ・デプロイcircuit breaker有効）
aws ecs create-service   --cluster myapp-cluster   --service-name myapp-service   --task-definition myapp-task:1   --desired-count 2   --launch-type FARGATE   --network-configuration "awsvpcConfiguration={
    subnets=[subnet-0a1b2c3d4e,subnet-0f1e2d3c4b],
    securityGroups=[sg-ecs-xxxxxxxx],
    assignPublicIp=DISABLED
  }"   --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:ap-northeast-1:123456789012:targetgroup/myapp-tg/abc123,containerName=myapp,containerPort=8080"   --deployment-configuration "deploymentCircuitBreaker={enable=true,rollback=true},maximumPercent=200,minimumHealthyPercent=100"

resource "aws_ecs_service" "app" {
  name            = "myapp-service"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 2
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = data.aws_subnets.private.ids
    security_groups  = [aws_security_group.ecs_tasks.id]
    assign_public_ip = false
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = "myapp"   # タスク定義のname と完全一致させること
    container_port   = 8080
  }

  depends_on = [aws_lb_listener.https]   # ALBリスナーが先に存在することを保証

  deployment_minimum_healthy_percent = 100
  deployment_maximum_percent         = 200

  # Javaアプリなど起動に時間がかかるコンテナは猶予時間を設定する
  health_check_grace_period_seconds  = 60

  # タスク定義更新時に自動で再デプロイをトリガーする
  force_new_deployment = true

  lifecycle {
    ignore_changes = [task_definition, desired_count]
  }
}

# ECSサービスの起動状態を確認する
aws ecs describe-services   --cluster myapp-cluster   --services myapp-service   --query 'services[0].{Status:status,Running:runningCount,Desired:desiredCount,Pending:pendingCount}'

# 正常な出力例
{
    "Status": "ACTIVE",
    "Running": 2,
    "Desired": 2,
    "Pending": 0
}

# aws_ecs_serviceにtimeoutsブロックを追加する例
resource "aws_ecs_service" "app" {
  # ... 既存の設定 ...

  timeouts {
    create = "20m"
    update = "20m"
    delete = "20m"
  }
}

resource "aws_ecs_service" "app" {
  # ...
  deployment_minimum_healthy_percent = 100
  deployment_maximum_percent         = 200

  deployment_circuit_breaker {
    enable   = true   # デプロイ失敗時に自動ロールバックを有効化
    rollback = true
  }
}

resource "aws_ecs_service" "app" {
  # ...
  deployment_controller {
    type = "CODE_DEPLOY"   # Rolling Updateの場合は"ECS"（デフォルト）
  }

  lifecycle {
    # CodeDeployが管理するためTerraformでは差分を無視する
    ignore_changes = [task_definition, load_balancer]
  }
}

# 既存VPC・サブネットをTagベースで参照する（Terraform data source）
data "aws_vpc" "main" {
  tags = { Name = "${var.project}-vpc" }
}

data "aws_subnets" "private" {
  filter {
    name   = "vpc-id"
    values = [data.aws_vpc.main.id]
  }
  tags = { Tier = "private" }
}

data "aws_subnets" "public" {
  filter {
    name   = "vpc-id"
    values = [data.aws_vpc.main.id]
  }
  tags = { Tier = "public" }
}

# タスク配置戦略を確認する
aws ecs describe-services   --cluster myapp-cluster   --services myapp-service   --query 'services[0].placementStrategy'

# AZ均等分散の配置戦略を設定する（update-service）
aws ecs update-service   --cluster myapp-cluster   --service myapp-service   --placement-strategy "[{"type":"spread","field":"attribute:ecs.availability-zone"}]"

# ECSサービスをAuto Scalingのターゲットとして登録する
aws application-autoscaling register-scalable-target   --service-namespace ecs   --scalable-dimension ecs:service:DesiredCount   --resource-id service/myapp-cluster/myapp-service   --min-capacity 2   --max-capacity 10

# CPU使用率70%を目標にするターゲットトラッキングポリシーを設定する
aws application-autoscaling put-scaling-policy   --service-namespace ecs   --scalable-dimension ecs:service:DesiredCount   --resource-id service/myapp-cluster/myapp-service   --policy-name myapp-cpu-scaling   --policy-type TargetTrackingScaling   --target-tracking-scaling-policy-configuration '{
    "TargetValue": 70.0,
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ECSServiceAverageCPUUtilization"
    },
    "ScaleOutCooldown": 60,
    "ScaleInCooldown": 300
  }'

# メモリ使用率80%でもスケールするポリシーを追加する（CPU・メモリの両方を監視）
aws application-autoscaling put-scaling-policy   --service-namespace ecs   --scalable-dimension ecs:service:DesiredCount   --resource-id service/myapp-cluster/myapp-service   --policy-name myapp-memory-scaling   --policy-type TargetTrackingScaling   --target-tracking-scaling-policy-configuration '{
    "TargetValue": 80.0,
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ECSServiceAverageMemoryUtilization"
    },
    "ScaleOutCooldown": 60,
    "ScaleInCooldown": 300
  }'

# Auto ScalingターゲットとしてECSサービスを登録する
resource "aws_appautoscaling_target" "ecs" {
  max_capacity       = 10
  min_capacity       = 2
  resource_id        = "service/${aws_ecs_cluster.main.name}/${aws_ecs_service.app.name}"
  scalable_dimension = "ecs:service:DesiredCount"
  service_namespace  = "ecs"
}

# CPU使用率70%を目標にするターゲットトラッキングポリシー
resource "aws_appautoscaling_policy" "cpu" {
  name               = "myapp-cpu-scaling"
  policy_type        = "TargetTrackingScaling"
  resource_id        = aws_appautoscaling_target.ecs.resource_id
  scalable_dimension = aws_appautoscaling_target.ecs.scalable_dimension
  service_namespace  = aws_appautoscaling_target.ecs.service_namespace

  target_tracking_scaling_policy_configuration {
    predefined_metric_specification {
      predefined_metric_type = "ECSServiceAverageCPUUtilization"
    }
    target_value       = 70.0
    scale_in_cooldown  = 300   # スケールインは慎重に（5分）
    scale_out_cooldown = 60    # スケールアウトは素早く（60秒）
  }
}

# メモリ使用率80%でのスケールポリシーも追加する場合
resource "aws_appautoscaling_policy" "memory" {
  name               = "myapp-memory-scaling"
  policy_type        = "TargetTrackingScaling"
  resource_id        = aws_appautoscaling_target.ecs.resource_id
  scalable_dimension = aws_appautoscaling_target.ecs.scalable_dimension
  service_namespace  = aws_appautoscaling_target.ecs.service_namespace

  target_tracking_scaling_policy_configuration {
    predefined_metric_specification {
      predefined_metric_type = "ECSServiceAverageMemoryUtilization"
    }
    target_value       = 80.0
    scale_in_cooldown  = 300
    scale_out_cooldown = 60
  }
}

# 実行ロールに必要な最低限のポリシー（AWSマネージドポリシー）
# AmazonECSTaskExecutionRolePolicy に以下が含まれる
# - ecr:GetAuthorizationToken
# - ecr:BatchGetImage
# - logs:CreateLogStream
# - logs:PutLogEvents

# SecretsManagerを使う場合は追加で以下が必要
# - secretsmanager:GetSecretValue
# - kms:Decrypt（KMSで暗号化している場合）

# 実行ロールの信頼ポリシー（ecs-tasks.amazonaws.com が引き受ける）
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": {"Service": "ecs-tasks.amazonaws.com"},
    "Action": "sts:AssumeRole"
  }]
}

# タスクロールの作成例（S3とDynamoDBを使うアプリケーション用）
aws iam create-role   --role-name myapp-task-role   --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [{
      "Effect": "Allow",
      "Principal": {"Service": "ecs-tasks.amazonaws.com"},
      "Action": "sts:AssumeRole"
    }]
  }'

# タスクロールに最小権限ポリシーをアタッチする
# 例: S3バケットへのPUTのみ許可（GetやDeleteは付与しない）
aws iam put-role-policy   --role-name myapp-task-role   --policy-name myapp-s3-put   --policy-document '{
    "Version": "2012-10-17",
    "Statement": [{
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Resource": "arn:aws:s3:::myapp-uploads/*"
    }]
  }'

# タスク実行ロール（ECR pull・CloudWatch Logs書き込み用）
resource "aws_iam_role" "ecs_task_execution" {
  name = "${var.project}-ecs-task-execution"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action    = "sts:AssumeRole"
      Effect    = "Allow"
      Principal = { Service = "ecs-tasks.amazonaws.com" }
    }]
  })
}

resource "aws_iam_role_policy_attachment" "ecs_task_execution" {
  role       = aws_iam_role.ecs_task_execution.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
}

# タスクロール（コンテナ内アプリがAWSサービスを呼び出す場合）
resource "aws_iam_role" "ecs_task" {
  name = "${var.project}-ecs-task"

  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Action    = "sts:AssumeRole"
      Effect    = "Allow"
      Principal = { Service = "ecs-tasks.amazonaws.com" }
    }]
  })
}

# アプリ固有の権限をインラインポリシーで付与する（例: S3・DynamoDB）
resource "aws_iam_role_policy" "ecs_task_app" {
  name = "${var.project}-ecs-task-app"
  role = aws_iam_role.ecs_task.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect   = "Allow"
        Action   = ["s3:PutObject"]
        Resource = "${aws_s3_bucket.app_uploads.arn}/*"
      },
      {
        Effect   = "Allow"
        Action   = ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:Query"]
        Resource = aws_dynamodb_table.app.arn
      }
    ]
  })
}

# aws_iam_policy_documentデータソースを使った信頼ポリシー定義（jsonencode代替）
data "aws_iam_policy_document" "ecs_assume" {
  statement {
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["ecs-tasks.amazonaws.com"]
    }
  }
}

# 既存のSecretsManagerシークレットをデータソースで参照する
data "aws_secretsmanager_secret" "db" {
  name = "prod/app/db-password"
}

# 実行ロールにsecretsmanager:GetSecretValueを追加する（対象ARNのみに限定）
resource "aws_iam_role_policy" "ecs_execution_secrets" {
  name = "${var.project}-ecs-execution-secrets"
  role = aws_iam_role.ecs_task_execution.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect   = "Allow"
      Action   = ["secretsmanager:GetSecretValue"]
      Resource = [data.aws_secretsmanager_secret.db.arn]
    }]
  })
}

# ECRイメージpullに必要なVPCエンドポイントを確認する
aws ec2 describe-vpc-endpoints   --filters "Name=vpc-id,Values=vpc-0123456789abcdef0"   --query 'VpcEndpoints[*].{service:ServiceName,state:State}'

# ECRのイメージpullに必要な3つのエンドポイント
# - com.amazonaws.ap-northeast-1.ecr.dkr  → Dockerイメージの取得
# - com.amazonaws.ap-northeast-1.ecr.api  → ECR API呼び出し
# - com.amazonaws.ap-northeast-1.s3       → ECRレイヤーの取得（S3バケット経由）

# CloudWatch Logsへの書き込みに必要
# - com.amazonaws.ap-northeast-1.logs

# SecretsManagerを使う場合も必要
# - com.amazonaws.ap-northeast-1.secretsmanager

# 停止したタスクの停止理由を確認する
aws ecs describe-tasks   --cluster myapp-cluster   --tasks arn:aws:ecs:ap-northeast-1:123456789012:task/myapp-cluster/a1b2c3d4   --query 'tasks[0].{status:lastStatus,stopCode:stopCode,reason:stoppedReason}'

# 出力例（実行ロールの権限不足の場合）
{
    "status": "STOPPED",
    "stopCode": "TaskFailedToStart",
    "reason": "CannotPullContainerError: pull image manifest has been retried 5 time(s): ..."
}

# CloudWatch Logsでコンテナのエラーログを確認する
aws logs get-log-events   --log-group-name /ecs/myapp   --log-stream-name ecs/myapp/a1b2c3d4   --limit 50

# NG: 文字列リテラルで固定するとapply後もリビジョンが変わらない
task_definition = "myapp-task:5"

# NG: :LATESTのような曖昧な参照も同様に問題になる
task_definition = "myapp-task:LATEST"

# OK: リソース参照にすると常に最新リビジョンのARNが使われる
task_definition = aws_ecs_task_definition.app.arn

# ターゲットグループのヘルスチェック状態を確認する
aws elbv2 describe-target-health   --target-group-arn arn:aws:elasticloadbalancing:ap-northeast-1:123456789012:targetgroup/myapp-tg/abc123   --query 'TargetHealthDescriptions[*].{id:Target.Id,port:Target.Port,state:TargetHealth.State,reason:TargetHealth.Reason}'

# 出力例（unhealthyの場合）
[
    {
        "id": "10.0.1.45",
        "port": 8080,
        "state": "unhealthy",
        "reason": "Target.ResponseCodeMismatch"
    }
]

# ECSサービスの直近イベントを確認する
aws ecs describe-services   --cluster myapp-cluster   --services myapp-service   --query 'services[0].events[:5]'

# 出力例（ヘルスチェック失敗で登録・解除が繰り返されている場合）
[
    {
        "createdAt": "2026-10-05T09:23:41+09:00",
        "message": "service myapp-service deregistered 1 targets in target-group myapp"
    },
    {
        "createdAt": "2026-10-05T09:23:10+09:00",
        "message": "service myapp-service registered 1 targets in target-group myapp"
    }
]

# プライベートサブネットのルートテーブルを確認する
# 0.0.0.0/0 がNATゲートウェイ（nat-xxxxxxxxx）に向いているか確認
aws ec2 describe-route-tables   --filters "Name=association.subnet-id,Values=subnet-0a1b2c3d4e"   --query 'RouteTables[0].Routes[*].{dest:DestinationCidrBlock,gw:GatewayId,nat:NatGatewayId}'

# 出力例（正常な場合）
[
    {"dest": "10.0.0.0/16", "gw": "local",          "nat": null},
    {"dest": "0.0.0.0/0",   "gw": null,              "nat": "nat-0abc12345def67890"}
]

# VPCエンドポイント経由でECRにアクセスする場合は以下のエンドポイントを作成する
# - com.amazonaws.ap-northeast-1.ecr.dkr  （イメージpull）
# - com.amazonaws.ap-northeast-1.ecr.api  （API呼び出し）
# - com.amazonaws.ap-northeast-1.s3       （ECRレイヤーの取得）
# - com.amazonaws.ap-northeast-1.logs     （CloudWatch Logsへの書き込み）
# - com.amazonaws.ap-northeast-1.secretsmanager  （シークレット取得）
aws ec2 describe-vpc-endpoints   --filters "Name=vpc-id,Values=vpc-0123456789abcdef0"   --query 'VpcEndpoints[*].{service:ServiceName,state:State}'

# ECSサービスのイベントを確認する（直近の10件）
aws ecs describe-services   --cluster myapp-cluster   --services myapp-service   --query 'services[0].events[:10].{createdAt:createdAt,message:message}'

# 出力例（ヘルスチェック失敗でタスクが入れ替わり続けている場合）
[
    {
        "createdAt": "2024-01-15T10:23:45+09:00",
        "message": "(service myapp-service) (task a1b2c3d4) failed container health checks."
    },
    {
        "createdAt": "2024-01-15T10:23:20+09:00",
        "message": "(service myapp-service) registered 1 targets in (target-group arn:...)"
    }
]

# ターゲットグループのプロトコルを確認する
aws elbv2 describe-target-groups   --names myapp-tg   --query 'TargetGroups[0].{Protocol:Protocol,TargetType:TargetType,Port:Port}'

# 出力例（間違ってTCPになっている場合）
{
    "Protocol": "TCP",
    "TargetType": "ip",
    "Port": 8080
}

# 修正方法: ターゲットグループを削除して再作成する（protocolはHTTPを指定）
aws elbv2 delete-target-group   --target-group-arn arn:aws:elasticloadbalancing:ap-northeast-1:123456789012:targetgroup/myapp-tg/abc123

aws elbv2 create-target-group   --name myapp-tg   --protocol HTTP   --port 8080   --vpc-id vpc-0123456789abcdef0   --target-type ip   --health-check-path /health

# ECSサービスのイベントを確認する（直近の10件）
aws ecs describe-services   --cluster myapp-cluster   --services myapp-service   --query 'services[0].events[:10].{createdAt:createdAt,message:message}'

# よくあるイベントメッセージ例（ヘルスチェック失敗でタスクが入れ替わり続けている場合）
[
    {
        "createdAt": "2024-01-15T10:23:45+09:00",
        "message": "(service myapp-service) (task a1b2c3d4) failed container health checks."
    }
]

# aws_ecs_service.app will be updated in-place
~ resource "aws_ecs_service" "app" {
    ~ task_definition = "arn:.../myapp:3" -> (known after apply)
    ...
  }

# planをファイルに保存して内容を確認してからapplyする
terraform plan -out=tfplan
terraform show tfplan   # 変更内容を確認
terraform apply tfplan  # 確認済みのplanを適用

Error: error updating ECS Service: InvalidParameterException:
TaskDefinition is inactive.