Fundamentos de Playbooks Ansible

Introdução

Neste laboratório, você aprenderá os fundamentos dos playbooks do Ansible. Os playbooks do Ansible são arquivos YAML que descrevem um conjunto de tarefas a serem executadas em hosts remotos. Eles são os blocos de construção para fluxos de trabalho complexos de automação de TI. Você criará seu primeiro playbook, entenderá sua estrutura e aprenderá como executá-lo. Ao final deste laboratório, você terá experiência prática na escrita e execução de playbooks do Ansible, o que servirá como base para um uso mais avançado do Ansible.

Criando Seu Primeiro Playbook

Vamos começar criando um playbook Ansible simples que criará um diretório e um arquivo na máquina local. Isso ajudará você a entender a estrutura básica de um playbook e como executá-lo.

Primeiro, vamos criar um novo arquivo chamado first_playbook.yml no diretório /home/labex/project:

nano /home/labex/project/first_playbook.yml

Este comando abre o editor de texto nano. Se você não estiver familiarizado com o nano, não se preocupe - é um editor de texto simples. Você pode digitar diretamente nele.

Agora, adicione o seguinte conteúdo ao arquivo:

---
- name: My First Playbook
  hosts: localhost
  connection: local
  tasks:
    - name: Create a directory
      file:
        path: /home/labex/project/test_directory
        state: directory
        mode: "0755"

    - name: Create a file
      copy:
        content: "Hello from Ansible!"
        dest: /home/labex/project/test_directory/hello.txt

Vamos analisar este playbook para entender cada parte:

• O --- no topo marca o início de um arquivo YAML. YAML é o formato usado para playbooks Ansible.
• name: My First Playbook é um nome descritivo para este play. Ele ajuda você a identificar o que este playbook faz.
• hosts: localhost especifica que este playbook será executado na máquina local. Em um cenário real, você pode especificar hosts remotos aqui.
• connection: local diz ao Ansible para executar o playbook localmente em vez de usar SSH. Isso é útil para testes e para tarefas que precisam ser executadas no próprio nó de controle do Ansible.
• tasks: é seguido por uma lista de tarefas a serem executadas. Cada tarefa é uma ação que você deseja que o Ansible execute.
• Cada tarefa tem um name para descrição. Isso ajuda você a entender o que cada tarefa faz e facilita a solução de problemas.
• As tarefas usam módulos Ansible:
  • O módulo file é usado para criar o diretório.
  • O módulo copy é usado para criar um arquivo com conteúdo específico.

Não se preocupe se você ainda não entender todos os módulos. À medida que você avança, aprenderá sobre muitos mais módulos e seus usos.

Salve e saia do editor. No nano, você pode fazer isso pressionando Ctrl+X, depois Y e depois Enter.

Agora, vamos executar este playbook. No seu terminal, digite:

ansible-playbook /home/labex/project/first_playbook.yml

Este comando diz ao Ansible para executar o playbook que acabamos de criar. Você deve ver uma saída semelhante a esta:

PLAY [My First Playbook] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a directory] ******************************************************
changed: [localhost]

TASK [Create a file] ***********************************************************
changed: [localhost]

PLAY RECAP *********************************************************************
localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Esta saída mostra que o Ansible executou nossas tarefas com sucesso. O status "changed" indica que o Ansible fez alterações no sistema (criou um diretório e um arquivo).

Se você quiser verificar os resultados manualmente, pode usar estes comandos:

ls -l /home/labex/project/test_directory
cat /home/labex/project/test_directory/hello.txt

O primeiro comando deve mostrar o diretório que criamos, e o segundo deve exibir o conteúdo do arquivo que criamos.

Entendendo a Estrutura do Playbook

Agora que você criou e executou seu primeiro playbook, vamos nos aprofundar em sua estrutura. Entender a estrutura de um playbook é crucial para escrever tarefas de automação mais complexas no futuro.

Os playbooks do Ansible são compostos por um ou mais plays, e cada play consiste em vários elementos-chave. Vamos editar nosso arquivo first_playbook.yml para adicionar comentários explicando cada parte:

nano /home/labex/project/first_playbook.yml

Atualize o conteúdo da seguinte forma:

---
## Playbook começa com três traços
- name: My First Playbook ## Nome do play
  hosts: localhost ## Host(s) de destino para este play
  connection: local ## Tipo de conexão (local neste caso)

  tasks: ## Lista de tarefas a serem executadas
    - name: Create a directory ## Nome da primeira tarefa
      file: ## O módulo 'file' é usado para esta tarefa
        path: /home/labex/project/test_directory ## Caminho do diretório a ser criado
        state: directory ## Estado desejado (criar o diretório)
        mode: "0755" ## Permissões para o diretório

    - name: Create a file ## Nome da segunda tarefa
      copy: ## O módulo 'copy' é usado para esta tarefa
        content: "Hello from Ansible!" ## Conteúdo a ser escrito no arquivo
        dest: /home/labex/project/test_directory/hello.txt ## Caminho de destino para o arquivo

Salve e saia do editor.

Esta versão comentada do playbook ajuda a entender a estrutura e o propósito de cada elemento. Aqui estão alguns pontos-chave para lembrar:

1. Um playbook pode conter múltiplos plays, cada um começando com um traço (-). Neste caso, temos apenas um play.
2. Cada play tem como alvo hosts específicos e define uma lista de tarefas. O campo hosts especifica em quais máquinas o play deve ser executado.
3. As tarefas usam módulos Ansible (como file e copy) para realizar ações. O Ansible tem muitos módulos embutidos para vários propósitos.
4. Cada tarefa deve ter um nome descritivo. Isso ajuda a entender o que a tarefa faz e na solução de problemas.
5. A indentação é crucial em arquivos YAML. Certifique-se de que seu playbook esteja devidamente indentado. Indentação incorreta pode causar erros ao executar o playbook.

O módulo file é versátil e pode ser usado para criar, modificar ou excluir arquivos e diretórios. Em nosso caso, estamos usando-o para criar um diretório.

O módulo copy é usado para copiar arquivos para locais remotos ou, como em nosso caso, para criar um novo arquivo com conteúdo específico.

Entender essas estruturas básicas o ajudará à medida que você avança para criar playbooks mais complexos no futuro.

Adicionando Variáveis aos Playbooks

As variáveis tornam seus playbooks mais flexíveis e reutilizáveis. Elas permitem que você escreva playbooks que podem se adaptar a diferentes cenários sem precisar alterar o próprio playbook. Vamos modificar nosso playbook para usar variáveis.

Edite o arquivo first_playbook.yml:

nano /home/labex/project/first_playbook.yml

Atualize o conteúdo da seguinte forma:

---
- name: My First Playbook
  hosts: localhost
  connection: local
  vars:
    dir_path: /home/labex/project/test_directory
    file_content: "Hello from Ansible! The time is {{ ansible_date_time.iso8601 }}"

  tasks:
    - name: Create a directory
      file:
        path: "{{ dir_path }}"
        state: directory
        mode: "0755"

    - name: Create a file
      copy:
        content: "{{ file_content }}"
        dest: "{{ dir_path }}/hello.txt"

    - name: Display file content
      debug:
        msg: "The content of the file is: {{ file_content }}"

Vamos analisar as mudanças e os novos elementos neste playbook atualizado:

1. Adicionamos uma seção vars para definir variáveis. É aqui que você pode definir valores que usará várias vezes em seu playbook.

2. dir_path e file_content agora são variáveis. Podemos facilmente alterar esses valores em um só lugar para afetar várias tarefas.

3. Estamos usando a sintaxe {{ }} para referenciar variáveis. Isso diz ao Ansible para substituir a variável por seu valor.

4. Usamos a variável embutida do Ansible ansible_date_time.iso8601 para incluir o carimbo de data/hora atual. O Ansible fornece muitas variáveis ​​desse tipo que você pode usar em seus playbooks.

5. Uma nova tarefa usando o módulo debug foi adicionada. O módulo debug é muito útil para exibir informações durante a execução do playbook, o que pode ajudar na solução de problemas.

O uso de variáveis torna este playbook mais flexível. Por exemplo, se você quisesse alterar o caminho do diretório, precisaria alterá-lo apenas na seção vars, e não em cada tarefa.

Salve e saia do editor.

Agora, vamos executar o playbook atualizado:

ansible-playbook /home/labex/project/first_playbook.yml

Você deve ver a saída mostrando as tarefas sendo executadas, incluindo a mensagem de depuração exibindo o conteúdo do arquivo com o carimbo de data/hora atual. A saída terá uma aparência semelhante a esta:

PLAY [My First Playbook] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a directory] ******************************************************
ok: [localhost]

TASK [Create a file] ***********************************************************
changed: [localhost]

TASK [Display file content] ****************************************************
ok: [localhost] => {
    "msg": "The content of the file is: Hello from Ansible! The time is 2023-06-09T12:34:56Z"
}

PLAY RECAP *********************************************************************
localhost                  : ok=4    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

O carimbo de data/hora real será diferente quando você executar o playbook.

Isso demonstra como as variáveis podem tornar seus playbooks mais dinâmicos. O conteúdo do arquivo agora inclui um carimbo de data/hora que será diferente cada vez que você executar o playbook.

Resumo

Neste laboratório, você aprendeu os conceitos básicos dos playbooks do Ansible. Você passou de criar seu primeiro playbook simples para entender sua estrutura e usar variáveis para tornar seus playbooks mais dinâmicos e reutilizáveis.

Principais conclusões deste laboratório:

1. Os playbooks do Ansible são escritos em formato YAML e descrevem um conjunto de tarefas a serem executadas em hosts especificados.
2. Um playbook consiste em um ou mais plays, cada um contendo uma lista de tarefas.
3. As tarefas usam módulos Ansible para realizar ações nos hosts de destino. Usamos os módulos file, copy e debug neste laboratório.
4. As variáveis podem ser definidas e usadas em playbooks para aumentar a flexibilidade e a reutilização. Elas são referenciadas usando a sintaxe {{ }}.
5. O módulo debug é útil para exibir informações durante a execução do playbook, o que pode ajudar na solução de problemas.
6. A indentação adequada é crucial em arquivos YAML e playbooks do Ansible.

À medida que você continua sua jornada com o Ansible, você descobrirá que os playbooks são uma ferramenta poderosa para automatizar tarefas de TI complexas. Pratique a escrita de playbooks para vários cenários para se sentir mais confortável com sua estrutura e capacidades. Tente modificar os playbooks que criamos hoje - altere o caminho do diretório, adicione mais tarefas ou use módulos diferentes.

Em laboratórios futuros, você aprenderá sobre recursos de playbook mais avançados, como condicionais, loops e roles, que permitirão que você crie fluxos de trabalho de automação ainda mais poderosos e flexíveis.

Lembre-se, a chave para dominar o Ansible é a prática e a exploração. Não tenha medo de experimentar diferentes módulos e estruturas em seus playbooks. A documentação do Ansible é um excelente recurso à medida que você continua a aprender e a aprimorar suas habilidades.