Gérer plusieurs inventaires Ansible

Introduction

Dans ce laboratoire (lab), vous apprendrez à travailler avec plusieurs inventaires dans Ansible. Gérer plusieurs inventaires est un scénario courant dans les environnements complexes comportant différents groupes d'hôtes ou des environnements distincts. Vous apprendrez à définir et organiser plusieurs inventaires, à accéder aux hôtes de différents inventaires et à effectuer des opérations sur plusieurs inventaires.

Créer le répertoire et les fichiers d'inventaire

Commençons par créer un répertoire pour stocker nos fichiers d'inventaire, puis créons deux fichiers d'inventaire distincts pour les environnements de développement et de production.

Tout d'abord, créez un nouveau répertoire appelé inventory dans le chemin /home/labex/project :

mkdir -p /home/labex/project/inventory

Cette commande crée un nouveau répertoire appelé inventory. L'option -p garantit que les répertoires parents sont créés s'ils n'existent pas.

Maintenant, créez deux fichiers d'inventaire : dev_inventory.ini et prod_inventory.ini à l'intérieur du répertoire inventory :

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

La commande touch crée des fichiers vides s'ils n'existent pas, ou met à jour la date de modification s'ils existent déjà.

Ensuite, nous allons ajouter du contenu à ces fichiers d'inventaire. Ouvrez dev_inventory.ini dans un éditeur de texte (vous pouvez utiliser nano ou tout autre éditeur de texte avec lequel vous êtes à l'aise) :

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

Ajoutez le contenu suivant :

[dev]
localhost ansible_connection=local

Enregistrez le fichier et quittez l'éditeur (dans nano, vous pouvez le faire en appuyant sur Ctrl+X, puis Y, puis Entrée).

Maintenant, ouvrez prod_inventory.ini :

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

Ajoutez le contenu suivant :

[prod]
localhost ansible_connection=local

Enregistrez et quittez l'éditeur.

Dans ces fichiers d'inventaire :

• [dev] et [prod] sont des noms de groupes. Ils aident à organiser les hôtes en groupes logiques.
• localhost est le nom d'hôte. Nous utilisons localhost pour simuler différents environnements sur la même machine.
• ansible_connection=local indique à Ansible d'exécuter les commandes localement au lieu d'essayer de se connecter en SSH à la machine. Cela est utile pour exécuter Ansible sur la même machine où il est installé.

Dans un scénario réel, vous aurez généralement des adresses IP ou des noms d'hôte différents pour vos serveurs de développement et de production au lieu d'utiliser localhost pour les deux.

Créer un playbook pour plusieurs inventaires

Dans cette étape, nous allons créer un playbook qui peut fonctionner avec nos inventaires de développement et de production. Dans Ansible, un playbook est un fichier YAML qui définit un ensemble de tâches à exécuter sur les hôtes.

Tout d'abord, créons un nouveau fichier appelé multi_env_playbook.yaml dans le répertoire /home/labex/project :

touch /home/labex/project/multi_env_playbook.yaml

Maintenant, ouvrons le fichier multi_env_playbook.yaml dans un éditeur de texte. Nous utiliserons nano, un éditeur de texte en ligne de commande simple :

nano /home/labex/project/multi_env_playbook.yaml

Copiez et collez le contenu suivant dans le fichier :

---
- 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 }}"

Après avoir collé le contenu, appuyez sur Ctrl + X, puis sur Y, et enfin sur Entrée pour enregistrer et quitter nano.

Analysons ce playbook pour comprendre chaque partie :

1. --- en haut du fichier indique le début d'un document YAML.
2. name: Demonstrate multi-environment playbook est un nom descriptif pour cette série de tâches (play).
3. hosts: all signifie que ce playbook sera exécuté sur tous les hôtes de l'inventaire.
4. gather_facts: no saute la phase de collecte de données (fact gathering) pour accélérer l'exécution. La collecte de données est le moment où Ansible collecte des informations sur les hôtes cibles.
5. tasks: commence la liste des tâches à exécuter.
6. La première tâche utilise le module debug pour afficher un message. Elle utilise une instruction conditionnelle pour déterminer si l'hôte appartient à l'environnement de production ou de développement :
   • group_names est une variable spéciale qui contient la liste de tous les groupes auxquels l'hôte actuel appartient.
   • Si 'prod' est dans la liste group_names, elle affiche "production", sinon "development".
7. La deuxième tâche exécute la commande hostname et stocke sa sortie dans une variable appelée hostname_output.
8. La troisième tâche affiche le nom d'hôte en utilisant le module debug. Elle accède à la sortie stockée en utilisant hostname_output.stdout.

Exécuter le playbook avec l'inventaire de développement

Maintenant que nous avons configuré notre playbook et nos inventaires, exécutons le playbook en utilisant l'inventaire de développement.

Exécutez la commande suivante dans votre terminal :

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

Analysons cette commande :

• ansible-playbook est la commande pour exécuter un playbook Ansible.
• -i /home/labex/project/inventory/dev_inventory.ini spécifie le fichier d'inventaire à utiliser. L'option -i signifie "inventory" (inventaire).
• /home/labex/project/multi_env_playbook.yaml est le chemin vers notre fichier de playbook.

Cette commande indique à Ansible d'utiliser le fichier dev_inventory.ini et d'exécuter le playbook multi_env_playbook.yaml.

Vous devriez voir une sortie similaire à ce qui suit :

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

Cette sortie montre que :

1. Le playbook s'est exécuté avec succès sur l'environnement de développement.
2. Il a correctement identifié que l'hôte appartient à l'environnement de développement.
3. Il a réussi à récupérer et afficher le nom d'hôte.
4. Le "PLAY RECAP" affiche un résumé de l'exécution du playbook. Ici, "ok=3" signifie que trois tâches ont été exécutées avec succès, et "changed=1" signifie qu'une tâche a apporté une modification au système (l'exécution de la commande hostname).

Exécuter le playbook avec l'inventaire de production

Maintenant, exécutons le même playbook en utilisant l'inventaire de production pour voir comment il se comporte différemment.

Exécutez la commande suivante dans votre terminal :

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

Cette commande est similaire à la précédente, mais elle utilise le fichier prod_inventory.ini au lieu de dev_inventory.ini.

Vous devriez voir une sortie similaire à ce qui suit :

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

Notez que cette fois, le playbook identifie correctement qu'il s'exécute dans l'environnement de production. C'est parce que nous utilisons le fichier d'inventaire de production, qui définit l'hôte dans le groupe [prod].

Le reste de la sortie est similaire à ce que nous avons vu avec l'inventaire de développement, ce qui est normal puisque nous exécutons toujours sur la même machine locale.

Exécuter le Playbook avec les deux inventaires

Enfin, exécutons le playbook en utilisant les deux inventaires simultanément. Cela démontre comment Ansible peut fonctionner avec plusieurs inventaires en même temps.

Exécutez la commande suivante dans votre 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

Cette commande inclut les deux fichiers d'inventaire en utilisant plusieurs options -i. Ansible combinera ces inventaires lors de l'exécution du playbook.

Vous devriez voir une sortie similaire à la suivante :

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

Vous pourriez remarquer que même si nous avons inclus les deux inventaires, le playbook n'a été exécuté qu'une seule fois. C'est parce que les deux inventaires font référence au même localhost, et Ansible déduplique les hôtes par défaut. S'il y avait eu des hôtes différents dans chaque inventaire, Ansible aurait exécuté le playbook pour chaque hôte unique.

L'environnement est identifié comme "production" car lorsque le même hôte apparaît dans plusieurs inventaires avec des groupes différents, Ansible ajoute l'hôte à tous les groupes auxquels il appartient. Comme localhost est défini dans les groupes [dev] et [prod], la variable group_names contient à la fois 'dev' et 'prod'. La logique du playbook vérifie si 'prod' est dans group_names, ce qui sera toujours vrai dans ce cas, il affiche donc "production" quel que soit l'ordre des inventaires.

Cette approche d'utilisation de plusieurs inventaires peut être très utile dans des scénarios réels où vous pourriez avoir des hôtes communs entre les environnements, ou lorsque vous souhaitez exécuter un playbook sur une combinaison d'hôtes provenant de différents fichiers d'inventaire.

Résumé

Dans ce laboratoire, vous avez appris à gérer plusieurs inventaires Ansible. Vous avez créé des fichiers d'inventaire distincts pour les environnements de développement et de production, écrit un playbook qui peut fonctionner avec les deux environnements, et exécuté le playbook en utilisant différentes configurations d'inventaire.

Les principaux points clés de ce laboratoire sont les suivants :

1. Création et organisation de plusieurs fichiers d'inventaire : Vous avez appris à créer des fichiers d'inventaire distincts pour différents environnements, ce qui facilite l'organisation et la gestion des hôtes.
2. Écriture de playbooks adaptables à différents environnements : Vous avez créé un playbook qui vérifie dans quel environnement il s'exécute et ajuste son comportement en conséquence.
3. Exécution de playbooks avec un ou plusieurs inventaires : Vous avez appris à spécifier un ou plusieurs fichiers d'inventaire lors de l'exécution d'un playbook, ce qui permet de cibler les hôtes de manière flexible.
4. Compréhension de la gestion par Ansible des hôtes apparaissant dans plusieurs inventaires : Vous avez vu qu'Ansible élimine les doublons d'hôtes et utilise la dernière occurrence d'un hôte pour déterminer l'appartenance au groupe.

Ces compétences sont cruciales pour la gestion d'infrastructures complexes avec des environnements distincts. En utilisant plusieurs inventaires, vous pouvez maintenir une meilleure organisation et un meilleur contrôle sur votre automatisation Ansible à travers différents ensembles d'hôtes ou d'environnements.