O Ansible é uma ferramenta de automação de TI que permite gerenciar configurações, provisionar servidores, implantar aplicações e orquestrar tarefas complexas de forma simples e declarativa. Diferente de outras ferramentas como Puppet ou Chef, o Ansible é agente-less, ou seja, não requer a instalação de nenhum software nos nós gerenciados, utilizando apenas SSH para se comunicar. Isso o torna extremamente fácil de adotar e gerenciar, especialmente em ambientes que já utilizam SSH como padrão.

Nesta aula, vamos explorar os conceitos fundamentais do Ansible: o inventário, que define quais servidores serão gerenciados; os playbooks, escritos em YAML, que descrevem as tarefas a serem executadas; e os módulos, que são as unidades de trabalho do Ansible. Também veremos casos de uso comuns, desde a configuração de servidores até a implantação de aplicações. Ao final, você terá uma base sólida para começar a usar o Ansible em seus projetos de DevOps.

Inventário

O inventário é um arquivo que define os hosts (servidores) que o Ansible irá gerenciar. Ele pode ser estático, em formato INI ou YAML, ou dinâmico, vindo de fontes como AWS EC2, OpenStack, etc. O inventário também pode agrupar hosts, permitindo aplicar configurações a grupos inteiros de servidores.

Um inventário estático em formato INI é o mais comum e simples. Ele pode listar hosts individuais ou grupos, e você pode definir variáveis específicas para cada host ou grupo. Vamos ver um exemplo:

[web]
web1.example.com
web2.example.com

[db]
db1.example.com

[all:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/path/to/key.pem

Neste exemplo, temos dois grupos: 'web' com dois hosts, e 'db' com um host. A seção [all:vars] define variáveis que se aplicam a todos os hosts, como o usuário SSH e a chave privada. Você também pode definir variáveis por host ou grupo, como:

[web]
web1.example.com ansible_host=192.168.1.10
web2.example.com

Para usar o inventário, basta passar o arquivo com a opção -i ou definir no arquivo de configuração ansible.cfg. Você pode testar a conectividade com o comando ansible all -m ping.

Playbooks (YAML)

Playbooks são arquivos YAML que descrevem as automações a serem executadas. Eles são o coração do Ansible, permitindo definir uma série de tarefas (tasks) que serão executadas nos hosts do inventário. Um playbook pode conter um ou mais 'plays', onde cada play define quais hosts serão afetados e quais tarefas serão executadas.

A estrutura básica de um playbook é:

- name: Meu primeiro playbook
  hosts: web
  become: yes
  tasks:
    - name: Instalar nginx
      apt:
        name: nginx
        state: present

Neste exemplo, o playbook tem um play chamado 'Meu primeiro playbook', que é aplicado aos hosts do grupo 'web', com privilégios elevados (become: yes). A tarefa usa o módulo apt para instalar o nginx. O YAML usa indentação para definir a hierarquia, e é importante ser consistente com os espaços (não usar tabs).

Playbooks podem incluir variáveis, condicionais, loops, handlers e muito mais. Eles são idempotentes, ou seja, podem ser executados várias vezes sem causar efeitos colaterais, pois o Ansible verifica o estado atual e só aplica mudanças quando necessário.

Módulos

Os módulos são as unidades de trabalho do Ansible. Eles são scripts que executam tarefas específicas, como copiar arquivos, instalar pacotes, gerenciar serviços, etc. Cada módulo aceita parâmetros que definem o comportamento desejado.

Existem centenas de módulos disponíveis, cobrindo desde operações básicas até integrações com APIs de serviços de nuvem. Alguns exemplos comuns:

  • copy: copia arquivos para o host remoto.
  • service: gerencia serviços (iniciar, parar, reiniciar).
  • yum/apt: instala pacotes em distribuições Linux.
  • command: executa comandos arbitrários.
  • template: gera arquivos a partir de modelos Jinja2.

Exemplo de uso do módulo copy:

- name: Copiar arquivo de configuração
  copy:
    src: /local/nginx.conf
    dest: /etc/nginx/nginx.conf
    owner: root
    group: root
    mode: '0644'

Para descobrir como usar um módulo, você pode usar o comando ansible-doc <módulo> no terminal.

Casos de uso

O Ansible é extremamente versátil e pode ser usado em diversos cenários de DevOps. Alguns casos de uso comuns incluem:

  • Provisionamento de servidores: Configurar novos servidores com pacotes, usuários, chaves SSH, etc.
  • Configuração de ambientes: Aplicar configurações consistentes em múltiplos servidores (ex.: instalar e configurar Nginx, PostgreSQL, etc.).
  • Implantação de aplicações: Deploy de aplicações web, atualização de código, reinício de serviços.
  • Orquestração de tarefas: Executar tarefas em sequência ou em paralelo, como backups, migrações de banco de dados.
  • Gerenciamento de configuração: Garantir que os servidores estejam sempre no estado desejado, corrigindo desvios.

Por exemplo, um playbook para provisionar um servidor web poderia:

- name: Provisionar servidor web
  hosts: web
  become: yes
  tasks:
    - name: Atualizar apt cache
      apt:
        update_cache: yes

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

    - name: Iniciar nginx
      service:
        name: nginx
        state: started
        enabled: yes

Esse playbook garante que o nginx esteja instalado e rodando, e que seja habilitado para iniciar automaticamente no boot. Isso é um exemplo de automação que economiza tempo e evita erros manuais.

Boas práticas e observações finais

Ao trabalhar com Ansible, algumas boas práticas incluem: sempre versionar seus playbooks e inventários em um repositório Git; usar roles para organizar tarefas reutilizáveis; utilizar variáveis e templates para evitar repetição; e testar seus playbooks em ambientes de desenvolvimento antes de aplicá-los em produção.

Também é importante lembrar que o Ansible usa SSH, então é necessário garantir que as chaves SSH estejam configuradas corretamente e que o usuário tenha as permissões adequadas. Além disso, a idempotência é uma característica fundamental: sempre escreva playbooks que possam ser executados múltiplas vezes sem efeitos colaterais indesejados.

Com esses conceitos, você está pronto para explorar mais a fundo o mundo do Ansible e integrá-lo aos seus fluxos de DevOps.

Referências

Exercícios

  1. Crie um inventário estático com dois grupos: 'webservers' contendo 'server1.example.com' e 'server2.example.com', e 'databases' contendo 'db1.example.com'. Defina uma variável de grupo para 'ansible_user=ubuntu'.

    2. ✓ Resposta: Um arquivo de inventário em INI: 
    [webservers]
server1.example.com
server2.example.com

[databases]
db1.example.com

[all:vars]
ansible_user=ubuntu
  2. Escreva um playbook que instale o pacote 'git' em todos os hosts do grupo 'webservers' usando o módulo apt (assumindo Ubuntu).

    3. ✓ Resposta: 
    - name: Instalar git
  hosts: webservers
  become: yes
  tasks:
    - name: Instalar git
      apt:
        name: git
        state: present
  3. Explique a diferença entre um módulo e um playbook.

    4. ✓ Resposta: Um módulo é uma unidade de trabalho que executa uma tarefa específica (ex.: copiar arquivo, instalar pacote). Um playbook é um arquivo YAML que define uma sequência de tarefas (usando módulos) a serem executadas em hosts específicos, com lógica e controle de fluxo. Em resumo, módulos são as ferramentas, e playbooks são os planos de automação que orquestram essas ferramentas.
  4. Crie um playbook que copie um arquivo local 'app.conf' para '/etc/app/' nos hosts do grupo 'databases', com permissões 0640, e reinicie o serviço 'app' se o arquivo for alterado.

    5. ✓ Resposta: 
    - name: Configurar aplicação
  hosts: databases
  become: yes
  tasks:
    - name: Copiar arquivo de configuração
      copy:
        src: app.conf
        dest: /etc/app/app.conf
        mode: '0640'
      notify: reiniciar app

  handlers:
    - name: reiniciar app
      service:
        name: app
        state: restarted
  5. Dê um exemplo de caso de uso do Ansible no contexto de DevOps e explique como ele ajuda.

    6. ✓ Resposta: Um caso de uso comum é o provisionamento automático de servidores de aplicação. Com um playbook, você pode definir todos os passos para configurar um servidor: instalar dependências, configurar serviços, criar usuários, etc. Isso garante que todos os servidores sejam configurados de forma consistente, reduzindo erros manuais e acelerando o processo de deploy. Além disso, a idempotência permite que o mesmo playbook seja executado repetidamente, corrigindo desvios de configuração.