Ansible Roles

Introdução

Neste laboratório, você explorará as Ansible Roles, um recurso poderoso que permite organizar e estruturar seu código Ansible de forma modular e reutilizável. As Roles fornecem uma maneira de carregar automaticamente variáveis (vars), arquivos, tarefas (tasks), handlers e outros artefatos Ansible relacionados com base em uma estrutura de arquivos conhecida. Ao final deste laboratório, você entenderá como criar, usar e organizar Ansible Roles, o que o ajudará a escrever um código de automação mais sustentável e escalável.

Compreendendo a Estrutura das Ansible Roles

Antes de começarmos a criar nossa própria role, vamos entender a estrutura de uma Ansible Role.

Uma Ansible Role tem uma estrutura de diretórios definida com oito diretórios principais padrão. Cada diretório deve conter um arquivo main.yml, que contém o conteúdo relevante. Aqui está uma breve visão geral de cada diretório:

1. tasks - contém a lista principal de tarefas (tasks) a serem executadas pela role.
2. handlers - contém handlers, que podem ser usados por esta role ou fora dela.
3. defaults - variáveis padrão para a role.
4. vars - outras variáveis para a role.
5. files - contém arquivos que podem ser implantados por meio desta role.
6. templates - contém templates que podem ser implantados por meio desta role.
7. meta - define alguns metadados para esta role.
8. tests - contém testes para a role.

Vamos começar criando uma estrutura de role simples. Primeiro, navegue até o diretório do seu projeto:

cd ~/project

Agora, vamos criar um diretório para nossas roles:

mkdir -p roles/example_role
cd roles/example_role

A flag -p no comando mkdir cria diretórios pai conforme necessário.

Agora, vamos criar a estrutura básica para nossa role:

mkdir {tasks,handlers,defaults,vars,files,templates,meta}

Este comando cria todos os diretórios que precisamos para nossa role de uma só vez. É um atalho útil no bash para criar vários diretórios de uma vez.

Agora, vamos criar um arquivo main.yml no diretório tasks:

nano tasks/main.yml

Adicione o seguinte conteúdo a este arquivo:

---
- name: Print a message
  debug:
    msg: "This is a task from our example role!"

Salve e saia do editor nano (Ctrl+X, depois Y, depois Enter).

Agora criamos uma estrutura de role básica com uma tarefa simples. Nos próximos passos, vamos expandir isso e aprender como usar nossa role.

Expandindo Nossa Role

Agora que temos uma estrutura de role básica, vamos expandi-la para incluir mais componentes de uma Ansible Role típica. Adicionaremos variáveis, um handler e um template.

Primeiro, vamos adicionar uma variável padrão. Crie um arquivo main.yml no diretório defaults:

nano defaults/main.yml

Adicione o seguinte conteúdo:

---
example_variable: "This is a default value"

Isso define um valor padrão para example_variable, que pode ser substituído quando a role for usada.

Em seguida, vamos criar um handler. Crie um arquivo main.yml no diretório handlers:

nano handlers/main.yml

Adicione o seguinte conteúdo:

---
- name: Restart example service
  debug:
    msg: "This would restart a service in a real scenario"

Em um cenário real, este handler pode reiniciar um serviço, mas para este exemplo, estamos apenas imprimindo uma mensagem.

Agora, vamos criar um template. Crie um arquivo chamado example_template.j2 no diretório templates:

nano templates/example_template.j2

Adicione o seguinte conteúdo:

This is an example template.
The value of example_variable is: {{ example_variable }}

Este template usa a sintaxe Jinja2 para incluir o valor de nossa example_variable.

Finalmente, vamos atualizar nosso tasks/main.yml para usar esses novos componentes:

nano tasks/main.yml

Substitua o conteúdo existente por:

---
- name: Print a message
  debug:
    msg: "This is a task from our example role!"

- name: Use our variable
  debug:
    msg: "The value of example_variable is: {{ example_variable }}"

- name: Create a file from our template
  template:
    src: example_template.j2
    dest: /tmp/example_file.txt
  notify: Restart example service

Esta lista de tarefas atualizada agora usa nossa variável, cria um arquivo a partir de nosso template e notifica nosso handler.

Usando Nossa Role em um Playbook

Agora que criamos nossa role, vamos usá-la em um playbook. Primeiro, navegue de volta para a raiz do projeto:

cd ~/project

Antes de criarmos nosso playbook, vamos criar um arquivo de inventário simples que especifica o localhost:

nano inventory.ini

Adicione o seguinte conteúdo ao arquivo de inventário:

[local]
localhost ansible_connection=local

Este arquivo de inventário define um grupo chamado local com o localhost como membro, usando uma conexão local.

Agora, crie um novo arquivo de playbook chamado use_role.yml:

nano use_role.yml

Adicione o seguinte conteúdo:

---
- name: Use our example role
  hosts: localhost
  roles:
    - example_role

Este playbook simplesmente aplica nossa example_role ao localhost.

Agora, vamos executar este playbook:

ansible-playbook -i inventory.ini use_role.yml

Você deverá ver a saída mostrando a execução das tarefas que definimos em nossa role.

Vamos detalhar o que aconteceu:

1. O Ansible procurou por uma role chamada example_role no diretório roles.
2. Ele encontrou nossa role e executou as tarefas definidas em tasks/main.yml.
3. Ele usou o valor padrão para example_variable que definimos em defaults/main.yml.
4. Ele criou um arquivo em /tmp/example_file.txt usando nosso template.
5. Finalmente, ele chamou nosso handler, que imprimiu uma mensagem de debug.

Isso demonstra como as roles nos permitem empacotar tarefas, variáveis e arquivos relacionados juntos, tornando nosso código Ansible mais organizado e reutilizável.

Substituindo Variáveis da Role

Uma das funcionalidades poderosas das Ansible roles é a capacidade de substituir variáveis padrão. Isso permite que você crie roles flexíveis que podem ser usadas em diferentes cenários.

Vamos criar um novo playbook que substitui nossa example_variable. Crie um arquivo chamado override_role_var.yml:

nano override_role_var.yml

Adicione o seguinte conteúdo:

---
- name: Use our example role with a custom variable
  hosts: localhost
  vars:
    example_variable: "This is a custom value"
  roles:
    - example_role

Neste playbook, estamos definindo example_variable para um valor personalizado antes de aplicar nossa role.

Agora, vamos executar este playbook:

ansible-playbook -i inventory.ini override_role_var.yml

Você deve ver que as tarefas agora usam o valor personalizado para example_variable em vez do valor padrão.

Isso demonstra como você pode criar roles com padrões sensíveis, mas ainda ter a flexibilidade de personalizar seu comportamento quando necessário.

Dependências de Roles

As Ansible roles podem depender de outras roles. Isso permite que você construa roles mais complexas combinando roles mais simples. Vamos criar uma nova role que depende da nossa example_role.

Primeiro, crie uma nova estrutura de role:

cd ~/project/roles
mkdir -p dependent_role/{tasks,meta}

Agora, vamos definir as dependências da role. Crie um arquivo main.yml no diretório meta:

nano dependent_role/meta/main.yml

Adicione o seguinte conteúdo:

---
dependencies:
  - role: example_role

Isso especifica que dependent_role depende de example_role.

Agora, vamos adicionar uma tarefa à nossa dependent_role. Crie um arquivo main.yml no diretório tasks:

nano dependent_role/tasks/main.yml

Adicione o seguinte conteúdo:

---
- name: Task from dependent role
  debug:
    msg: "This task is from the dependent role"

Agora, vamos criar um playbook para usar nossa dependent_role. Navegue de volta para a raiz do projeto:

cd ~/project
nano use_dependent_role.yml

Adicione o seguinte conteúdo:

---
- name: Use our dependent role
  hosts: localhost
  roles:
    - dependent_role

Finalmente, vamos executar este playbook:

ansible-playbook -i inventory.ini use_dependent_role.yml

Você deve ver que ambas as tarefas de example_role e dependent_role são executadas. Isso demonstra como as dependências de role permitem que você construa uma automação mais complexa combinando roles mais simples.

Resumo

Neste laboratório, você aprendeu sobre Ansible Roles, um recurso poderoso para organizar e estruturar seu código Ansible. Aqui estão os principais pontos a serem lembrados:

1. As Ansible Roles fornecem uma maneira de carregar automaticamente variáveis (vars), arquivos, tarefas (tasks), handlers e outros artefatos Ansible relacionados com base em uma estrutura de arquivos conhecida.
2. A estrutura básica de uma role inclui diretórios para tarefas (tasks), handlers, defaults, vars, arquivos, templates e informações de meta.
3. As Roles permitem que você defina variáveis padrão que podem ser substituídas quando a role é usada, proporcionando flexibilidade e reutilização.
4. Você pode usar templates dentro das roles para gerar arquivos com conteúdo dinâmico.
5. As Roles podem ser facilmente incluídas em playbooks, permitindo que você aplique configurações complexas com uma única linha.
6. Você pode substituir variáveis de role em seus playbooks, permitindo que você personalize o comportamento das roles sem modificar a própria role.
7. As Roles podem depender de outras roles, permitindo que você construa uma automação mais complexa combinando roles mais simples.

As Ansible Roles são um conceito fundamental para escrever código Ansible sustentável e reutilizável. Elas permitem que você divida tarefas de automação complexas em partes menores e mais gerenciáveis, e promovem a reutilização de código em toda a sua organização. À medida que você continua trabalhando com Ansible, você descobrirá que as roles se tornam uma ferramenta essencial em seu kit de ferramentas de automação, especialmente para projetos maiores e mais complexos.