apiモジュールの作成

baseモジュールでネットワークやデータベースなどの基盤が整い、コンテナイメージもECRにPushできたので、次にECS(Fargate)でAPIサーバを構築するモジュールを作成します。

このモジュールで作成されるリソースは以下のとおりです。

種類 リソース名 用途
ACM 証明書 api.example.com ALBのHTTPS通信用SSL証明書
ALB test-noteapp-api-alb APIへのトラフィックを分散
Route53 Aレコード api.example.com → ALB APIのカスタムドメインをALBに紐付け
ALB ターゲットグループ test-noteapp-api-tg ECSタスクへのトラフィック振り分け
ALB リスナー(HTTPS) ポート443 HTTPSリクエストをターゲットグループに転送
ALB リスナー(HTTP) ポート80 HTTPリクエストをHTTPSにリダイレクト
ECS クラスタ test-noteapp-cluster ECSサービスを配置する論理グループ
ECS タスク定義 test-noteapp-api コンテナの設定(イメージ、CPU、メモリ、環境変数)
ECS サービス test-noteapp-api Fargateタスクの実行・管理
IAM ロール test-noteapp-ecs-task-execution-role ECRからのイメージ取得とログ書き込み用

1. コードの記載

ここでは、FastAPIコンテナを**ECS(Fargate)**で実行し、ALB、ACM証明書、Route53 Aレコード、ALBターゲットグループ、ALBリスナーでトラフィックを分散する構成を作成します。ALB本体やACM証明書もこのモジュールで作成し、baseモジュールからはネットワークやセキュリティグループの情報を受け取ります。modules/api/ディレクトリの各ファイルにコードを記述していきます。

1.1 variables.tf

modules/api/variables.tfに以下の内容を記述します。

variable "project_name" {
  description = "プロジェクト名"
  type        = string
}

variable "vpc_id" {
  description = "VPC ID"
  type        = string
}

variable "public_subnet_ids" {
  description = "パブリックサブネットIDのリスト"
  type        = list(string)
}

variable "private_subnet_ids" {
  description = "プライベートサブネットIDのリスト"
  type        = list(string)
}

variable "api_security_group_id" {
  description = "API用セキュリティグループID"
  type        = string
}

variable "alb_security_group_id" {
  description = "ALB用セキュリティグループID"
  type        = string
}

variable "ecr_repository_url" {
  description = "ECRリポジトリURL"
  type        = string
}

variable "container_image_tag" {
  description = "コンテナイメージのタグ"
  type        = string
  default     = "latest"
}

variable "db_host" {
  description = "データベースホスト"
  type        = string
}

variable "db_name" {
  description = "データベース名"
  type        = string
}

variable "db_username" {
  description = "データベースユーザ名"
  type        = string
}

variable "db_password" {
  description = "データベースパスワード"
  type        = string
  sensitive   = true
}

variable "log_group_name" {
  description = "CloudWatch Logsグループ名"
  type        = string
}

variable "domain_name" {
  description = "カスタムドメイン名"
  type        = string
}

variable "route53_zone_id" {
  description = "Route53ホストゾーンID"
  type        = string
}

コードを解説します。

project_name / vpc_id / サブネット関連

variable "project_name" {
  type        = string
}

variable "vpc_id" {
  type        = string
}

variable "public_subnet_ids" {
  type        = list(string)
}

variable "private_subnet_ids" {
  type        = list(string)
}

baseモジュールから受け取るネットワーク情報です。project_nameはリソース名のプレフィックスとして使用します。vpc_idはALBターゲットグループの作成先VPCを指定するために使用します。public_subnet_idsはALBの配置先、private_subnet_idsはFargateタスクの配置先として使用します。

セキュリティグループ関連(api_security_group_id / alb_security_group_id)

variable "api_security_group_id" {
  type        = string
}

variable "alb_security_group_id" {
  type        = string
}

baseモジュールから受け取るセキュリティグループです。api_security_group_idはFargateタスクに適用するセキュリティグループ、alb_security_group_idはALBに適用するセキュリティグループです。

コンテナ関連(ecr_repository_url / container_image_tag)

variable "ecr_repository_url" {
  type        = string
}

variable "container_image_tag" {
  type        = string
  default     = "latest"
}

ECRリポジトリのURLとイメージタグです。ecr_repository_urlはbaseモジュールから受け取り、container_image_tagはデフォルトでlatestを使用します。タスク定義で${ecr_repository_url}:${container_image_tag}の形式でイメージを指定します。

データベース関連(db_host / db_name / db_username / db_password)

variable "db_host" {
  type        = string
}

variable "db_name" {
  type        = string
}

variable "db_username" {
  type        = string
}

variable "db_password" {
  type        = string
  sensitive   = true
}

ECSタスクの環境変数としてコンテナに渡すデータベース接続情報です。db_hostはbaseモジュールのRDSエンドポイントを受け取ります。

sensitiveは、変数の値を出力に表示するかどうかを制御する設定です。db_passwordにsensitive = trueを設定することで、terraform planやterraform applyの出力にパスワードが表示されることを防ぎます。

domain_name / route53_zone_id

variable "domain_name" {
  type        = string
}

variable "route53_zone_id" {
  type        = string
}

domain_nameはACM証明書の発行(api.<ドメイン名>)とRoute53 Aレコードの作成に使用します。route53_zone_idはbaseモジュールから受け取り、DNS検証レコードとALB向けのAレコードを作成するRoute53ホストゾーンを指定します。

log_group_name

variable "log_group_name" {
  type        = string
}

ECSタスクのログ出力先となるCloudWatch Logsグループ名です。baseモジュールで作成したロググループを受け取り、タスク定義のlogConfigurationで指定します。

1.2 main.tf

modules/api/main.tfに以下の内容を記述します。

# ACM証明書(ALB用、東京リージョン)
resource "aws_acm_certificate" "api" {
  domain_name       = "api.${var.domain_name}"
  validation_method = "DNS"

  tags = {
    Name = "${var.project_name}-api-cert"
  }

  lifecycle {
    create_before_destroy = true
  }
}

# ACM証明書のDNS検証レコード
resource "aws_route53_record" "api_cert_validation" {
  for_each = {
    for dvo in aws_acm_certificate.api.domain_validation_options : dvo.domain_name => {
      name   = dvo.resource_record_name
      record = dvo.resource_record_value
      type   = dvo.resource_record_type
    }
  }

  zone_id = var.route53_zone_id
  name    = each.value.name
  type    = each.value.type
  records = [each.value.record]
  ttl     = 60
}

# ACM証明書の検証完了を待機
resource "aws_acm_certificate_validation" "api" {
  certificate_arn         = aws_acm_certificate.api.arn
  validation_record_fqdns = [for record in aws_route53_record.api_cert_validation : record.fqdn]
}

# ALB
resource "aws_lb" "api" {
  name               = "${var.project_name}-api-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [var.alb_security_group_id]
  subnets            = var.public_subnet_ids

  tags = {
    Name = "${var.project_name}-api-alb"
  }
}

# Route53 Aレコード(api.example.com → ALB)
resource "aws_route53_record" "api" {
  zone_id = var.route53_zone_id
  name    = "api.${var.domain_name}"
  type    = "A"

  alias {
    name                   = aws_lb.api.dns_name
    zone_id                = aws_lb.api.zone_id
    evaluate_target_health = true
  }
}

# ALBターゲットグループ
resource "aws_lb_target_group" "api" {
  name        = "${var.project_name}-api-tg"
  port        = 8000
  protocol    = "HTTP"
  vpc_id      = var.vpc_id
  target_type = "ip"  # Fargate の場合は ip を指定

  health_check {
    path                = "/health"
    healthy_threshold   = 2
    unhealthy_threshold = 3
    timeout             = 5
    interval            = 30
    matcher             = "200"
  }

  tags = {
    Name = "${var.project_name}-api-tg"
  }
}

# ALBリスナー(HTTPS)
resource "aws_lb_listener" "api_https" {
  load_balancer_arn = aws_lb.api.arn
  port              = 443
  protocol          = "HTTPS"
  ssl_policy        = "ELBSecurityPolicy-TLS13-1-2-2021-06"
  certificate_arn   = aws_acm_certificate_validation.api.certificate_arn

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

# ALBリスナー(HTTP → HTTPSリダイレクト)
resource "aws_lb_listener" "api_http_redirect" {
  load_balancer_arn = aws_lb.api.arn
  port              = 80
  protocol          = "HTTP"

  default_action {
    type = "redirect"
    redirect {
      port        = "443"
      protocol    = "HTTPS"
      status_code = "HTTP_301"
    }
  }
}

# ECSタスク実行ロール(ECRからのイメージ取得、CloudWatch Logsへの書き込みに必要)
resource "aws_iam_role" "ecs_task_execution" {
  name = "${var.project_name}-ecs-task-execution-role"

  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"
}

# ECSクラスタ
resource "aws_ecs_cluster" "main" {
  name = "${var.project_name}-cluster"

  tags = {
    Name = "${var.project_name}-cluster"
  }
}

# ECSタスク定義
resource "aws_ecs_task_definition" "api" {
  family                   = "${var.project_name}-api"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = "256"   # 0.25 vCPU
  memory                   = "512"   # 512 MB
  execution_role_arn       = aws_iam_role.ecs_task_execution.arn

  container_definitions = jsonencode([{
    name  = "api"
    image = "${var.ecr_repository_url}:${var.container_image_tag}"
    portMappings = [{
      containerPort = 8000
      protocol      = "tcp"
    }]
    environment = [
      { name = "DB_HOST", value = var.db_host },
      { name = "DB_NAME", value = var.db_name },
      { name = "DB_USER", value = var.db_username },
      { name = "DB_PASSWORD", value = var.db_password },
    ]
    logConfiguration = {
      logDriver = "awslogs"
      options = {
        "awslogs-group"         = var.log_group_name
        "awslogs-region"        = "ap-northeast-1"
        "awslogs-stream-prefix" = "api"
      }
    }
  }])

  tags = {
    Name = "${var.project_name}-api-task"
  }
}

# ECSサービス
resource "aws_ecs_service" "api" {
  name            = "${var.project_name}-api"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.api.arn
  desired_count   = 1
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = var.private_subnet_ids
    security_groups  = [var.api_security_group_id]
    assign_public_ip = false
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.api.arn
    container_name   = "api"
    container_port   = 8000
  }

  tags = {
    Name = "${var.project_name}-api-service"
  }
}

コードを解説します。

ACM証明書とDNS検証

resource "aws_acm_certificate" "api" {
  domain_name       = "api.${var.domain_name}"
  validation_method = "DNS"

ALBでHTTPS通信を行うためのSSL証明書を作成します。domain_nameにapi.example.comを指定し、validation_methodをDNSにすることで、Route53にDNS検証レコードを自動作成して証明書の所有権を検証します。

resource "aws_route53_record" "api_cert_validation" {
  for_each = {
    for dvo in aws_acm_certificate.api.domain_validation_options : dvo.domain_name => { ... }
  }

ACM証明書のDNS検証に必要なCNAMEレコードをRoute53に作成します。for_eachで検証オプションをループし、証明書が要求するレコードを自動的に作成します。

resource "aws_acm_certificate_validation" "api" {
  certificate_arn         = aws_acm_certificate.api.arn
  validation_record_fqdns = [for record in aws_route53_record.api_cert_validation : record.fqdn]
}

DNS検証レコードが作成された後、ACMが証明書の検証を完了するまで待機します。このリソースが完了すると、証明書がALBで使用可能になります。

ALB

resource "aws_lb" "api" {
  name               = "${var.project_name}-api-alb"
  internal           = false
  load_balancer_type = "application"

インターネット向け(internal = false)のApplication Load Balancerを作成します。applicationタイプを指定することで、HTTP/HTTPSトラフィックをレイヤ7で処理できます。

Route53 Aレコード(ALB用)

resource "aws_route53_record" "api" {
  zone_id = var.route53_zone_id
  name    = "api.${var.domain_name}"
  type    = "A"

  alias {
    name                   = aws_lb.api.dns_name
    zone_id                = aws_lb.api.zone_id

api.example.comをALBに向けるエイリアスレコードを作成します。エイリアスレコードはCNAMEと異なりゾーンの頂点(Zone Apex)にも設定でき、ALBのDNS名に直接解決されます。

ALBターゲットグループ

resource "aws_lb_target_group" "api" {
  name        = "${var.project_name}-api-tg"
  port        = 8000
  protocol    = "HTTP"
  vpc_id      = var.vpc_id
  target_type = "ip"

  health_check {
    path                = "/health"
    healthy_threshold   = 2
    unhealthy_threshold = 3
    timeout             = 5
    interval            = 30
    matcher             = "200"
  }

ALBからトラフィックを転送するターゲットグループを作成します。

target_typeは、ターゲットの種類を指定する設定です。ip、instance、lambdaの3つから選択でき、Fargateではタスクごとに動的にIPアドレスが割り当てられるためipを指定します。

health_check.pathは、ヘルスチェックのリクエスト先パスを指定する設定です。/healthを指定することで、ALBが30秒間隔でこのエンドポイントにリクエストを送り、ステータスコード200が返ればhealthyと判定します。

ALBリスナー(HTTPS / HTTPリダイレクト)

resource "aws_lb_listener" "api_https" {
  load_balancer_arn = aws_lb.api.arn
  port              = 443
  protocol          = "HTTPS"
  ssl_policy        = "ELBSecurityPolicy-TLS13-1-2-2021-06"
  certificate_arn   = aws_acm_certificate_validation.api.certificate_arn

HTTPSリスナーでは、ポート443でHTTPSトラフィックを受け付け、ターゲットグループにフォワードします。

ssl_policyは、TLS通信で使用する暗号化ポリシーを指定する設定です。ELBSecurityPolicy-TLS13-1-2-2021-06を指定することで、TLS 1.3と1.2をサポートするセキュアなポリシーが適用されます。

certificate_arnは、HTTPS通信に使用するSSL証明書を指定する設定です。同モジュール内で作成・検証済みのACM証明書のARNを設定しています。

resource "aws_lb_listener" "api_http_redirect" {
  load_balancer_arn = aws_lb.api.arn
  port              = 80
  protocol          = "HTTP"

  default_action {
    type = "redirect"
    redirect {
      port        = "443"
      protocol    = "HTTPS"
      status_code = "HTTP_301"
    }
  }

HTTPリスナーでは、ポート80へのHTTPアクセスをHTTPS(443)に301リダイレクトします。これにより、すべての通信がHTTPSで暗号化されます。

ECSタスク実行ロール

resource "aws_iam_role" "ecs_task_execution" {
  name = "${var.project_name}-ecs-task-execution-role"

  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"
}

ECSタスクがECRからコンテナイメージを取得し、CloudWatch Logsにログを書き込むために必要なIAMロールです。AmazonECSTaskExecutionRolePolicyマネージドポリシーをアタッチすることで、これらの権限が付与されます。

ECSクラスタ

resource "aws_ecs_cluster" "main" {
  name = "${var.project_name}-cluster"

ECSサービスを配置するための論理的なグループです。クラスタ自体にはコストは発生せず、その中で実行されるタスク(Fargate)に対して課金されます。

ECSタスク定義

resource "aws_ecs_task_definition" "api" {
  family                   = "${var.project_name}-api"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = "256"
  memory                   = "512"
  execution_role_arn       = aws_iam_role.ecs_task_execution.arn

  container_definitions = jsonencode([{
    name  = "api"
    image = "${var.ecr_repository_url}:${var.container_image_tag}"
    environment = [
      { name = "DB_HOST", value = var.db_host },
      { name = "DB_NAME", value = var.db_name },
      { name = "DB_USER", value = var.db_username },
      { name = "DB_PASSWORD", value = var.db_password },
    ]

Fargateで実行するタスクの設定です。

requires_compatibilitiesは、タスクの起動タイプを指定する設定です。["FARGATE"]を指定することで、サーバレスのFargate起動タイプでタスクを実行します。

network_modeは、タスクのネットワークモードを指定する設定です。Fargateではawsvpcが必須で、各タスクに独自のENI(ネットワークインターフェース)が割り当てられます。

cpuとmemoryは、タスクに割り当てるCPUとメモリのリソース量を指定する設定です。cpu = "256"(0.25 vCPU)、memory = "512"(512 MB)の検証用の最小構成にしています。

container_definitionsでコンテナイメージとポートマッピング、環境変数(データベース接続情報)、ログ設定を定義しています。

ECSサービス

resource "aws_ecs_service" "api" {
  name            = "${var.project_name}-api"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.api.arn
  desired_count   = 1
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = var.private_subnet_ids
    security_groups  = [var.api_security_group_id]
    assign_public_ip = false
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.api.arn
    container_name   = "api"
    container_port   = 8000
  }

ECSクラスタ上でタスクを実行・管理するサービスです。

desired_countは、同時に起動するタスクの数を指定する設定です。1にすることで、検証用の最小構成にしています。本番環境では可用性を高めるために2以上に設定します。

launch_typeは、タスクの起動タイプを指定する設定です。FARGATEにすることで、EC2インスタンスの管理が不要になります。

assign_public_ipは、タスクにパブリックIPアドレスを割り当てるかどうかを制御する設定です。falseにすることで、プライベートサブネットに配置し、NATゲートウェイ経由でインターネットにアクセスします。

load_balancerブロックでALBターゲットグループと連携し、コンテナのポート8000にトラフィックを転送します。

📝 Fargateのネットワーク構成について
Fargateタスクはプライベートサブネットに配置しています。プライベートサブネットからECRへのイメージ取得やCloudWatch Logsへのログ送信にはインターネットアクセスが必要なため、baseモジュールでNATゲートウェイを作成し、プライベートサブネットのルートテーブルでNATゲートウェイを経由するよう設定しています。

1.3 outputs.tf

modules/api/outputs.tfに以下の内容を記述します。

output "cluster_name" {
  description = "ECSクラスタ名"
  value       = aws_ecs_cluster.main.name
}

output "service_name" {
  description = "ECSサービス名"
  value       = aws_ecs_service.api.name
}

output "alb_dns_name" {
  description = "ALBのDNS名"
  value       = aws_lb.api.dns_name
}

次に、environments/test/main.tfにapiモジュールの呼び出しを追加します。baseモジュールの呼び出しの下に以下を追記してください。

# APIモジュール(ECS/Fargate + ALB + ACM + Route53)
module "api" {
  source = "../../modules/api"

  project_name          = local.project_name
  vpc_id                = module.base.vpc_id
  public_subnet_ids     = module.base.public_subnet_ids
  private_subnet_ids    = module.base.private_subnet_ids
  api_security_group_id = module.base.api_security_group_id
  alb_security_group_id = module.base.alb_security_group_id
  ecr_repository_url    = module.base.ecr_repository_url
  db_host               = module.base.rds_endpoint
  db_name               = local.db_name
  db_username           = local.db_username
  db_password           = var.db_password
  log_group_name        = module.base.cloudwatch_log_group_name
  domain_name           = var.domain_name
  route53_zone_id       = module.base.route53_zone_id
}

2. Terraformの再初期化

apiモジュールを追加したため、Terraformを再初期化します。コンテナイメージのPushでapp/api/api/ディレクトリに移動しているため、まずenvironments/test/ディレクトリに戻ります。

cd ../../../environments/test

Terraformを再初期化します。

terraform init

3. 差分の確認

terraform planで差分を確認します。

terraform plan

以下のような実行結果が表示されます。

Terraform will perform the following actions:

  # module.api.aws_acm_certificate.api will be created
  # module.api.aws_acm_certificate_validation.api will be created
  # module.api.aws_route53_record.api will be created
  # module.api.aws_route53_record.api_cert_validation["api.example.com"] will be created
  # module.api.aws_lb.api will be created
  # module.api.aws_ecs_cluster.main will be created
  # module.api.aws_ecs_service.api will be created
  # module.api.aws_ecs_task_definition.api will be created
  # module.api.aws_iam_role.ecs_task_execution will be created
  # module.api.aws_iam_role_policy_attachment.ecs_task_execution will be created
  # module.api.aws_lb_listener.api_https will be created
  # module.api.aws_lb_listener.api_http_redirect will be created
  # module.api.aws_lb_target_group.api will be created

Plan: 13 to add, 0 to change, 0 to destroy.

ACM証明書、DNS検証レコード、証明書検証、ALB、Route53 Aレコード(ALB用)、ECSクラスタ、ECSサービス、タスク定義、タスク実行ロール、ターゲットグループ、HTTPSリスナー、HTTPリダイレクトリスナーの合計13リソースが作成されることを確認してください。

4. AWSへの反映

問題なければterraform applyで反映します。

terraform apply

確認プロンプトが表示されたら、yesと入力して実行します。以下のように、13件のリソースが作成されたことを確認します。

Apply complete! Resources: 13 added, 0 changed, 0 destroyed.
💡 ポイント
ACM証明書のDNS検証には数分かかる場合があります。terraform applyが完了するまでしばらくお待ちください。

5. AWSコンソールでの確認

AWSマネジメントコンソールで以下の内容を確認してください。

ACM(Certificate Manager): ACMのダッシュボードを開き、api.<ドメイン名>の証明書が作成されていることを確認します。

  • ステータス が「発行済み」であること

Route53: Route53のダッシュボードでホストゾーンを開き、以下のレコードが追加されていることを確認します。

  • api.<ドメイン名> のAレコード(ALBへのエイリアス)
  • ACM証明書のDNS検証用のCNAMEレコード

EC2 > ロードバランサー: 「test-noteapp-api-alb」が作成されていることを確認します。

  • タイプ が「application」であること
  • スキーム が「internet-facing」であること

EC2 > ロードバランサー > リスナー: ALBのリスナータブを開き、以下の2つのリスナーが設定されていることを確認します。

  • HTTPS:443 — ターゲットグループ「test-noteapp-api-tg」に転送
  • HTTP:80 — HTTPS(443)にリダイレクト

ECS > クラスタ: 「test-noteapp-cluster」が作成されていることを確認します。

ECS > クラスタ > test-noteapp-cluster > サービス: 「test-noteapp-api」サービスが実行中であることを確認します。

ECS > クラスタ > test-noteapp-cluster > タスク: Fargateタスクが1つ「実行中」であることを確認します。

EC2 > ターゲットグループ: 「test-noteapp-api-tg」が作成されていることを確認します。

  • ターゲットタイプ が「ip」であること
  • ターゲットのヘルスステータスが「healthy」であること

💡 ポイント
ECSサービスがタスクを起動し、ターゲットグループのヘルスチェックがhealthyになるまでに数分かかる場合があります。ステータスが「PROVISIONING」や「unhealthy」の場合は、しばらく待ってから再度確認してください。

これらすべてのリソースがAWSコンソールで確認できれば、apiモジュールのデプロイは完了です。

6. APIの動作確認

フロントエンドの構築に進む前に、APIが正しく動作しているか確認しておきましょう。カスタムドメインを設定したので、api.<ドメイン名>でアクセスできます。

ヘルスチェックエンドポイントにアクセスして、APIが起動していることを確認します。<ドメイン名>の部分はご自身のドメイン名に置き換えてください。

curl https://api.<ドメイン名>/health

以下のようなレスポンスが返れば、APIは正常に動作しています。

{"status":"healthy"}

次に、ノートを作成してデータベースとの接続も確認します。

curl -X POST https://api.<ドメイン名>/notes -H "Content-Type: application/json" -d '{"title":"Test Note","content":"Hello from Terraform!"}'

以下のようなレスポンスが返れば、ECSからRDSへの接続も正常に動作しています。

{"id":1,"title":"Test Note","content":"Hello from Terraform!","created_at":"...","updated_at":"..."}

ノートの一覧を取得して、登録したデータが正しく保存されていることを確認します。

curl https://api.<ドメイン名>/notes

以下のように、先ほど登録したノートが返されれば成功です。

[{"id":1,"title":"Test Note","content":"Hello from Terraform!","created_at":"...","updated_at":"..."}]
⚠️ APIから 5xx やタイムアウトが返る場合
ECSタスクの起動直後は、コンテナがまだ起動中の可能性があります。数分待ってから再度試してください。ALBのターゲットグループで、ターゲットのヘルスチェックが「healthy」になっていることをAWSコンソールで確認することもできます。

APIの動作確認ができたら、次のセクションでフロントエンドの構築に進みます。