Como criar um arquivo com conteúdo no Ansible - Guia Prático

Introdução

Ansible é uma ferramenta poderosa de automação de TI que simplifica o gerenciamento da infraestrutura. Neste laboratório prático, você aprenderá como usar o Ansible para criar arquivos com conteúdo específico em sistemas-alvo. Ao final deste laboratório, você entenderá os fundamentos do gerenciamento de arquivos com Ansible e será capaz de implementar a criação automatizada de arquivos em sua própria infraestrutura.

Instalando e Configurando o Ansible

Antes de começarmos a usar o Ansible para criar arquivos, precisamos instalá-lo e configurá-lo em nosso sistema. Vamos configurar nosso ambiente:

Instalando o Ansible

Primeiramente, atualizaremos as listas de pacotes e instalaremos o Ansible em nosso sistema Ubuntu 22.04:

sudo apt update
sudo apt install -y ansible

Após executar esses comandos, você deverá ver uma saída indicando que o Ansible foi instalado com sucesso. Vamos verificar a instalação:

ansible --version

Você deverá ver uma saída semelhante a esta:

ansible [core 2.12.0]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, ...) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Criando um Inventário Ansible Simples

O Ansible usa um arquivo de inventário para definir os hosts que ele irá gerenciar. Para este laboratório, criaremos um inventário local que inclui nossa própria máquina:

Crie um novo diretório para nosso projeto Ansible:

mkdir -p ~/project/ansible-files
cd ~/project/ansible-files

Crie um arquivo de inventário usando o VSCode:
- Clique no ícone Explorer na WebIDE
- Navegue até o diretório ~/project/ansible-files
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como inventory
- Adicione o seguinte conteúdo ao arquivo:

[local]
localhost ansible_connection=local

Este arquivo de inventário diz ao Ansible para executar comandos na máquina local sem usar SSH.

Crie um arquivo ansible.cfg simples no mesmo diretório:
- Clique no ícone Explorer na WebIDE
- Navegue até o diretório ~/project/ansible-files
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como ansible.cfg
- Adicione o seguinte conteúdo ao arquivo:

[defaults]
inventory = ./inventory
host_key_checking = False

Vamos verificar nossa configuração executando um comando Ansible simples:

cd ~/project/ansible-files
ansible local -m ping

Você deverá ver uma saída semelhante a:

localhost | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Isso confirma que o Ansible está corretamente instalado e configurado para executar comandos em sua máquina local.

Criando Arquivos com Conteúdo Usando Playbooks Ansible

Agora que temos o Ansible configurado, vamos aprender como criar arquivos com conteúdo. O Ansible fornece vários módulos para gerenciar arquivos, e nos concentraremos no módulo copy nesta etapa.

Entendendo os Playbooks Ansible

Playbooks Ansible são arquivos YAML que descrevem um conjunto de tarefas a serem executadas em hosts-alvo. Cada tarefa utiliza um módulo Ansible específico para realizar uma ação.

Vamos criar nosso primeiro playbook para criar um arquivo com conteúdo:

Na WebIDE, crie um novo arquivo no diretório ~/project/ansible-files:
- Clique com o botão direito no diretório e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como create_file.yml
- Adicione o seguinte conteúdo:

---
- name: Create a file with content
  hosts: local
  tasks:
    - name: Create a simple text file
      copy:
        dest: "~/project/hello.txt"
        content: |
          Hello from Ansible!
          This file was created using the Ansible copy module.
          Current date: {{ ansible_date_time.date }}

Vamos entender o que este playbook faz:

A linha hosts: local especifica que este playbook será executado nos hosts no grupo local do nosso inventário.
A seção tasks contém uma lista de tarefas a serem executadas.
O módulo copy é usado para criar um arquivo com conteúdo.
O parâmetro dest especifica o caminho de destino para o arquivo.
O parâmetro content contém o conteúdo de texto que será escrito no arquivo.
{{ ansible_date_time.date }} é uma variável que será substituída pela data atual quando o playbook for executado.

Agora, vamos executar o playbook:

cd ~/project/ansible-files
ansible-playbook create_file.yml

Você deverá ver uma saída semelhante a:

PLAY [Create a file with content] ***********************************************

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

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

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

Vamos verificar se o arquivo foi criado e contém o conteúdo esperado:

cat ~/project/hello.txt

Você deverá ver uma saída semelhante a:

Hello from Ansible!
This file was created using the Ansible copy module.
Current date: 2023-08-15

A data refletirá a data atual quando você executar o playbook.

Idempotência no Ansible

Idempotência é uma característica chave do Ansible - executar o mesmo playbook várias vezes deve produzir o mesmo resultado. Vamos executar o playbook novamente para ver a idempotência em ação:

ansible-playbook create_file.yml

Desta vez, você deverá ver que a contagem "changed" é 0:

PLAY [Create a file with content] ***********************************************

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

TASK [Create a simple text file] ***********************************************
ok: [localhost]

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

Isso mostra que o Ansible reconhece que o arquivo já existe com o conteúdo correto, então ele não o modifica novamente.

Usando Variáveis e Templates no Ansible

Nesta etapa, exploraremos como usar variáveis e templates para criar arquivos mais dinâmicos com o Ansible.

Trabalhando com Variáveis

Variáveis tornam seus playbooks mais flexíveis e reutilizáveis. Vamos criar um playbook que usa variáveis para criar um arquivo de configuração:

Crie um novo arquivo na WebIDE no diretório ~/project/ansible-files:
- Clique com o botão direito no diretório e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como variables_demo.yml
- Adicione o seguinte conteúdo:

---
- name: Create files using variables
  hosts: local
  vars:
    app_name: "MyApplication"
    app_version: "1.0.0"
    port_number: 8080
    log_level: "INFO"
  tasks:
    - name: Create config file with variables
      copy:
        dest: "~/project/app_config.ini"
        content: |
          ## Configuration for {{ app_name }}
          ## Generated by Ansible

          [application]
          name = {{ app_name }}
          version = {{ app_version }}

          [server]
          port = {{ port_number }}
          log_level = {{ log_level }}

Neste playbook:

A seção vars define variáveis que podem ser usadas em todo o playbook.
As variáveis são referenciadas usando a sintaxe {{ variable_name }}.
O módulo copy é usado para criar um arquivo com conteúdo que inclui essas variáveis.

Agora, vamos executar o playbook:

cd ~/project/ansible-files
ansible-playbook variables_demo.yml

Você deverá ver uma saída semelhante a:

PLAY [Create files using variables] ********************************************

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

TASK [Create config file with variables] ***************************************
changed: [localhost]

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

Vamos examinar o conteúdo do arquivo gerado:

cat ~/project/app_config.ini

Você deverá ver uma saída semelhante a:

## Configuration for MyApplication
## Generated by Ansible

[application]
name = MyApplication
version = 1.0.0

[server]
port = 8080
log_level = INFO

Usando Templates Jinja2

Para conteúdo de arquivo mais complexo, o Ansible suporta templates Jinja2. Vamos criar um arquivo de template e usá-lo em um playbook:

Crie um diretório de templates:

mkdir -p ~/project/ansible-files/templates

Crie um arquivo de template na WebIDE:
- Navegue até o diretório ~/project/ansible-files/templates
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como web_config.j2
- Adicione o seguinte conteúdo:

## Web Server Configuration
## Generated by Ansible on {{ ansible_date_time.date }}

server {
    listen {{ web_port }};
    server_name {{ server_name }};

    location / {
        root {{ doc_root }};
        index index.html;
    }

    {% if enable_ssl %}
    ## SSL Configuration
    ssl_certificate {{ ssl_cert }};
    ssl_certificate_key {{ ssl_key }};
    {% endif %}
}

Agora, crie um playbook que usa este template:
- Navegue até o diretório ~/project/ansible-files
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como template_demo.yml
- Adicione o seguinte conteúdo:

---
- name: Create files using templates
  hosts: local
  vars:
    web_port: 80
    server_name: "example.com"
    doc_root: "/var/www/html"
    enable_ssl: true
    ssl_cert: "/etc/ssl/certs/example.com.crt"
    ssl_key: "/etc/ssl/private/example.com.key"
  tasks:
    - name: Create web server config from template
      template:
        src: templates/web_config.j2
        dest: ~/project/web_server.conf

Neste playbook:

O módulo template é usado em vez de copy.
O parâmetro src aponta para o nosso arquivo de template.
O parâmetro dest especifica onde criar o arquivo de saída.
As variáveis definidas na seção vars serão usadas no template.

Execute o playbook:

cd ~/project/ansible-files
ansible-playbook template_demo.yml

Você deverá ver uma saída semelhante a:

PLAY [Create files using templates] ********************************************

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

TASK [Create web server config from template] **********************************
changed: [localhost]

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

Vamos examinar o arquivo de configuração gerado:

cat ~/project/web_server.conf

Você deverá ver uma saída semelhante a:

## Web Server Configuration
## Generated by Ansible on 2023-08-15

server {
    listen 80;
    server_name example.com;

    location / {
        root /var/www/html;
        index index.html;
    }

    ## SSL Configuration
    ssl_certificate /etc/ssl/certs/example.com.crt;
    ssl_certificate_key /etc/ssl/private/example.com.key;
}

Observe como o template Jinja2 foi renderizado com nossas variáveis, e a seção condicional para SSL foi incluída porque enable_ssl foi definido como true.

Gerenciamento Avançado de Arquivos com Ansible

Nesta etapa final, exploraremos algumas técnicas avançadas de gerenciamento de arquivos com Ansible, incluindo permissões de arquivo, criação condicional de arquivos e o uso de múltiplos módulos relacionados a arquivos.

Definindo Permissões e Propriedade de Arquivos

Ao criar arquivos, você frequentemente precisa definir permissões e propriedade específicas. Vamos criar um playbook que demonstra isso:

Crie um novo arquivo na WebIDE:
- Navegue até o diretório ~/project/ansible-files
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como file_permissions.yml
- Adicione o seguinte conteúdo:

---
- name: Manage file permissions and ownership
  hosts: local
  tasks:
    - name: Create a script file with execute permissions
      copy:
        dest: ~/project/script.sh
        content: |
          #!/bin/bash
          echo "This script was created by Ansible"
          echo "Current user: $(whoami)"
          echo "Current directory: $(pwd)"
        mode: "0755"

    - name: Create a read-only configuration file
      copy:
        dest: ~/project/readonly.conf
        content: |
          ## This is a read-only configuration file
          setting1 = value1
          setting2 = value2
        mode: "0444"

Neste playbook:

O parâmetro mode é usado para definir as permissões do arquivo.
0755 significa leitura, escrita e execução para o proprietário, e leitura e execução para o grupo e outros.
0444 significa somente leitura para todos.

Execute o playbook:

cd ~/project/ansible-files
ansible-playbook file_permissions.yml

Você deverá ver uma saída semelhante a:

PLAY [Manage file permissions and ownership] **********************************

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

TASK [Create a script file with execute permissions] **************************
changed: [localhost]

TASK [Create a read-only configuration file] **********************************
changed: [localhost]

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

Vamos verificar as permissões dos arquivos criados:

ls -l ~/project/script.sh ~/project/readonly.conf

Você deverá ver uma saída semelhante a:

-rwxr-xr-x 1 labex labex 118 Aug 15 12:34 /home/labex/project/script.sh
-r--r--r-- 1 labex labex  73 Aug 15 12:34 /home/labex/project/readonly.conf

Vamos verificar se o script pode ser executado:

~/project/script.sh

Você deverá ver uma saída semelhante a:

This script was created by Ansible
Current user: labex
Current directory: /home/labex/project/ansible-files

Criação Condicional de Arquivos

Às vezes, você precisa criar arquivos somente quando certas condições são atendidas. Vamos criar um playbook que demonstra a criação condicional de arquivos:

Crie um novo arquivo na WebIDE:
- Navegue até o diretório ~/project/ansible-files
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como conditional_file.yml
- Adicione o seguinte conteúdo:

---
- name: Conditional file creation
  hosts: local
  vars:
    environment: "development"
    create_debug_file: true
    create_backup: false
  tasks:
    - name: Create environment-specific configuration
      copy:
        dest: "~/project/{{ environment }}_config.yml"
        content: |
          ## Configuration for {{ environment }} environment
          debug: {{ 'enabled' if environment == 'development' else 'disabled' }}
          log_level: {{ 'DEBUG' if environment == 'development' else 'INFO' }}

    - name: Create debug log file
      copy:
        dest: ~/project/debug.log
        content: |
          ## Debug log file
          ## Created: {{ ansible_date_time.iso8601 }}
        mode: "0644"
      when: create_debug_file

    - name: Create backup directory
      file:
        path: ~/project/backup
        state: directory
        mode: "0755"
      when: create_backup

Neste playbook:

A diretiva when é usada para execução condicional de tarefas.
Condicionais Jinja2 são usados no conteúdo do arquivo para alterar valores com base em variáveis.
O módulo file é usado para criar um diretório.

Execute o playbook:

cd ~/project/ansible-files
ansible-playbook conditional_file.yml

Você deverá ver uma saída semelhante a:

PLAY [Conditional file creation] **********************************************

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

TASK [Create environment-specific configuration] ******************************
changed: [localhost]

TASK [Create debug log file] **************************************************
changed: [localhost]

TASK [Create backup directory] ************************************************
skipped: [localhost]

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

Observe que a tarefa "Create backup directory" (Criar diretório de backup) foi ignorada porque create_backup foi definido como false.

Vamos examinar os arquivos criados:

cat ~/project/development_config.yml
cat ~/project/debug.log
ls -la ~/project/ | grep backup

Você deverá ver o conteúdo dos dois arquivos que foram criados e confirmar que nenhum diretório de backup foi criado.

Usando Múltiplos Módulos Relacionados a Arquivos

O Ansible fornece vários módulos para gerenciamento de arquivos. Vamos criar um playbook que demonstra o uso de múltiplos módulos relacionados a arquivos:

Crie um novo arquivo na WebIDE:
- Navegue até o diretório ~/project/ansible-files
- Clique com o botão direito e selecione "New File" (Novo Arquivo)
- Nomeie o arquivo como file_modules.yml
- Adicione o seguinte conteúdo:

---
- name: Demonstrate file-related modules
  hosts: local
  tasks:
    - name: Create a directory
      file:
        path: ~/project/ansible_demo
        state: directory
        mode: "0755"

    - name: Create a file using the copy module
      copy:
        dest: ~/project/ansible_demo/copied.txt
        content: "This file was created using the copy module.\n"

    - name: Create a symbolic link
      file:
        src: ~/project/ansible_demo/copied.txt
        dest: ~/project/ansible_demo/link_to_copied.txt
        state: link

    - name: Create a file with blockinfile module
      blockinfile:
        path: ~/project/ansible_demo/block.txt
        create: true
        block: |
          This is a block of text
          that will be inserted
          as a single unit.
        marker: "## {mark} ANSIBLE MANAGED BLOCK"

Neste playbook:

O módulo file é usado com state: directory para criar um diretório.
O módulo file é usado com state: link para criar um link simbólico.
O módulo blockinfile é usado para criar um arquivo com um bloco de texto cercado por comentários de marcador.

Execute o playbook:

cd ~/project/ansible-files
ansible-playbook file_modules.yml

Você deverá ver uma saída semelhante a:

PLAY [Demonstrate file-related modules] ***************************************

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

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

TASK [Create a file using the copy module] ************************************
changed: [localhost]

TASK [Create a symbolic link] *************************************************
changed: [localhost]

TASK [Create a file with blockinfile module] **********************************
changed: [localhost]

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

Vamos verificar os resultados:

ls -la ~/project/ansible_demo/
cat ~/project/ansible_demo/copied.txt
cat ~/project/ansible_demo/link_to_copied.txt
cat ~/project/ansible_demo/block.txt

Você deverá ver:

Um diretório chamado ansible_demo
Um arquivo chamado copied.txt com o conteúdo especificado
Um link simbólico chamado link_to_copied.txt apontando para copied.txt
Um arquivo chamado block.txt com um bloco de texto cercado por comentários de marcador

A saída do último comando deve ser semelhante a:

## BEGIN ANSIBLE MANAGED BLOCK
This is a block of text
that will be inserted
as a single unit.
## END ANSIBLE MANAGED BLOCK

Isso demonstra a versatilidade dos recursos de gerenciamento de arquivos do Ansible.

Resumo

Parabéns por concluir este laboratório de gerenciamento de arquivos com Ansible. Você aprendeu vários conceitos e técnicas importantes:

Como instalar e configurar o Ansible para tarefas básicas de automação
Criar arquivos com conteúdo específico usando o módulo copy
Usar variáveis para tornar o conteúdo do seu arquivo dinâmico
Trabalhar com templates Jinja2 para geração de arquivos mais complexa
Definir permissões e propriedade de arquivos
Implementar a criação condicional de arquivos com base em variáveis
Usar vários módulos Ansible para diferentes tarefas de gerenciamento de arquivos

Essas habilidades formam uma base sólida para automatizar tarefas de gerenciamento de arquivos em sua infraestrutura. Com o Ansible, você pode garantir conteúdo de arquivo consistente em vários servidores, aplicar alterações de maneira controlada e manter um registro auditável de sua configuração.

Para continuar sua jornada de aprendizado do Ansible, considere explorar tópicos mais avançados, como roles (papéis), organização de playbooks e integração do Ansible com outras ferramentas DevOps.