Pular para o conteúdo
Início » Explorando Módulos do Ansible

Explorando Módulos do Ansible

Explorando Módulos do Ansible

Neste artigo, vamos explorar os Módulos do Ansible: sua caixa de ferramentas para configuração e gerenciamento sem problemas. Desde a instalação de pacotes até a manipulação de arquivos, administração de usuários e controle de serviços, os módulos do Ansible desempenham um papel fundamental na automação do Ansible, atuando como scripts independentes projetados para realizar tarefas específicas em nós gerenciados.

A Importância dos Módulos do Ansible

O propósito de criar módulos do Ansible é abstrair a complexidade, oferecendo aos usuários finais uma maneira simplificada de executar tarefas de automação sem se preocupar com detalhes técnicos. Ao aproveitar os módulos, os usuários do Ansible podem realizar tarefas de maneira eficiente, deixando de lado a carga cognitiva associada a operações mais complexas.

Características-Chave dos Módulos do Ansible

Execução de Tarefas

Os módulos são os blocos de construção para executar tarefas nos playbooks do Ansible. Eles fornecem a implementação real das tarefas especificadas no playbook.

Abstração da Complexidade

Os módulos abstraem a complexidade das operações subjacentes, permitindo que os usuários se concentrem no resultado desejado, em vez de nos detalhes intrincados.

Diversidade de Funções

Os módulos do Ansible abrangem uma ampla variedade de funções, desde tarefas básicas, como manipulação de arquivos e instalação de pacotes, até operações complexas envolvendo recursos na nuvem, bancos de dados e muito mais.

Padronização

Os módulos do Ansible seguem uma estrutura e interface padronizadas, facilitando a consistência e previsibilidade entre diferentes módulos. Essa uniformidade simplifica a curva de aprendizado para os usuários.

Idempotência

Os módulos são projetados para serem idempotentes, o que significa que aplicar o mesmo módulo várias vezes tem o mesmo resultado que aplicá-lo uma vez. Isso garante previsibilidade e confiabilidade na execução dos playbooks.

Manipulação de Entrada Dinâmica

Os módulos aceitam parâmetros de entrada dinâmica, permitindo que os usuários personalizem o comportamento das tarefas com base em requisitos específicos. Essa flexibilidade melhora a adaptabilidade do Ansible a diferentes casos de uso.

Módulos da Comunidade e Personalizados

O Ansible possui uma vasta coleção de módulos contribuídos pela comunidade, abrangendo uma ampla variedade de tecnologias e serviços. Os usuários também podem criar módulos personalizados para estender a funcionalidade do Ansible para tarefas especializadas.

Execução Remota

Os módulos são executados em hosts remotos, permitindo que o Ansible gerencie e configure sistemas sem a necessidade de agentes nos nós gerenciados.

Manipulação de Saída

Os módulos fornecem saída estruturada, facilitando que tarefas ou scripts subsequentes analisem e interpretem os resultados. Essa saída estruturada geralmente está no formato JSON.

Natureza Declarativa

Os playbooks do Ansible, que utilizam módulos, seguem uma sintaxe declarativa, especificando o estado desejado do sistema, em vez de prescrever as etapas para alcançar esse estado. Isso contribui para a simplicidade e legibilidade da automação do Ansible.

Exemplo de Tarefa do Ansible

Aqui está um exemplo de uma tarefa do Ansible usando o módulo yum para instalar uma versão específica do Apache HTTP Server (pacote httpd) em uma máquina CentOS:

---
- name: Instalar o Apache HTTP Server com uma Versão Específica no CentOS
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Instalar o Apache HTTP Server
      yum:
        name: httpd  # Nome do pacote para o Apache HTTP Server
        state: present  # Garantir que o pacote esteja instalado

    - name: Garantir que uma Versão Específica do Apache está Instalada
      yum:
        name: httpd-2.4.6-90.el7.centos  # Especifique a versão desejada
        state: present

A primeira tarefa instala o Apache HTTP Server (pacote httpd) usando o módulo yum. O estado: present garante que o pacote esteja instalado.

A segunda tarefa utiliza novamente o módulo yum para garantir que uma versão específica do Apache esteja instalada. Neste exemplo, está instalando a versão 2.4.6-90.el7.centos do pacote httpd.

Módulos do Ansible Mais Úteis e Comuns no CentOS

Aqui estão alguns dos módulos mais úteis e comuns do Ansible no CentOS:

yum:

Descrição: O módulo yum permite realizar tarefas como instalação, atualização ou remoção de pacotes.

Casos de Uso: Instalação, atualização ou remoção de pacotes.

Aqui está um exemplo básico de uso do módulo yum para instalar um pacote:

---
- name: Instalar o Apache HTTP Server
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Instalar o Apache HTTP Server
      yum:
        name: httpd
        state: present  # Garantir que o pacote esteja instalado

service:

Descrição: O módulo service no Ansible é usado para gerenciar serviços em hosts remotos. Ele permite iniciar, parar, reiniciar, habilitar ou desabilitar serviços.

Casos de Uso: Iniciar, parar ou reiniciar serviços.

Aqui está um exemplo básico de uso do módulo service para garantir que o Apache HTTP Server esteja em execução:

---
- name: Gerenciar o Serviço Apache
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Garantir que o serviço Apache esteja em execução
      service:
        name: httpd
        state: started
        enabled: yes

file:

Descrição: O módulo file no Ansible é usado para gerenciar arquivos e diretórios em hosts remotos. Ele permite criar, excluir, modificar ou definir permissões para arquivos e diretórios.

Casos de Uso: Criar, excluir ou modificar arquivos e diretórios.

Aqui está uma visão geral do módulo file:

---
- name: Gerenciar Arquivos e Diretórios
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Criar um diretório
      file:
        path: /caminho/para/diretorio
        state: directory

    - name: Criar um arquivo com conteúdo
      file:
        path: /caminho/para/diretorio/meuarquivo.txt
        state: touch
        content: "Olá, Ansible!"

template:

Descrição: O módulo template no Ansible é usado para gerar dinamicamente arquivos em hosts remotos usando a formatação Jinja2. Ele permite criar arquivos de configuração com conteúdo dinâmico.

Casos de Uso: Criar arquivos de configuração com conteúdo dinâmico.

Aqui está um exemplo básico de uso do módulo template para gerar um arquivo de configuração:

---
- name: Gerenciar Arquivo de Configuração com Modelo
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Criar um arquivo de configuração a partir de um modelo
      template:
        src: /caminho/para/modelo.conf.j2
        dest: /etc/minhaplicacao/minhaplicacao.conf

Formatação Jinja2:

Dentro do arquivo de modelo Jinja2 (por exemplo, modelo.conf.j2), você pode usar a sintaxe Jinja2 para incluir variáveis, condicionais e loops. Aqui está um exemplo simples:

# modelo.conf.j2

# Arquivo de configuração para MinhaAplicacao
url_banco_de_dados = {{ url_banco_de_dados }}
modo_debug = {{ modo_debug | default(false) }}

user:

Descrição: O módulo user no Ansible é usado para gerenciar contas de usuário em hosts remotos. Ele permite criar, modificar ou remover contas de usuário e atributos associados.

Casos de Uso: Criar, modificar ou remover contas de usuário.

Aqui está um exemplo básico de uso do módulo user para criar um novo usuário:

---
- name: Gerenciar Conta de Usuário
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Criar um novo usuário
      user:
        name: joao_silva
        password: "$6$salt_aleatorio$senha_hashed"
        groups: usuarios

copy:

Descrição: O módulo copy no Ansible é usado para copiar arquivos da máquina local para hosts remotos. Ele permite transferir arquivos e definir propriedades como propriedade e permissões.

Casos de Uso: Transferir arquivos de configuração ou scripts para sistemas de destino.

Aqui está um exemplo básico de uso do módulo copy para transferir um arquivo para hosts remotos:

---
- name: Copiar Arquivos para Hosts Remotos
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Copiar um arquivo
      copy:
        src: /caminho/para/arquivo/local.txt
        dest: /caminho/no/servidor/remoto/arquivo.txt

command:

Descrição: O módulo command no Ansible é usado para executar comandos em hosts remotos. Ele executa o comando no shell padrão (/bin/sh) no host remoto, permitindo realizar várias tarefas.

Casos de Uso: Executar operações básicas na linha de comando.

Aqui está um exemplo básico de uso do módulo command para executar um comando simples em hosts remotos:

---
- name: Executar Comando em Hosts Remotos
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Executar um comando
      command: ls /caminho/para/diretorio

shell:

Descrição: O módulo shell no Ansible é usado para executar comandos em um shell em hosts remotos. Ele permite executar sequências de comandos ou scripts mais complexos em comparação com o módulo command.

Casos de Uso: Executar sequências de comandos ou scripts complexos.

Aqui está um exemplo básico de uso do módulo shell para executar um comando em um shell em hosts remotos:

---
- name: Executar Comando Shell em Hosts Remotos
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Executar um comando no shell
      shell: ls /caminho/para/diretorio

cron:

Descrição: O módulo cron permite criar, modificar ou remover tarefas cron.

Casos de Uso: Agendamento de tarefas periódicas.

Aqui está um exemplo básico de uso do módulo cron para criar uma tarefa cron:

---
- name: Gerenciar Tarefas Cron
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Criar uma tarefa cron
      cron:
        name: "Minha Tarefa Diária"
        minute: "0"
        hour: "2"
        job: "/caminho/para/script.sh"

lineinfile:

Descrição: O módulo lineinfile no Ansible é usado para garantir que uma linha específica esteja presente ou ausente em um arquivo. É comumente usado para gerenciar arquivos de configuração, adicionando, modificando ou removendo linhas específicas.

Casos de Uso: Modificação de arquivos de configuração, adicionando, modificando ou removendo linhas específicas.

Aqui está um exemplo básico de uso do módulo lineinfile para adicionar uma linha a um arquivo de configuração:

---
- name: Gerenciar Arquivo de Configuração
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Adicionar uma linha a um arquivo
      lineinfile:
        path: /caminho/para/arquivo_de_configuracao
        line: 'nova_linha_a_ser_adicionada'

git:

Descrição: O módulo git no Ansible é usado para gerenciar repositórios Git em hosts remotos. Ele permite clonar repositórios, atualizá-los e realizar várias tarefas relacionadas ao Git.

Casos de Uso: Gerenciar repositórios Git, como clonar, adicionar, atualizar e executar tarefas relacionadas ao Git.

Aqui está um exemplo básico de uso do módulo git para clonar um repositório Git:

---
- name: Gerenciar Repositório Git
  hosts: all
  become: yes  # Isso permite que a tarefa seja executada com privilégios elevados (sudo)

  tasks:
    - name: Clonar um repositório Git
      git:
        repo: https://github.com/exemplo/repo.git
        dest: /caminho/para/clonagem/local

Exemplo de Tarefas do Ansible

Aqui está um exemplo que abrange tarefas como instalação de pacotes, gerenciamento de arquivos, administração de usuários e gerenciamento de serviços:

---
- name: Configuração do Sistema
  hosts: all
  become: yes  # Isso permite que as tarefas sejam executadas com privilégios elevados (sudo)

  tasks:
    - name: Atualizar pacotes do sistema
      yum:
        name: '*'
        state: latest
      when: ansible_os_family == 'RedHat'

    - name: Garantir que o serviço NTP esteja instalado e em execução
      service:
        name: ntpd
        state: started
        enabled: yes

    - name: Criar um usuário de sistema
      user:
        name: sysadmin
        group: wheel
        password: "$6$salt_aleatorio$senha_hashed"
        shell: /bin/bash

    - name: Garantir a chave SSH para o usuário sysadmin
      authorized_key:
        user: sysadmin
        key: "{{ lookup('file', '/caminho/para/chave_publica.local.pub') }}"
        state: present

    - name: Configurar o firewall para permitir SSH
      firewalld:
        service: ssh
        permanent: yes
        state: enabled
      notify: Recarregar Firewalld

  handlers:
    - name: Recarregar Firewalld
      command: firewall-cmd --reload

Explicação:

  • Atualizar pacotes do sistema: O módulo yum garante que todos os pacotes do sistema no CentOS sejam atualizados para a versão mais recente.
  • Garantir que o serviço NTP esteja instalado e em execução: O módulo service garante que o serviço NTP (Network Time Protocol) esteja instalado, em execução e configurado para iniciar durante a inicialização.
  • Criar um usuário de sistema: O módulo user cria um usuário chamado ‘sysadmin’ pertencente ao grupo ‘wheel’, com uma senha e shell especificados.
  • Garantir a chave SSH para o usuário sysadmin: O módulo authorized_key adiciona uma chave pública SSH ao arquivo authorized_keys para o usuário ‘sysadmin’, permitindo acesso seguro.
  • Configurar o firewall para permitir SSH: O módulo firewalld garante que o firewall permita conexões SSH de entrada. O manipulador aciona uma recarga do firewall para aplicar as alterações.

Em resumo, os módulos do Ansible são a espinha dorsal da automação, oferecendo ferramentas poderosas para gerenciar diversas tarefas. Os módulos destacados aqui fornecem uma base sólida, e à medida que suas necessidades evoluem, explorar módulos adicionais usando o comando ‘ansible-doc ‘ abre as portas para possibilidades infinitas. A arquitetura modular do Ansible permite personalizar e otimizar fluxos de trabalho de automação, tornando-o uma ferramenta versátil e indispensável para orquestração e gerenciamento de configuração de TI.

Espero que este artigo tenha fornecido informações valiosas sobre os aspectos práticos e benéficos dos Módulos do Ansible.

Marcações: