ECS를 사용해서 어플리케이션 서비스 하기

// echo.js
const http = require('http');
const server = http.createServer((req, res) => {
  req.pipe(res);
});
server.listen(3000);

FROM node:16
WORKDIR /opt/app
COPY echo.js .
EXPOSE 3000
CMD ["node", "echo.js"]

$ docker build . -t simon-sample

$ docker run -p 3000 -d simon-sample

$ curl http://localhost:3000 --data 'hello world'    
hello world

provider "aws" {
  region = "ap-northeast-2"
}

locals {
  vpc_name        = "simon-test"
  cidr            = "10.194.0.0/16"
  public_subnets  = ["10.194.0.0/24", "10.194.1.0/24"]
  private_subnets = ["10.194.100.0/24", "10.194.101.0/24"]
  azs             = ["ap-northeast-2a", "ap-northeast-2c"]
}

## VPC를 생성합니다
resource "aws_vpc" "this" {
  cidr_block = local.cidr
  tags       = { Name = local.vpc_name }
}

## VPC 생성시 기본으로 생성되는 라우트 테이블에 이름을 붙입니다
## 이걸 서브넷에 연결해 써도 되지만, 여기서는 사용하지 않습니다
resource "aws_default_route_table" "this" {
  default_route_table_id = aws_vpc.this.default_route_table_id
  tags                   = { Name = "${local.vpc_name}-default" }
}

## VPC 생성시 기본으로 생성되는 보안 그룹에 이름을 붙입니다
resource "aws_default_security_group" "this" {
  vpc_id = aws_vpc.this.id
  tags   = { Name = "${local.vpc_name}-default" }
}

## 퍼플릭 서브넷에 연결할 인터넷 게이트웨이를 정의합니다
resource "aws_internet_gateway" "this" {
  vpc_id = aws_vpc.this.id
  tags   = { Name = "${local.vpc_name}-igw" }
}

## 퍼플릭 서브넷에 적용할 라우팅 테이블
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.this.id
  tags   = { Name = "${local.vpc_name}-public" }
}

## 퍼플릭 서브넷에서 인터넷에 트래픽 요청시 앞서 정의한 인터넷 게이트웨이로 보냅니다
resource "aws_route" "public_worldwide" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.this.id
}

## 퍼플릭 서브넷을 정의합니다
resource "aws_subnet" "public" {
  count = length(local.public_subnets) # 여러개를 정의합니다

  vpc_id                  = aws_vpc.this.id
  cidr_block              = local.public_subnets[count.index]
  availability_zone       = local.azs[count.index]
  map_public_ip_on_launch = true # 퍼플릭 서브넷에 배치되는 서비스는 자동으로 공개 IP를 부여합니다
  tags                    = { Name = "${local.vpc_name}-public-${count.index + 1}" }
}

## 퍼플릭 서브넷을 라우팅 테이블에 연결합니다
resource "aws_route_table_association" "public" {
  count = length(local.public_subnets)

  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

## NAT 게이트웨이는 고정 IP를 필요로 합니다
resource "aws_eip" "nat_gateway" {
  vpc  = true
  tags = { Name = "${local.vpc_name}-natgw" }
}

## 프라이빗 서브넷에서 인터넷 접속시 사용할 NAT 게이트웨이
resource "aws_nat_gateway" "this" {
  allocation_id = aws_eip.nat_gateway.id
  subnet_id     = aws_subnet.public[0].id # NAT 게이트웨이 자체는 퍼플릭 서브넷에 위치해야 합니다
  tags          = { Name = "${local.vpc_name}-natgw" }
}

## 프라이빗 서브넷에 적용할 라우팅 테이블
resource "aws_route_table" "private" {
  vpc_id = aws_vpc.this.id
  tags   = { Name = "${local.vpc_name}-private" }
}

## 프라이빗 서브넷에서 인터넷에 트래픽 요청시 앞서 정의한 NAT 게이트웨이로 보냅니다
resource "aws_route" "private_worldwide" {
  route_table_id         = aws_route_table.private.id
  destination_cidr_block = "0.0.0.0/0"
  nat_gateway_id         = aws_nat_gateway.this.id
}

## 프라이빗 서브넷을 정의합니다
resource "aws_subnet" "private" {
  count = length(local.private_subnets) # 여러개를 정의합니다

  vpc_id            = aws_vpc.this.id
  cidr_block        = local.private_subnets[count.index]
  availability_zone = local.azs[count.index]
  tags              = { Name = "${local.vpc_name}-private-${count.index + 1}" }
}

## 프라이빗 서브넷을 라우팅 테이블에 연결합니다
resource "aws_route_table_association" "private" {
  count = length(local.private_subnets)

  subnet_id      = aws_subnet.private[count.index].id
  route_table_id = aws_route_table.private.id
}

## ECS 클러스터를 생성합니다
resource "aws_ecs_cluster" "this" {
  name = "simon-test"
}

locals {
  app_name = "simon-sample"
}

## simon-sample 앱을 위한 저장소를 만듭니다
resource "aws_ecr_repository" "simon_sample" {
  name = local.app_name
}

## ECR 저장소에 로그인합니다
$ aws ecr get-login-password --region ap-northeast-2 | docker login --username AWS --password-stdin <aws-account-id>.dkr.ecr.ap-northeast-2.amazonaws.com
## 앞서 만든 이미지에 ECR 이름을 붙여줍니다
$ docker tag simon-sample:latest <aws-account-id>.dkr.ecr.ap-northeast-2.amazonaws.com/simon-sample:latest
## 이미지를 올립니다
$ docker push <aws-account-id>.dkr.ecr.ap-northeast-2.amazonaws.com/simon-sample:latest

## 태스크 정의시 AmazonECSTaskExecutionRolePolicy 정책을 포함한
## IAM 역할을 실행 역할(execution role)로 설정해줘야 합니다
resource "aws_iam_role" "execution" {
  name = "${local.app_name}-exec-role"
  assume_role_policy = jsonencode({
    Version = "2012-10-17",
    Statement = [{
      Action = "sts:AssumeRole",
      Principal = {
        Service = "ecs-tasks.amazonaws.com"
      },
      Effect = "Allow",
    }]
  })
}

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

## ECS 위에서 띄울 태스크에 대한 정의입니다
resource "aws_ecs_task_definition" "this" {
  family                   = local.app_name
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = 256 # CPU, 메모리는 가장 작은 값을 사용합니다
  memory                   = 512
  execution_role_arn       = aws_iam_role.execution.arn
  container_definitions = jsonencode([{
    name  = "app"
    image = "${aws_ecr_repository.simon_sample.repository_url}:latest", # ECR에 올라온 이미지를 사용합니다
    cpu   = 0
    portMappings = [{ # 3000번 포트를 외부에 엽니다
      hostPort      = 3000
      protocol      = "tcp"
      containerPort = 3000
    }]
  }])
}

## ECR에서 데이터를 가져오려면 태스크에 인터넷에 접근할 수 있는 권한을 주어야 합니다
resource "aws_security_group" "this" {
  name   = "${local.app_name}-sg"
  vpc_id = aws_vpc.this.id
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

## ECS 서비스를 정의합니다
resource "aws_ecs_service" "this" {
  desired_count   = 1 # 태스크를 하나만 띄웁니다
  name            = local.app_name
  cluster         = aws_ecs_cluster.this.arn
  task_definition = aws_ecs_task_definition.this.arn
  launch_type     = "FARGATE"
  network_configuration {
    subnets         = aws_subnet.private[*].id # 프라이빗 서브넷에 배치합니다
    security_groups = [aws_security_group.this.id]
  }
}

locals {
  lb_name = "simon-test-lb"
}

## 외부에 80번 포트를 여는 보안 그룹을 생성합니다
resource "aws_security_group" "lb" {
  name   = "${local.lb_name}-sg"
  vpc_id = aws_vpc.this.id
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

## HTTP 요청을 분산하는 어플리케이션 로드 밸런서를 정의합니다
resource "aws_lb" "this" {
  name               = local.lb_name
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.lb.id]
  subnets            = aws_subnet.public[*].id # 퍼블릭 서브넷에 배치합니다
}

## 로드 밸런서로 온 요청을 받아 처리할 목표 그룹을 정의합니다
resource "aws_lb_target_group" "this" {
  name        = local.app_name
  port        = 3000 # 우리가 만든 컨테이너는 3000번 포트에서 입력을 받습니다
  protocol    = "HTTP"
  target_type = "ip"
  vpc_id      = aws_vpc.this.id
}

## HTTP(80)에 대한 리스너를 생성합니다.
resource "aws_lb_listener" "http" {
  load_balancer_arn = aws_lb.this.arn
  port              = "80"
  protocol          = "HTTP"
  # 앞서 정의한 타겟 그룹으로 모든 트래픽을 보냅니다
  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.this.arn
  }
}

## ECS는 로드 밸런서에서 3000번 포트로 온 요청을 받을 수 있습니다.
resource "aws_security_group_rule" "ecs_from_lb" {
  security_group_id        = aws_security_group.this.id
  type                     = "ingress"
  from_port                = 3000
  to_port                  = 3000
  protocol                 = "tcp"
  source_security_group_id = aws_security_group.lb.id
}

## 로드 밸런서에서 ECS의 3000번 포트로 요청을 보낼 수 있습니다.
resource "aws_security_group_rule" "lb_to_ecs" {
  security_group_id        = aws_security_group.lb.id
  type                     = "egress"
  from_port                = 3000
  to_port                  = 3000
  protocol                 = "tcp"
  source_security_group_id = aws_security_group.this.id
}

resource "aws_ecs_service" "this" {
  desired_count   = 1
  name            = local.app_name
  cluster         = aws_ecs_cluster.this.arn
  task_definition = aws_ecs_task_definition.this.arn
  launch_type     = "FARGATE"
  network_configuration {
    subnets         = aws_subnet.private[*].id
    security_groups = [aws_security_group.this.id]
  }
  # 다음을 추가합니다.
  load_balancer {
    target_group_arn = aws_lb_target_group.this.arn
    container_name   = "app"
    container_port   = 3000
  }
}

$ curl simon-test-lb-135798642.ap-northeast-2.elb.amazonaws.com --data 'hello world'
hello world