Dominando Múltiplos Inventários Ansible

Introdução

Neste laboratório, você aprenderá como trabalhar com múltiplos inventários no Ansible. Gerenciar múltiplos inventários é um cenário comum em ambientes complexos com diferentes grupos de hosts ou ambientes separados. Você aprenderá como definir e organizar múltiplos inventários, acessar hosts de diferentes inventários e realizar operações em múltiplos inventários.

Criar Diretório e Arquivos de Inventário

Vamos começar criando um diretório para armazenar nossos arquivos de inventário e, em seguida, criar dois arquivos de inventário separados para os ambientes de desenvolvimento e produção.

Primeiro, crie um novo diretório chamado inventory no caminho /home/labex/project:

mkdir -p /home/labex/project/inventory

Este comando cria um novo diretório chamado inventory. A opção -p garante que os diretórios pai sejam criados se não existirem.

Agora, crie dois arquivos de inventário: dev_inventory.ini e prod_inventory.ini dentro do diretório inventory:

touch /home/labex/project/inventory/dev_inventory.ini
touch /home/labex/project/inventory/prod_inventory.ini

O comando touch cria arquivos vazios se eles não existirem, ou atualiza o tempo de modificação se eles existirem.

Em seguida, adicionaremos conteúdo a esses arquivos de inventário. Abra dev_inventory.ini em um editor de texto (você pode usar nano ou qualquer outro editor de texto com o qual se sinta confortável):

nano /home/labex/project/inventory/dev_inventory.ini

Adicione o seguinte conteúdo:

[dev]
localhost ansible_connection=local

Salve o arquivo e saia do editor (no nano, você pode fazer isso pressionando Ctrl+X, depois Y, depois Enter).

Agora, abra prod_inventory.ini:

nano /home/labex/project/inventory/prod_inventory.ini

Adicione o seguinte conteúdo:

[prod]
localhost ansible_connection=local

Salve e saia do editor.

Nestes arquivos de inventário:

[dev] e [prod] são nomes de grupos. Eles ajudam a organizar hosts em grupos lógicos.
localhost é o hostname. Estamos usando localhost para simular diferentes ambientes na mesma máquina.
ansible_connection=local diz ao Ansible para executar comandos localmente, em vez de tentar SSH na máquina. Isso é útil para executar o Ansible na mesma máquina em que ele está instalado.

Em um cenário do mundo real, você normalmente teria diferentes endereços IP ou hostnames para seus servidores de desenvolvimento e produção, em vez de usar localhost para ambos.

Criar um Playbook para Múltiplos Inventários

Nesta etapa, criaremos um playbook que pode trabalhar com nossos inventários de desenvolvimento e produção. No Ansible, um playbook é um arquivo YAML que define um conjunto de tarefas a serem executadas em hosts.

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

touch /home/labex/project/multi_env_playbook.yaml

Agora, vamos abrir o arquivo multi_env_playbook.yaml em um editor de texto. Usaremos o nano, que é um editor de texto de linha de comando simples:

nano /home/labex/project/multi_env_playbook.yaml

Copie e cole o seguinte conteúdo no arquivo:

---
- name: Demonstrate multi-environment playbook
  hosts: all
  gather_facts: no
  tasks:
    - name: Print environment type
      debug:
        msg: "This host belongs to the {{ 'production' if 'prod' in group_names else 'development' }} environment"

    - name: Show hostname
      command: hostname
      register: hostname_output

    - name: Display hostname
      debug:
        msg: "The hostname is: {{ hostname_output.stdout }}"

Após colar, pressione Ctrl + X, depois Y e, finalmente, Enter para salvar e sair do nano.

Vamos analisar este playbook para entender cada parte:

--- no topo do arquivo indica o início de um documento YAML.
name: Demonstrate multi-environment playbook é um nome descritivo para este play.
hosts: all significa que este playbook será executado em todos os hosts no inventário.
gather_facts: no pula a fase de coleta de fatos para acelerar a execução. A coleta de fatos é quando o Ansible coleta informações sobre os hosts de destino.
tasks: inicia a lista de tarefas a serem executadas.
A primeira tarefa usa o módulo debug para imprimir uma mensagem. Ele usa uma instrução condicional para determinar se o host está no ambiente de produção ou desenvolvimento:
- group_names é uma variável especial que contém uma lista de todos os grupos aos quais o host atual pertence.
- Se 'prod' estiver na lista group_names, ele imprime "production", caso contrário, "development".
A segunda tarefa executa o comando hostname e armazena sua saída em uma variável chamada hostname_output.
A terceira tarefa exibe o hostname usando o módulo debug. Ele acessa a saída armazenada usando hostname_output.stdout.

Executar o Playbook com o Inventário de Desenvolvimento

Agora que temos nosso playbook e inventários configurados, vamos executar o playbook usando o inventário de desenvolvimento.

Execute o seguinte comando em seu terminal:

ansible-playbook -i /home/labex/project/inventory/dev_inventory.ini /home/labex/project/multi_env_playbook.yaml

Vamos analisar este comando:

ansible-playbook é o comando para executar um playbook Ansible.
-i /home/labex/project/inventory/dev_inventory.ini especifica o arquivo de inventário a ser usado. A opção -i significa "inventory" (inventário).
/home/labex/project/multi_env_playbook.yaml é o caminho para o nosso arquivo playbook.

Este comando diz ao Ansible para usar o arquivo dev_inventory.ini e executar o playbook multi_env_playbook.yaml.

Você deve ver uma saída semelhante à seguinte:

PLAY [Demonstrate multi-environment playbook] *******************************************

TASK [Print environment type] *********************************************************
ok: [localhost] => {
    "msg": "This host belongs to the development environment"
}

TASK [Show hostname] ******************************************************************
changed: [localhost]

TASK [Display hostname] ***************************************************************
ok: [localhost] => {
    "msg": "The hostname is: 66d80191e483433f91fbdca9"
}

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

Esta saída mostra que:

O playbook foi executado com sucesso no ambiente de desenvolvimento.
Ele identificou corretamente que o host pertence ao ambiente de desenvolvimento.
Ele recuperou e exibiu o hostname com sucesso.
O "PLAY RECAP" mostra um resumo da execução do playbook. Aqui, "ok=3" significa que três tarefas foram executadas com sucesso, e "changed=1" significa que uma tarefa fez uma alteração no sistema (executando o comando hostname).

Executar o Playbook com o Inventário de Produção

Agora, vamos executar o mesmo playbook usando o inventário de produção para ver como ele se comporta de forma diferente.

Execute o seguinte comando em seu terminal:

ansible-playbook -i /home/labex/project/inventory/prod_inventory.ini /home/labex/project/multi_env_playbook.yaml

Este comando é semelhante ao anterior, mas usa o arquivo prod_inventory.ini em vez de dev_inventory.ini.

Você deve ver uma saída semelhante à seguinte:

PLAY [Demonstrate multi-environment playbook] *********************************

TASK [Print environment type] *************************************************
ok: [localhost] => {
    "msg": "This host belongs to the production environment"
}

TASK [Show hostname] **********************************************************
changed: [localhost]

TASK [Display hostname] *******************************************************
ok: [localhost] => {
    "msg": "The hostname is: labex-instance"
}

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

Observe que, desta vez, o playbook identifica corretamente que está sendo executado no ambiente de produção. Isso ocorre porque estamos usando o arquivo de inventário de produção, que define o host sob o grupo [prod].

O restante da saída é semelhante ao que vimos com o inventário de desenvolvimento, o que é esperado, pois ainda estamos executando na mesma máquina local.

Executar o Playbook com Ambos os Inventários

Finalmente, vamos executar o playbook usando ambos os inventários simultaneamente. Isso demonstra como o Ansible pode trabalhar com múltiplos inventários ao mesmo tempo.

Execute o seguinte comando no seu terminal:

ansible-playbook -i /home/labex/project/inventory/dev_inventory.ini -i /home/labex/project/inventory/prod_inventory.ini /home/labex/project/multi_env_playbook.yaml

Este comando inclui ambos os arquivos de inventário usando múltiplas opções -i. O Ansible combinará esses inventários ao executar o playbook.

Você deverá ver uma saída semelhante à seguinte:

PLAY [Demonstrate multi-environment playbook] *******************************************************************************************************************************************************************************************************************************************

TASK [Print environment type] ***********************************************************************************************************************************************************************************************************************************************************
ok: [localhost] => {
    "msg": "This host belongs to the production environment"
}

TASK [Show hostname] ********************************************************************************************************************************************************************************************************************************************************************
changed: [localhost]

TASK [Display hostname] *****************************************************************************************************************************************************************************************************************************************************************
ok: [localhost] => {
    "msg": "The hostname is: 66d80191e483433f91fbdca9"
}

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

Você pode notar que, embora tenhamos incluído ambos os inventários, o playbook foi executado apenas uma vez. Isso ocorre porque ambos os inventários se referem ao mesmo localhost, e o Ansible desduplica hosts por padrão. Se houvesse hosts diferentes em cada inventário, o Ansible executaria o playbook para cada host exclusivo.

O ambiente é identificado como "production" porque, quando o mesmo host aparece em múltiplos inventários com grupos diferentes, o Ansible adiciona o host a todos os grupos aos quais pertence. Como localhost é definido em ambos os grupos [dev] e [prod], a variável group_names contém tanto 'dev' quanto 'prod'. A lógica do playbook verifica se 'prod' está em group_names, o que sempre será verdadeiro neste caso, portanto, ele exibe "production" independentemente da ordem do inventário.

Essa abordagem de usar múltiplos inventários pode ser muito útil em cenários do mundo real onde você pode ter hosts comuns entre ambientes, ou quando deseja executar um playbook contra uma combinação de hosts de diferentes arquivos de inventário.

Resumo

Neste laboratório, você aprendeu como gerenciar múltiplos inventários do Ansible. Você criou arquivos de inventário separados para os ambientes de desenvolvimento e produção, escreveu um playbook que pode trabalhar com ambos os ambientes e executou o playbook usando diferentes configurações de inventário.

Os principais pontos deste laboratório incluem:

Criar e organizar múltiplos arquivos de inventário: Você aprendeu como criar arquivos de inventário separados para diferentes ambientes, o que ajuda na organização e gerenciamento de hosts.
Escrever playbooks que podem se adaptar a diferentes ambientes: Você criou um playbook que verifica em qual ambiente ele está sendo executado e ajusta seu comportamento de acordo.
Executar playbooks com inventários únicos e múltiplos: Você aprendeu como especificar um ou mais arquivos de inventário ao executar um playbook, o que permite o direcionamento flexível de hosts.
Compreender como o Ansible lida com hosts que aparecem em múltiplos inventários: Você viu que o Ansible remove hosts duplicados e usa a última ocorrência de um host ao determinar a associação ao grupo.

Essas habilidades são cruciais ao gerenciar infraestruturas complexas com ambientes distintos. Ao alavancar múltiplos inventários, você pode manter uma melhor organização e controle sobre sua automação Ansible em diferentes conjuntos de hosts ou ambientes.

Gerenciar Múltiplos Inventários Ansible