Les bases des playbooks Ansible

Introduction

Dans ce laboratoire, vous apprendrez les bases des playbooks Ansible. Les playbooks Ansible sont des fichiers YAML qui décrivent un ensemble de tâches à exécuter sur des hôtes distants. Ils constituent les éléments de base des flux de travail d'automatisation IT complexes. Vous allez créer votre premier playbook, comprendre sa structure et apprendre à l'exécuter. À la fin de ce laboratoire, vous aurez acquis une expérience pratique dans l'écriture et l'exécution de playbooks Ansible, ce qui constituera une base pour une utilisation plus avancée d'Ansible.

Skills Graph

Création de votre premier playbook

Commençons par créer un simple playbook Ansible qui créera un répertoire et un fichier sur la machine locale. Cela vous aidera à comprendre la structure de base d'un playbook et à savoir comment l'exécuter.

Tout d'abord, créons un nouveau fichier nommé first_playbook.yml dans le répertoire /home/labex/project :

nano /home/labex/project/first_playbook.yml

Cette commande ouvre l'éditeur de texte nano. Si vous n'êtes pas familier avec nano, ne vous inquiétez pas - c'est un éditeur de texte simple. Vous pouvez taper directement dedans.

Maintenant, ajoutez le contenu suivant au fichier :

---
- name: My First Playbook
  hosts: localhost
  connection: local
  tasks:
    - name: Create a directory
      file:
        path: /home/labex/project/test_directory
        state: directory
        mode: "0755"

    - name: Create a file
      copy:
        content: "Hello from Ansible!"
        dest: /home/labex/project/test_directory/hello.txt

Décortiquons ce playbook pour comprendre chaque partie :

• Le --- en haut marque le début d'un fichier YAML. YAML est le format utilisé pour les playbooks Ansible.
• name: My First Playbook est un nom descriptif pour cette série de tâches (play). Il vous aide à identifier ce que fait ce playbook.
• hosts: localhost spécifie que ce playbook sera exécuté sur la machine locale. Dans un scénario réel, vous pourriez spécifier des hôtes distants ici.
• connection: local indique à Ansible d'exécuter le playbook localement au lieu d'utiliser SSH. Cela est utile pour les tests et pour les tâches qui doivent être effectuées sur le nœud de contrôle Ansible lui-même.
• tasks: est suivi d'une liste de tâches à exécuter. Chaque tâche est une action que vous souhaitez que Ansible effectue.
• Chaque tâche a un name pour la description. Cela vous aide à comprendre ce que chaque tâche fait et facilite la résolution des problèmes.
• Les tâches utilisent des modules Ansible :
  • Le module file est utilisé pour créer le répertoire.
  • Le module copy est utilisé pour créer un fichier avec un contenu spécifique.

Ne vous inquiétez pas si vous ne comprenez pas tous les modules pour l'instant. Au fur et à mesure que vous progresserez, vous apprendrez à connaître de nombreux autres modules et leurs utilisations.

Enregistrez et quittez l'éditeur. Dans nano, vous pouvez le faire en appuyant sur Ctrl+X, puis Y, puis Enter.

Maintenant, exécutons ce playbook. Dans votre terminal, tapez :

ansible-playbook /home/labex/project/first_playbook.yml

Cette commande indique à Ansible d'exécuter le playbook que nous venons de créer. Vous devriez voir une sortie similaire à celle-ci :

PLAY [My First Playbook] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a directory] ******************************************************
changed: [localhost]

TASK [Create a file] ***********************************************************
changed: [localhost]

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

Cette sortie montre qu'Ansible a exécuté nos tâches avec succès. Le statut "changed" indique qu'Ansible a apporté des modifications au système (créé un répertoire et un fichier).

Si vous souhaitez vérifier les résultats manuellement, vous pouvez utiliser ces commandes :

ls -l /home/labex/project/test_directory
cat /home/labex/project/test_directory/hello.txt

La première commande devrait afficher le répertoire que nous avons créé, et la deuxième devrait afficher le contenu du fichier que nous avons créé.

Comprendre la structure d'un playbook

Maintenant que vous avez créé et exécuté votre premier playbook, approfondissons-en la structure. Comprendre la structure d'un playbook est essentiel pour écrire des tâches d'automatisation plus complexes à l'avenir.

Les playbooks Ansible sont composés d'une ou plusieurs séries de tâches (plays), et chaque série de tâches se compose de plusieurs éléments clés. Modifions notre fichier first_playbook.yml pour ajouter des commentaires expliquant chaque partie :

nano /home/labex/project/first_playbook.yml

Mettez à jour le contenu comme suit :

---
## Le playbook commence par trois tirets
- name: My First Playbook ## Nom de la série de tâches
  hosts: localhost ## Hôte(s) cible(s) pour cette série de tâches
  connection: local ## Type de connexion (locale dans ce cas)

  tasks: ## Liste des tâches à exécuter
    - name: Create a directory ## Nom de la première tâche
      file: ## Le module 'file' est utilisé pour cette tâche
        path: /home/labex/project/test_directory ## Chemin du répertoire à créer
        state: directory ## État souhaité (créer le répertoire)
        mode: "0755" ## Permissions du répertoire

    - name: Create a file ## Nom de la deuxième tâche
      copy: ## Le module 'copy' est utilisé pour cette tâche
        content: "Hello from Ansible!" ## Contenu à écrire dans le fichier
        dest: /home/labex/project/test_directory/hello.txt ## Chemin de destination du fichier

Enregistrez et quittez l'éditeur.

Cette version commentée du playbook aide à comprendre la structure et le but de chaque élément. Voici quelques points clés à retenir :

1. Un playbook peut contenir plusieurs séries de tâches, chacune commençant par un tiret (-). Dans ce cas, nous n'avons qu'une seule série de tâches.
2. Chaque série de tâches cible des hôtes spécifiques et définit une liste de tâches. Le champ hosts spécifie sur quelles machines la série de tâches doit être exécutée.
3. Les tâches utilisent des modules Ansible (comme file et copy) pour effectuer des actions. Ansible dispose de nombreux modules intégrés à des fins diverses.
4. Chaque tâche devrait avoir un nom descriptif. Cela aide à comprendre ce que fait la tâche et à résoudre les problèmes.
5. L'indentation est cruciale dans les fichiers YAML. Assurez-vous que votre playbook est correctement indenté. Une indentation incorrecte peut entraîner des erreurs lors de l'exécution du playbook.

Le module file est polyvalent et peut être utilisé pour créer, modifier ou supprimer des fichiers et des répertoires. Dans notre cas, nous l'utilisons pour créer un répertoire.

Le module copy est utilisé pour copier des fichiers vers des emplacements distants ou, comme dans notre cas, pour créer un nouveau fichier avec un contenu spécifique.

Comprendre ces structures de base vous aidera à créer des playbooks plus complexes à l'avenir.

Ajout de variables aux playbooks

Les variables rendent vos playbooks plus flexibles et réutilisables. Elles vous permettent d'écrire des playbooks qui peuvent s'adapter à différents scénarios sans avoir à modifier le playbook lui-même. Modifions notre playbook pour utiliser des variables.

Modifiez le fichier first_playbook.yml :

nano /home/labex/project/first_playbook.yml

Mettez à jour le contenu comme suit :

---
- name: My First Playbook
  hosts: localhost
  connection: local
  vars:
    dir_path: /home/labex/project/test_directory
    file_content: "Hello from Ansible! The time is {{ ansible_date_time.iso8601 }}"

  tasks:
    - name: Create a directory
      file:
        path: "{{ dir_path }}"
        state: directory
        mode: "0755"

    - name: Create a file
      copy:
        content: "{{ file_content }}"
        dest: "{{ dir_path }}/hello.txt"

    - name: Display file content
      debug:
        msg: "The content of the file is: {{ file_content }}"

Décortiquons les modifications et les nouveaux éléments de ce playbook mis à jour :

1. Nous avons ajouté une section vars pour définir des variables. C'est là que vous pouvez définir des valeurs que vous utiliserez plusieurs fois dans votre playbook.

2. dir_path et file_content sont maintenant des variables. Nous pouvons facilement modifier ces valeurs à un seul endroit pour affecter plusieurs tâches.

3. Nous utilisons la syntaxe {{ }} pour faire référence aux variables. Cela indique à Ansible de remplacer la variable par sa valeur.

4. Nous avons utilisé la variable intégrée ansible_date_time.iso8601 d'Ansible pour inclure l'horodatage actuel. Ansible propose de nombreuses variables de ce type que vous pouvez utiliser dans vos playbooks.

5. Une nouvelle tâche utilisant le module debug a été ajoutée. Le module debug est très utile pour afficher des informations pendant l'exécution du playbook, ce qui peut aider à résoudre les problèmes.

L'utilisation de variables rend ce playbook plus flexible. Par exemple, si vous souhaitez modifier le chemin du répertoire, vous n'avez qu'à le modifier dans la section vars, et non dans chaque tâche.

Enregistrez et quittez l'éditeur.

Maintenant, exécutons le playbook mis à jour :

ansible-playbook /home/labex/project/first_playbook.yml

Vous devriez voir une sortie montrant l'exécution des tâches, y compris le message de débogage affichant le contenu du fichier avec l'horodatage actuel. La sortie ressemblera à ceci :

PLAY [My First Playbook] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a directory] ******************************************************
ok: [localhost]

TASK [Create a file] ***********************************************************
changed: [localhost]

TASK [Display file content] ****************************************************
ok: [localhost] => {
    "msg": "The content of the file is: Hello from Ansible! The time is 2023-06-09T12:34:56Z"
}

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

L'horodatage réel sera différent lorsque vous exécuterez le playbook.

Cela démontre comment les variables peuvent rendre vos playbooks plus dynamiques. Le contenu du fichier inclut maintenant un horodatage qui sera différent chaque fois que vous exécuterez le playbook.

Résumé

Dans ce laboratoire, vous avez appris les bases des playbooks Ansible. Vous êtes passé de la création de votre premier playbook simple à la compréhension de sa structure et à l'utilisation de variables pour rendre vos playbooks plus dynamiques et réutilisables.

Points clés à retenir de ce laboratoire :

1. Les playbooks Ansible sont écrits au format YAML et décrivent un ensemble de tâches à exécuter sur des hôtes spécifiés.
2. Un playbook est composé d'une ou plusieurs séries de tâches (plays), chacune contenant une liste de tâches.
3. Les tâches utilisent des modules Ansible pour effectuer des actions sur les hôtes cibles. Nous avons utilisé les modules file, copy et debug dans ce laboratoire.
4. Les variables peuvent être définies et utilisées dans les playbooks pour augmenter la flexibilité et la réutilisabilité. Elles sont référencées à l'aide de la syntaxe {{ }}.
5. Le module debug est utile pour afficher des informations pendant l'exécution du playbook, ce qui peut aider à résoudre les problèmes.
6. Une indentation correcte est cruciale dans les fichiers YAML et les playbooks Ansible.

Au fur et à mesure de votre progression avec Ansible, vous constaterez que les playbooks sont un outil puissant pour automatiser des tâches IT complexes. Entraînez-vous à écrire des playbooks pour différents scénarios pour vous familiariser avec leur structure et leurs capacités. Essayez de modifier les playbooks que nous avons créés aujourd'hui - changez le chemin du répertoire, ajoutez plus de tâches ou utilisez différents modules.

Dans les prochains laboratoires, vous apprendrez des fonctionnalités plus avancées des playbooks, telles que les conditions, les boucles et les rôles, qui vous permettront de créer des flux de travail d'automatisation encore plus puissants et flexibles.

N'oubliez pas que la clé pour maîtriser Ansible est la pratique et l'exploration. N'ayez pas peur d'expérimenter avec différents modules et structures dans vos playbooks. La documentation d'Ansible est une excellente ressource pour continuer à apprendre et à développer vos compétences.