Implementar um Playbook Ansible no RHEL

Introdução

Neste laboratório, você aprenderá a implementar um playbook Ansible completo para implantar um servidor web Apache em um sistema Red Hat Enterprise Linux (RHEL). Você começará configurando os componentes fundamentais de um projeto Ansible, que inclui a criação de um arquivo de inventário estático para definir seus nós gerenciados e a configuração do ambiente Ansible local usando um arquivo ansible.cfg.

Após a configuração inicial, você escreverá um playbook com múltiplas tarefas para automatizar o processo de implantação principal. Isso envolve a instalação e inicialização do serviço Apache, a implantação de uma página web personalizada e a configuração do firewall do sistema para permitir tráfego HTTP. Para concluir o laboratório, você adicionará uma segunda "play" ao seu playbook que testará o servidor web a partir da linha de comando, verificando se toda a implantação foi bem-sucedida.

Criar um Arquivo de Inventário Estático para Servidores Web

Nesta etapa, você aprenderá os fundamentos de um inventário Ansible. Um inventário é um arquivo de texto que lista os servidores (ou "nós gerenciados") que o Ansible gerenciará. Você criará um arquivo de inventário simples e estático para um grupo de servidores web e aprenderá como verificar seu conteúdo.

Primeiro, você precisa garantir que o Ansible esteja instalado em seu sistema. Como ele não é instalado por padrão, você usará o gerenciador de pacotes dnf para instalá-lo.

1. Abra seu terminal e instale o pacote ansible-core, que fornece as ferramentas fundamentais de linha de comando do Ansible.

   sudo dnf install -y ansible-core
   

   Você deverá ver uma saída indicando que o pacote está sendo instalado e verificado.

   ...
   Installed:
     ansible-core-2.16.x-x.el9.x86_64
   ...
   Complete!
   

2. Para uma melhor organização, crie um diretório dedicado para este projeto dentro do seu diretório pessoal. Vamos chamá-lo de ansible-lab.

   mkdir -p ~/project/ansible-lab
   

3. Navegue até o seu diretório de projeto recém-criado. Todo o trabalho subsequente neste laboratório será feito a partir desta localização.

   cd ~/project/ansible-lab
   

4. Agora, você criará seu primeiro arquivo de inventário. Um arquivo de inventário é tipicamente escrito em um formato semelhante a INI. Você usará o editor de texto nano para criar um arquivo chamado inventory.

   nano inventory
   

5. Dentro do editor nano, adicione o seguinte conteúdo. Esta configuração define um grupo chamado [webservers] e adiciona sua máquina local, localhost, a este grupo.

   • [webservers] é um nome de grupo. Grupos são usados para direcionar múltiplos hosts com um único comando.
   • localhost é o nome do host da máquina que você deseja gerenciar. Neste caso, é a própria VM LabEx.
   • ansible_connection=local é uma variável especial que instrui o Ansible a executar comandos diretamente no nó de controle (sua VM) em vez de tentar se conectar a ele via SSH.

   [webservers]
   localhost ansible_connection=local
   

   Para salvar o arquivo no nano, pressione Ctrl+O, depois Enter para confirmar o nome do arquivo e Ctrl+X para sair do editor.

6. Com seu arquivo de inventário criado, você pode usar o comando ansible-inventory para analisar o arquivo e exibir uma lista dos hosts que ele contém. A flag -i especifica o caminho para o seu arquivo de inventário.

   ansible-inventory --list -i inventory
   

   O comando produzirá uma representação em formato JSON do seu inventário, o que confirma que o Ansible pode ler e entender seu arquivo corretamente.

   {
     "_meta": {
       "hostvars": {
         "localhost": {
           "ansible_connection": "local"
         }
       }
     },
     "all": {
       "children": ["ungrouped", "webservers"]
     },
     "webservers": {
       "hosts": ["localhost"]
     }
   }
   

Você criou com sucesso um arquivo de inventário estático básico e verificou que o Ansible pode interpretá-lo corretamente. Este arquivo de inventário será a base para os playbooks que você escreverá nas próximas etapas.

Configurar o Ambiente Ansible com ansible.cfg

Nesta etapa, você criará um arquivo de configuração Ansible, ansible.cfg. Este arquivo permite definir comportamentos padrão para o Ansible, economizando o trabalho de digitar opções comuns na linha de comando repetidamente. Ao colocar um arquivo ansible.cfg em seu diretório de projeto, você pode definir configurações como o caminho padrão do arquivo de inventário, que o Ansible usará automaticamente quando executado a partir desse diretório.

Você ainda deve estar no diretório ~/project/ansible-lab da etapa anterior.

1. Use o editor de texto nano para criar um novo arquivo chamado ansible.cfg em seu diretório atual (~/project/ansible-lab).

   nano ansible.cfg
   

2. Dentro do editor nano, adicione o seguinte conteúdo. Esta configuração informa ao Ansible onde encontrar seu arquivo de inventário padrão.

   • A seção [defaults] é uma parte padrão do arquivo ansible.cfg onde você define a maioria das configurações padrão.
   • A linha inventory = ./inventory define o inventário padrão para o arquivo inventory localizado no diretório atual (.).

   [defaults]
   inventory = ./inventory
   

   Salve o arquivo pressionando Ctrl+O, depois Enter, e saia com Ctrl+X.

3. Agora que você configurou o caminho padrão do inventário, não precisa mais usar a flag -i com seus comandos Ansible (desde que esteja no diretório ~/project/ansible-lab).

   Para testar isso, execute o comando ansible-inventory --list novamente, mas desta vez, omita a parte -i inventory.

   ansible-inventory --list
   

   Você deverá ver exatamente a mesma saída JSON da etapa anterior, o que confirma que o Ansible está encontrando e usando automaticamente seu arquivo inventory graças à nova configuração ansible.cfg.

   {
     "_meta": {
       "hostvars": {
         "localhost": {
           "ansible_connection": "local"
         }
       }
     },
     "all": {
       "children": ["ungrouped", "webservers"]
     },
     "webservers": {
       "hosts": ["localhost"]
     }
   }
   

Ao criar um ansible.cfg específico para o projeto, você tornou seu fluxo de trabalho mais eficiente. Esta é uma prática comum em projetos Ansible para garantir um comportamento consistente e reduzir a complexidade da linha de comando.

Escrever um Playbook para Instalar e Iniciar o Serviço Apache

Nesta etapa, você escreverá seu primeiro Ansible Playbook. Um playbook é um arquivo escrito em formato YAML que descreve um conjunto de tarefas a serem executadas em seus hosts gerenciados. Você criará um playbook que instala o servidor web Apache (httpd) e inicia seu serviço na máquina localhost definida em seu inventário.

Você ainda deve estar no diretório ~/project/ansible-lab.

1. Primeiro, use o editor de texto nano para criar um novo arquivo chamado apache.yml. Este arquivo conterá seu playbook.

   nano apache.yml
   

2. Dentro do editor nano, você definirá um "play". Um play é a unidade central de um playbook e mapeia um grupo de hosts para um conjunto de tarefas. Adicione o seguinte conteúdo a apache.yml.

   • ---: Este é um marcador YAML padrão indicando o início de um documento.
   • - name: ...: Este é o início do seu play. Dar um nome descritivo é uma boa prática.
   • hosts: webservers: Isso diz ao Ansible para executar este play em todos os hosts do grupo webservers do seu arquivo de inventário.
   • become: true: Isso instrui o Ansible a usar a escalada de privilégios (como sudo) para executar as tarefas. Isso é necessário para ações como instalar software ou gerenciar serviços.
   • tasks:: Esta palavra-chave inicia a lista de tarefas a serem realizadas.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
   

3. Agora, adicione as tarefas ao seu playbook. Cada tarefa é uma única ação que chama um módulo Ansible. A indentação é crítica em YAML, portanto, certifique-se de que as tarefas estejam corretamente indentadas sob a seção tasks:.

   • Tarefa 1: Instalar httpd. Esta tarefa usa o módulo ansible.builtin.dnf para garantir que o pacote httpd esteja instalado. O parâmetro state: present significa que o Ansible instalará o pacote se ele estiver ausente e não fará nada se ele já estiver instalado.
   • Tarefa 2: Iniciar o serviço httpd. Esta tarefa usa o módulo ansible.builtin.service. state: started garante que o serviço esteja em execução e enabled: true garante que ele será iniciado automaticamente na inicialização do sistema.

   Adicione as seguintes tarefas ao seu arquivo apache.yml, diretamente abaixo da linha tasks::

   - name: Install httpd package
     ansible.builtin.dnf:
       name: httpd
       state: present
   
   - name: Start and enable httpd service
     ansible.builtin.service:
       name: httpd
       state: started
       enabled: true
   

4. Seu playbook apache.yml completo deve agora parecer com isto. Verifique cuidadosamente a indentação.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   

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

5. Antes de executar seu playbook, é uma boa prática verificá-lo em busca de erros de sintaxe usando o comando ansible-playbook com a flag --syntax-check.

   ansible-playbook --syntax-check apache.yml
   

   Se a sintaxe estiver correta, o comando imprimirá o nome do arquivo do playbook sem erros.

   playbook: apache.yml
   

6. Agora, execute o playbook.

   ansible-playbook apache.yml
   

   O Ansible executará as tarefas. Como esta é a primeira execução, você verá o status changed para ambas as tarefas, indicando que o estado do sistema foi modificado.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   changed: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

7. Finalmente, verifique se o servidor web Apache está em execução usando curl para solicitar a página web padrão do localhost.

   curl http://localhost
   

   Você deverá ver a Página de Teste Padrão do Apache, o que confirma que seu playbook funcionou com sucesso.

   <html>
     <head>
       <title>Test Page</title>
     </head>
     <body>
       <h1>Test Page</h1>
       <p>This is the default test page for the Apache HTTP server.</p>
     </body>
   </html>
   

Adicionar Tarefas para Implantar uma Página Web

Nesta etapa, você expandirá seu playbook para realizar uma configuração mais realista do servidor web. Você adicionará uma tarefa para implantar uma página index.html personalizada. Isso demonstra como gerenciar arquivos usando os módulos de gerenciamento de arquivos do Ansible.

Você ainda deve estar no diretório ~/project/ansible-lab.

1. Primeiro, crie um arquivo HTML simples que seu playbook implantará. Use nano para criar um arquivo chamado index.html em seu diretório atual.

   nano index.html
   

2. Adicione o seguinte conteúdo HTML ao arquivo. Este será o conteúdo da sua página web personalizada.

   <h1>Welcome to the Ansible-managed Web Server!</h1>
   <p>This page was deployed using an Ansible Playbook.</p>
   

   Salve e saia do nano (Ctrl+O, Enter, Ctrl+X).

3. Agora, você atualizará seu playbook apache.yml para adicionar a nova tarefa. Para evitar erros de formatação YAML, é recomendado recriar o arquivo com o conteúdo completo.

   Importante: Para garantir a formatação YAML correta e evitar erros de indentação, remova o arquivo apache.yml existente e crie um novo com o conteúdo completo mostrado abaixo.

   rm apache.yml
   nano apache.yml
   

4. Você adicionará uma nova tarefa ao playbook. Esta tarefa copiará o arquivo index.html para a raiz do documento do servidor web (/var/www/html/).

   • Tarefa: Implantar index.html. Esta tarefa usa o módulo ansible.builtin.copy. src especifica o arquivo de origem no nó de controle (index.html), e dest especifica o caminho de destino no host gerenciado.

5. Copie e cole o conteúdo completo do playbook apache.yml abaixo. Isso garante a formatação e indentação YAML corretas.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Deploy custom index.html
         ansible.builtin.copy:
           src: index.html
           dest: /var/www/html/index.html
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   

   Salve e saia do nano.

6. Salve o arquivo e saia do nano (Ctrl+O, Enter, Ctrl+X), em seguida, execute o playbook atualizado.

   ansible-playbook apache.yml
   

   Desta vez, você deverá ver a nova tarefa sendo executada. As tarefas "Install httpd" e "Start httpd" deverão reportar ok porque seu estado desejado já foi alcançado. A tarefa "Deploy custom index.html" reportará changed.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   ok: [localhost]
   
   TASK [Deploy custom index.html] ************************************************
   changed: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   ok: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=4    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

7. Finalmente, use curl novamente para verificar se sua página web personalizada está agora sendo servida.

   curl http://localhost
   

   A saída agora deve ser o conteúdo do seu arquivo index.html.

   <h1>Welcome to the Ansible-managed Web Server!</h1>
   <p>This page was deployed using an Ansible Playbook.</p>
   

Implementar um Segundo Play para Testar a Implantação do Servidor Web

Nesta etapa final, você adicionará um segundo play ao seu playbook. Um único arquivo de playbook pode conter múltiplos plays, que são executados sequencialmente. Isso é útil para organizar tarefas que visam hosts diferentes ou têm propósitos diferentes. Você adicionará um novo play que será executado apenas no nó de controle (localhost) para testar o servidor web que foi configurado no primeiro play.

Você ainda deve estar no diretório ~/project/ansible-lab.

1. Agora você adicionará um segundo play ao seu playbook. Para garantir a formatação YAML correta ao adicionar o segundo play, é recomendado recriar o arquivo com o conteúdo completo.

   Importante: Para evitar erros de indentação YAML ao adicionar o segundo play, remova o arquivo apache.yml existente e crie um novo com o conteúdo completo de dois plays mostrado abaixo.

   rm apache.yml
   nano apache.yml
   

2. Você adicionará um segundo play ao playbook. Um segundo play permite organizar tarefas que visam hosts diferentes ou têm propósitos diferentes.

   • name: Test web server: Um nome descritivo para o novo play.
   • hosts: localhost: Este play será executado em localhost, o próprio nó de controle.
   • become: false: Este teste não requer privilégios de root, portanto, desativamos explicitamente a escalada de privilégios.
   • Tarefa: Verificar conteúdo da web. Esta tarefa usa o módulo ansible.builtin.uri para fazer uma requisição HTTP ao servidor web. Ela verifica se o servidor retorna um código de status 200 (OK) e se o conteúdo retornado contém a string "Ansible-managed". Isso automatiza a verificação curl e grep que você tem feito manualmente.

3. Copie e cole o conteúdo completo do playbook apache.yml abaixo, que agora inclui ambos os plays:

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Deploy custom index.html
         ansible.builtin.copy:
           src: index.html
           dest: /var/www/html/index.html
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   
   - name: Test web server from localhost
     hosts: localhost
     become: false
     tasks:
       - name: Verify web server is serving correct content
         ansible.builtin.uri:
           url: http://localhost
           return_content: yes
           status_code: 200
         register: result
         failed_when: "'Ansible-managed' not in result.content"
   

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

4. Execute o playbook completo. O Ansible executará o primeiro play, descobrirá que todas as tarefas já estão em seu estado desejado (ok) e, em seguida, prosseguirá para o segundo play para executar o teste.

   ansible-playbook apache.yml
   

   A saída mostrará ambos os plays sendo executados. Todas as tarefas devem ser concluídas com sucesso com um status ok.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   ok: [localhost]
   
   TASK [Deploy custom index.html] ************************************************
   ok: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   ok: [localhost]
   
   PLAY [Test web server from localhost] ******************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Verify web server is serving correct content] ****************************
   ok: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=6    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

Ao adicionar um segundo play, você criou um fluxo de trabalho de automação mais robusto que não apenas configura um serviço, mas também inclui um teste integrado para verificar se a implantação foi bem-sucedida.

Resumo

Neste laboratório, você aprendeu como preparar um ambiente RHEL para automação com Ansible, instalando o pacote ansible-core e estruturando um diretório de projeto. Você criou um arquivo de inventário estático fundamental para definir um grupo de nós gerenciados, especificando localhost com uma conexão local. Você também configurou o ambiente Ansible usando um arquivo ansible.cfg para apontar para seu inventário personalizado, estabelecendo um espaço de trabalho limpo e organizado para executar playbooks.

Em seguida, você elaborou um playbook Ansible abrangente para automatizar a implantação de um servidor web Apache. Isso envolveu a escrita de tarefas para instalar o pacote httpd usando o módulo ansible.builtin.dnf e para garantir que o serviço fosse iniciado e habilitado com o módulo ansible.builtin.service. O playbook foi aprimorado para implantar uma página web index.html personalizada usando o módulo ansible.builtin.copy. Finalmente, você implementou um segundo play dentro do mesmo playbook para validar a implantação, usando o módulo ansible.builtin.uri para testar a conectividade com o servidor web recém-implantado, demonstrando um fluxo de trabalho completo de configuração e verificação.