Primeiros passos no Terraform

“Hello World” Terraform + AWS

O nosso Hello world com Terraforma + AWS vai ser uma infraestrutura básica com um servidor Apache com uma página simples em html.

Vamos criar uma infraestrutura básica na AWS usando Terraform, incluindo:

• Uma VPC (Virtual Private Cloud)
• Uma subnet pública
• Um Internet Gateway
• Uma tabela de rotas
• Um grupo de segurança
• Uma instância EC2 com servidor web

Pré-requisitos

1. Conta AWS: Você precisa de uma conta AWS com permissões para criar recursos.
2. AWS CLI instalada e configurada: Execute aws configure para configurar suas credenciais.
3. Terraform instalado: Baixe em terraform.io.
4. Editor de códigos: No caso estou usando o VS Code.

Instale no VS Code a extesão Terraform que vai ajudar em alguns momentos com sugestões.

Caso queira criar um usuário somente com as permissões necessárias para este laboratório crie uma conta com as políticas a seguir:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                // Ações genéricas de descrição (somente leitura)
                "ec2:Describe*",

                // Gerenciamento completo de VPCs (criação, exclusão e tagging)
                "ec2:CreateVpc",
                "ec2:DeleteVpc",
                "ec2:CreateTags",

                // Gerenciamento de subnets (criação e exclusão)
                "ec2:CreateSubnet",
                "ec2:DeleteSubnet",

                // Gerenciamento completo de Security Groups (criação, exclusão e regras)
                "ec2:CreateSecurityGroup",
                "ec2:DeleteSecurityGroup",
                "ec2:DescribeSecurityGroups",
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:AuthorizeSecurityGroupEgress",
                "ec2:RevokeSecurityGroupEgress",

                // Gerenciamento de Internet Gateways (ciclo completo)
                "ec2:CreateInternetGateway",
                "ec2:DeleteInternetGateway",
                "ec2:AttachInternetGateway",
                "ec2:DetachInternetGateway",

                // Gerenciamento de Route Tables e rotas
                "ec2:CreateRouteTable",
                "ec2:DeleteRouteTable",
                "ec2:CreateRoute",
                "ec2:AssociateRouteTable",
                "ec2:DisassociateRouteTable",

                // Gerenciamento de Elastic IPs (alocação e associação)
                "ec2:AllocateAddress",
                "ec2:AssociateAddress",

                // Gerenciamento de instâncias EC2 (inicialização e término)
                "ec2:RunInstances",
                "ec2:TerminateInstances"
            ],
            "Resource": "*"
        }
    ]
}

Passo 1: Configuração Inicial

Crie um arquivo chamado main.tf e cole o código fornecido abaixo. Vamos analisar cada seção, e todos os códigos informados ficaram dentro desse arquivo.

Passo 2: Entendendo o Código

1. Configuração do Provider AWS

provider "aws" {
  region = "us-east-1" # Escolha sua região preferida
}

• provider "aws": Define que estamos usando o provedor AWS.
• region: Especifica a região AWS onde os recursos serão criados.

2. Criação da VPC

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  
  tags = {
    Name = "Tutorial-VPC"
  }
}

• aws_vpc: Recurso que cria uma VPC.
• cidr_block: Define o bloco IP para a VPC (10.0.0.0/16 permite 65.536 endereços IP).
• tags: Metadados para identificar o recurso.

3. Criação da Subnet Pública

resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "us-east-1a"
  
  tags = {
    Name = "Public-Subnet-Tutorial"
  }
}

• aws_subnet: Cria uma subnet dentro da VPC.
• vpc_id: Referencia a VPC criada anteriormente.
• cidr_block: Define um bloco IP menor (/24 = 256 endereços) dentro da VPC.
• availability_zone: Define em qual zona de disponibilidade a subnet será criada.

4. Criação do Internet Gateway

resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id
  
  tags = {
    Name = "Tutorial-IGW"   
  }
}

• aws_internet_gateway: Cria um gateway para acesso à internet.
• vpc_id: Associa o gateway à VPC criada.

5. Criação da Tabela de Rotas

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.gw.id
  }
  
  tags = {
    Name = "Public-Route-Table"
  }
}

• aws_route_table: Cria uma tabela de rotas.
• route: Define uma rota padrão (0.0.0.0/0) para o Internet Gateway.

6. Associação da Tabela de Rotas

resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

• aws_route_table_association: Associa a tabela de rotas à subnet pública.

7. Criação do Grupo de Segurança

resource "aws_security_group" "web" {
  name        = "web-sg"
  description = "Allow HTTP traffic"
  vpc_id      = aws_vpc.main.id

  ingress {
    description = "HTTP from anywhere"
    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 = "Web-Security-Group"
  }
}

• aws_security_group: Cria um firewall virtual.
• ingress: Regra de entrada permitindo tráfego HTTP (porta 80).
• egress: Regra de saída permitindo todo tráfego.

8. Criação da Instância EC2

resource "aws_instance" "web_server" {
  ami           = "ami-085386e29e44dacd7" # Amazon Linux 2 (us-east-1)
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]
  associate_public_ip_address = true
  
  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<html><body><h1>Hello World from Terraform!</h1></body></html>" > /var/www/html/index.html
              EOF

  tags = {
    Name = "Web-Server-Tutorial"
  }
}

• aws_instance: Cria uma instância EC2.
• ami: ID da imagem da máquina (Amazon Linux 2 na us-east-1).
• instance_type: Tipo da instância (t2.micro é elegível para o free tier).
• subnet_id: Define em qual subnet a instância será criada.
• vpc_security_group_ids: Associa o grupo de segurança criado.
• associate_public_ip_address: Atribui um IP público automaticamente.
• user_data: Script executado no primeiro boot para instalar e configurar o Apache.

9. Saída do IP Público

output "public_ip" {
  value = aws_instance.web_server.public_ip
}

• output: Exibe o IP público da instância após a implantação.

10. Verificação do configuração

Validar configuração: terraform validate
O comando vai verificar se toda a configuração feita no arquivo esta ok.

Passo 3: Inicialização e Aplicação

1. Inicialize o Terraform: terraform init
   Isso baixará o provedor AWS necessário.
2. Verifique o plano de execução: terraform plan
   Revise quais recursos serão criados.
3. Aplique a configuração: terraform apply
   Digite yes quando solicitado para confirmar.

Passo 4: Teste a Implantação

1. Após a conclusão, o Terraform exibirá o IP público da instância.
2. Abra um navegador e acesse http://<IP_PUBLICO>.
3. Você deve ver a mensagem “Hello World from Terraform!”.

Passo 5: Limpeza dos Recursos

Para evitar custos desnecessários, destrua os recursos quando não precisar mais deles:

terraform destroy

Digite yes quando solicitado para confirmar.

Abaixo o nosso código completo:

provider "aws" {
  region = "us-east-1" # Escolha sua região preferida
}

#Criação de um VPC
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  
  tags = {
    Name = "Tutorial-VPC"
  }
}


#Criação de uma Subnet pública
#A subnet pública é uma sub-rede que pode se comunicar com a Internet
resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "us-east-1a" # Altere conforme sua região
  
  tags = {
    Name = "Public-Subnet-Tutorial"
  }
}

#Criação de uma Internet Gateway
#A Internet Gateway é um ponto de acesso à Internet para a VPC
resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id
  
  tags = {
    Name = "Tutorial-IGW"   
  }
}

#Criação de uma Route Table
#A tabela de rotas é usada para direcionar o tráfego da subnet pública para a Internet Gateway
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.gw.id
  }
  
  tags = {
    Name = "Public-Route-Table"
  }
}

#Associa a tabela de rotas à subnet pública
resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}


#Criação de um Security Group
#O Security Group é um firewall virtual que controla o tráfego de entrada e saída da instância EC2
resource "aws_security_group" "web" {
  name        = "web-sg"
  description = "Allow HTTP traffic"
  vpc_id      = aws_vpc.main.id

  ingress {
    description = "HTTP from anywhere"
    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 = "Web-Security-Group"
  }
}


#Criação de uma instância EC2
#A instância EC2 é uma máquina virtual na nuvem da AWS
resource "aws_instance" "web_server" {
  ami           = "ami-085386e29e44dacd7" # Amazon Linux 2 (us-east-1)
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]
  associate_public_ip_address = true
  
  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<html><body><h1>Hello World from Terraform!</h1></body></html>" > /var/www/html/index.html
              EOF

  tags = {
    Name = "Web-Server-Tutorial"
  }
}

#Saída do IP público da instância EC2
output "public_ip" {
  value = aws_instance.web_server.public_ip
}

Conclusão

Neste tutorial, você aprendeu a:

• Criar uma VPC e subnets
• Configurar um Internet Gateway e tabelas de rotas
• Definir grupos de segurança
• Implantar uma instância EC2 com configuração automática
• Gerenciar o ciclo de vida da infraestrutura com Terraform

Este é um exemplo básico que pode ser expandido com mais recursos.
A nossa página em html é bem simples, você pode alterar a parte do User Data para baixar uma página mais elaborada direto do github ou qualquer outro local.

Vale também lembrar que o nosso código esta todo dentro do arquivo main.tf, o ideal seria usar modulos, mas isso será um assunto para outro tutorial.