Ansible: Automação de Infraestrutura como Código para DevOps

O que é o Ansible?

Ansible é uma ferramenta open-source de automação de TI desenvolvida pela Red Hat. Diferente de ferramentas como Puppet, Chef ou SaltStack, o Ansible adota uma arquitetura agentless (sem agentes) — ele se conecta aos servidores via SSH (Linux) ou WinRM (Windows) e executa as tarefas remotamente, sem precisar instalar nenhum software nos nós gerenciados.

Sua sintaxe é declarativa e baseada em YAML, o que torna os playbooks extremamente legíveis mesmo para quem não é especialista em infraestrutura.

Por que usar Ansible?

Agentless — Nada para instalar nos servidores gerenciados. Apenas Python e SSH são necessários
YAML puro — Playbooks fáceis de ler, escrever e versionar no Git
Idempotente — Executar o mesmo playbook múltiplas vezes produz o mesmo resultado
Modular — Mais de 1.500 módulos prontos para nuvem, rede, containers, banco de dados e mais
Push-based — Você controla quando e como as alterações são aplicadas

Instalação do Ansible

O Ansible é instalado apenas na máquina de controle (seu computador ou servidor CI/CD):

# Linux (Ubuntu/Debian)
sudo apt update
sudo apt install ansible -y

# macOS
brew install ansible

# Verificar instalação
ansible --version

Primeiro playbook: Instalando Nginx

Crie um arquivo chamado primeiro-playbook.yml:

---
- hosts: servidores_web
  become: yes
  vars:
    porta_nginx: 80

  tasks:
    - name: Instalar nginx
      apt:
        name: nginx
        state: present
        update_cache: yes

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

    - name: Copiar arquivo de configuração
      template:
        src: templates/meu-site.j2
        dest: /etc/nginx/sites-available/meu-site

    - name: Criar link simbólico
      file:
        src: /etc/nginx/sites-available/meu-site
        dest: /etc/nginx/sites-enabled/meu-site
        state: link

    - name: Testar configuração do nginx
      command: nginx -t
      register: resultado_teste

    - name: Reiniciar nginx
      service:
        name: nginx
        state: restarted
      when: resultado_teste.rc == 0

Inventário: organizando seus servidores

O inventário define quais servidores o Ansible irá gerenciar. Pode ser um arquivo estático ou dinâmico via API:

# inventory/homolog.yml
[servidores_web]
web-01.craftxp.com.br
web-02.craftxp.com.br

[servidores_db]
db-primary.craftxp.com.br ansible_user=ubuntu

[monitoramento]
prometheus-server ansible_host=10.0.1.50

[todos:children]
servidores_web
servidores_db
monitoramento

Executando playbooks

# Executar contra servidores específicos
ansible-playbook -i inventory/homolog.yml primeiro-playbook.yml

# Verificar sintaxe (dry-run sintático)
ansible-playbook --syntax-check playbook.yml

# Modo check (dry-run lógico — sem alterações reais)
ansible-playbook -i inventory.yml playbook.yml --check

# Verbosidade para debug
ansible-playbook playbook.yml -vvv

Roles: organização profissional

Roles permitem organizar playbooks em estruturas reutilizáveis. A estrutura padrão é:

roles/
  nginx/
    tasks/
      main.yml      # Tarefas principais
    handlers/
      main.yml      # Handlers (reiniciar serviço, etc.)
    templates/
      site.conf.j2  # Templates Jinja2
    vars/
      main.yml      # Variáveis da role
    defaults/
      main.yml      # Valores padrão (sobrescritos por variáveis externas)
    meta/
      main.yml      # Dependências entre roles

Exemplo com templates Jinja2

No templates do Ansible, você pode usar a engine de templates Jinja2:

{# templates/meu-site.j2 #}
server {
    listen {{ porta_nginx }};
    server_name {{ domain_name }};

    location / {
        proxy_pass http://localhost:{{ app_port }};
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /static/ {
        alias /var/www/{{ app_name }}/static/;
        expires 30d;
    }
}

Ansible na prática: deploy de aplicação Node.js

---
- hosts: servidores_web
  become: yes
  tasks:
    - name: Instalar Node.js 20.x
      apt:
        deb: https://deb.nodesource.com/node_20.x/nodesource-release-noble-1.deb

    - name: Clonar repositório
      git:
        repo: https://github.com/craftxp/meu-app.git
        dest: /opt/meu-app
        version: main

    - name: Instalar dependências
      npm:
        path: /opt/meu-app
        state: present

    - name: Configurar variáveis de ambiente
      copy:
        content: |
          DATABASE_URL={{ db_url }}
          REDIS_URL={{ redis_url }}
          NODE_ENV=production
        dest: /opt/meu-app/.env

    - name: Iniciar aplicação com PM2
      command: pm2 start /opt/meu-app/app.js --name meu-app
      args:
        creates: /root/.pm2/logs/meu-app-out.log

Ansible + Docker: combinando ferramentas

Você pode usar Ansible para provisionar containers Docker em múltiplos hosts:

---
- hosts: servidores_app
  become: yes
  tasks:
    - name: Instalar Docker
      apt:
        name: docker.io
        state: present

    - name: Instalar Docker Compose
      get_url:
        url: https://github.com/docker/compose/releases/latest/download/docker-compose-linux-x86_64
        dest: /usr/local/bin/docker-compose
        mode: '0755'

    - name: Subir containers com Docker Compose
      docker_compose:
        project_src: /opt/meu-app
        state: present
        restarted: yes

Boas práticas e armadilhas comuns

Use --check sempre — O modo check evita surpresas antes de aplicar alterações em produção
Versionar tudo — Playbooks, inventários e variáveis devem estar no Git. Considere usar Ansible Vault para secrets
Prefira módulos a comandos shell — Módulos são idempotentes; comandos shell nem sempre
Evite delegar senhas no inventário — Use ansible-vault ou AWS Secrets Manager para dados sensíveis
Roles para reaproveitamento — Organize tarefas em roles na Ansible Galaxy para compartilhar entre projetos
Teste em staging primeiro — Um playbook mal escrito pode derrubar servidores inteiros

Conclusão

O Ansible é a ferramenta ideal para quem quer começar com automação de infraestrutura sem complexidade desnecessária. Sua abordagem agentless, sintaxe YAML simples e enorme ecossistema de módulos fazem dele a escolha número 1 para DevOps que precisam automatizar servidores, deploys e configurações de forma confiável.

Comece hoje: instale o Ansible, crie um inventário de servidores de teste e escreva seu primeiro playbook para instalar e configurar um serviço. A automação vai transformar a forma como você gerencia infraestrutura.

Devops

Entrar em contato

Entre em contato