Automação de infraestrutura com Terraform e Ansible

1. Fundamentos da Automação de Infraestrutura

A automação de infraestrutura moderna baseia-se no conceito de Infraestrutura como Código (IaC), que trata servidores, redes e bancos de dados como recursos programáveis. Os benefícios incluem repetibilidade, versionamento, redução de erros manuais e agilidade na entrega de ambientes.

Duas abordagens complementares dominam o ecossistema:
- Declarativa (Terraform): você descreve o estado desejado da infraestrutura e a ferramenta calcula as ações necessárias para atingi-lo.
- Imperativa (Ansible): você especifica passo a passo as ações a serem executadas nos servidores.

O ciclo de vida completo da automação envolve três fases: provisionamento (criação de recursos), configuração (instalação de software e ajustes) e gerenciamento contínuo (atualizações e manutenção).

2. Terraform: Provisionamento Declarativo de Recursos

O Terraform utiliza a HashiCorp Configuration Language (HCL) para definir infraestrutura. Um projeto básico contém:

# providers.tf
provider "aws" {
  region = "us-east-1"
}

# main.tf
resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"

  tags = {
    Name = "WebServer"
  }
}

# terraform.tf
terraform {
  backend "s3" {
    bucket = "meu-state-terraform"
    key    = "prod/terraform.tfstate"
    region = "us-east-1"
  }
}

O gerenciamento de estado remoto é essencial para equipes. Workpaces permitem isolar ambientes:

terraform workspace new dev
terraform workspace new prod
terraform workspace select dev
terraform apply

3. Ansible: Configuração e Orquestração de Servidores

Ansible organiza tarefas em playbooks YAML, roles e inventários. Exemplo de inventário dinâmico:

[webservers]
web01 ansible_host=192.168.1.10 ansible_user=ubuntu
web02 ansible_host=192.168.1.11 ansible_user=ubuntu

[dbservers]
db01 ansible_host=192.168.1.20 ansible_user=ubuntu

Playbook para configurar Nginx:

---
- name: Configurar servidor web
  hosts: webservers
  become: yes
  tasks:
    - name: Instalar Nginx
      apt:
        name: nginx
        state: present
        update_cache: yes

    - name: Iniciar e habilitar serviço
      service:
        name: nginx
        state: started
        enabled: yes

    - name: Copiar arquivo de configuração
      copy:
        src: files/nginx.conf
        dest: /etc/nginx/nginx.conf
      notify: restart nginx

  handlers:
    - name: restart nginx
      service:
        name: nginx
        state: restarted

A idempotência garante que executar o playbook múltiplas vezes produza o mesmo resultado, sem efeitos colaterais.

4. Integração Terraform + Ansible: Fluxo de Trabalho Completo

A integração permite provisionar recursos com Terraform e configurá-los com Ansible. Exemplo prático:

Passo 1: Terraform provisiona VMs e gera inventário

# output.tf
output "web_ips" {
  value = aws_instance.web[*].public_ip
}

# provisioner local-exec para gerar inventário
resource "null_resource" "generate_inventory" {
  triggers = {
    instance_ids = join(",", aws_instance.web[*].id)
  }

  provisioner "local-exec" {
    command = <<EOF
cat > inventory.ini << EOL
[webservers]
${join("\n", aws_instance.web[*].public_ip)}
EOL
EOF
  }
}

Passo 2: Executar Ansible após provisionamento

# local-exec para executar playbook
resource "null_resource" "run_ansible" {
  depends_on = [null_resource.generate_inventory]

  provisioner "local-exec" {
    command = "ansible-playbook -i inventory.ini playbook.yml --private-key ~/.ssh/id_rsa"
  }
}

Passo 3: Playbook Ansible configura as VMs

---
- name: Configurar servidores web
  hosts: webservers
  become: yes
  tasks:
    - name: Instalar Docker
      apt:
        name: docker.io
        state: present

    - name: Iniciar container de aplicação
      docker_container:
        name: app
        image: nginx:alpine
        ports:
          - "80:80"
        state: started

5. Boas Práticas e Padrões de Projeto

Modularização: Crie módulos Terraform reutilizáveis:

modules/
  vpc/
    main.tf
    variables.tf
    outputs.tf
  compute/
    main.tf
    variables.tf
    outputs.tf

Roles Ansible organizam configurações por função:

roles/
  common/
    tasks/
    handlers/
    templates/
  webserver/
    tasks/
    vars/

Versionamento: Mantenha todo código em Git com branches para ambientes (dev, staging, prod). Integre CI/CD com GitHub Actions ou GitLab CI.

Segredos: Use ansible-vault para criptografar senhas:

ansible-vault create secrets.yml
ansible-playbook playbook.yml --ask-vault-pass

No Terraform, utilize variáveis de ambiente ou HashiCorp Vault:

variable "db_password" {
  sensitive = true
}

6. Estratégias de Testes e Validação

Validação de sintaxe:

terraform validate
ansible-lint playbook.yml
ansible-playbook --syntax-check playbook.yml

Simulação segura:

terraform plan
ansible-playbook --check playbook.yml

Testes automatizados com Terratest (Go):

package test

import (
    "testing"
    "github.com/gruntwork-io/terratest/modules/terraform"
)

func TestTerraformWebServer(t *testing.T) {
    terraformOptions := &terraform.Options{
        TerraformDir: "../examples/webserver",
    }
    defer terraform.Destroy(t, terraformOptions)
    terraform.InitAndApply(t, terraformOptions)
}

Molecule para testar roles Ansible:

molecule init role myrole
molecule test

7. Monitoramento e Manutenção Contínua

Atualizações incrementais: Terraform aplica apenas mudanças necessárias, sem downtime para recursos não afetados:

terraform apply -auto-approve

Automação de patches com Ansible:

---
- name: Atualizar sistema
  hosts: all
  become: yes
  tasks:
    - name: Aplicar atualizações de segurança
      apt:
        upgrade: dist
        update_cache: yes
      register: result

    - name: Reiniciar se necessário
      reboot:
        reboot_timeout: 300
      when: result is changed

Rollback com snapshots e playbooks inversos:

- name: Restaurar configuração anterior
  copy:
    src: backups/nginx.conf.bkp
    dest: /etc/nginx/nginx.conf

Observabilidade: Integre com Prometheus e Grafana para monitorar métricas dos servidores provisionados:

- name: Instalar node_exporter
  get_url:
    url: https://github.com/prometheus/node_exporter/releases/download/v1.6.0/node_exporter-1.6.0.linux-amd64.tar.gz
    dest: /opt/

A combinação de Terraform e Ansible oferece uma abordagem completa e flexível para automação de infraestrutura. Enquanto o Terraform gerencia o ciclo de vida dos recursos de infraestrutura de forma declarativa, o Ansible cuida da configuração detalhada dos sistemas operacionais e aplicações. Essa separação de responsabilidades, aliada a boas práticas de modularização, versionamento e testes, permite construir pipelines de infraestrutura robustos e escaláveis.

A adoção dessa stack reduz significativamente o tempo de provisionamento de ambientes, elimina inconsistências manuais e proporciona rastreabilidade total das mudanças na infraestrutura — pilares fundamentais para operações modernas em nuvem e datacenters.

Referências