Como subir uma aplicação com Terraform com Fargate
Tags: aws, terraform, devops, tutorial
Published: 2023-05-12 02:47:08

A seguir, você encontrará um guia passo a passo de como subir uma aplicação Fargate na AWS com Terraform:

Certifique-se de ter uma conta na AWS e um ambiente de desenvolvimento configurado em sua máquina.

Crie um arquivo de configuração do Terraform chamado "main.tf" e defina suas credenciais da AWS, a região e o provedor que você está usando:

```terraform
provider "aws" {
  access_key = "SUA_ACCESS_KEY"
  secret_key = "SUA_SECRET_KEY"
  region     = "US-WEST-2"
}
```
Defina uma VPC (Virtual Private Cloud) onde sua aplicação será executada:

```terraform
resource "aws_vpc" "my_vpc" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name = "My VPC"
  }
}
```
Em seguida, crie um sub-rede dentro da VPC:

```terraform
resource "aws_subnet" "my_subnet" {
  vpc_id     = aws_vpc.my_vpc.id
  cidr_block = "10.0.1.0/24"
  tags = {
    Name = "My Subnet"
  }
}
```
Defina uma regra de segurança para a aplicação:

```terraform
resource "aws_security_group" "my_security_group" {
  name_prefix = "my-security-group"
  vpc_id      = aws_vpc.my_vpc.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}
```
Crie um cluster ECS (Elastic Container Service) para a aplicação:

```terraform
resource "aws_ecs_cluster" "my_cluster" {
  name = "My Cluster"
}
```
Em seguida, crie uma definição de tarefa ECS que será usada para executar sua aplicação:

```terraform
data "template_file" "my_task_definition" {
  template = file("${path.module}/task_definition.json")

  vars = {
    image_name = "my-image-name"
    port       = "80"
  }
}

resource "aws_ecs_task_definition" "my_task_definition" {
  family                   = "my-task-definition"
  container_definitions    = data.template_file.my_task_definition.rendered
  requires_compatibilities = ["FARGATE"]
}
```
Crie um serviço ECS que irá executar a tarefa:

```terraform
resource "aws_ecs_service" "my_service" {
  name            = "My Service"
  cluster         = aws_ecs_cluster.my_cluster.arn
  task_definition = aws_ecs_task_definition.my_task_definition.arn
  desired_count   = 1
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = [aws_subnet.my_subnet.id]
    security_groups  = [aws_security_group.my_security_group.id]
    assign_public_ip = true
  }
}
```

## Dicas
Ao iniciar instâncias Fargate elas não podem ter o mesmo numero de cpu e memória idênticos abaixo segue uma tabela de como definir cpu e memória 

| CPU value | Memory value | Operating systems supported for AWS Fargate |
|--- |------ |------ |
| 256 (.25 vCPU) | 512 MiB, 1 GB, 2 GB | Linux |
| 512 (.5 vCPU) | 1 GB, 2 GB, 3 GB, 4 GB | Linux|
| 1024 (1 vCPU) | 2 GB, 3 GB, 4 GB, 5 GB, 6 GB, 7 GB, 8 GB | Linux, Windows|
| 2048 (2 vCPU) | Between 4 GB and 16 GB in 1 GB increments | Linux, Windows|
| 4096 (4 vCPU)| Between 8 GB and 30 GB in 1 GB increments | Linux, Windows|
| 8192 (8 vCPU) | Between 16 GB and 60 GB in 4 GB increments| Linux|
| 16384 (16vCPU)| Between 32 GB and 120 GB in 8 GB increments| Linux|


Por fim, execute o comando "terraform init" para inicializar o projeto e "terraform apply" para criar a infraestrutura na AWS.
Este é um exemplo simples de como subir uma aplicação Fargate na AWS usando Terraform. Você pode personalizar e ajustar os recursos conforme necessário para atender às necessidades do seu aplicativo.