Implémenter un Playbook Ansible sur RHEL

Introduction

Dans ce laboratoire, vous apprendrez à implémenter un playbook Ansible complet pour déployer un serveur web Apache sur un système Red Hat Enterprise Linux (RHEL). Vous commencerez par configurer les composants fondamentaux d'un projet Ansible, notamment la création d'un fichier d'inventaire statique pour définir vos nœuds gérés et la configuration de l'environnement Ansible local à l'aide d'un fichier ansible.cfg.

Suite à la configuration initiale, vous rédigerez un playbook multi-tâches pour automatiser le processus de déploiement principal. Cela impliquera l'installation et le démarrage du service Apache, le déploiement d'une page web personnalisée et la configuration du pare-feu système pour autoriser le trafic HTTP. Pour terminer le laboratoire, vous ajouterez un second "play" à votre playbook qui testera le serveur web depuis la ligne de commande, vérifiant ainsi que l'ensemble du déploiement a été réalisé avec succès.

Créer un fichier d'inventaire statique pour les serveurs Web

Dans cette étape, vous apprendrez les bases d'un inventaire Ansible. Un inventaire est un fichier texte qui liste les serveurs (ou "nœuds gérés") qu'Ansible gérera. Vous allez créer un fichier d'inventaire statique simple pour un groupe de serveurs web et apprendre à vérifier son contenu.

Tout d'abord, vous devez vous assurer qu'Ansible est installé sur votre système. Comme il n'est pas installé par défaut, vous utiliserez le gestionnaire de paquets dnf pour l'installer.

1. Ouvrez votre terminal et installez le paquet ansible-core, qui fournit les outils fondamentaux en ligne de commande d'Ansible.

   sudo dnf install -y ansible-core
   

   Vous devriez voir une sortie indiquant que le paquet est en cours d'installation et de vérification.

   ...
   Installed:
     ansible-core-2.16.x-x.el9.x86_64
   ...
   Complete!
   

2. Pour une meilleure organisation, créez un répertoire dédié à ce projet dans votre répertoire personnel. Nommons-le ansible-lab.

   mkdir -p ~/project/ansible-lab
   

3. Naviguez dans votre répertoire de projet nouvellement créé. Tout le travail ultérieur dans ce laboratoire sera effectué à partir de cet emplacement.

   cd ~/project/ansible-lab
   

4. Maintenant, vous allez créer votre premier fichier d'inventaire. Un fichier d'inventaire est généralement écrit dans un format similaire à INI. Vous utiliserez l'éditeur de texte nano pour créer un fichier nommé inventory.

   nano inventory
   

5. À l'intérieur de l'éditeur nano, ajoutez le contenu suivant. Cette configuration définit un groupe appelé [webservers] et ajoute votre machine locale, localhost, à ce groupe.

   • [webservers] est le nom d'un groupe. Les groupes sont utilisés pour cibler plusieurs hôtes avec une seule commande.
   • localhost est le nom d'hôte de la machine que vous souhaitez gérer. Dans ce cas, il s'agit de la VM LabEx elle-même.
   • ansible_connection=local est une variable spéciale qui indique à Ansible d'exécuter les commandes directement sur le nœud de contrôle (votre VM) au lieu d'essayer de s'y connecter via SSH.

   [webservers]
   localhost ansible_connection=local
   

   Pour enregistrer le fichier dans nano, appuyez sur Ctrl+O, puis sur Entrée pour confirmer le nom du fichier, et Ctrl+X pour quitter l'éditeur.

6. Avec votre fichier d'inventaire créé, vous pouvez utiliser la commande ansible-inventory pour analyser le fichier et afficher une liste des hôtes qu'il contient. L'indicateur -i spécifie le chemin d'accès à votre fichier d'inventaire.

   ansible-inventory --list -i inventory
   

   La commande produira une représentation formatée en JSON de votre inventaire, ce qui confirme qu'Ansible peut lire et comprendre correctement votre fichier.

   {
     "_meta": {
       "hostvars": {
         "localhost": {
           "ansible_connection": "local"
         }
       }
     },
     "all": {
       "children": ["ungrouped", "webservers"]
     },
     "webservers": {
       "hosts": ["localhost"]
     }
   }
   

Vous avez créé avec succès un fichier d'inventaire statique de base et vérifié qu'Ansible peut l'interpréter correctement. Ce fichier d'inventaire servira de base aux playbooks que vous rédigerez dans les étapes suivantes.

Configurer l'environnement Ansible avec ansible.cfg

Dans cette étape, vous allez créer un fichier de configuration Ansible, ansible.cfg. Ce fichier vous permet de définir les comportements par défaut d'Ansible, vous évitant ainsi de taper des options courantes en ligne de commande de manière répétée. En plaçant un fichier ansible.cfg dans votre répertoire de projet, vous pouvez définir des paramètres tels que le chemin du fichier d'inventaire par défaut, qu'Ansible utilisera automatiquement lorsqu'il sera exécuté depuis ce répertoire.

Vous devriez toujours être dans le répertoire ~/project/ansible-lab de l'étape précédente.

1. Utilisez l'éditeur de texte nano pour créer un nouveau fichier nommé ansible.cfg dans votre répertoire actuel (~/project/ansible-lab).

   nano ansible.cfg
   

2. À l'intérieur de l'éditeur nano, ajoutez le contenu suivant. Cette configuration indique à Ansible où trouver votre fichier d'inventaire par défaut.

   • La section [defaults] est une partie standard du fichier ansible.cfg où vous définissez la plupart des paramètres par défaut.
   • La ligne inventory = ./inventory définit l'inventaire par défaut sur le fichier inventory situé dans le répertoire courant (.).

   [defaults]
   inventory = ./inventory
   

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

3. Maintenant que vous avez configuré le chemin de l'inventaire par défaut, vous n'avez plus besoin d'utiliser l'indicateur -i avec vos commandes Ansible (tant que vous êtes dans le répertoire ~/project/ansible-lab).

   Pour tester cela, exécutez à nouveau la commande ansible-inventory --list, mais cette fois, omettez la partie -i inventory.

   ansible-inventory --list
   

   Vous devriez voir exactement la même sortie JSON que lors de l'étape précédente, ce qui confirme qu'Ansible trouve et utilise automatiquement votre fichier inventory grâce à la nouvelle configuration ansible.cfg.

   {
     "_meta": {
       "hostvars": {
         "localhost": {
           "ansible_connection": "local"
         }
       }
     },
     "all": {
       "children": ["ungrouped", "webservers"]
     },
     "webservers": {
       "hosts": ["localhost"]
     }
   }
   

En créant un ansible.cfg spécifique au projet, vous avez rendu votre flux de travail plus efficace. C'est une pratique courante dans les projets Ansible pour assurer un comportement cohérent et réduire la complexité de la ligne de commande.

Écrire un playbook pour installer et démarrer le service Apache

Dans cette étape, vous allez écrire votre premier Playbook Ansible. Un playbook est un fichier écrit en format YAML qui décrit un ensemble de tâches à exécuter sur vos hôtes gérés. Vous allez créer un playbook qui installe le serveur web Apache (httpd) et démarre son service sur la machine localhost définie dans votre inventaire.

Vous devriez toujours être dans le répertoire ~/project/ansible-lab.

1. Tout d'abord, utilisez l'éditeur de texte nano pour créer un nouveau fichier nommé apache.yml. Ce fichier contiendra votre playbook.

   nano apache.yml
   

2. À l'intérieur de l'éditeur nano, vous allez définir un "play". Un play est l'unité centrale d'un playbook et associe un groupe d'hôtes à un ensemble de tâches. Ajoutez le contenu suivant à apache.yml.

   • ---: C'est un marqueur YAML standard indiquant le début d'un document.
   • - name: ...: C'est le début de votre play. Lui donner un nom descriptif est une bonne pratique.
   • hosts: webservers: Ceci indique à Ansible d'exécuter ce play sur tous les hôtes du groupe webservers de votre fichier d'inventaire.
   • become: true: Ceci demande à Ansible d'utiliser l'escalade de privilèges (comme sudo) pour exécuter les tâches. Ceci est nécessaire pour des actions comme l'installation de logiciels ou la gestion de services.
   • tasks:: Ce mot-clé commence la liste des tâches à effectuer.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
   

3. Maintenant, ajoutez les tâches à votre playbook. Chaque tâche est une action unique qui appelle un module Ansible. L'indentation est critique en YAML, assurez-vous donc que les tâches sont correctement indentées sous la section tasks:.

   • Tâche 1 : Installer httpd. Cette tâche utilise le module ansible.builtin.dnf pour s'assurer que le paquet httpd est installé. Le paramètre state: present signifie qu'Ansible installera le paquet s'il est manquant, et ne fera rien s'il est déjà installé.
   • Tâche 2 : Démarrer le service httpd. Cette tâche utilise le module ansible.builtin.service. state: started garantit que le service est en cours d'exécution, et enabled: true garantit qu'il démarrera automatiquement au démarrage du système.

   Ajoutez les tâches suivantes à votre fichier apache.yml, directement sous la ligne tasks: :

   - name: Install httpd package
     ansible.builtin.dnf:
       name: httpd
       state: present
   
   - name: Start and enable httpd service
     ansible.builtin.service:
       name: httpd
       state: started
       enabled: true
   

4. Votre playbook apache.yml complet devrait maintenant ressembler à ceci. Vérifiez attentivement l'indentation.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   

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

5. Avant d'exécuter votre playbook, il est conseillé de vérifier sa syntaxe à l'aide de la commande ansible-playbook avec l'indicateur --syntax-check.

   ansible-playbook --syntax-check apache.yml
   

   Si la syntaxe est correcte, la commande affichera le nom du fichier du playbook sans aucune erreur.

   playbook: apache.yml
   

6. Maintenant, exécutez le playbook.

   ansible-playbook apache.yml
   

   Ansible parcourra les tâches. Comme il s'agit de la première exécution, vous verrez le statut changed pour les deux tâches, indiquant que l'état du système a été modifié.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   changed: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

7. Enfin, vérifiez que le serveur web Apache est en cours d'exécution en utilisant curl pour demander la page web par défaut depuis localhost.

   curl http://localhost
   

   Vous devriez voir la page de test par défaut d'Apache, ce qui confirme que votre playbook a fonctionné avec succès.

   <html>
     <head>
       <title>Test Page</title>
     </head>
     <body>
       <h1>Test Page</h1>
       <p>This is the default test page for the Apache HTTP server.</p>
     </body>
   </html>
   

Ajouter des tâches pour déployer une page web

Dans cette étape, vous allez étendre votre playbook pour effectuer une configuration de serveur web plus réaliste. Vous ajouterez une tâche pour déployer une page index.html personnalisée. Cela démontre comment gérer des fichiers à l'aide des modules de gestion de fichiers d'Ansible.

Vous devriez toujours être dans le répertoire ~/project/ansible-lab.

1. Tout d'abord, créez un fichier HTML simple que votre playbook déploiera. Utilisez nano pour créer un fichier nommé index.html dans votre répertoire actuel.

   nano index.html
   

2. Ajoutez le contenu HTML suivant au fichier. Ce sera le contenu de votre page web personnalisée.

   <h1>Welcome to the Ansible-managed Web Server!</h1>
   <p>This page was deployed using an Ansible Playbook.</p>
   

   Enregistrez et quittez nano (Ctrl+O, Entrée, Ctrl+X).

3. Maintenant, vous allez mettre à jour votre playbook apache.yml pour ajouter la nouvelle tâche. Pour éviter les erreurs de formatage YAML, il est recommandé de recréer le fichier avec le contenu complet.

   Important : Pour assurer un formatage YAML correct et éviter les erreurs d'indentation, supprimez le fichier apache.yml existant et créez-en un nouveau avec le contenu complet indiqué ci-dessous.

   rm apache.yml
   nano apache.yml
   

4. Vous ajouterez une nouvelle tâche au playbook. Cette tâche copiera le fichier index.html dans la racine du document du serveur web (/var/www/html/).

   • Tâche : Déployer index.html. Cette tâche utilise le module ansible.builtin.copy. src spécifie le fichier source sur le nœud de contrôle (index.html), et dest spécifie le chemin de destination sur l'hôte géré.

5. Copiez et collez le contenu complet du playbook apache.yml ci-dessous. Cela garantit un formatage et une indentation YAML corrects.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Deploy custom index.html
         ansible.builtin.copy:
           src: index.html
           dest: /var/www/html/index.html
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   

   Enregistrez et quittez nano.

6. Enregistrez le fichier et quittez nano (Ctrl+O, Entrée, Ctrl+X), puis exécutez le playbook mis à jour.

   ansible-playbook apache.yml
   

   Cette fois, vous devriez voir la nouvelle tâche en cours d'exécution. Les tâches "Install httpd" et "Start httpd" devraient indiquer ok car leur état souhaité est déjà atteint. La tâche "Deploy custom index.html" indiquera changed.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   ok: [localhost]
   
   TASK [Deploy custom index.html] ************************************************
   changed: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   ok: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=4    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

7. Enfin, utilisez à nouveau curl pour vérifier que votre page web personnalisée est maintenant servie.

   curl http://localhost
   

   La sortie devrait maintenant être le contenu de votre fichier index.html.

   <h1>Welcome to the Ansible-managed Web Server!</h1>
   <p>This page was deployed using an Ansible Playbook.</p>
   

Implémenter un deuxième play pour tester le déploiement du serveur web

Dans cette dernière étape, vous ajouterez un deuxième play à votre playbook. Un seul fichier de playbook peut contenir plusieurs plays, qui sont exécutés séquentiellement. Ceci est utile pour organiser des tâches qui ciblent différents hôtes ou ont des objectifs différents. Vous ajouterez un nouveau play qui s'exécutera uniquement sur le nœud de contrôle (localhost) pour tester le serveur web qui a été configuré dans le premier play.

Vous devriez toujours être dans le répertoire ~/project/ansible-lab.

1. Vous allez maintenant ajouter un deuxième play à votre playbook. Pour assurer un formatage YAML correct lors de l'ajout du deuxième play, il est recommandé de recréer le fichier avec le contenu complet.

   Important : Pour éviter les erreurs d'indentation YAML lors de l'ajout du deuxième play, supprimez le fichier apache.yml existant et créez-en un nouveau avec le contenu complet des deux plays indiqué ci-dessous.

   rm apache.yml
   nano apache.yml
   

2. Vous ajouterez un deuxième play au playbook. Un deuxième play vous permet d'organiser des tâches qui ciblent différents hôtes ou ont des objectifs différents.

   • name: Test web server: Un nom descriptif pour le nouveau play.
   • hosts: localhost: Ce play s'exécutera sur localhost, le nœud de contrôle lui-même.
   • become: false: Ce test ne nécessite pas de privilèges root, nous désactivons donc explicitement l'escalade de privilèges.
   • Tâche : Vérifier le contenu web. Cette tâche utilise le module ansible.builtin.uri pour effectuer une requête HTTP vers le serveur web. Elle vérifie que le serveur renvoie un code de statut de 200 (OK) et que le contenu renvoyé contient la chaîne "Ansible-managed". Cela automatise la vérification curl et grep que vous faisiez manuellement.

3. Copiez et collez le contenu complet du playbook apache.yml ci-dessous, qui inclut maintenant les deux plays :

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Deploy custom index.html
         ansible.builtin.copy:
           src: index.html
           dest: /var/www/html/index.html
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   
   - name: Test web server from localhost
     hosts: localhost
     become: false
     tasks:
       - name: Verify web server is serving correct content
         ansible.builtin.uri:
           url: http://localhost
           return_content: yes
           status_code: 200
         register: result
         failed_when: "'Ansible-managed' not in result.content"
   

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

4. Exécutez le playbook complet. Ansible exécutera le premier play, constatera que toutes les tâches sont déjà dans leur état souhaité (ok), puis passera au deuxième play pour exécuter le test.

   ansible-playbook apache.yml
   

   La sortie affichera les deux plays en cours d'exécution. Toutes les tâches devraient s'achever avec succès avec un statut ok.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   ok: [localhost]
   
   TASK [Deploy custom index.html] ************************************************
   ok: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   ok: [localhost]
   
   PLAY [Test web server from localhost] ******************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Verify web server is serving correct content] ****************************
   ok: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=6    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

En ajoutant un deuxième play, vous avez créé un flux d'automatisation plus robuste qui non seulement configure un service, mais inclut également un test intégré pour vérifier que le déploiement a réussi.

Résumé

Dans ce laboratoire, vous avez appris à préparer un environnement RHEL pour l'automatisation Ansible en installant le paquet ansible-core et en structurant un répertoire de projet. Vous avez créé un fichier d'inventaire statique fondamental pour définir un groupe de nœuds gérés, en spécifiant localhost avec une connexion locale. Vous avez également configuré l'environnement Ansible en utilisant un fichier ansible.cfg pour pointer vers votre inventaire personnalisé, établissant ainsi un espace de travail propre et organisé pour l'exécution des playbooks.

Vous avez ensuite rédigé un playbook Ansible complet pour automatiser le déploiement d'un serveur web Apache. Cela a impliqué l'écriture de tâches pour installer le paquet httpd à l'aide du module ansible.builtin.dnf et pour s'assurer que le service était démarré et activé avec le module ansible.builtin.service. Le playbook a été amélioré pour déployer une page web index.html personnalisée à l'aide du module ansible.builtin.copy. Enfin, vous avez implémenté un deuxième play dans le même playbook pour valider le déploiement, en utilisant le module ansible.builtin.uri pour tester la connectivité au serveur web nouvellement déployé, démontrant ainsi un flux de travail complet de configuration et de vérification.