Como Criar Modelos Ansible para Economizar Tempo de Configuração

Gerenciar configurações de múltiplos servidores e ambientes é um grande benefício de usar o Ansible. Mas o que acontece quando os arquivos de configuração variam de servidor para servidor? Em vez de criar uma configuração separada para cada servidor ou ambiente, você deve considerar os modelos do Ansible.

Neste tutorial, você vai aprender o que são os modelos do Ansible, como eles funcionam e como você pode usar o módulo de template do Ansible para economizar muito tempo.

Pré-requisitos

Este post será um tutorial passo a passo. Se você deseja acompanhar, certifique-se de ter um host controlador do Ansible. Este tutorial estará utilizando o Ansible v2.9.18

O que é um modelo do Ansible?

Às vezes, é necessário transferir arquivos de texto para hosts remotos. Esses arquivos de texto geralmente são algum tipo de arquivo de configuração. Se você estiver trabalhando com um único servidor, por exemplo, talvez seja necessário criar um arquivo de configuração chamado app.conf que algum serviço utiliza.

Aquela configuração pode conter informações específicas do servidor, como nome do host, endereço IP, etc. Como você está trabalhando com um único servidor, você pode criar o arquivo no controlador do Ansible e, em seguida, usar o módulo copy em um playbook para copiá-lo para o servidor.

Mas e se você tiver vários servidores web, cada um precisando do mesmo arquivo de configuração, mas com valores específicos? Você não pode simplesmente copiar o arquivo de configuração para todas as máquinas; ele é projetado apenas para um único servidor com um nome de host, endereço IP, etc. Você precisa de um modelo do Ansible.

Os modelos do Ansible permitem que você defina arquivos de texto com variáveis em vez de valores estáticos e, em seguida, substitua essas variáveis durante a execução do playbook.

Como é um modelo do Ansible?

Um modelo do Ansible é um arquivo de texto construído com a linguagem de modelagem Jinja2 com a extensão de arquivo j2. Um modelo Jinja2 parece exatamente com o arquivo de texto que você gostaria de colocar em um host remoto. A única diferença é que, em vez de valores estáticos, o arquivo contém variáveis.

Por exemplo, talvez seja necessário obter um arquivo de configuração chamado app.conf em todos os seus servidores da web que contenha referências ao endereço IP de cada servidor, ao host do Ansible e ao usuário do Ansible. O arquivo app.conf de um único servidor pode se parecer com o exemplo abaixo.

my_ip    = "192.168.0.1"
my_host  = "ANSBILECONTROL"
my_user  = "ansible_user"

Você não pode simplesmente copiar este arquivo para cada servidor da web, pois cada item será único dependendo do IP do host remoto, do nome do host do controlador do Ansible e do usuário do Ansible.

Em vez de definir estaticamente cada um desses valores, um modelo do Ansible permite que você defina variáveis que são interpretadas durante a execução e substituídas no host remoto.

Abaixo, você encontrará um exemplo do arquivo de modelo app.conf.j2. Agora você pode ver que cada valor estático foi substituído por uma variável indicada com chaves duplas em ambos os lados. Neste caso, essas variáveis vêm dos fatos do Ansible.

Arquivos de modelo sempre têm a extensão de arquivo J2 e geralmente têm o mesmo nome que o arquivo que criam no host de destino.

my_ip    = "{{ansible_default_ipv4["address"]}}"
my_host  = "{{ansible_host}}"
my_user  = "{{ansible_user}}"

Como os arquivos de modelo são criados nos hosts remotos?

Depois de criar um modelo, você precisa transferir esse arquivo de modelo para o host remoto e “convertê-lo” no arquivo de texto real do que deveria parecer. Para fazer isso, você precisa referenciar o arquivo de modelo em um playbook.

A maioria dos administradores do Ansible utiliza o módulo de cópia para transferir arquivos para hosts remotos, mas, como mencionado anteriormente, isso não é viável com templates.

Abaixo, você pode ver um exemplo simples de referência de um playbook que copia o arquivo app.conf para o diretório /opt em todos os hosts-alvo do playbook.

- name: copy file from local host to remote host
  copy:                               # Declaring Copy Module 
    src: "app.conf"                   # Source Location 
    dest: "/opt/app.conf"             # Destination Location on remote host

Agora, digamos que você “templatezou” o arquivo de configuração app.conf para se tornar um arquivo de modelo app.conf.j2, conforme abordado na seção anterior, em seu controlador Ansible. Agora você precisa garantir que o app.conf ainda chegue ao diretório /opt, mas com as variáveis substituídas por valores reais.

Para instruir o playbook a criar o arquivo app.conf no diretório /opt, basta substituir a referência copy por template, como mostrado abaixo. Ao fazer isso, o Ansible então invoca o módulo de template para transferir o modelo e substituir as variáveis por valores estáticos.

- name: template file to remote host
  template:                 # Ansible template module
    src: "app.conf.j2"      # This is template src i.e source location 
    dest: "/opt/app.conf"   # Destination of Remote host

Uma vez que a tarefa acima no playbook é executada, o Ansible copiará o app.conf.j2 para o diretório /opt no host remoto, substituirá todas as variáveis internas por valores estáticos e renomeará o arquivo para app.conf.

Ao fornecer o modelo src com um caminho de diretório, o Ansible procura modelos no diretório /<diretório_de_instalação_do_ansible>/files/. Se você simplesmente fornecer o nome do arquivo, o Ansible procurará o modelo no diretório /<diretório_de_instalação_do_ansible>/templates/ em vez disso.

Renderizando um Arquivo de Configuração: Um Exemplo de Modelo

Vamos agora para uma demonstração para ver como configurar um modelo do Ansible e usar o módulo de modelo do Ansible para gerar dinamicamente um arquivo de configuração. Neste exemplo, você está criando um arquivo chamado app.conf no diretório /etc em um servidor chamado SRV1.

Os passos desta seção funcionarão para qualquer tipo de arquivo de texto. O tutorial usará um arquivo de configuração como exemplo único.

1. Faça login no seu host controlador do Ansible usando o usuário que você normalmente usa para gerenciar o Ansible.

2. Crie uma pasta no seu diretório pessoal para armazenar os arquivos de demonstração deste tutorial e mude o diretório de trabalho para ele.

mkdir ~/ansible_template_demo
cd ~/ansible_template_demo

3. Crie um arquivo de modelo chamado app.conf.j2 no diretório que se parece com abaixo.

my_ip = {{ansible_default_ipv4["address"]}}
my_host  = {{ansible_host}}
my_user  = {{ansible_user}}

Você também pode usar várias variáveis específicas do próprio módulo de modelo do Ansible no seu modelo.

4. Crie um playbook simples no mesmo diretório chamado my_playbook.yml. Este playbook cria o arquivo app.conf no diretório /etc.

name: Ansible template example 
hosts: myserver 
remote_user: ubuntu   # Using Remote host as ubuntu 
tasks: 
 - name: Create the app.conf configuration file
   template:
     src: "~/ansible_template_demo/app.conf.j2"
     dest: "/etc/app.conf"
   become: true 

5. Invoque o playbook do Ansible direcionando o host remoto SRV1.

ansible-playbook my_playbook.yml --inventory SRV1

6. Agora confirme se o arquivo de configuração /etc/app.conf existe e possui os valores esperados.

Atualizando as Permissões do Arquivo com o Módulo de Modelo

Agora que você viu o básico do uso do módulo de modelo, vamos avançar um pouco mais. Para esta demonstração, você vai criar o mesmo arquivo app.conf como mostrado anteriormente. Mas desta vez, você vai definir o proprietário do arquivo e as permissões nele.

Relacionado:Um Cara do Windows em um Mundo Linux: Usuário e Permissões de Arquivos

Para alterar as permissões no arquivo criado pelo módulo de modelo, você deve usar três parâmetros dentro do playbook:

• owner – O proprietário do arquivo
• group – O grupo ao qual o arquivo deve pertencer
• mode – As permissões. Esta string pode ser expressa tanto em símbolos quanto em números octais

No modo simbólico, u representa “usuário”, g representa “grupo” e o representa “outros”.

Assumindo que você ainda tenha a pasta ~/ansible_template_demo criada na seção anterior, abra o playbook my_playbook.yml e substitua o conteúdo pelo seguinte. Neste exemplo, o Ansible definirá o proprietário e o grupo como o usuário Ansible usando variáveis de conexão. Em seguida, define as permissões do arquivo para 0644, o que representa:

• O proprietário tem permissão de leitura/escrita
• Usuários no grupo e qualquer outra pessoa têm permissão de leitura

---
- name: Ansible file permission example
  remote_user: ubuntu
  tasks:
    - name: Create the app.conf configuration file and assign permissions
      template:
          src: "~/ansible_template_demo/app.conf.j2"
          dest: "/etc/app.conf"
	  owner: "{{ ansible_user }}"
          group: "{{ ansible_user }}"
          mode:  0644 ## OR  mode: u=rw, g=w,o=r       
      become: true

Você pode encontrar todos os parâmetros disponíveis do módulo de modelo no documento do módulo de modelo do Ansible.

Agora, execute o playbook novamente conforme mostrado abaixo.

ansible-playbook my_playbook.yml --inventory SRV1

Agora você pode ver que o app.conf tem as permissões de arquivo esperadas atribuídas a ele.

Usando Loops para Criar Múltiplos Arquivos de Modelo

Às vezes, um único arquivo não é suficiente; você precisa adicionar vários arquivos em um host remoto. Nesse caso, você pode usar loops com o módulo de modelo. Definir um loop usando o parâmetro loop permite adicionar muitos arquivos de texto armazenados em um diretório.

Assumindo que você ainda tenha a pasta ~/ansible_template_demo criada na seção anterior, você deve ter o arquivo app.conf.j2 lá.

1. Crie um segundo arquivo de modelo chamado app2.conf.j2 na pasta ~/ansible_template_demo conforme mostrado abaixo.

 template_host = "{{ template_host }}"
 template_uid = "{{ template_uid }}"
 template_path = "{{ template_path }}"
 template_fullpath = "{{ template_fullpath }}"
 template_run_date = "{{ template_run_date }}"

2. Abra o livro my_playbook.yml e substitua todo o conteúdo pelo YAML abaixo. Este playbook utiliza a variável {{item}} para representar cada arquivo de modelo processado no loop. O parâmetro loop então define cada um dos arquivos de modelo para o loop processar.

---
- name: Ansible file permission example 
  remote_user: ubuntu 
  tasks: 
   - name: Create the app.conf configuration file and assign permissions 
     template:   
        src: "~/ansible_template_demo/{{item}}.j2"    # Itera sobre 2 modelos   
        dest: "/etc/{{item}}"
        owner: "{{ ansible_user }}"   
        group: "{{ ansible_user }}"   
        mode:  0644 ## OU  modo: u=rw, g=w,o=r        
     become: true     
     loop: # Informa ao módulo de modelo para encontrar cada um desses modelos e processar                                              
      - app1.conf 
      - app2.conf 

3. Agora execute o playbook novamente. ansible-playbook my_playbook.yml --inventory SRV1

ansible-playbook my_playbook.yml --inventory SRV1

Conclusão

Os modelos e o módulo de modelo do Ansible podem economizar muito tempo e criar arquivos de texto dinâmicos em todos os seus hosts remotos. O módulo de cópia fornece funcionalidade semelhante, mas se precisar criar arquivos de texto dinâmicos, o módulo de modelo é seu amigo.