3 de junho de 2025 Emerson Silva 86 Views

Gitlab CI + Terraform – Deploy de uma EC2

Olá pessoal!!!

Tudo bem com vocês? Espero que sim!

Hoje no nosso blog da 4Linux vamos falar de como desenvolver uma pipeline para criar uma EC2 na AWS usando o Gitlab CI e armazenando o tf state no próprio GitLab. Bora lá?

O que é o Terraform

O Terraform é uma ferramenta open-source desenvolvida pela HashiCorp que permite o gerenciamento de infraestrutura como código (Infrastructure as Code – IaC). Com o Terraform, você pode definir, provisionar e gerenciar recursos de infraestrutura em diversos provedores (como AWS, Azure, Google Cloud, entre outros) de maneira declarativa.

Por que usar o Terraform?

Portabilidade: Suporte a múltiplos provedores, como AWS, Azure, GCP, Kubernetes, etc.

Controle de versões: Como o código está em arquivos.tf, é fácil versionar a infraestrutura com Git.

Infraestrutura declarativa: Você descreve o estado desejado, e o Terraform faz o resto.

Execução planejada: Antes de aplicar mudanças, o Terraform gera um plano (terraform plan), mostrando o impacto das alterações.

Fluxo de Trabalho do Terraform

Escrever código: Escreva arquivos de configuração.tf que definem os recursos.

Inicializar: Prepare o ambiente com o comando terraform init.

Validar: Verifique se a configuração está correta com terraform validate.

Planejar: Veja o que será criado, alterado ou destruído com terraform plan.

Aplicar: Aplique as mudanças para provisionar recursos com terraform apply.

Criando manifestos do Terraform

Primeiro, crie um arquivo chamado backend.tf

terraform {
  backend "http" {

  }
}

Segundo, crie outro arquivo chamado ec2.tf

resource "aws_instance" "gitlab-ci-example-pipeline" {
  ami           = "ami-01b7be8d0c978c77c"
  instance_type = "t2.micro"
  tags = {
    Name = "gitlab-ci-example-pipeline"
  }
}

Por fim, crie um arquivo chamado provider.tf:


provider "aws" {
  region = "us-east-1"
}

Criando Pipeline

Os pontos de atenção nessa pipeline é as variáveis, elas são definidas no próprio GitLab, no menu de Settings -> CI/CD -> Variables

GITLAB_CI_TOKEN: Token do GitLab.

AWS_SECRET_ACCESS_KEY: Secret para autenticação na AWS.

AWS_ACCESS_KEY_ID: KEY para autenticação na AWS.

AWS_DEFAULT_REGION: Região da AWS.

Crie um arquivo chamado .gitlab-ci.yml e inicie primeiro definindo a imagem que vamos utilizar para executar essa pipeline:

image:
  name: hashicorp/terraform:light
  entrypoint: ["/usr/bin/env"]

Após isso, vamos definir os stages:

stages:
  - plan
  - apply
  - destroy

plan: Para planejar nossa infra.

apply: Para Criar a nossa infra.

destroy: Para destruir nossa infra.

Agora, bora definir as váriaveis:

variables:
  GITLAB_CI_TOKEN: "${GITLAB_CI_TOKEN}" 
  AWS_SECRET_ACCESS_KEY: "${AWS_SECRET_ACCESS_KEY}"
  AWS_ACCESS_KEY_ID: "${AWS_ACCESS_KEY_ID}"
  TF_ADDRESS: "https://gitlab.com/api/v4/projects/ID_PROJETO/terraform/state/state-name"
  TF_USERNAME: "SEU USER"
  TF_PASSWORD: "${GITLAB_CI_TOKEN}"

Preencha com ás informações do seu repositório e token.

Finalize a pipeline com os stages que definimos, além de configurar um before_script para executar sempre antes dos stages para carregar o tfstate:

before_script:
  - terraform init -backend-config="address=$TF_ADDRESS" -backend-config="lock_address=$TF_ADDRESS/lock" -backend-config="unlock_address=$TF_ADDRESS/lock" -backend-config="username=$TF_USERNAME" -backend-config="password=$TF_PASSWORD" -backend-config="lock_method=POST" -backend-config="unlock_method=DELETE" -backend-config="retry_wait_min=5"

plan:
  stage: plan
  script:
    - terraform plan -out=tfplan -input=false -lock=false

apply:
  stage: apply
  script:
    - terraform apply -input=false -lock=false -auto-approve

destroy:
  stage: destroy
  when: manual
  script:
    - terraform destroy -input=false -lock=false -auto-approve