[Terraform]ECS FargateでFireLensを使って複数サービスにログ出力する

Terraformで使用するプロバイダー及びリージョンを指定します。

provider "aws" {
  ##東京リージョン
  region  = "ap-northeast-1"
}

Terraform本体のバージョンを固定します。

terraform {
  ## バージョンを固定
  required_version = "1.0.7"
}

Terraform RegistryのModuleを使用してVPCを作成します。今回の検証ではALBとECSを同じサブネットに作成します。

# Terraform Registry
# AWS VPC Terraform module
module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "3.10.0"

  name = "my-vpc"
  cidr                 = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  azs             = ["ap-northeast-1a", "ap-northeast-1c"]
  public_subnets  = ["10.0.11.0/24", "10.0.12.0/24"]

  #デフォルトセキュリティグループのルール削除
  manage_default_security_group  = true
  default_security_group_ingress = []
  default_security_group_egress  = []
}

インターネットからのHTTP通信をECSに振り分けるロードバランサーを作成します。

resource "aws_lb" "alb" {
  name               = "inomaso-dev-alb"
  load_balancer_type = "application"
  internal           = false
  idle_timeout       = 60
  # ALB削除保護無効
  # 本番はtrue推奨
  enable_deletion_protection = false
  security_groups            = [aws_security_group.alb.id]
  subnets                    = module.vpc.public_subnets
}

resource "aws_alb_listener" "alb_http" {
  load_balancer_arn = aws_lb.alb.arn
  port              = "80"
  protocol          = "HTTP"
  default_action {
    target_group_arn = aws_lb_target_group.alb_tg.arn
    type             = "forward"
  }
}

resource "aws_lb_target_group" "alb_tg" {
  name        = "inomaso-dev-alb-tg"
  port        = 80
  protocol    = "HTTP"
  vpc_id      = module.vpc.vpc_id
  target_type = "ip"

  health_check {
    path                = "/"
    port                = "traffic-port"
    protocol            = "HTTP"
    timeout             = 5
    interval            = 10
    healthy_threshold   = 2
    unhealthy_threshold = 2
    matcher             = 200
  }
}

ALB用のセキュリティグループを作成します。インターネットからのHTTP通信を全許可しています。

resource "aws_security_group" "alb" {
  name        = "inomaso-dev-alb-sg"
  description = "inomaso-dev-alb-sg"
  vpc_id      = module.vpc.vpc_id
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "inomaso-dev-alb-sg"
  }
}

Terraformのtfstateファイルから、ALBのDNS名をコンソールに出力します。

output "alb_dns_name" {
  description = "ALB DNS Name"
  value       = aws_lb.alb.dns_name
}

Fluent Bitのカスタム設定ファイルをイメージ内にコピーしています。2021/11/6時点でFargateでホストする場合はカスタム設定ファイルをS3から取得できないので、イメージ作成時に対応する必要があります。

FROM amazon/aws-for-fluent-bit:latest
COPY fluentbit/extra.conf /fluent-bit/etc/extra.conf

Fluent Bitのカスタム設定ファイルで、httpdログの保存先を指定しています。CloudWatch Logsは auto_create_group を true にすることで、コンテナデプロイ時にロググループを作成することができます。

一点注意なのが、この方法でロググループを作成した場合は、Terraformのtfstateファイルの管理対象外となるため、terraform destroyしてもリソースは残り続けます。

[OUTPUT]
    Name   cloudwatch_logs
    Match  *
    region ap-northeast-1
    log_group_name /ecs/firelens/httpd
    log_stream_prefix from-
    auto_create_group true
    log_retention_days 90

[OUTPUT]
    Name   kinesis_firehose
    Match  *
    region ap-northeast-1
    delivery_stream inomaso-dev-kinesis-firehose

ECRを作成し、Fluent Bitのコンテナイメージをプッシュします。

resource "aws_ecr_repository" "fluentbit" {
  name = "inomaso-dev-ecr-fluentbit"
  ## 同じタグを使用した後続イメージのプッシュによるイメージタグの上書き許可
  image_tag_mutability = "MUTABLE"

  ## プッシュ時のイメージスキャン
  image_scanning_configuration {
    scan_on_push = true
  }
}

# AWSアカウント情報取得
data "aws_caller_identity" "my" {}

# terraform apply時にFluent Bitのコンテナイメージプッシュ
resource "null_resource" "fluentbit" {
  ## 認証トークンを取得し、レジストリに対して Docker クライアントを認証
  provisioner "local-exec" {
    command = "aws ecr get-login-password --region ap-northeast-1 | docker login --username AWS --password-stdin ${data.aws_caller_identity.my.account_id}.dkr.ecr.ap-northeast-1.amazonaws.com"
  }

  ## Dockerイメージ作成
  provisioner "local-exec" {
    command = "docker build -f fluentbit/Dockerfile -t inomaso-dev-fluentbit ."
  }

  ## ECRリポジトリにイメージをプッシュできるように、イメージにタグ付け
  provisioner "local-exec" {
    command = "docker tag inomaso-dev-fluentbit:latest ${aws_ecr_repository.fluentbit.repository_url}:latest"
  }

  ## ECRリポジトリにイメージをプッシュ
  provisioner "local-exec" {
    command = "docker push ${aws_ecr_repository.fluentbit.repository_url}:latest"
  }
}

ECS Fargateを作成します。各コードの補足はコード内のコメントに記載しました。

# タスク定義
resource "aws_ecs_task_definition" "task" {
  depends_on = [null_resource.fluentbit]

  family             = "httpd-task"
  task_role_arn      = aws_iam_role.ecs_task.arn
  execution_role_arn = aws_iam_role.ecs_task_exec.arn
  #0.25vCPU
  cpu = "256"
  #0.5GB
  memory                   = "512"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  ## templatefile関数でFluent BitのイメージがプッシュされたECRリポジトリURLを、imageurl変数で引き渡し
  container_definitions = templatefile("httpd/container_definitions.json", {
    imageurl = "${aws_ecr_repository.fluentbit.repository_url}:latest"
  })
}

# クラスター
resource "aws_ecs_cluster" "cluster" {
  name = "httpd-cluster"
}

# サービス
resource "aws_ecs_service" "service" {
  #depends_on = [aws_cloudwatch_log_group.firelens]

  name             = "httpd-service"
  cluster          = aws_ecs_cluster.cluster.arn
  task_definition  = aws_ecs_task_definition.task.arn
  desired_count    = 2
  launch_type      = "FARGATE"
  platform_version = "1.4.0"
  
  health_check_grace_period_seconds = 60

  network_configuration {
    assign_public_ip = true
    security_groups  = [aws_security_group.ecs.id]
    subnets = module.vpc.public_subnets
  }

  ## ALBのターゲットグループに登録する、コンテナ定義のnameとportMappings.containerPortを指定
  load_balancer {
    target_group_arn = aws_lb_target_group.alb_tg.arn
    container_name   = "httpd"
    container_port   = 80
  }

  ## デプロイ毎にタスク定義が更新されるため、リソース初回作成時を除き変更を無視
  lifecycle {
    ignore_changes = [task_definition]
  }
}

Apache httpdとFirelensのコンテナ定義です。Firelensの設定ファイルは、Fluent Bitのイメージ作成時に使用した /fluent-bit/etc/extra.conf を指定しています。

[
  {
    "essential": true,
    "name": "httpd",
    "image": "httpd:latest",
    "portMappings": [
      {
        "protocol": "tcp",
        "containerPort": 80
      }
    ],
    "memoryReservation": 100,
    "logConfiguration": {
      "logDriver": "awsfirelens"
    }
  },
  {
    "essential": true,
    "name": "log_router",
    "image": "${imageurl}",
    "memoryReservation": 50,
    "logConfiguration": {
      "logDriver": "awslogs",
      "options": {
        "awslogs-group": "/ecs/firelens",
        "awslogs-region": "ap-northeast-1",
        "awslogs-stream-prefix": "httpd-sidecar"
      }
    },
    "firelensConfiguration": {
      "type": "fluentbit",
      "options": {
        "config-file-type": "file",
        "config-file-value": "/fluent-bit/etc/extra.conf"
      }
    }
  }
]

ECSサービス用のセキュリティグループを作成します。ALBからのHTTP通信のみ許可しています。

resource "aws_security_group" "ecs" {
  name        = "inomaso-dev-ecs-sg"
  description = "inomaso-dev-ecs-sg"
  vpc_id      = module.vpc.vpc_id
  ingress {
    from_port       = 80
    to_port         = 80
    protocol        = "tcp"
    security_groups = [aws_security_group.alb.id]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "inomaso-dev-ecs-sg"
  }
}

ECSタスクロールとECSタスク実行ロールを作成します。ECSタスクロールの権限は最低限の Actions のみ許可しています。ただCloudWatchLogsのロググループを自由に作成できるように Resouces は特に制限していません。

# ECSタスクロール作成
resource "aws_iam_role" "ecs_task" {
  name               = "inomaso-dev-ecs-task-role"
  assume_role_policy = data.aws_iam_policy_document.ecs_task_assume.json
}

# ECSタスクロールを引き受けるための信頼関係を設定
data "aws_iam_policy_document" "ecs_task_assume" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["ecs-tasks.amazonaws.com"]
    }
  }
}

# ECSタスクロール用のIAMポリシーを作成し、IAMロールにアタッチ
resource "aws_iam_role_policy" "ecs_task" {
  name   = "inomaso-dev-ecs-task-role-policy"
  role   = aws_iam_role.ecs_task.id
  policy = data.aws_iam_policy_document.ecs_task_access.json
}

# ECSタスクロール用のIAMポリシーJSON
data "aws_iam_policy_document" "ecs_task_access" {
  version = "2012-10-17"

  statement {
    sid = "CloudWatchLogsAccess"

    effect = "Allow"
    actions = [
      "logs:CreateLogStream",
      "logs:CreateLogGroup",
      "logs:DescribeLogStreams",
      "logs:PutLogEvents",
      "logs:PutRetentionPolicy"
    ]
    resources = [
      "*"
    ]
  }
  statement {
    sid = "FirehoseAccess"

    effect = "Allow"
    actions = [
      "firehose:PutRecordBatch"
    ]
    resources = [
      "${aws_kinesis_firehose_delivery_stream.firelens.arn}"
    ]
  }
}

# ECSタスク実行ロール作成
resource "aws_iam_role" "ecs_task_exec" {
  name               = "inomaso-dev-ecs-task-exec-role"
  assume_role_policy = data.aws_iam_policy_document.ecs_task_exec_assume.json
}

# ECSタスク実行ロールを引き受けるための信頼関係を設定
data "aws_iam_policy_document" "ecs_task_exec_assume" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["ecs-tasks.amazonaws.com"]
    }
  }
}

# ECSタスク実行ロールに既存IAMポリシーをアタッチ
resource "aws_iam_role_policy_attachment" "ecs_task_exec" {
  role       = aws_iam_role.ecs_task_exec.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
}

FireLens用のKinesis Data Firehoseを作成します。エラーログ記録の有効化は cloudwatch_logging_options で設定しますが、ロググループとログストリームは自動で作成されないため、事前に作成する必要があります。

resource "aws_kinesis_firehose_delivery_stream" "firelens" {
  name        = "inomaso-dev-kinesis-firehose"
  destination = "s3"

  s3_configuration {
    role_arn           = aws_iam_role.firehose.arn
    bucket_arn         = aws_s3_bucket.firelens.arn
    buffer_size        = 1
    buffer_interval    = 60
    compression_format = "GZIP"

    cloudwatch_logging_options {
      enabled         = "true"
      log_group_name  = aws_cloudwatch_log_group.firelens.name
      log_stream_name = "kinesis_error"
    }
  }
}

Kinesis Data Firehoseから、S3バケットとCloudWatch Logsへの配信するためのIAMロールを作成します。IAMロールの権限は最低限の Actions のみ許可しています。また特定のS3バケットとCloudWatch Logsにのみ Actions を許可るすため Resources も制限しています。

# firehose用IAMロール作成
resource "aws_iam_role" "firehose" {
  name               = "inomaso-dev-firehose-role"
  assume_role_policy = data.aws_iam_policy_document.firehose_assume.json
}

# firehose用IAMロールを引き受けるための信頼関係を設定
data "aws_iam_policy_document" "firehose_assume" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
    principals {
      type        = "Service"
      identifiers = ["firehose.amazonaws.com"]
    }
  }
}

# firehose用IAMロール用のIAMポリシーを作成し、IAMロールにアタッチ
resource "aws_iam_role_policy" "firehose" {
  name   = "inomaso-dev-firehose-role-policy"
  role   = aws_iam_role.firehose.id
  policy = data.aws_iam_policy_document.firehose_access.json
}

# firehose用IAMロールのIAMポリシーJSON
data "aws_iam_policy_document" "firehose_access" {
  version = "2012-10-17"

  statement {
    sid = "S3Access"

    effect = "Allow"
    actions = [
      "s3:AbortMultipartUpload",
      "s3:GetBucketLocation",
      "s3:GetObject",
      "s3:ListBucket",
      "s3:ListBucketMultipartUploads",
      "s3:PutObject"
    ]
    resources = [
      "arn:aws:s3:::${aws_s3_bucket.firelens.bucket}",
      "arn:aws:s3:::${aws_s3_bucket.firelens.bucket}/*",
    ]
  }
  statement {
    sid = "CloudWatchLogsDeliveryErrorLogging"

    effect = "Allow"
    actions = [
      "logs:PutLogEvents"
    ]
    resources = [
      "${aws_cloudwatch_log_group.firelens.arn}:log-stream:*"
    ]
  }
}

FireLensとKinesis Data Firehoseの障害切り分け用のロググループを作成します。また、Kinesis Data Firehose用のログストリームは事前に作成する必要があるので、注意が必要です。

resource "aws_cloudwatch_log_group" "firelens" {
  name = "/ecs/firelens"
  #retention_in_days = 90
}

resource "aws_cloudwatch_log_stream" "kinesis" {
  name           = "kinesis_error"
  log_group_name = aws_cloudwatch_log_group.firelens.name
}

Kinesis Data Firehoseから配信するためのS3バケットを作成します。

resource "aws_s3_bucket" "firelens" {
  ## bucketを指定しないと[terraform-xxxx]というバケット名になる
  bucket = "inomaso-dev-firelens"
  acl    = "private"

  ## S3バケットにオブジェクトがあっても削除
  ## 本番はfalse推奨
  force_destroy = true
  ## SSE-S3で暗号化
  server_side_encryption_configuration {
    rule {
      apply_server_side_encryption_by_default {
        sse_algorithm = "AES256"
      }
    }
  }

  lifecycle_rule {
    id      = "Delete-After-90days"
    enabled = true

    expiration {
      days = 90
    }
  }
}

resource "aws_s3_bucket_public_access_block" "firelens" {
  bucket = aws_s3_bucket.firelens.id

  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}