Instalar Ansible no Red Hat Enterprise Linux

Introdução

Neste laboratório, você aprenderá como instalar o Ansible Core em um sistema Red Hat Enterprise Linux (RHEL). Ansible é uma ferramenta de automação poderosa que permite gerenciar e configurar sistemas, implantar aplicações e orquestrar fluxos de trabalho de TI complexos.

Você usará o gerenciador de pacotes dnf com privilégios sudo para instalar o pacote ansible-core, que fornece o motor Ansible principal e as ferramentas de linha de comando. Após a instalação, você verificará se o Ansible está funcionando corretamente, verificando sua versão e executando comandos básicos.

Esta é uma habilidade fundamental para administradores de sistemas e engenheiros DevOps que trabalham com sistemas Red Hat Enterprise Linux.

Instalar Ansible Core Usando dnf

Nesta etapa, você instalará o pacote ansible-core usando o gerenciador de pacotes dnf. Ansible Core fornece o motor Ansible essencial, incluindo ansible, ansible-playbook e outras ferramentas de linha de comando principais necessárias para tarefas de automação.

O gerenciador de pacotes dnf (Dandified YUM) é a ferramenta padrão para gerenciar pacotes de software no Red Hat Enterprise Linux. Como a instalação de software requer privilégios administrativos, você deve usar o comando sudo.

Execute o seguinte comando para instalar o Ansible Core com confirmação automática:

sudo dnf install ansible-core -y

A flag -y responde automaticamente "sim" a todos os prompts, tornando a instalação não interativa. O sistema fará o download e instalará o ansible-core junto com suas dependências Python, incluindo Jinja2 para modelagem (templating) e PyYAML para processamento YAML.

Você deve ver uma saída semelhante a esta, mostrando a resolução do pacote e o progresso da instalação:

Updating Subscription Management repositories.
Last metadata expiration check: ...
Dependencies resolved.
================================================================================
 Package                  Arch   Version                Repository         Size
================================================================================
Installing:
 ansible-core             noarch 2.16.x-x.el9            rhel-9-appstream   xx M
Installing dependencies:
 python3-jinja2           noarch x.x.x-x.el9              rhel-9-appstream   xxx k
 python3-yaml             x86_64 x.x.x-x.el9              rhel-9-appstream   xxx k
 ...

Transaction Summary
================================================================================
Install  XX Packages

Complete!

Verificar a Instalação do Ansible

Agora que você instalou o Ansible Core, vamos verificar se a instalação foi bem-sucedida, verificando a versão e confirmando que as ferramentas de linha de comando essenciais estão disponíveis.

Primeiro, verifique a versão do Ansible executando:

ansible --version

Este comando exibe informações detalhadas sobre sua instalação do Ansible, incluindo a versão do core, a versão do Python e os locais de vários componentes. Você deve ver uma saída como esta:

ansible [core 2.14.18]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3.9/site-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.9.21 (main, Feb 10 2025, 00:00:00) [GCC 11.5.0 20240719 (Red Hat 11.5.0-5)] (/usr/bin/python3)
  jinja version = 3.1.2
  libyaml = True

Vamos entender o que cada linha significa:

• ansible [core 2.14.18]: Mostra a versão do Ansible Core instalada
• config file: Aponta para o arquivo de configuração principal do Ansible que contém as configurações padrão
• configured module search path: Diretórios onde o Ansible procura por módulos personalizados
• ansible python module location: Onde o código Python principal do Ansible está instalado
• ansible collection location: Diretórios onde as coleções Ansible (módulos e plugins empacotados) são armazenadas
• executable location: A localização real do binário do comando ansible
• python version: A versão do interpretador Python que o Ansible usa
• jinja version: A versão do mecanismo de modelagem (templating) usado pelo Ansible para conteúdo dinâmico
• libyaml = True: Confirma que o analisador YAML rápido está disponível para melhor desempenho

Isso confirma que o Ansible está corretamente instalado e pronto para uso. Em seguida, vamos também verificar se o comando ansible-playbook está disponível:

ansible-playbook --version

Você deve ver informações de versão semelhantes para a ferramenta ansible-playbook, que é essencial para executar playbooks Ansible.

Testar o Ansible com um Comando Simples

Nesta etapa, você testará sua instalação do Ansible executando um comando simples contra o sistema local. Mude para o diretório do projeto e use o arquivo de inventário pré-configurado para executar um comando ad-hoc do Ansible.

Navegue até o diretório do projeto e teste a funcionalidade básica de ping:

cd /home/labex/project
ansible localhost -m ping

O módulo ping na verdade não envia pacotes ICMP; em vez disso, ele verifica se o Ansible pode se conectar ao destino e executar código Python. Uma resposta bem-sucedida terá esta aparência:

localhost | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false,
    "ping": "pong"
}

Vamos analisar esta saída:

• localhost | SUCCESS: Mostra que o comando foi executado com sucesso no destino localhost
• ansible_facts: Contém informações do sistema descobertas durante a execução
• discovered_interpreter_python: O caminho do interpretador Python que o Ansible encontrou e usará
• changed: false: Indica que nenhuma alteração foi feita no sistema (ping é somente leitura)
• ping: "pong": A resposta clássica confirmando a conectividade do Ansible

A resposta "pong" confirma que o Ansible está funcionando corretamente e pode se comunicar com o sistema de destino.

Vamos também testar a coleta de informações do sistema usando o módulo setup:

ansible localhost -m setup -a "filter=ansible_distribution*"

Este comando usa o módulo setup para coletar fatos do sistema, filtrando especificamente por informações de distribuição. Você deve ver uma saída contendo detalhes sobre seu sistema Red Hat Enterprise Linux:

localhost | SUCCESS => {
    "ansible_facts": {
        "ansible_distribution": "RedHat",
        "ansible_distribution_file_parsed": true,
        "ansible_distribution_file_path": "/etc/redhat-release",
        "ansible_distribution_file_search_string": "Red Hat",
        "ansible_distribution_file_variety": "RedHat",
        "ansible_distribution_major_version": "9",
        "ansible_distribution_release": "Plow",
        "ansible_distribution_version": "9.6",
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false
}

Entendendo a saída dos fatos do sistema:

• ansible_distribution: O nome da distribuição Linux (RedHat)
• ansible_distribution_file_parsed: Se o Ansible leu com sucesso o arquivo de distribuição
• ansible_distribution_file_path: O arquivo que contém informações de distribuição
• ansible_distribution_file_search_string: O padrão de texto usado para identificar a distribuição
• ansible_distribution_file_variety: A família da distribuição (família RedHat)
• ansible_distribution_major_version: O número da versão principal (9)
• ansible_distribution_release: O codinome da versão (Plow)
• ansible_distribution_version: O número da versão completo (9.6)
• discovered_interpreter_python: Interpretador Python descoberto pelo Ansible

Isso confirma que o Ansible pode coletar com sucesso informações do sistema do host de destino, o que é essencial para criar automação condicional com base nas características do sistema.

Explorar os Módulos Ansible Disponíveis

O Ansible vem com centenas de módulos embutidos para várias tarefas de automação. Vamos explorar alguns dos módulos disponíveis para entender quais recursos estão imediatamente disponíveis após a instalação.

Para ver uma lista dos módulos disponíveis, execute:

ansible-doc -l | head -20

O comando ansible-doc -l lista todos os módulos disponíveis, e usar head -20 mostra os primeiros 20 módulos. Isso dá uma ideia das extensas capacidades de automação disponíveis com o Ansible. Você verá uma saída semelhante a:

ansible.builtin.add_host               Add a host (and alternatively a grou...
ansible.builtin.apt                    Manages apt-packages
ansible.builtin.apt_key                Add or remove an apt key
ansible.builtin.apt_repository         Add and remove APT repositories
ansible.builtin.assemble               Assemble configuration files from fr...
ansible.builtin.assert                 Asserts given expressions are true
ansible.builtin.async_status           Obtain status of asynchronous task
ansible.builtin.blockinfile            Insert/update/remove a text block su...
ansible.builtin.command                Execute commands on targets
ansible.builtin.copy                   Copy files to remote locations
ansible.builtin.cron                   Manage cron.d and crontab entries
ansible.builtin.debconf                Configure a .deb package
ansible.builtin.debug                  Print statements during execution
ansible.builtin.dnf                    Manages packages with the `dnf' pack...
ansible.builtin.dpkg_selections        Dpkg package selection selections
ansible.builtin.expect                 Executes a command and responds to p...
ansible.builtin.fail                   Fail with custom message
ansible.builtin.fetch                  Fetch files from remote nodes
ansible.builtin.file                   Manage files and file properties
ansible.builtin.find                   Return a list of files based on spec...

Entendendo o formato da lista de módulos:

• ansible.builtin.: Indica que estes são módulos embutidos que vêm com o Ansible Core
• Nome do módulo: O nome que você usa ao chamar o módulo em playbooks ou comandos ad-hoc
• Descrição: Uma breve explicação do que o módulo faz

Alguns módulos importantes que você usará comumente:

• command: Executar comandos de shell em sistemas de destino
• copy: Copiar arquivos da sua máquina de controle para hosts remotos
• dnf: Instalar, atualizar ou remover pacotes em sistemas Red Hat
• file: Criar diretórios, definir permissões ou gerenciar propriedades de arquivos
• debug: Imprimir mensagens durante a execução do playbook para solução de problemas

Para obter documentação detalhada de um módulo específico, você pode usar o comando ansible-doc com o nome do módulo. Por exemplo, para aprender sobre o módulo copy:

ansible-doc copy

Isso exibirá documentação abrangente para o módulo copy, incluindo exemplos e descrições de parâmetros. O comando ansible-doc fornece documentação detalhada para qualquer módulo Ansible, facilitando o aprendizado de como usar diferentes capacidades de automação. Pressione q para sair do visualizador de documentação quando terminar de ler.

Resumo

Neste laboratório, você aprendeu com sucesso como instalar e verificar o Ansible Core em um sistema Red Hat Enterprise Linux. Aqui está o que você realizou:

1. Instalou o Ansible Core: Você usou o comando sudo dnf install ansible-core -y para instalar o pacote Ansible core e suas dependências dos repositórios oficiais do Red Hat.

2. Verificou a Instalação: Você confirmou que o Ansible foi instalado corretamente verificando a versão dos comandos ansible e ansible-playbook.

3. Testou a Funcionalidade Básica: Você executou comandos Ansible simples para verificar se a instalação funciona corretamente, incluindo:

   • Usando o módulo ping para testar a conectividade
   • Usando o módulo setup para coletar fatos do sistema

4. Explorou os Módulos Disponíveis: Você aprendeu como descobrir e ler a documentação da extensa biblioteca de módulos Ansible usando ansible-doc.

Você agora tem uma instalação Ansible totalmente funcional no RHEL e entende os comandos básicos necessários para começar a automatizar sua infraestrutura. Essa base o prepara para tópicos mais avançados do Ansible, como escrever playbooks, gerenciar inventários e implementar fluxos de trabalho de automação complexos.