Instalar o 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). O 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 de sudo para instalar o pacote ansible-core, que fornece o motor principal do Ansible e as ferramentas de linha de comando. Após a instalação, você verificará se o Ansible está funcionando corretamente conferindo sua versão e executando comandos básicos.

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

Instalar o Ansible Core usando o dnf

Nesta etapa, você instalará o pacote ansible-core usando o gerenciador de pacotes dnf. O Ansible Core fornece o motor essencial do Ansible, incluindo o ansible, ansible-playbook e outras ferramentas de linha de comando 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 "yes" a todas as solicitações, tornando a instalação não interativa. O sistema fará o download e instalará o ansible-core junto com suas dependências Python, incluindo o Jinja2 para templates e o PyYAML para processamento de YAML.

Você deverá ver uma saída semelhante a esta, mostrando a resolução de pacotes 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 conferindo 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 núcleo, a versão do Python e os locais de vários componentes. Você deverá 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 definiçõ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 do Ansible (módulos e plugins empacotados) estão armazenadas
executable location: O local real do binário do comando ansible
python version: A versão do interpretador Python que o Ansible utiliza
jinja version: A versão do motor de templates usado pelo Ansible para conteúdo dinâmico
libyaml = True: Confirma que o parser YAML rápido está disponível para melhor desempenho

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

ansible-playbook --version

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

Testar o Ansible com um comando simples

Nesta etapa, você testará sua instalação do Ansible executando um comando simples no sistema local. Acesse 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. Salve a saída em um arquivo para que você possa revisá-la e para que o verificador da etapa possa confirmar o resultado de forma confiável:

cd /home/labex/project
ansible localhost -m ping | tee ping-output.txt

O módulo ping não envia pacotes ICMP; em vez disso, ele verifica se o Ansible consegue se conectar ao destino e executar código Python. Uma resposta bem-sucedida será assim:

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 (o ping é apenas leitura)
ping: "pong": A resposta clássica confirmando a conectividade com o 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 e salvar essa saída também:

ansible localhost -m setup -a "filter=ansible_distribution*" | tee setup-output.txt

Este comando usa o módulo setup para coletar fatos do sistema, filtrando especificamente por informações de distribuição. Você deverá 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 conseguiu ler o arquivo de distribuição com sucesso
ansible_distribution_file_path: O arquivo que contém as 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 completo da versão (9.6)
discovered_interpreter_python: Interpretador Python descoberto pelo Ansible

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

Explorar módulos disponíveis do Ansible

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

Para ver uma lista de módulos disponíveis, execute o seguinte comando e salve as primeiras linhas em um arquivo:

ansible-doc -l | head -20 | tee module-list.txt

O comando ansible-doc -l lista todos os módulos disponíveis, e usar head -20 mostra os primeiros 20 módulos. Isso lhe 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 integrados que acompanham 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á com frequência:

command: Executar comandos 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. Redirecione a saída para um arquivo para que o comando permaneça não interativo e você possa inspecioná-lo mais tarde. Por exemplo, para aprender sobre o módulo copy:

ansible-doc copy | tee copy-doc.txt

Isso exibirá a documentação abrangente para o módulo copy, incluindo exemplos e descrições de parâmetros, enquanto também salva uma cópia em copy-doc.txt. O comando ansible-doc fornece documentação detalhada para qualquer módulo do Ansible, facilitando o aprendizado de como usar diferentes capacidades de automação.

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:

Instalou o Ansible Core: Você usou o comando sudo dnf install ansible-core -y para instalar o pacote principal do Ansible e suas dependências a partir dos repositórios oficiais da Red Hat.
Verificou a instalação: Você confirmou que o Ansible foi instalado corretamente verificando a versão dos comandos ansible e ansible-playbook.
Testou a funcionalidade básica: Você executou comandos simples do Ansible para verificar se a instalação funciona corretamente, incluindo:
- Uso do módulo ping para testar a conectividade
- Uso do módulo setup para coletar fatos do sistema
Explorou os módulos disponíveis: Você aprendeu como descobrir e ler a documentação da extensa biblioteca de módulos do Ansible usando o ansible-doc.

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