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

Gerenciar configurações de vários servidores e ambientes é um grande benefício ao 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 explorar 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 modelo do Ansible para economizar muito tempo.

Pré-requisitos

Este post será um tutorial passo a passo. Se deseja acompanhar, certifique-se de ter um host controlador do Ansible. Este tutorial usará 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 são tipicamente algum tipo de arquivo de configuração. Se 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.

Aquele arquivo de 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 Ansible e depois 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 e endereço IP específicos, etc. Você precisa de um modelo Ansible.

Os modelos 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 Ansible?

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

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

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

Você não pode copiar este arquivo para cada servidor web porque cada item será único dependendo do IP do host remoto, do nome 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 em tempo de 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 observada com chaves duplas de ambos os lados. Neste caso, essas variáveis vêm dos fatos do Ansible.

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

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

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

Depois de ter criado um modelo, você precisa transferir esse arquivo de modelo para o host remoto e “convertê-lo” no arquivo de texto real do que ele 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 copy para transferir arquivos para hosts remotos, mas, como mencionado acima, 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, vamos supor que você “templateizou” o arquivo de configuração app.conf para se tornar um arquivo de template app.conf.j2, conforme abordado na seção anterior, no 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, simplesmente substitua a referência de copy por template, conforme mostrado abaixo. Ao fazer isso, o Ansible invocará o módulo de template para transferir o template 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

Depois que a tarefa acima no playbook for executada, o Ansible copiará o app.conf.j2 para o diretório /opt do host remoto, substituirá todas as variáveis 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 /<ansible_installation_directory>/files/. Se você fornecer apenas o nome do arquivo, o Ansible procurará o modelo no diretório /<ansible_installation_directory>/templates/.

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

Agora, vamos fazer uma demonstração para ver como configurar um modelo Ansible e usar o módulo de modelo 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.

As etapas 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 via SSH no host controlador do Ansible usando o usuário que você normalmente usa para gerenciar o Ansible.

2. Crie uma pasta em seu diretório home para armazenar os arquivos de demonstração deste tutorial e mude o diretório de trabalho para ela.

mkdir ~/ansible_template_demo
cd ~/ansible_template_demo

3. Crie um arquivo de modelo chamado app.conf.j2 no diretório com a seguinte aparência.

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 módulo de modelo Ansible em 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. Execute 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 mostrado anteriormente. Mas desta vez, você vai definir o proprietário e as permissões do arquivo.

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

Para alterar as permissões no arquivo que o módulo de modelo cria, 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”.

Supondo 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 como 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 arquivo app.conf tem as permissões de arquivo esperadas atribuídas a ele.

Usando Loops para Modelar Múltiplos Arquivos

À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.

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

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 arquivo 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: # Diga 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 do Ansible e o módulo de modelo 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.