Gerenciar Variáveis e Fatos no RHEL com Ansible

Introdução

Neste laboratório, você aprenderá técnicas fundamentais para gerenciar variáveis, fatos e segredos dentro de playbooks do 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 do Ansible (tanto integrados quanto personalizados) e protegendo dados confidenciais, como senhas, usando o Ansible Vault.

Por meio 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 web, depois aproveitará fatos personalizados para atualizar dinamicamente a configuração do servidor web. Por fim, 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.

Definir e usar variáveis de playbook para implantar um servidor web Apache

Nesta etapa, você aprenderá como usar variáveis em um playbook do Ansible. As 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 ao longo do playbook. Criaremos um playbook simples que usa variáveis para instalar o servidor web Apache (httpd) e implantar uma página web básica.

Navegue até o diretório do projeto

Primeiro, certifique-se de estar 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
```
Criar o Playbook do 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 o 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 análise 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 elevação de privilégios (equivalente ao 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.
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 de 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 {{ variable_name }} para referenciar as variáveis que definimos anteriormente. Este é o modelo Jinja2, que o Ansible usa para variáveis. Isso torna as definições de tarefa genéricas; se você quisesse instalar o Nginx, precisaria apenas alterar a variável web_pkg, não a tarefa em si.

Revisar e salvar o Playbook

Seu arquivo playbook.yml completo agora deve estar assim. Verifique o conteúdo e o recuo, 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 gravar o arquivo com o nome playbook.yml.

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 é válido:
```
playbook: playbook.yml
```
Se você vir algum erro, reabra o arquivo com nano playbook.yml e corrija-o. Preste muita atenção ao recuo correto (geralmente dois espaços).

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ê deve 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 devem relatar ok em vez de changed, porque o pacote já está instalado e o arquivo já tem o conteúdo correto. Isso demonstra a idempotência do Ansible.

Verificar a configuração manualmente

Embora o playbook tenha sido concluído, você pode verificar manualmente se as tarefas funcionaram conforme o 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 do Ansible para configurar um sistema.

Exibir informações do sistema usando fatos do Ansible

Nesta etapa, você explorará os fatos do Ansible. Fatos são informações que o Ansible coleta sobre os sistemas que gerencia (neste caso, localhost). Essas informações incluem detalhes como 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. Usar fatos permite que você crie playbooks dinâmicos que se adaptam ao ambiente em que estão sendo executados.

Navegue até o diretório do projeto

Primeiro, certifique-se de estar no diretório ~/project onde você criará o novo playbook.
```
cd ~/project
```
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 o 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 o 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.

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

Criar um playbook para exibir fatos específicos

Exibir todos os fatos é útil para descoberta, mas na maioria dos casos, você só precisa de informações específicas. Vamos criar outro playbook, display_specific_facts.yml, para exibir uma mensagem formatada com apenas alguns fatos importantes.
```
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 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 do YAML que permite escrever uma string de várias linhas de forma mais limpa. Salve o arquivo e saia do nano.

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 do 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á a usar fatos personalizados. Embora o Ansible colete automaticamente uma ampla gama de fatos padrão, você também pode definir os seus próprios. Eles 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 fatos personalizados no diretório /etc/ansible/facts.d no host gerenciado. Qualquer arquivo neste diretório com uma extensão .fact será processado. Esses arquivos podem ser arquivos de texto simples no estilo INI ou arquivos JSON.

Criar o diretório de fatos personalizados

Primeiro, você precisa criar o diretório onde o Ansible procurará 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.
Criar um arquivo de fato personalizado

Agora, vamos criar um arquivo de fato personalizado para definir uma mensagem de boas-vindas para 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.
Criar um playbook para usar o fato personalizado

Com o fato personalizado no lugar, agora podemos 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 analisar 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 fatos (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.

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 (alterou) 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

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 fatos personalizado:
```
Welcome to the server configured by Custom Facts!
```
Você criou com sucesso um fato personalizado no host gerenciado e o usou dentro de um playbook para configurar dinamicamente um serviço. Essa técnica é incrivelmente útil para tornar sua automação mais flexível e orientada a dados.

Criar um usuário do sistema usando variáveis criptografadas com o Ansible Vault

Nesta etapa, você aprenderá a gerenciar dados confidenciais, como senhas ou chaves de API, usando o Ansible Vault. Armazenar informações confidenciais em texto simples dentro de seus playbooks é um grande risco de segurança. O Ansible Vault oferece 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 com hash e, em seguida, usaremos um playbook para criar um novo usuário do sistema com essas credenciais.

Navegue até o diretório do projeto

Certifique-se de estar no diretório ~/project para esta tarefa.
```
cd ~/project
```
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. Esta 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 a senha do vault para simplificar as coisas. 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.
Adicionar variáveis secretas ao arquivo Vault

Dentro do editor nano, que agora está editando o arquivo secrets.yml criptografado, adicione as seguintes variáveis. Definiremos um nome de usuário e uma senha pré-hash para um novo usuário. Usar uma senha com hash é muito mais seguro do que armazenar uma senha em texto simples.
```
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.
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 diz 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.

Executar o playbook com a senha do Vault

Para executar um playbook que usa um arquivo protegido por 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:

Depois de fornecer a senha correta, o Ansible descriptografará o arquivo na memória e executará o playbook. Você deve 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

Verificar se o usuário foi criado

Você pode confirmar se o myappuser foi criado com sucesso no sistema usando o comando id.
```
id myappuser
```
Se o usuário existir, você verá as 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 confidenciais para 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.

Navegue até o diretório do projeto

Certifique-se de estar no diretório ~/project onde seu playbook e arquivo vault estão localizados.
```
cd ~/project
```
Criar o arquivo de senha do Vault

Vamos criar um arquivo para armazenar nossa senha do vault. Vamos chamá-lo de vault_pass.txt. Podemos usar o comando echo para criar o arquivo e gravar 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
```
Proteger o arquivo de senha

Armazenar uma senha em um arquivo de texto simples é arriscado. Você deve restringir as permissões do arquivo para protegê-lo. O comando chmod permite alterar as permissões de arquivo. Definiremos as permissões como 600, o que significa que apenas o proprietário do arquivo (neste caso, o usuário labex) tem permissões de leitura e gravação. 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
```
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 adicionar o usuário.
- 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.

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 porque a lê diretamente de vault_pass.txt. Você deve 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.

Verificar a associação do usuário ao grupo

Finalmente, verifique se myappuser agora é membro do grupo wheel. Você pode fazer isso com o comando groups.
```
groups myappuser
```
A saída deve mostrar tanto o grupo principal 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ê estava verificando 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 uma suíte de testes, verificando programaticamente se o servidor web está instalado, se a página web tem o conteúdo correto e se o usuário do sistema existe com a associação de grupo adequada. 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.

Navegue até o diretório do projeto

Primeiro, certifique-se de estar no diretório ~/project.
```
cd ~/project
```
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
```

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 qualquer afirmação falhar, o playbook parará 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.ansible_facts.getent_passwd['myappuser'] is defined
        fail_msg: "User 'myappuser' does not exist."
        success_msg: "User 'myappuser' exists."

    - name: Query the wheel group members
      ansible.builtin.getent:
        database: group
        key: wheel
      register: wheel_group_info

    - name: Assert that myappuser is in the wheel group
      ansible.builtin.assert:
        that:
          - "'myappuser' in (wheel_group_info.ansible_facts.getent_group['wheel'][2] | default('') | split(','))"
        fail_msg: "User 'myappuser' is not in the wheel group."
        success_msg: "User 'myappuser' is in the wheel group."

Vamos revisar os principais módulos usados aqui:

ansible.builtin.dnf com list: Isso verifica um pacote e register (registra) 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. Os resultados são armazenados em ansible_facts, portanto, acesse os dados retornados por meio de chaves como user_info.ansible_facts.getent_passwd.
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.

Observe que consultamos os bancos de dados passwd e group separadamente. Isso mantém a verificação de existência do usuário e a verificação de associação ao grupo wheel alinhadas com os dados reais retornados pelo getent.

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

Executar o playbook de verificação

Agora, execute seu playbook de verificação. Como ele não usa nenhum arquivo protegido por 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 afirmaçã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 [Query the wheel group members] *******************************************
ok: [localhost]

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 o Vault e, finalmente, verificar o estado do seu sistema de forma automatizada.

Resumo

Neste laboratório, você aprendeu a gerenciar diferentes tipos de dados dentro de playbooks do Ansible para configurar um sistema RHEL. Você começou definindo e usando variáveis de playbook padrão para instalar e configurar de forma flexível um servidor web Apache. Em seguida, você 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 com segurança, 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 foi concluído verificando se o servidor web e o novo usuário do sistema foram configurados corretamente, confirmando a aplicação bem-sucedida de todos os conceitos aprendidos.