Gerenciar Variáveis e Fatos em RHEL com Ansible

AnsibleBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá técnicas fundamentais para gerenciar variáveis, fatos (facts) e segredos em playbooks Ansible em um sistema Red Hat Enterprise Linux (RHEL). Você explorará como tornar sua automação mais flexível e poderosa usando variáveis de playbook, coletando informações do sistema com fatos Ansible integrados e personalizados, e protegendo dados sensíveis como senhas usando o Ansible Vault.

Através de uma série de etapas práticas, você criará um playbook para implantar e configurar um servidor web Apache. Você começará definindo variáveis simples para o nome do pacote e o conteúdo da web, em seguida, utilizará fatos personalizados para atualizar dinamicamente a configuração do servidor web. Finalmente, você usará o Ansible Vault para criar com segurança um novo usuário do sistema com uma senha criptografada, executará o playbook completo e verificará se todas as configurações foram aplicadas com sucesso.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível intermediário com uma taxa de conclusão de 79%. Recebeu uma taxa de avaliações positivas de 98% dos estudantes.

Definir e Usar Variáveis de Playbook para Implantar um Servidor Web Apache

Nesta etapa, você aprenderá como usar variáveis em um playbook Ansible. Variáveis são essenciais para tornar sua automação flexível, reutilizável e mais fácil de ler e manter. Em vez de codificar valores como nomes de pacotes ou caminhos de arquivos diretamente em suas tarefas, você pode defini-los como variáveis e referenciá-los em todo o playbook. Criaremos um playbook simples que usa variáveis para instalar o servidor web Apache (httpd) e implantar uma página web básica.

  1. Navegar para o Diretório do Projeto

    Primeiro, certifique-se de que você está no diretório de trabalho correto. Todo o seu trabalho para este laboratório será feito dentro do diretório ~/project, que foi criado para você.

    cd ~/project

    Instale o pacote ansible-core.

    sudo dnf install -y ansible-core
  2. Criar o Playbook Ansible

    Agora, vamos criar nosso arquivo de playbook. Vamos chamá-lo de playbook.yml. Você pode usar um editor de texto de linha de comando como nano para criar e editar o arquivo.

    nano playbook.yml

    Este comando abre um arquivo vazio no editor nano. Agora, adicione a parte inicial do playbook. Esta seção define o nome do play, o host de destino (localhost, já que estamos executando na mesma máquina) e uma seção vars onde definiremos nossas variáveis.

    ---
    - name: Deploy Apache using variables
      hosts: localhost
      become: true
      vars:
        web_pkg: httpd
        web_content: "Hello from Ansible Variables"

    Aqui está uma descrição da estrutura do playbook:

    • hosts: localhost: Especifica que o playbook deve ser executado na máquina local.
    • become: true: Diz ao Ansible para usar a escalada de privilégios (equivalente a sudo) para as tarefas, o que é necessário para instalar software.
    • vars: Este é um dicionário onde definimos nossos pares chave-valor para variáveis. Definimos web_pkg para o nome do pacote e web_content para o conteúdo da nossa página web de teste.
  3. Adicionar Tarefas ao Playbook

    Em seguida, abaixo da seção vars, adicione as tasks que usarão essas variáveis. A primeira tarefa instalará o pacote Apache e a segunda criará um arquivo index.html. Adicione o seguinte bloco tasks ao seu arquivo playbook.yml enquanto ainda estiver no editor nano.

    tasks:
      - name: Install the latest version of Apache
        ansible.builtin.dnf:
          name: "{{ web_pkg }}"
          state: latest
    
      - name: Create a basic index.html file
        ansible.builtin.copy:
          content: "{{ web_content }}"
          dest: /var/www/html/index.html

    Observe como usamos {{ nome_da_variavel }} para referenciar as variáveis que definimos anteriormente. Esta é a templateização Jinja2, que o Ansible usa para variáveis. Isso torna as definições de tarefas genéricas; se você quisesse instalar o Nginx em vez disso, precisaria apenas alterar a variável web_pkg, não a tarefa em si.

  4. Revisar e Salvar o Playbook

    Seu arquivo playbook.yml completo agora deve se parecer com isto. Verifique o conteúdo e a indentação, pois o YAML é muito sensível ao espaçamento.

    ---
    - name: Deploy Apache using variables
      hosts: localhost
      become: true
      vars:
        web_pkg: httpd
        web_content: "Hello from Ansible Variables"
      tasks:
        - name: Install the latest version of Apache
          ansible.builtin.dnf:
            name: "{{ web_pkg }}"
            state: latest
    
        - name: Create a basic index.html file
          ansible.builtin.copy:
            content: "{{ web_content }}"
            dest: /var/www/html/index.html

    Para salvar o arquivo no nano, pressione Ctrl+X, depois Y para confirmar as alterações e, finalmente, Enter para escrever o arquivo com o nome playbook.yml.

  5. Verificar a Sintaxe do Playbook

    Antes de executar um playbook, é sempre uma boa prática verificar sua sintaxe em busca de erros.

    ansible-playbook --syntax-check playbook.yml

    Se a sintaxe estiver correta, você verá o caminho do arquivo do playbook como saída, confirmando que ele é válido:

    playbook: playbook.yml

    Se você vir algum erro, reabra o arquivo com nano playbook.yml e corrija-os. Preste muita atenção à indentação correta (geralmente dois espaços).

  6. Executar o Playbook

    Agora, execute o playbook. O Ansible se conectará ao localhost, lerá as variáveis e executará as tarefas.

    ansible-playbook playbook.yml

    Você deverá ver uma saída indicando a execução bem-sucedida de cada tarefa. O status changed significa que o Ansible fez uma modificação no sistema, como instalar um pacote ou criar um arquivo.

    PLAY [Deploy Apache using variables] *******************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Install the latest version of Apache] ************************************
    changed: [localhost]
    
    TASK [Create a basic index.html file] ******************************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    Se você executar o playbook uma segunda vez, as tarefas deverão relatar ok em vez de changed, porque o pacote já está instalado e o arquivo já possui o conteúdo correto. Isso demonstra a idempotência do Ansible.

  7. Verificar a Configuração Manualmente

    Embora o playbook tenha sido concluído, você pode verificar manualmente se as tarefas funcionaram como esperado. Primeiro, verifique se o pacote httpd foi instalado:

    rpm -q httpd

    A saída deve mostrar o nome e a versão do pacote:

    httpd-2.4.57-7.el9.x86_64

    Em seguida, verifique o conteúdo do arquivo index.html:

    cat /var/www/html/index.html

    A saída deve corresponder ao valor da sua variável web_content:

    Hello from Ansible Variables

    Você usou com sucesso variáveis em um playbook Ansible para configurar um sistema.

Exibir Informações do Sistema usando Ansible Facts

Nesta etapa, você explorará os fatos Ansible. Fatos são pedaços de informação que o Ansible coleta sobre os sistemas que gerencia (neste caso, localhost). Essas informações incluem detalhes como o sistema operacional, interfaces de rede, memória e muito mais. Por padrão, o Ansible coleta fatos no início de cada play, tornando-os disponíveis em uma variável especial chamada ansible_facts. O uso de fatos permite criar playbooks dinâmicos que se adaptam ao ambiente em que estão sendo executados.

  1. Navegar para o Diretório do Projeto

    Primeiro, certifique-se de que você está no diretório ~/project, onde criará o novo playbook.

    cd ~/project
  2. Criar um Playbook para Exibir Todos os Fatos

    Vamos começar criando um playbook que simplesmente exibe todos os fatos que o Ansible pode coletar sobre seu sistema. Isso lhe dará uma ideia da vasta quantidade de informações disponíveis. Use nano para criar um novo arquivo chamado display_facts.yml.

    nano display_facts.yml

    Dentro do editor nano, adicione o seguinte conteúdo. Este playbook tem como alvo localhost e usa o módulo ansible.builtin.debug para imprimir o conteúdo da variável ansible_facts.

    ---
    - name: Display all Ansible facts
      hosts: localhost
      tasks:
        - name: Print all available facts
          ansible.builtin.debug:
            var: ansible_facts

    Salve o arquivo e saia do nano pressionando Ctrl+X, depois Y e Enter.

  3. Executar o Playbook

    Agora, execute o playbook para ver o resultado.

    ansible-playbook display_facts.yml

    A saída será muito longa, pois o Ansible coleta muitos dados. Será uma grande estrutura JSON contendo todos os detalhes do sistema. Isso é esperado.

    PLAY [Display all Ansible facts] ***********************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Print all available facts] ***********************************************
    ok: [localhost] => {
        "ansible_facts": {
            "ansible_all_ipv4_addresses": [
                "172.17.0.2"
            ],
            "ansible_all_ipv6_addresses": [
                "fe80::42:acff:fe11:2"
            ],
            "ansible_apparmor": {
                "status": "disabled"
            },
            "ansible_architecture": "x86_64",
            "ansible_bios_date": "01/01/2011",
            "ansible_bios_version": "1.0",
            "ansible_cmdline": {
                "BOOT_IMAGE": "/boot/vmlinuz-5.14.0-427.16.1.el9_4.x86_64",
                "root": "UUID=...",
                "ro": true
            },
            "ansible_date_time": {
                "date": "2024-05-21",
                "day": "21",
                "epoch": "1716298855",
                ...
            },
            "ansible_distribution": "RedHat",
            "ansible_distribution_major_version": "9",
            "ansible_distribution_version": "9.4",
            ...
        }
    }
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
  4. Criar um Playbook para Exibir Fatos Específicos

    Exibir todos os fatos é útil para descoberta, mas na maioria dos casos, você precisa apenas de informações específicas. Vamos criar outro playbook, display_specific_facts.yml, para exibir uma mensagem formatada com apenas alguns fatos-chave.

    nano display_specific_facts.yml

    Adicione o seguinte conteúdo. Este playbook usa o parâmetro msg do módulo debug para imprimir uma string personalizada. Acessamos fatos individuais usando a notação de colchetes, como ansible_facts['distribution'].

    ---
    - name: Display specific Ansible facts
      hosts: localhost
      tasks:
        - name: Print a summary of system facts
          ansible.builtin.debug:
            msg: >
              The operating system is {{ ansible_facts['distribution'] }}
              version {{ ansible_facts['distribution_major_version'] }}.
              It has {{ ansible_facts['processor_cores'] }} processor cores and
              {{ ansible_facts['memtotal_mb'] }} MB of total memory.

    O caractere > em msg: > é um recurso YAML que permite escrever uma string de várias linhas de forma mais limpa. Salve o arquivo e saia do nano.

  5. Executar o Playbook para Fatos Específicos

    Agora, execute este novo playbook.

    ansible-playbook display_specific_facts.yml

    A saída será muito mais limpa e legível, mostrando apenas as informações que você solicitou.

    PLAY [Display specific Ansible facts] ******************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Print a summary of system facts] *****************************************
    ok: [localhost] => {
        "msg": "The operating system is RedHat version 9. It has 2 processor cores and 3925 MB of total memory."
    }
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    Isso demonstra como você pode aproveitar os fatos Ansible para tornar seus playbooks cientes do ambiente em que estão sendo executados, permitindo uma automação mais inteligente e condicional.

Configurar o Servidor Web usando Fatos Personalizados do Host Gerenciado

Nesta etapa, você aprenderá como usar fatos personalizados. Embora o Ansible colete automaticamente uma ampla gama de fatos padrão, você também pode definir os seus próprios. Estes são chamados de "fatos locais" ou "fatos personalizados". Este é um recurso poderoso que permite fornecer informações específicas de um host gerenciado para seus playbooks, como configurações de aplicativos ou dados específicos de hardware que o Ansible não coleta por padrão.

O Ansible procura por fatos personalizados no diretório /etc/ansible/facts.d no host gerenciado. Qualquer arquivo neste diretório com a extensão .fact será processado. Esses arquivos podem ser arquivos de texto simples no estilo INI ou arquivos JSON.

  1. Criar o Diretório de Fatos Personalizados

    Primeiro, você precisa criar o diretório onde o Ansible procurará os arquivos de fatos personalizados. Como este é um diretório do sistema, você deve usar sudo para criá-lo.

    sudo mkdir -p /etc/ansible/facts.d

    O sinalizador -p garante que o comando não retorne um erro se o diretório já existir.

  2. Criar um Arquivo de Fato Personalizado

    Agora, vamos criar um arquivo de fato personalizado para definir uma mensagem de boas-vindas para o nosso servidor web. Criaremos um arquivo formatado em INI chamado web_config.fact dentro do diretório /etc/ansible/facts.d.

    sudo nano /etc/ansible/facts.d/web_config.fact

    Adicione o seguinte conteúdo ao arquivo. Isso define uma seção [webserver] com uma chave welcome_message.

    [webserver]
    welcome_message = Welcome to the server configured by Custom Facts!

    Salve o arquivo e saia do nano pressionando Ctrl+X, depois Y e Enter.

  3. Criar um Playbook para Usar o Fato Personalizado

    Com o fato personalizado no lugar, podemos agora criar um playbook que lê esse fato e o usa para configurar a página inicial do nosso servidor web. No seu diretório ~/project, crie um novo playbook chamado configure_web.yml.

    cd ~/project
    nano configure_web.yml

    Adicione o seguinte conteúdo ao playbook. Este playbook atualizará o arquivo /var/www/html/index.html com a mensagem definida em nosso fato personalizado.

    ---
    - name: Configure web server using custom facts
      hosts: localhost
      become: true
      tasks:
        - name: Update index.html with custom message
          ansible.builtin.copy:
            content: "{{ ansible_facts.ansible_local.web_config.webserver.welcome_message }}"
            dest: /var/www/html/index.html

    Vamos detalhar a variável {{ ansible_facts.ansible_local.web_config.webserver.welcome_message }}:

    • ansible_facts: O dicionário raiz para todos os fatos.
    • ansible_local: A chave onde todos os fatos personalizados são armazenados.
    • web_config: O nome do nosso arquivo de fato (web_config.fact), sem a extensão.
    • webserver: O nome da seção [webserver] do nosso arquivo INI.
    • welcome_message: A chave para o valor que queremos usar.

    Salve o arquivo e saia do nano.

  4. Executar o Playbook de Configuração

    Agora, execute o playbook para aplicar a configuração.

    ansible-playbook configure_web.yml

    A saída deve mostrar que a tarefa copy changed o arquivo index.html.

    PLAY [Configure web server using custom facts] *********************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Update index.html with custom message] ***********************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
  5. Verificar o Resultado

    Finalmente, vamos verificar se a página web foi atualizada corretamente. Use o comando cat para visualizar o conteúdo do arquivo index.html.

    cat /var/www/html/index.html

    A saída agora deve exibir a mensagem do seu arquivo de fato personalizado:

    Welcome to the server configured by Custom Facts!

    Você criou com sucesso um fato personalizado no host gerenciado e o usou em um playbook para configurar dinamicamente um serviço. Essa técnica é incrivelmente útil para tornar sua automação mais flexível e orientada por dados.

Criar um Usuário do Sistema usando Variáveis Criptografadas com Ansible Vault

Nesta etapa, você aprenderá como gerenciar dados sensíveis, como senhas ou chaves de API, usando o Ansible Vault. Armazenar informações sensíveis em texto puro em seus playbooks representa um grande risco de segurança. O Ansible Vault fornece uma maneira de criptografar arquivos ou variáveis individuais, mantendo seus segredos seguros. Você pode então usar esses arquivos criptografados em seus playbooks, e o Ansible os descriptografará em tempo de execução quando você fornecer a senha correta.

Criaremos um arquivo criptografado contendo um nome de usuário e uma senha hasheada, e então usaremos um playbook para criar um novo usuário do sistema com essas credenciais.

  1. Navegar para o Diretório do Projeto

    Certifique-se de que você está no diretório ~/project para esta tarefa.

    cd ~/project
  2. Criar um Arquivo Vault Criptografado

    Usaremos o comando ansible-vault create para criar um novo arquivo YAML criptografado chamado secrets.yml. Este comando solicitará que você crie uma senha para o vault. Essa senha é necessária para abrir, editar ou usar o arquivo posteriormente.

    Primeiro, vamos definir o editor como nano para facilitar o trabalho:

    export EDITOR=nano

    Agora crie o arquivo vault:

    ansible-vault create secrets.yml

    Quando solicitado, insira uma senha para o seu vault. Para este laboratório, vamos usar labex como senha do vault para simplificar. Você precisará inseri-la duas vezes.

    New Vault password:
    Confirm New Vault password:

    Após confirmar a senha, o comando abrirá o arquivo secrets.yml no editor de texto nano.

  3. Adicionar Variáveis Secretas ao Arquivo Vault

    Dentro do editor nano, que agora está editando o arquivo criptografado secrets.yml, adicione as seguintes variáveis. Definiremos um nome de usuário e uma senha hasheada previamente para um novo usuário. Usar uma senha hasheada é muito mais seguro do que armazenar uma senha em texto puro.

    username: myappuser
    pwhash: $6$mysalt$QwMzWSEyCAGmz7tzVrAi5o.8k4d05i2QsfGGwmPtlJsWhGjSjCW6yFCH/OEqEsHk7GMSxqYNXu5sshxPmWyxo0
    • username: O nome do usuário do sistema que queremos criar.
    • pwhash: Uma senha com hash seguro. Este hash específico corresponde à senha AnsibleUserP@ssw0rd e está em um formato que o módulo ansible.builtin.user entende.

    Salve o arquivo e saia do nano (Ctrl+X, depois Y, depois Enter). O arquivo secrets.yml no seu diretório ~/project agora está criptografado. Se você tentar visualizá-lo com cat secrets.yml, verá apenas texto criptografado.

  4. Criar um Playbook para Usar o Arquivo Vault

    Agora, crie um novo playbook chamado create_user.yml que usará as variáveis do seu arquivo secrets.yml criptografado.

    nano create_user.yml

    Adicione o seguinte conteúdo. A diretiva vars_files informa ao Ansible para carregar variáveis do arquivo especificado.

    ---
    - name: Create a user from secret variables
      hosts: localhost
      become: true
      vars_files:
        - secrets.yml
      tasks:
        - name: Create the {{ username }} user
          ansible.builtin.user:
            name: "{{ username }}"
            password: "{{ pwhash }}"
            state: present

    Este playbook criará um usuário com o nome e o hash de senha definidos em secrets.yml. Salve o arquivo e saia do nano.

  5. Executar o Playbook com a Senha do Vault

    Para executar um playbook que usa um arquivo vault, você deve fornecer a senha do vault. Você pode fazer isso interativamente usando o sinalizador --ask-vault-pass.

    ansible-playbook --ask-vault-pass create_user.yml

    O Ansible solicitará a senha do vault. Insira labex (a senha que você definiu na etapa 2).

    Vault password:

    Após fornecer a senha correta, o Ansible descriptografará o arquivo na memória e executará o playbook. Você deverá ver a seguinte saída, indicando que o usuário foi criado.

    PLAY [Create a user from secret variables] *************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Create the myappuser user] ***********************************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
  6. Verificar se o Usuário foi Criado

    Você pode confirmar que o myappuser foi criado com sucesso no sistema usando o comando id.

    id myappuser

    Se o usuário existir, você verá suas informações de ID de usuário (uid) e ID de grupo (gid).

    uid=1002(myappuser) gid=1002(myappuser) groups=1002(myappuser)

    Isso confirma que você usou com sucesso o Ansible Vault para gerenciar dados sensíveis em suas tarefas de automação.

Executar um Playbook com um Arquivo de Senha do Vault para Aplicar Configurações

Nesta etapa, você aprenderá uma maneira mais automatizada de fornecer a senha do vault ao Ansible. Na etapa anterior, você usou --ask-vault-pass para inserir a senha interativamente. Embora isso seja seguro, não é adequado para ambientes automatizados como pipelines de CI/CD, onde nenhum usuário está presente para digitar uma senha.

A solução é usar um arquivo de senha do vault. Este é um arquivo de texto simples que contém a senha do vault. Você pode então referenciar este arquivo ao executar seu playbook, e o Ansible lerá a senha dele automaticamente. Por segurança, é crucial restringir as permissões deste arquivo de senha para que apenas usuários autorizados possam lê-lo.

  1. Navegar para o Diretório do Projeto

    Certifique-se de que você está no diretório ~/project, onde seu playbook e arquivo vault estão localizados.

    cd ~/project
  2. Criar o Arquivo de Senha do Vault

    Vamos criar um arquivo para armazenar nossa senha do vault. Chamaremos de vault_pass.txt. Podemos usar o comando echo para criar o arquivo e escrever a senha (labex) nele em uma única etapa.

    echo "labex" > vault_pass.txt

    Você pode verificar o conteúdo do arquivo com cat:

    cat vault_pass.txt

    A saída deve ser:

    labex
  3. Proteger o Arquivo de Senha

    Armazenar uma senha em um arquivo de texto puro é arriscado. Você deve restringir suas permissões de arquivo para protegê-lo. O comando chmod permite alterar as permissões de arquivo. Definiremos as permissões para 600, o que significa que apenas o proprietário do arquivo (neste caso, o usuário labex) tem permissões de leitura e escrita. Nenhum outro usuário no sistema poderá acessá-lo.

    chmod 600 vault_pass.txt

    Você pode verificar as novas permissões usando o comando ls -l:

    ls -l vault_pass.txt

    A saída deve começar com -rw-------, confirmando as permissões restritas.

    -rw-------. 1 labex labex 6 May 21 14:30 vault_pass.txt
  4. Modificar o Playbook para Adicionar um Usuário a um Grupo

    Vamos modificar nosso playbook create_user.yml para realizar uma ação adicional. Adicionaremos o myappuser ao grupo wheel, que em muitos sistemas concede privilégios administrativos (sudo). Isso demonstrará a execução de um playbook que faz uma alteração em uma configuração existente.

    Primeiro, abra o playbook create_user.yml para edição.

    nano create_user.yml

    Modifique a tarefa ansible.builtin.user para incluir os parâmetros groups e append.

    ---
    - name: Create a user from secret variables
      hosts: localhost
      become: true
      vars_files:
        - secrets.yml
      tasks:
        - name: Create the {{ username }} user and add to wheel group
          ansible.builtin.user:
            name: "{{ username }}"
            password: "{{ pwhash }}"
            state: present
            groups: wheel
            append: true
    • groups: wheel: Especifica o grupo ao qual o usuário será adicionado.
    • append: true: Garante que o usuário seja adicionado a este grupo sem removê-lo de quaisquer outros grupos aos quais ele possa pertencer.

    Salve o arquivo e saia do nano.

  5. Executar o Playbook com o Arquivo de Senha do Vault

    Agora, execute o playbook novamente. Desta vez, em vez de --ask-vault-pass, use a opção --vault-password-file (ou seu alias mais curto --vault-pass-file) para especificar o caminho para o seu arquivo de senha.

    ansible-playbook --vault-password-file vault_pass.txt create_user.yml

    O Ansible agora será executado sem solicitar uma senha, pois a lê diretamente de vault_pass.txt. Você deverá ver uma saída indicando que a configuração do usuário foi alterada.

    PLAY [Create a user from secret variables] *************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Create the myappuser user and add to wheel group] ************************
    changed: [localhost]
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    O status changed confirma que o Ansible modificou o usuário adicionando-o ao grupo wheel.

  6. Verificar a Associação de Grupo do Usuário

    Finalmente, verifique se o myappuser agora é membro do grupo wheel. Você pode fazer isso com o comando groups.

    groups myappuser

    A saída deve mostrar tanto o grupo primário do usuário (myappuser) quanto o grupo wheel.

    myappuser : myappuser wheel

    Você usou com sucesso um arquivo de senha do vault para executar um playbook de forma não interativa, uma habilidade fundamental para automatizar fluxos de trabalho seguros.

Verificar a Configuração do Servidor Web e do Usuário

Nesta etapa final, você consolidará seu aprendizado criando um playbook de verificação dedicado. Até agora, você tem verificado manualmente os resultados de seus playbooks usando comandos Linux padrão como cat, id e groups. Uma abordagem mais poderosa e repetível é usar o próprio Ansible para auditar e validar o estado do seu sistema.

Este playbook atuará como um conjunto de testes, verificando programaticamente que o servidor web está instalado, a página web tem o conteúdo correto e o usuário do sistema existe com a associação de grupo apropriada. Isso demonstra como o Ansible pode ser usado não apenas para gerenciamento de configuração, mas também para conformidade e validação de estado.

  1. Navegar para o Diretório do Projeto

    Primeiro, certifique-se de que você está no diretório ~/project.

    cd ~/project
  2. Criar o Playbook de Verificação

    Vamos criar um novo playbook chamado verify_config.yml. Este playbook conterá uma série de tarefas que verificam as configurações que você aplicou nas etapas anteriores.

    nano verify_config.yml
  3. Adicionar Tarefas para Verificar a Configuração

    Dentro do editor nano, adicione o seguinte conteúdo. Construiremos este playbook com várias tarefas, cada uma projetada para afirmar que uma condição específica é verdadeira. Se alguma asserção falhar, o playbook será interrompido e relatará um erro, informando imediatamente o que está errado.

    ---
    - name: Verify system configuration
      hosts: localhost
      become: true
      tasks:
        - name: Check if httpd package is installed
          ansible.builtin.dnf:
            list: httpd
          register: httpd_pkg_info
    
        - name: Assert that httpd is installed
          ansible.builtin.assert:
            that:
              - httpd_pkg_info.results | length > 0
            fail_msg: "Apache (httpd) package is not installed."
            success_msg: "Apache (httpd) package is installed."
    
        - name: Read the content of the index.html file
          ansible.builtin.slurp:
            src: /var/www/html/index.html
          register: index_file
    
        - name: Assert that the web page content is correct
          ansible.builtin.assert:
            that:
              - "'Custom Facts' in (index_file.content | b64decode)"
            fail_msg: "Web page content is incorrect."
            success_msg: "Web page content is correct."
    
        - name: Check if myappuser exists
          ansible.builtin.getent:
            database: passwd
            key: myappuser
          register: user_info
    
        - name: Assert that myappuser exists
          ansible.builtin.assert:
            that:
              - user_info.getent_passwd['myappuser'] is defined
            fail_msg: "User 'myappuser' does not exist."
            success_msg: "User 'myappuser' exists."
    
        - name: Assert that myappuser is in the wheel group
          ansible.builtin.assert:
            that:
              - "'wheel' in user_info.getent_passwd['myappuser'][3]"
            fail_msg: "User 'myappuser' is not in the wheel group."
            success_msg: "User 'myappuser' is in the wheel group."

    Vamos revisar os módulos chave usados aqui:

    • ansible.builtin.dnf com list: Isso verifica um pacote e register o resultado.
    • ansible.builtin.slurp: Isso "suga" todo o conteúdo de um arquivo do host remoto. O conteúdo é codificado em base64 para transporte seguro.
    • ansible.builtin.getent: Esta é uma maneira segura de consultar bancos de dados do sistema como passwd e group.
    • ansible.builtin.assert: Este é o núcleo da nossa verificação. Ele verifica se uma determinada condição é verdadeira. Se não for, ele falha o play. Fornecemos mensagens personalizadas de sucesso e falha.
    • b64decode: Este é um filtro Jinja2 usado para decodificar o conteúdo base64 que obtivemos do módulo slurp.

    Salve o arquivo e saia do nano (Ctrl+X, Y, Enter).

  4. Executar o Playbook de Verificação

    Agora, execute seu playbook de verificação. Como ele não usa nenhum arquivo com vault, você não precisa fornecer uma senha.

    ansible-playbook verify_config.yml

    Se todas as suas etapas anteriores foram concluídas corretamente, o playbook será executado com sucesso, e você verá a mensagem de sucesso personalizada para cada asserção.

    PLAY [Verify system configuration] *********************************************
    
    TASK [Gathering Facts] *********************************************************
    ok: [localhost]
    
    TASK [Check if httpd package is installed] *************************************
    ok: [localhost]
    
    TASK [Assert that httpd is installed] ******************************************
    ok: [localhost] => {
        "changed": false,
        "msg": "Apache (httpd) package is installed."
    }
    
    TASK [Read the content of the index.html file] *********************************
    ok: [localhost]
    
    TASK [Assert that the web page content is correct] *****************************
    ok: [localhost] => {
        "changed": false,
        "msg": "Web page content is correct."
    }
    
    TASK [Check if myappuser exists] ***********************************************
    ok: [localhost]
    
    TASK [Assert that myappuser exists] ********************************************
    ok: [localhost] => {
        "changed": false,
        "msg": "User 'myappuser' exists."
    }
    
    TASK [Assert that myappuser is in the wheel group] *****************************
    ok: [localhost] => {
        "changed": false,
        "msg": "User 'myappuser' is in the wheel group."
    }
    
    PLAY RECAP *********************************************************************
    localhost                  : ok=9    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

    Parabéns! Você usou com sucesso o Ansible para definir variáveis, coletar fatos do sistema, gerenciar segredos com Vault e, finalmente, para verificar o estado do seu sistema de forma automatizada.

Resumo

Neste laboratório, você aprendeu a gerenciar diferentes tipos de dados em playbooks Ansible para configurar um sistema RHEL. Você começou definindo e usando variáveis de playbook padrão para instalar e configurar um servidor web Apache de forma flexível. Em seguida, explorou como aproveitar os fatos integrados do Ansible para exibir informações do sistema, fornecendo uma base para a criação de tarefas de automação dinâmicas e cientes do host.

Com base nisso, você configurou ainda mais o servidor web criando e utilizando fatos personalizados do host gerenciado. Para lidar com informações confidenciais de forma segura, você usou o Ansible Vault para criptografar uma senha de usuário, criou um novo usuário do sistema com essa variável criptografada e executou o playbook de forma não interativa com um arquivo de senha do vault. O laboratório concluiu verificando se tanto o servidor web quanto o novo usuário do sistema foram configurados corretamente, confirmando a aplicação bem-sucedida de todos os conceitos aprendidos.