Skip to main content

Chapitre 3 - Travailler avec les Playbooks Ansible - Pratique 03

Dans ce chapitre, nous allons explorer l'utilisation des playbooks dans Ansible pour automatiser des tâches complexes de manière efficace. Les playbooks avancés vous permettent d'organiser et de réutiliser votre code de manière structurée. Cette fonctionnalité est particulièrement utile pour :

  • Créer des playbooks modulaires et réutilisables.
  • Organiser les tâches de manière logique avec des tags.
  • Gérer efficacement des configurations complexes.

📋 Table des Matières​

  1. Introduction
  2. Prérequis
  3. Résumé des Étapes Précédentes
  4. Partie 1 : Créer et Exécuter votre Premier Playbook
  5. Partie 2 : Créer un Playbook Multi-Tâches
  6. Partie 3 : Réutiliser des Tâches via l'Importation
  7. Partie 4 : Utiliser les Tags pour l'Exécution Sélective
  8. Conclusion

Introduction​

Dans cette pratique, vous allez apprendre à automatiser des tâches sur vos conteneurs Docker en utilisant Ansible avec des playbooks. Nous commencerons par des tâches simples avant de passer à des opérations plus avancées. Assurez-vous d’avoir bien configuré Docker, Docker Compose et Ansible avant de débuter.

Prérequis​

Pour réaliser cette pratique, il est obligatoire d'avoir effectué les étapes 1 à 4 du Chapitre 2 - Déployer une Infrastructure Docker avec Ansible - Pratique 02.

Si vous aviez précédemment arrêté les conteneurs, vous pouvez les redémarrer avec :

docker start node1 node2 node3 node4 node5 node6

ou

docker compose up -d

🔙 Retournez à la Table des Matières​

Résumé des Étapes Précédentes (Chapitre 2)​

Dans le chapitre précédent, nous avons mis en place une infrastructure Docker complète pour nos tests Ansible :

1. Installation des Prérequis​

  • Installation de Docker et Docker Compose sur Ubuntu 22.04
  • Configuration de l'environnement de base

2. Déploiement de l'Infrastructure​

  • Création d'une architecture avec 6 conteneurs Docker :
    • node1, node5, node6 : Ubuntu
    • node2 : Debian
    • node3, node4 : AlmaLinux
  • Configuration réseau avec des IPs statiques (172.20.0.2-7)
  • Exposition des ports SSH (22) et HTTP (80)

3. Configuration SSH​

  • Génération des clés SSH
  • Distribution des clés publiques aux conteneurs
  • Configuration de l'accès SSH sans mot de passe
  • Vérification de la connectivité

4. Structure de l'Inventaire​

Organisation des conteneurs en groupes fonctionnels :

  • [node_containers] : Tous les nœuds
  • [web] : node1, node5
  • [database] : node2, node3
  • [mail] : node4, node6

Cette infrastructure nous permet maintenant de :

  • Tester des playbooks sur différentes distributions Linux
  • Organiser nos déploiements par groupes fonctionnels
  • Automatiser des tâches de manière structurée

Architecture de l'infrastructure à créer avec docker-compose :

                          +----------------------+
                          |  Ansible Controller  |
                          |     Ubuntu 22.04     |
                          |  IP: 172.20.0.X      |
                          +----------------------+
                                     |
                                     |
        --------------------------------------------------------------------------
        |        |        |        |        |        |        |
   +---------+ +---------+ +---------+ +---------+ +---------+ +---------+ +---------+
   | Node1   | | Node2   | | Node3   | | Node4   | | Node5   | | Node6   | |  NodeX   |
   | Ubuntu  | | Debian  | | AlmaLin | | AlmaLin | | Ubuntu  | | Ubuntu  | |  (opt)  |
   | 172.20.0.2| 172.20.0.3| 172.20.0.4| 172.20.0.5| 172.20.0.6| 172.20.0.7|  ...    |
   +---------+ +---------+ +---------+ +---------+ +---------+ +---------+ +---------+

🔙 Retournez à la Table des Matières​

1 - Vérifiez la configuration de l'inventaire Ansible​

L'inventaire Ansible est un fichier essentiel pour définir les hôtes gérés par Ansible. Il spécifie les adresses IP, les utilisateurs, et peut organiser les hôtes en groupes.

  1. Créer un fichier inventory.ini :

    nano inventory.ini

  2. Ajouter les informations des nœuds dans inventory.ini :

    [node_containers]
    node1 ansible_host=172.20.0.2 ansible_user=root
    node2 ansible_host=172.20.0.3 ansible_user=root
    node3 ansible_host=172.20.0.4 ansible_user=root
    node4 ansible_host=172.20.0.5 ansible_user=root
    node5 ansible_host=172.20.0.6 ansible_user=root
    node6 ansible_host=172.20.0.7 ansible_user=root

    [web]
    node1
    node5

    [database]
    node2
    node3

    [mail]
    node4
    node6

    Explications :

    • [node_containers] : Groupe principal contenant tous les conteneurs.
    • ansible_host : Spécifie l'adresse IP de chaque nœud.
    • ansible_user : Définit l’utilisateur pour l’accès SSH, ici root pour tous les nœuds.
    • [web], [database], [mail] : Groupes permettant de structurer les nœuds selon leur fonction.

  3. Enregistrer et quitter l'éditeur :

    • Appuyez sur Ctrl + X, puis Y et Entrée.

🔙 Retournez à la Table des Matières​

2 - Vérifier la Connectivité​

Avant d'exécuter des playbooks, il est important de vérifier que l'inventaire est correctement configuré et que la connectivité SSH est opérationnelle.

  1. Lister les hôtes d'un groupe spécifique :

    ansible web -i inventory.ini --list-hosts

  2. Lister tous les hôtes dans l'inventaire :

    ansible all -i inventory.ini --list-hosts

  3. Tester la connectivité avec une commande ping :

    ansible all -m ping -i inventory.ini

  4. Vérifier un nœud individuel (exemple avec node1) :

    ansible node1 -i inventory.ini --list-hosts

  5. Exécuter une commande sur un nœud (par exemple, obtenir la date sur node1) :

    ansible node1 -m command -a "date" -i inventory.ini

Note : Si vous rencontrez des avertissements concernant l'interpréteur Python, vous pouvez spécifier l'interpréteur Python dans l'inventaire pour chaque hôte :

node1 ansible_host=172.20.0.2 ansible_user=root ansible_python_interpreter=/usr/bin/python3

🔙 Retournez à la Table des Matières​

3 - Créer et Exécuter votre Premier Playbook​

Étape 1 : Écrire un Playbook de Base pour la Création de Fichiers​

  1. Créer un fichier nommé first-playbook.yml :

    nano first-playbook.yml

  2. Ajouter le contenu suivant :

    ---
    - name: Premier Playbook de Création de Fichier
      hosts: all
      become: yes
      tasks:
        - name: Créer un fichier de configuration
          file:
            path: /tmp/foo.conf
            mode: '0664'
            owner: root
            state: touch

    Explications :

    • hosts: all : Le playbook s'exécute sur tous les hôtes définis dans l'inventaire.
    • become: yes : Exécute les tâches avec les privilèges élevés (root).
    • tasks : Liste des tâches à exécuter.
    • Le module file est utilisé pour gérer les fichiers et répertoires.

  3. Enregistrer et quitter l'éditeur :

    • Appuyez sur Ctrl + X, puis Y et Entrée.

Étape 2 : Exécuter le Playbook​

  1. Lancer le playbook :

    ansible-playbook -i inventory.ini first-playbook.yml

  2. Vérifier que le fichier a bien été créé :

    ansible all -m command -a "ls -l /tmp/foo.conf" -i inventory.ini

🔙 Retournez à la Table des Matières​

4 - Créer un Playbook Multi-Tâches​

🔥 Étape 1 : Écrire un Playbook avec Plusieurs Tâches​

👷 1. Créer un fichier nommé multi-tasks-playbook.yml :

nano multi-tasks-playbook.yml

📝 2. Ajouter le contenu suivant :

---
- name: 🚒 Installation et Archivage des Logs
  hosts: all
  become: yes
  tasks:
    - name: 🔧 Installer tmux sur tous les nœuds
      package:
        name: tmux
        state: present
      tags: install_tmux

    - name: 📦 Créer une archive des logs système
      archive:
        path: /var/log
        dest: /tmp/logs.tar.gz
        format: gz
        excludes:
          - '/var/log/wtmp'
          - '/var/log/btmp'
      tags: archive_logs

- name: 🔧 Installation de Git sur les nœuds Ubuntu
  hosts: node1,node5,node6
  become: yes
  tasks:
    - name: 🔄 Mettre à jour le cache APT
      apt:
        update_cache: yes
      tags: update_cache

    - name: 📥 Installer Git
      apt:
        name: git
        state: present
      tags: install_git

💡 Explications :

  • ✅ Des tags ont été ajoutés pour permettre une exécution sélective des tâches.
  • 📂 Exclusion de certains fichiers lors de l'archivage des logs pour éviter d'inclure des fichiers sensibles ou volumineux.
  • 🔄 Mise à jour du cache APT avant l'installation de Git sur les nœuds Ubuntu.

😱 Oups !!! 🔥 Erreur repérée ! On a besoin d'un pompier ici ! 👨‍🚒👩‍🚒​

Défi : Trouvez l'erreur pour nous aider à maîtriser le feu dans ce Playbook ! 🔍

🏆 Solution (ne regardez pas si vous voulez relever le défi !)

---
- name: 🚒 Installation et Archivage des Logs
 hosts: all
 become: yes
 tasks:
   - name: 🔧 Installer tmux sur tous les nœuds
     package:
       name: tmux
       state: present
     tags: install_tmux

   - name: 📦 Créer une archive des logs système
     archive:
       path: /var/log
       dest: /tmp/logs.tar.gz
       format: gz
       exclusion_patterns:
         - '/var/log/wtmp'
         - '/var/log/btmp'
     tags: archive_logs

- name: 🔧 Installation de Git sur les nœuds Ubuntu
 hosts: node1,node5,node6
 become: yes
 tasks:
   - name: 🔄 Mettre à jour le cache APT
     apt:
       update_cache: yes
     tags: update_cache

   - name: 📥 Installer Git
     apt:
       name: git
       state: present
     tags: install_git

🎉 Bravo ! Vous avez trouvé l'erreur : il fallait remplacer excludes par exclusion_patterns pour que tout fonctionne correctement ! 🚒 Notre premier pompier du jour est vous ! 👏🏅

  1. Enregistrer et quitter l'éditeur.

Étape 2 : Exécuter le Playbook Multi-Tâches​

  1. Lancer le playbook :

    ansible-playbook -i inventory.ini multi-tasks-playbook.yml

  2. Vérifier que l’archive a bien été créée :

    ansible all -m command -a "ls -lh /tmp/logs.tar.gz" -i inventory.ini

  3. Vérifier que tmux est installé :

    ansible all -m shell -a "tmux -V" -i inventory.ini

  4. Vérifier que git est installé sur les nœuds Ubuntu :

    ansible node1,node5,node6 -m shell -a "git --version" -i inventory.ini

🔙 Retournez à la Table des Matières​

5 - Réutiliser des Tâches via l'Importation​

Étape 1 : Créer un Fichier de Tâches Réutilisables​

  1. Créer un fichier nommé group-tasks.yml :

    nano group-tasks.yml

  2. Ajouter le contenu suivant :

    ---
    - name: Créer le groupe développeurs
      group:
        name: developpeurs

    - name: Créer le groupe sécurité
      group:
        name: securite

    - name: Créer le groupe finance
      group:
        name: finance

  3. Enregistrer et quitter l'éditeur.

Étape 2 : Importer les Tâches dans un Playbook Principal​

  1. Modifier first-playbook.yml pour inclure group-tasks.yml :

    ---
    - name: Premier Playbook de Création de Fichier et de Groupes
      hosts: all
      become: yes
      tasks:
        - name: Créer un fichier de configuration
          file:
            path: /tmp/foo.conf
            mode: '0664'
            owner: root
            state: touch

        - name: Importer les tâches pour créer des groupes
          import_tasks: group-tasks.yml

  2. Lancer le playbook avec importation de tâches :

    ansible-playbook -i inventory.ini first-playbook.yml

  3. Vérifier que les groupes ont été créés :

    ansible all -m command -a "getent group developpeurs securite finance" -i inventory.ini

🔙 Retournez à la Table des Matières​

6 - Utiliser les Tags pour l'Exécution Sélective​

Les tags permettent de cibler des tâches spécifiques lors de l'exécution d'un playbook.

  1. Taguer les tâches dans multi-tasks-playbook.yml (si ce n'est pas déjà fait) :

    - name: Installer tmux sur tous les nœuds
      package:
        name: tmux
        state: present
      tags: install_tmux

    - name: Créer une archive des logs système
      archive:
        path: /var/log
        dest: /tmp/logs.tar.gz
        format: gz
        excludes:
          - '/var/log/wtmp'
          - '/var/log/btmp'
      tags: archive_logs

    - name: Mettre à jour le cache APT
      apt:
        update_cache: yes
      tags: update_cache

    - name: Installer Git
      apt:
        name: git
        state: present
      tags: install_git

  2. Exécuter des Tâches Spécifiques par Tag :

    • Pour installer uniquement tmux :

      ansible-playbook -i inventory.ini multi-tasks-playbook.yml --tags install_tmux

    • Pour créer l’archive uniquement :

      ansible-playbook -i inventory.ini multi-tasks-playbook.yml --tags archive_logs

    • Pour installer uniquement git sur les nœuds Ubuntu :

      ansible-playbook -i inventory.ini multi-tasks-playbook.yml --tags install_git

    • Pour exécuter toutes les tâches sauf celles d'un tag spécifique :

      ansible-playbook -i inventory.ini multi-tasks-playbook.yml --skip-tags install_tmux

🔙 Retournez à la Table des Matières​

7 - Conclusion​

Dans ce chapitre, vous avez appris à :

  • Écrire des playbooks Ansible avec des tâches simples et multiples.
  • Utiliser des modules Ansible appropriés pour gérer les paquets, les fichiers, et les archives.
  • Réutiliser des tâches via l'importation de fichiers de tâches.
  • Utiliser les tags pour exécuter sélectivement des parties de vos playbooks.

Ces pratiques vous permettront d'automatiser efficacement la gestion de vos conteneurs Docker et de vos serveurs, tout en maintenant vos playbooks organisés et maintenables.

🛠️ Conseils Supplémentaires​

  • Utiliser les Rôles Ansible : Pour des projets plus complexes, envisagez d'utiliser des rôles pour organiser vos playbooks et vos tâches.
  • Variables et Templates : Utilisez des variables pour rendre vos playbooks plus flexibles, et des templates Jinja2 pour générer des fichiers de configuration dynamiques.
  • Gestion des Différences de Plateforme : Utilisez des conditions when pour gérer les différences entre les systèmes d'exploitation.
  • Vérification des Erreurs : Toujours vérifier les messages d'erreur lors de l'exécution des playbooks pour corriger les problèmes potentiels.

🔙 Retournez à la Table des Matières​

📚 Ressources Utiles​

🙌 Félicitations !​

Vous avez amélioré vos compétences en écriture de playbooks Ansible avancés, en réutilisant des tâches, et en utilisant des fonctionnalités puissantes comme les tags. Continuez à pratiquer et à explorer les fonctionnalités d'Ansible pour automatiser efficacement vos tâches d'administration système.

🔙 Retournez à la Table des Matières​