Gérer les variables et les faits dans RHEL avec Ansible

Introduction

Dans ce laboratoire, vous apprendrez les techniques fondamentales pour gérer les variables, les faits et les secrets au sein des playbooks Ansible sur un système Red Hat Enterprise Linux (RHEL). Vous découvrirez comment rendre votre automatisation plus flexible et puissante en utilisant des variables de playbook, en collectant des informations système avec des faits Ansible intégrés et personnalisés, et en sécurisant les données sensibles comme les mots de passe à l'aide d'Ansible Vault.

À travers une série d'étapes pratiques, vous construirez un playbook pour déployer et configurer un serveur web Apache. Vous commencerez par définir des variables simples pour le nom du paquet et le contenu web, puis vous exploiterez des faits personnalisés pour mettre à jour dynamiquement la configuration du serveur web. Enfin, vous utiliserez Ansible Vault pour créer en toute sécurité un nouvel utilisateur système avec un mot de passe chiffré, exécuterez le playbook complet et vérifierez que toutes les configurations ont été appliquées avec succès.

Définir et utiliser des variables de playbook pour déployer un serveur web Apache

Dans cette étape, vous apprendrez à utiliser des variables dans un playbook Ansible. Les variables sont essentielles pour rendre votre automatisation flexible, réutilisable, plus facile à lire et à maintenir. Au lieu de coder en dur des valeurs comme les noms de paquets ou les chemins de fichiers directement dans vos tâches, vous pouvez les définir en tant que variables et les référencer tout au long du playbook. Nous allons créer un playbook simple qui utilise des variables pour installer le serveur web Apache (httpd) et déployer une page web de base.

1. Accéder au répertoire du projet

   Tout d'abord, assurez-vous d'être dans le répertoire de travail correct. Tout votre travail pour ce laboratoire sera effectué dans le répertoire ~/project, qui a été créé pour vous.

   cd ~/project
   

   Installez le paquet ansible-core.

   sudo dnf install -y ansible-core
   

2. Créer le playbook Ansible

   Maintenant, créons notre fichier de playbook. Nous l'appellerons playbook.yml. Vous pouvez utiliser un éditeur de texte en ligne de commande comme nano pour créer et modifier le fichier.

   nano playbook.yml
   

   Cette commande ouvre un fichier vide dans l'éditeur nano. Ajoutez maintenant la partie initiale du playbook. Cette section définit le nom du play, l'hôte cible (localhost, puisque nous l'exécutons sur la même machine) et une section vars où nous définirons nos variables.

   ---
   - name: Deploy Apache using variables
     hosts: localhost
     become: true
     vars:
       web_pkg: httpd
       web_content: "Hello from Ansible Variables"
   

   Voici une décomposition de la structure du playbook :

   • hosts: localhost : Spécifie que le playbook doit s'exécuter sur la machine locale.
   • become: true : Indique à Ansible d'utiliser l'élévation de privilèges (équivalent à sudo) pour les tâches, ce qui est nécessaire pour installer des logiciels.
   • vars : Il s'agit d'un dictionnaire où nous définissons nos paires clé-valeur pour les variables. Nous avons défini web_pkg pour le nom du paquet et web_content pour le contenu de notre page web de test.

3. Ajouter des tâches au playbook

   Ensuite, sous la section vars, ajoutez les tasks qui utiliseront ces variables. La première tâche installera le paquet Apache, et la seconde créera un fichier index.html. Ajoutez le bloc tasks suivant à votre fichier playbook.yml tout en restant dans l'éditeur nano.

   tasks:
     - name: Install the latest version of Apache
       ansible.builtin.dnf:
         name: "{{ web_pkg }}"
         state: latest
   
     - name: Create a basic index.html file
       ansible.builtin.copy:
         content: "{{ web_content }}"
         dest: /var/www/html/index.html
   

   Remarquez comment nous utilisons {{ variable_name }} pour référencer les variables que nous avons définies précédemment. Il s'agit du templating Jinja2, qu'Ansible utilise pour les variables. Cela rend les définitions de tâches génériques ; si vous vouliez installer Nginx à la place, il vous suffirait de modifier la variable web_pkg, et non la tâche elle-même.

4. Réviser et enregistrer le playbook

   Votre fichier playbook.yml complet devrait maintenant ressembler à ceci. Vérifiez le contenu et l'indentation, car YAML est très sensible aux espaces.

   ---
   - name: Deploy Apache using variables
     hosts: localhost
     become: true
     vars:
       web_pkg: httpd
       web_content: "Hello from Ansible Variables"
     tasks:
       - name: Install the latest version of Apache
         ansible.builtin.dnf:
           name: "{{ web_pkg }}"
           state: latest
   
       - name: Create a basic index.html file
         ansible.builtin.copy:
           content: "{{ web_content }}"
           dest: /var/www/html/index.html
   

   Pour enregistrer le fichier dans nano, appuyez sur Ctrl+X, puis Y pour confirmer les modifications, et enfin Entrée pour écrire le fichier sous le nom playbook.yml.

5. Vérifier la syntaxe du playbook

   Avant d'exécuter un playbook, il est toujours recommandé de vérifier sa syntaxe pour détecter d'éventuelles erreurs.

   ansible-playbook --syntax-check playbook.yml
   

   Si la syntaxe est correcte, vous verrez le chemin du fichier du playbook en sortie, confirmant qu'il est valide :

   playbook: playbook.yml
   

   Si vous voyez des erreurs, rouvrez le fichier avec nano playbook.yml et corrigez-les. Faites très attention à l'indentation correcte (généralement deux espaces).

6. Exécuter le playbook

   Maintenant, exécutez le playbook. Ansible se connectera à localhost, lira les variables et exécutera les tâches.

   ansible-playbook playbook.yml
   

   Vous devriez voir une sortie indiquant l'exécution réussie de chaque tâche. Le statut changed signifie qu'Ansible a apporté une modification au système, comme l'installation d'un paquet ou la création d'un fichier.

   PLAY [Deploy Apache using variables] *******************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install the latest version of Apache] ************************************
   changed: [localhost]
   
   TASK [Create a basic index.html file] ******************************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

   Si vous exécutez le playbook une seconde fois, les tâches devraient rapporter ok au lieu de changed, car le paquet est déjà installé et le fichier possède déjà le contenu correct. Cela démontre l'idempotence d'Ansible.

7. Vérifier manuellement la configuration

   Bien que le playbook soit terminé, vous pouvez vérifier manuellement que les tâches ont fonctionné comme prévu. Tout d'abord, vérifiez si le paquet httpd a été installé :

   rpm -q httpd
   

   La sortie devrait afficher le nom et la version du paquet :

   httpd-2.4.57-7.el9.x86_64
   

   Ensuite, vérifiez le contenu du fichier index.html :

   cat /var/www/html/index.html
   

   La sortie devrait correspondre à la valeur de votre variable web_content :

   Hello from Ansible Variables
   

   Vous avez utilisé avec succès des variables dans un playbook Ansible pour configurer un système.

Afficher les informations système à l'aide des faits Ansible

Dans cette étape, vous explorerez les faits Ansible. Les faits sont des informations qu'Ansible collecte sur les systèmes qu'il gère (dans ce cas, localhost). Ces informations incluent des détails tels que le système d'exploitation, les interfaces réseau, la mémoire, et bien plus encore. Par défaut, Ansible collecte des faits au début de chaque play, les rendant disponibles dans une variable spéciale appelée ansible_facts. L'utilisation des faits vous permet de créer des playbooks dynamiques qui s'adaptent à l'environnement dans lequel ils s'exécutent.

1. Accéder au répertoire du projet

   Tout d'abord, assurez-vous d'être dans le répertoire ~/project où vous créerez le nouveau playbook.

   cd ~/project
   

2. Créer un playbook pour afficher tous les faits

   Commençons par créer un playbook qui affiche simplement tous les faits qu'Ansible peut collecter sur votre système. Cela vous donnera une idée de la vaste quantité d'informations disponibles. Utilisez nano pour créer un nouveau fichier nommé display_facts.yml.

   nano display_facts.yml
   

   À l'intérieur de l'éditeur nano, ajoutez le contenu suivant. Ce playbook cible localhost et utilise le module ansible.builtin.debug pour imprimer le contenu de la variable ansible_facts.

   ---
   - name: Display all Ansible facts
     hosts: localhost
     tasks:
       - name: Print all available facts
         ansible.builtin.debug:
           var: ansible_facts
   

   Enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et Entrée.

3. Exécuter le playbook

   Maintenant, exécutez le playbook pour voir le résultat.

   ansible-playbook display_facts.yml
   

   La sortie sera très longue, car Ansible collecte beaucoup de données. Il s'agira d'une grande structure JSON contenant tous les détails du système. C'est normal.

   PLAY [Display all Ansible facts] ***********************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Print all available facts] ***********************************************
   ok: [localhost] => {
       "ansible_facts": {
           "ansible_all_ipv4_addresses": [
               "172.17.0.2"
           ],
           "ansible_all_ipv6_addresses": [
               "fe80::42:acff:fe11:2"
           ],
           "ansible_apparmor": {
               "status": "disabled"
           },
           "ansible_architecture": "x86_64",
           "ansible_bios_date": "01/01/2011",
           "ansible_bios_version": "1.0",
           "ansible_cmdline": {
               "BOOT_IMAGE": "/boot/vmlinuz-5.14.0-427.16.1.el9_4.x86_64",
               "root": "UUID=...",
               "ro": true
           },
           "ansible_date_time": {
               "date": "2024-05-21",
               "day": "21",
               "epoch": "1716298855",
               ...
           },
           "ansible_distribution": "RedHat",
           "ansible_distribution_major_version": "9",
           "ansible_distribution_version": "9.4",
           ...
       }
   }
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

4. Créer un playbook pour afficher des faits spécifiques

   Afficher tous les faits est utile pour la découverte, mais dans la plupart des cas, vous n'avez besoin que d'informations spécifiques. Créons un autre playbook, display_specific_facts.yml, pour afficher un message formaté avec seulement quelques faits clés.

   nano display_specific_facts.yml
   

   Ajoutez le contenu suivant. Ce playbook utilise le paramètre msg du module debug pour imprimer une chaîne personnalisée. Nous accédons aux faits individuels en utilisant la notation entre crochets, comme ansible_facts['distribution'].

   ---
   - name: Display specific Ansible facts
     hosts: localhost
     tasks:
       - name: Print a summary of system facts
         ansible.builtin.debug:
           msg: >
             The operating system is {{ ansible_facts['distribution'] }}
             version {{ ansible_facts['distribution_major_version'] }}.
             It has {{ ansible_facts['processor_cores'] }} processor cores and
             {{ ansible_facts['memtotal_mb'] }} MB of total memory.
   

   Le caractère > dans msg: > est une fonctionnalité YAML qui vous permet d'écrire une chaîne multiligne plus proprement. Enregistrez le fichier et quittez nano.

5. Exécuter le playbook pour des faits spécifiques

   Maintenant, exécutez ce nouveau playbook.

   ansible-playbook display_specific_facts.yml
   

   La sortie sera beaucoup plus propre et lisible, n'affichant que les informations que vous avez demandées.

   PLAY [Display specific Ansible facts] ******************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Print a summary of system facts] *****************************************
   ok: [localhost] => {
       "msg": "The operating system is RedHat version 9. It has 2 processor cores and 3925 MB of total memory."
   }
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

   Cela démontre comment vous pouvez tirer parti des faits Ansible pour rendre vos playbooks conscients de l'environnement dans lequel ils s'exécutent, permettant une automatisation plus intelligente et conditionnelle.

Configurer le serveur web à l'aide de faits personnalisés provenant de l'hôte géré

Dans cette étape, vous apprendrez à utiliser des faits personnalisés. Bien qu'Ansible collecte automatiquement un large éventail de faits standard, vous pouvez également définir les vôtres. Ce sont ce qu'on appelle des "faits locaux" ou "faits personnalisés". Il s'agit d'une fonctionnalité puissante qui vous permet de fournir des informations spécifiques depuis un hôte géré vers vos playbooks, telles que des paramètres d'application ou des données spécifiques au matériel qu'Ansible ne collecte pas par défaut.

Ansible recherche les faits personnalisés dans le répertoire /etc/ansible/facts.d sur l'hôte géré. Tout fichier dans ce répertoire avec une extension .fact sera traité. Ces fichiers peuvent être de simples fichiers texte de style INI ou des fichiers JSON.

1. Créer le répertoire des faits personnalisés

   Tout d'abord, vous devez créer le répertoire où Ansible recherchera les fichiers de faits personnalisés. Comme il s'agit d'un répertoire système, vous devez utiliser sudo pour le créer.

   sudo mkdir -p /etc/ansible/facts.d
   

   L'indicateur -p garantit que la commande ne renvoie pas d'erreur si le répertoire existe déjà.

2. Créer un fichier de faits personnalisés

   Maintenant, créons un fichier de faits personnalisés pour définir un message de bienvenue pour notre serveur web. Nous allons créer un fichier au format INI nommé web_config.fact dans le répertoire /etc/ansible/facts.d.

   sudo nano /etc/ansible/facts.d/web_config.fact
   

   Ajoutez le contenu suivant au fichier. Cela définit une section [webserver] avec une clé welcome_message.

   [webserver]
   welcome_message = Welcome to the server configured by Custom Facts!
   

   Enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et Entrée.

3. Créer un playbook pour utiliser le fait personnalisé

   Avec le fait personnalisé en place, nous pouvons maintenant créer un playbook qui lit ce fait et l'utilise pour configurer la page d'accueil de notre serveur web. Dans votre répertoire ~/project, créez un nouveau playbook nommé configure_web.yml.

   cd ~/project
   nano configure_web.yml
   

   Ajoutez le contenu suivant au playbook. Ce playbook mettra à jour le fichier /var/www/html/index.html avec le message défini dans notre fait personnalisé.

   ---
   - name: Configure web server using custom facts
     hosts: localhost
     become: true
     tasks:
       - name: Update index.html with custom message
         ansible.builtin.copy:
           content: "{{ ansible_facts.ansible_local.web_config.webserver.welcome_message }}"
           dest: /var/www/html/index.html
   

   Décomposons la variable {{ ansible_facts.ansible_local.web_config.webserver.welcome_message }} :

   • ansible_facts : Le dictionnaire racine pour tous les faits.
   • ansible_local : La clé où tous les faits personnalisés sont stockés.
   • web_config : Le nom de notre fichier de faits (web_config.fact), sans l'extension.
   • webserver : Le nom de la section [webserver] de notre fichier INI.
   • welcome_message : La clé pour la valeur que nous voulons utiliser.

   Enregistrez le fichier et quittez nano.

4. Exécuter le playbook de configuration

   Maintenant, exécutez le playbook pour appliquer la configuration.

   ansible-playbook configure_web.yml
   

   La sortie devrait montrer que la tâche copy a changed le fichier index.html.

   PLAY [Configure web server using custom facts] *********************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Update index.html with custom message] ***********************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

5. Vérifier le résultat

   Enfin, vérifions que la page web a été mise à jour correctement. Utilisez la commande cat pour afficher le contenu du fichier index.html.

   cat /var/www/html/index.html
   

   La sortie devrait maintenant afficher le message de votre fichier de faits personnalisés :

   Welcome to the server configured by Custom Facts!
   

   Vous avez créé avec succès un fait personnalisé sur l'hôte géré et l'avez utilisé dans un playbook pour configurer dynamiquement un service. Cette technique est incroyablement utile pour rendre votre automatisation plus flexible et axée sur les données.

Créer un utilisateur système à l'aide de variables chiffrées avec Ansible Vault

Dans cette étape, vous apprendrez à gérer des données sensibles, telles que des mots de passe ou des clés API, à l'aide d'Ansible Vault. Stocker des informations sensibles en texte clair dans vos playbooks constitue un risque de sécurité majeur. Ansible Vault fournit un moyen de chiffrer des fichiers ou des variables individuelles, gardant vos secrets en sécurité. Vous pouvez ensuite utiliser ces fichiers chiffrés dans vos playbooks, et Ansible les déchiffrera au moment de l'exécution lorsque vous fournirez le mot de passe correct.

Nous allons créer un fichier chiffré contenant un nom d'utilisateur et un mot de passe haché, puis utiliser un playbook pour créer un nouvel utilisateur système avec ces identifiants.

1. Accéder au répertoire du projet

   Assurez-vous d'être dans le répertoire ~/project pour cette tâche.

   cd ~/project
   

2. Créer un fichier Vault chiffré

   Nous utiliserons la commande ansible-vault create pour créer un nouveau fichier YAML chiffré nommé secrets.yml. Cette commande vous demandera de créer un mot de passe pour le vault. Ce mot de passe est requis pour ouvrir, modifier ou utiliser le fichier ultérieurement.

   Tout d'abord, définissons l'éditeur sur nano pour faciliter le travail :

   export EDITOR=nano
   

   Créez maintenant le fichier vault :

   ansible-vault create secrets.yml
   

   Lorsque vous y êtes invité, entrez un mot de passe pour votre vault. Pour ce laboratoire, utilisons labex comme mot de passe du vault pour simplifier les choses. Vous devrez l'entrer deux fois.

   New Vault password:
   Confirm New Vault password:
   

   Après avoir confirmé le mot de passe, la commande ouvrira le fichier secrets.yml dans l'éditeur de texte nano.

3. Ajouter des variables secrètes au fichier Vault

   À l'intérieur de l'éditeur nano, qui modifie maintenant le fichier secrets.yml chiffré, ajoutez les variables suivantes. Nous définirons un nom d'utilisateur et un mot de passe pré-haché pour un nouvel utilisateur. L'utilisation d'un mot de passe haché est beaucoup plus sécurisée que le stockage d'un mot de passe en texte clair.

   username: myappuser
   pwhash: $6$mysalt$QwMzWSEyCAGmz7tzVrAi5o.8k4d05i2QsfGGwmPtlJsWhGjSjCW6yFCH/OEqEsHk7GMSxqYNXu5sshxPmWyxo0
   

   • username : Le nom de l'utilisateur système que nous voulons créer.
   • pwhash : Un mot de passe haché de manière sécurisée. Ce hachage spécifique correspond au mot de passe AnsibleUserP@ssw0rd et est dans un format que le module ansible.builtin.user comprend.

   Enregistrez le fichier et quittez nano (Ctrl+X, puis Y, puis Entrée). Le fichier secrets.yml dans votre répertoire ~/project est maintenant chiffré. Si vous essayez de l'afficher avec cat secrets.yml, vous ne verrez que du texte chiffré.

4. Créer un playbook pour utiliser le fichier Vault

   Maintenant, créez un nouveau playbook nommé create_user.yml qui utilisera les variables de votre fichier secrets.yml chiffré.

   nano create_user.yml
   

   Ajoutez le contenu suivant. La directive vars_files indique à Ansible de charger les variables à partir du fichier spécifié.

   ---
   - name: Create a user from secret variables
     hosts: localhost
     become: true
     vars_files:
       - secrets.yml
     tasks:
       - name: Create the {{ username }} user
         ansible.builtin.user:
           name: "{{ username }}"
           password: "{{ pwhash }}"
           state: present
   

   Ce playbook créera un utilisateur avec le nom et le hachage de mot de passe définis dans secrets.yml. Enregistrez le fichier et quittez nano.

5. Exécuter le playbook avec le mot de passe Vault

   Pour exécuter un playbook qui utilise un fichier chiffré, vous devez fournir le mot de passe du vault. Vous pouvez le faire de manière interactive en utilisant l'indicateur --ask-vault-pass.

   ansible-playbook --ask-vault-pass create_user.yml
   

   Ansible vous demandera le mot de passe du vault. Entrez labex (le mot de passe que vous avez défini à l'étape 2).

   Vault password:
   

   Après avoir fourni le mot de passe correct, Ansible déchiffrera le fichier en mémoire et exécutera le playbook. Vous devriez voir la sortie suivante, indiquant que l'utilisateur a été créé.

   PLAY [Create a user from secret variables] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Create the myappuser user] ***********************************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

6. Vérifier que l'utilisateur a été créé

   Vous pouvez confirmer que myappuser a été créé avec succès sur le système en utilisant la commande id.

   id myappuser
   

   Si l'utilisateur existe, vous verrez ses informations d'identifiant utilisateur (uid) et d'identifiant de groupe (gid).

   uid=1002(myappuser) gid=1002(myappuser) groups=1002(myappuser)
   

   Cela confirme que vous avez utilisé avec succès Ansible Vault pour gérer des données sensibles pour vos tâches d'automatisation.

Exécuter un playbook avec un fichier de mot de passe Vault pour appliquer des configurations

Dans cette étape, vous apprendrez un moyen plus automatisé de fournir le mot de passe du vault à Ansible. À l'étape précédente, vous avez utilisé --ask-vault-pass pour entrer le mot de passe de manière interactive. Bien que cela soit sécurisé, ce n'est pas adapté aux environnements automatisés comme les pipelines CI/CD où aucun utilisateur n'est présent pour taper un mot de passe.

La solution consiste à utiliser un fichier de mot de passe vault. Il s'agit d'un simple fichier texte qui contient le mot de passe du vault. Vous pouvez ensuite référencer ce fichier lors de l'exécution de votre playbook, et Ansible lira automatiquement le mot de passe à partir de celui-ci. Pour des raisons de sécurité, il est crucial de restreindre les autorisations de ce fichier de mot de passe afin que seuls les utilisateurs autorisés puissent le lire.

1. Accéder au répertoire du projet

   Assurez-vous d'être dans le répertoire ~/project où se trouvent votre playbook et votre fichier vault.

   cd ~/project
   

2. Créer le fichier de mot de passe Vault

   Créons un fichier pour stocker notre mot de passe vault. Nous l'appellerons vault_pass.txt. Nous pouvons utiliser la commande echo pour créer le fichier et y écrire le mot de passe (labex) en une seule étape.

   echo "labex" > vault_pass.txt
   

   Vous pouvez vérifier le contenu du fichier avec cat :

   cat vault_pass.txt
   

   La sortie devrait être :

   labex
   

3. Sécuriser le fichier de mot de passe

   Stocker un mot de passe dans un fichier texte brut est risqué. Vous devez restreindre ses autorisations de fichier pour le protéger. La commande chmod vous permet de modifier les autorisations de fichier. Nous définirons les autorisations sur 600, ce qui signifie que seul le propriétaire du fichier (dans ce cas, l'utilisateur labex) dispose des autorisations de lecture et d'écriture. Aucun autre utilisateur sur le système ne pourra y accéder.

   chmod 600 vault_pass.txt
   

   Vous pouvez vérifier les nouvelles autorisations à l'aide de la commande ls -l :

   ls -l vault_pass.txt
   

   La sortie devrait commencer par -rw-------, confirmant les autorisations restreintes.

   -rw-------. 1 labex labex 6 May 21 14:30 vault_pass.txt
   

4. Modifier le playbook pour ajouter un utilisateur à un groupe

   Modifions notre playbook create_user.yml pour effectuer une action supplémentaire. Nous ajouterons myappuser au groupe wheel, qui, sur de nombreux systèmes, accorde des privilèges administratifs (sudo). Cela démontrera l'exécution d'un playbook qui apporte une modification à une configuration existante.

   Tout d'abord, ouvrez le playbook create_user.yml pour le modifier.

   nano create_user.yml
   

   Modifiez la tâche ansible.builtin.user pour inclure les paramètres groups et append.

   ---
   - name: Create a user from secret variables
     hosts: localhost
     become: true
     vars_files:
       - secrets.yml
     tasks:
       - name: Create the {{ username }} user and add to wheel group
         ansible.builtin.user:
           name: "{{ username }}"
           password: "{{ pwhash }}"
           state: present
           groups: wheel
           append: true
   

   • groups: wheel : Spécifie le groupe auquel ajouter l'utilisateur.
   • append: true : Garantit que l'utilisateur est ajouté à ce groupe sans être supprimé des autres groupes auxquels il pourrait appartenir.

   Enregistrez le fichier et quittez nano.

5. Exécuter le playbook avec le fichier de mot de passe Vault

   Maintenant, exécutez à nouveau le playbook. Cette fois, au lieu de --ask-vault-pass, utilisez l'option --vault-password-file (ou son alias plus court --vault-pass-file) pour spécifier le chemin vers votre fichier de mot de passe.

   ansible-playbook --vault-password-file vault_pass.txt create_user.yml
   

   Ansible s'exécutera désormais sans demander de mot de passe car il le lit directement depuis vault_pass.txt. Vous devriez voir une sortie indiquant que la configuration de l'utilisateur a été modifiée.

   PLAY [Create a user from secret variables] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Create the myappuser user and add to wheel group] ************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

   Le statut changed confirme qu'Ansible a modifié l'utilisateur en l'ajoutant au groupe wheel.

6. Vérifier l'appartenance au groupe de l'utilisateur

   Enfin, vérifiez que myappuser est maintenant membre du groupe wheel. Vous pouvez le faire avec la commande groups.

   groups myappuser
   

   La sortie devrait afficher à la fois le groupe principal de l'utilisateur (myappuser) et le groupe wheel.

   myappuser : myappuser wheel
   

   Vous avez utilisé avec succès un fichier de mot de passe vault pour exécuter un playbook de manière non interactive, une compétence clé pour automatiser des flux de travail sécurisés.

Vérifier la configuration du serveur web et de l'utilisateur

Dans cette dernière étape, vous consoliderez votre apprentissage en créant un playbook de vérification dédié. Jusqu'à présent, vous vérifiiez manuellement les résultats de vos playbooks à l'aide de commandes Linux standard comme cat, id et groups. Une approche plus puissante et reproductible consiste à utiliser Ansible lui-même pour auditer et valider l'état de votre système.

Ce playbook agira comme une suite de tests, vérifiant par programmation que le serveur web est installé, que la page web a le contenu correct et que l'utilisateur système existe avec l'appartenance au groupe appropriée. Cela démontre comment Ansible peut être utilisé non seulement pour la gestion de la configuration, mais aussi pour la conformité et la validation de l'état.

1. Accéder au répertoire du projet

   Tout d'abord, assurez-vous d'être dans le répertoire ~/project.

   cd ~/project
   

2. Créer le playbook de vérification

   Créons un nouveau playbook nommé verify_config.yml. Ce playbook contiendra une série de tâches qui vérifient les configurations que vous avez appliquées aux étapes précédentes.

   nano verify_config.yml
   

3. Ajouter des tâches pour vérifier la configuration

   À l'intérieur de l'éditeur nano, ajoutez le contenu suivant. Nous construirons ce playbook avec plusieurs tâches, chacune conçue pour affirmer qu'une condition spécifique est vraie. Si une assertion échoue, le playbook s'arrêtera et signalera une erreur, vous indiquant immédiatement ce qui ne va pas.

   ---
   - name: Verify system configuration
     hosts: localhost
     become: true
     tasks:
       - name: Check if httpd package is installed
         ansible.builtin.dnf:
           list: httpd
         register: httpd_pkg_info
   
       - name: Assert that httpd is installed
         ansible.builtin.assert:
           that:
             - httpd_pkg_info.results | length > 0
           fail_msg: "Apache (httpd) package is not installed."
           success_msg: "Apache (httpd) package is installed."
   
       - name: Read the content of the index.html file
         ansible.builtin.slurp:
           src: /var/www/html/index.html
         register: index_file
   
       - name: Assert that the web page content is correct
         ansible.builtin.assert:
           that:
             - "'Custom Facts' in (index_file.content | b64decode)"
           fail_msg: "Web page content is incorrect."
           success_msg: "Web page content is correct."
   
       - name: Check if myappuser exists
         ansible.builtin.getent:
           database: passwd
           key: myappuser
         register: user_info
   
       - name: Assert that myappuser exists
         ansible.builtin.assert:
           that:
             - user_info.ansible_facts.getent_passwd['myappuser'] is defined
           fail_msg: "User 'myappuser' does not exist."
           success_msg: "User 'myappuser' exists."
   
       - name: Query the wheel group members
         ansible.builtin.getent:
           database: group
           key: wheel
         register: wheel_group_info
   
       - name: Assert that myappuser is in the wheel group
         ansible.builtin.assert:
           that:
             - "'myappuser' in (wheel_group_info.ansible_facts.getent_group['wheel'][2] | default('') | split(','))"
           fail_msg: "User 'myappuser' is not in the wheel group."
           success_msg: "User 'myappuser' is in the wheel group."
   

   Passons en revue les modules clés utilisés ici :

   • ansible.builtin.dnf avec list : Cela vérifie la présence d'un paquet et register le résultat.
   • ansible.builtin.slurp : Cela "aspire" tout le contenu d'un fichier depuis l'hôte distant. Le contenu est encodé en base64 pour un transport sécurisé.
   • ansible.builtin.getent : C'est un moyen sûr d'interroger les bases de données système comme passwd et group. Les résultats sont stockés sous ansible_facts, accédez donc aux données renvoyées via des clés telles que user_info.ansible_facts.getent_passwd.
   • ansible.builtin.assert : C'est le cœur de notre vérification. Il vérifie si une condition donnée est vraie. Si ce n'est pas le cas, le play échoue. Nous fournissons des messages de succès et d'échec personnalisés.
   • b64decode : Il s'agit d'un filtre Jinja2 utilisé pour décoder le contenu base64 que nous avons obtenu du module slurp.

   Notez que nous interrogeons les bases de données passwd et group séparément. Cela permet de garder la vérification de l'existence de l'utilisateur et la vérification de l'appartenance au groupe wheel alignées avec les données réelles renvoyées par getent.

   Enregistrez le fichier et quittez nano (Ctrl+X, Y, Entrée).

4. Exécuter le playbook de vérification

   Maintenant, exécutez votre playbook de vérification. Comme il n'utilise aucun fichier chiffré, vous n'avez pas besoin de fournir de mot de passe.

   ansible-playbook verify_config.yml
   

   Si toutes vos étapes précédentes ont été effectuées correctement, le playbook s'exécutera avec succès et vous verrez le message de succès personnalisé pour chaque assertion.

   PLAY [Verify system configuration] *********************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Check if httpd package is installed] *************************************
   ok: [localhost]
   
   TASK [Assert that httpd is installed] ******************************************
   ok: [localhost] => {
       "changed": false,
       "msg": "Apache (httpd) package is installed."
   }
   
   TASK [Read the content of the index.html file] *********************************
   ok: [localhost]
   
   TASK [Assert that the web page content is correct] *****************************
   ok: [localhost] => {
       "changed": false,
       "msg": "Web page content is correct."
   }
   
   TASK [Check if myappuser exists] ***********************************************
   ok: [localhost]
   
   TASK [Assert that myappuser exists] ********************************************
   ok: [localhost] => {
       "changed": false,
       "msg": "User 'myappuser' exists."
   }
   
   TASK [Query the wheel group members] *******************************************
   ok: [localhost]
   
   TASK [Assert that myappuser is in the wheel group] *****************************
   ok: [localhost] => {
       "changed": false,
       "msg": "User 'myappuser' is in the wheel group."
   }
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=9    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

   Félicitations ! Vous avez utilisé avec succès Ansible pour définir des variables, collecter des faits système, gérer des secrets avec Vault et, enfin, vérifier l'état de votre système de manière automatisée.

Résumé

Dans ce laboratoire, vous avez appris à gérer différents types de données au sein des playbooks Ansible pour configurer un système RHEL. Vous avez commencé par définir et utiliser des variables de playbook standard pour installer et configurer de manière flexible un serveur web Apache. Ensuite, vous avez exploré comment tirer parti des faits intégrés d'Ansible pour afficher des informations système, fournissant une base pour créer des tâches d'automatisation dynamiques et conscientes de l'hôte.

En vous appuyant sur cela, vous avez configuré davantage le serveur web en créant et en utilisant des faits personnalisés provenant de l'hôte géré. Pour gérer les informations sensibles en toute sécurité, vous avez utilisé Ansible Vault pour chiffrer un mot de passe utilisateur, créé un nouvel utilisateur système avec cette variable chiffrée et exécuté le playbook de manière non interactive avec un fichier de mot de passe vault. Le laboratoire s'est conclu par la vérification que le serveur web et le nouvel utilisateur système étaient correctement configurés, confirmant l'application réussie de tous les concepts appris.