Dominando o Ansible: Instalação, Módulos Essenciais e Playbooks

Introdução e Preparação do Ambiente

O Ansible é uma ferramenta de automação de TI de código aberto que simplifica o gerenciamento de configurações, o provisionamento de infraestrutura e a orquestração de deployments. Diferente de outras ferramentas, ele opera sem agentes (agentless), utilizando SSH para comunicação.

Ambiente de Laboratório

Para os exemplos práticos, utilizaremos a seguinte topologia de rede baseada em sistemas Ubuntu 22.04 LTS:

Nó de Controle (ansible-control): 172.16.50.10
Nó Gerenciado 1 (web-node-01): 172.16.50.11
Nó Gerenciado 2 (web-node-02): 172.16.50.12

Nota: Certifique-se de que o acesso SSH sem senha (usando chaves RSA/Ed25519) esteja configurado entre o nó de controle e os nós gerenciados, e que o firewall permita a porta 22.

Instalação Moderna do Ansible

Embora versões antigas exigissem a compilação manual de dependências Python, a abordagem recomendada atualmente é utilizar o gerenciador de pacotes do sistema ou o pip.

Instalação via APT (Recomendado para Ubuntu/Debian)

sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository --yes --update ppa:ansible/ansible
sudo apt install -y ansible

Encapsulamento em Docker

Para ambientes isolados e reproduzíveis, encapsular o Ansible em um contêiner é uma prática excelente. Abaixo, um Dockerfile otimizado:

FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    openssh-client \
    sshpass \
    vim \
    iputils-ping \
    && pip3 install --no-cache-dir ansible \
    && mkdir -p /etc/ansible \
    && echo -e "[defaults]\nhost_key_checking = False\nforks = 10" > /etc/ansible/ansible.cfg

WORKDIR /workspace
CMD ["/bin/bash"]

Para construir e executar a imagem:

docker build -t ansible-automation:latest .
docker run -it --rm -v $(pwd):/workspace ansible-automation:latest

Configuração e Inventário

O Ansible utiliza um arquivo de inventário para definir os hosts gerenciados. O caminho padrão é /etc/ansible/hosts, mas você pode especificar inventários personalizados via linha de comando.

Definindo o Inventário

# /etc/ansible/hosts
[webservers]
172.16.50.11 ansible_user=ubuntu
172.16.50.12 ansible_user=ubuntu

[dbservers]
172.16.50.13 ansible_user=ubuntu

[webservers:vars]
http_port=8080
max_clients=200

Comandos Ad-Hoc e Módulos Essenciais

Comandos ad-hoc são úteis para tarefas rápidas e pontuais. A sintaxe básica é: ansible <grupo> -m <módulo> -a "<argumentos>".

Módulo Ping (Verificação de Conectividade)

ansible webservers -m ping

Módulos Shell e Command

O módulo command é mais seguro, pois não procesa variáveis de ambiente ou redirecionamentos. Para comandos complexos, use o shell.

# Verificando uso de disco com shell
ansible webservers -m shell -a "df -h | grep /dev/sda1"

# Criando um diretório com command
ansible webservers -m command -a "mkdir -p /opt/app/logs" -b

Módulos File e Copy (Gerenciamento de Arquivos)

# Alterando permissões e propriedade
ansible webservers -m file -a "path=/opt/app/logs state=directory mode=0755 owner=www-data group=www-data" -b

# Copiando conteúdo diretamente para um arquivo
ansible webservers -m copy -a "content='Bem-vindo ao servidor de produção\n' dest=/etc/motd mode=0644" -b

Módulo Apt (Gerenciamento de Pacotes)

# Instalando Nginx e Redis
ansible webservers -m apt -a "name=nginx,redis-server state=present update_cache=yes" -b

# Removendo pacotes
ansible webservers -m apt -a "name=redis-server state=absent" -b

Módulos User e Group

# Criando grupo e usuário de aplicação
ansible webservers -m group -a "name=appgroup gid=2000 system=yes" -b
ansible webservers -m user -a "name=deployer group=appgroup shell=/bin/bash create_home=yes state=present" -b

Módulo Cron (Agendamento de Tarefas)

# Agendando um script de backup diário às 02:00
ansible webservers -m cron -a "name='daily_backup' minute=0 hour=2 job='/opt/scripts/backup.sh >> /var/log/backup.log 2>&1'" -b

Playbooks e YAML

Playbooks são a linguagem de orquestração do Ansible, escritos em YAML. Eles permitem definir estados desejados de forma declarativa e idempotente.

Estrutura Básica de um Playbook

# webserver_setup.yml
---
- name: Configuração de Servidores Web
  hosts: webservers
  become: yes
  vars:
    app_dir: /var/www/html
    nginx_port: 8080

  tasks:
    - name: Instalar dependências do Nginx
      apt:
        name: "{{ item }}"
        state: present
      loop:
        - nginx
        - curl
        - unzip

    - name: Criar diretório da aplicação
      file:
        path: "{{ app_dir }}"
        state: directory
        owner: www-data
        group: www-data

    - name: Alterar porta do Nginx
      lineinfile:
        path: /etc/nginx/sites-available/default
        regexp: '^(\s*)listen 80;'
        line: '\1listen {{ nginx_port }};'
      notify: Reiniciar Nginx

  handlers:
    - name: Reiniciar Nginx
      service:
        name: nginx
        state: restarted

Execução e Opções do Playbook

# Execução padrão
ansible-playbook webserver_setup.yml

# Modo de verificação (Dry-run)
ansible-playbook webserver_setup.yml --check

# Executar apenas tarefas específicas por tag
ansible-playbook webserver_setup.yml --tags "install_packages"

Templates com Jinja2

O módulo template permite renderizar arquivos dinamicamente usando a engine Jinja2, substituindo variáveis do Ansible no arquivo de destino.

Exemplo de Template Nginx

Arquivo templates/nginx.conf.j2:

server {
    listen {{ nginx_port }};
    server_name {{ ansible_hostname }}.local;

    location / {
        root {{ app_dir }};
        index index.html;
    }

{% if enable_ssl is defined and enable_ssl %}
    # Configurações SSL seriam inseridas aqui
{% endif %}
}

Tarefa no Playbook para aplicar o template:

    - name: Aplicar configuração dinâmica do Nginx
      template:
        src: templates/nginx.conf.j2
        dest: /etc/nginx/conf.d/app.conf
        owner: root
        group: root
        mode: '0644'
      notify: Reiniciar Nginx

Organização com Roles

Para projetos complexos, o uso de Roles é essencial. Roles permitem estruturar variáveis, tarefas, handlers e templates em diretórios padronizados, promovendo a reutilização de código.

Estrutura de Diretórios de uma Role

roles/
  nginx_role/
    tasks/
      main.yml       # Lista principal de tarefas
    handlers/
      main.yml       # Handlers (ex: reiniciar serviços)
    templates/
      nginx.conf.j2  # Templates Jinja2
    vars/
      main.yml       # Variáveis de alta prioridade
    defaults/
      main.yml       # Variáveis padrão (baixa prioridade)
    files/
      index.html     # Arquivos estáticos para o módulo copy

Exemplo de Tasks e Handlers

roles/nginx_role/tasks/main.yml:

---
- name: Instalar Nginx
  apt:
    name: nginx
    state: present

- name: Copiar template de configuração
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: Reload Nginx

- name: Garantir que o Nginx esteja ativo
  systemd:
    name: nginx
    state: started
    enabled: yes

roles/nginx_role/handlers/main.yml:

---
- name: Reload Nginx
  systemd:
    name: nginx
    state: reloaded

Chamando Roles no Playbook

# site.yml
---
- name: Deploy de Infraestrutura Web
  hosts: webservers
  become: yes
  roles:
    - role: nginx_role
      vars:
        nginx_port: 80
        enable_ssl: false
    - role: app_deploy
      tags: ['deployment', 'app']

Ao executar ansible-playbook site.yml, o Ansible carregará automaticamente as tasks, handlers e variáveis definidas dentro de cada role, mantendo o playbook principal limpo e legível.

Tags: Ansible Automação devops YAML infraestrutura-como-codigo

Publicado em 7-29 21:53

Doido Dev