# Dépannage Ansible
<center>
<img src="https://dst-de.s3.eu-west-3.amazonaws.com/ansible_fr/ansible.png" width="20%" height="20%"/>
</center>
## Introduction
Le dépannage d'Ansible consiste à diagnostiquer et à résoudre les problèmes qui peuvent survenir au cours des processus de gestion de la configuration et d'automatisation. Lorsque vous rencontrez des problèmes, plusieurs étapes de dépannage peuvent être prises. Tout d'abord, il est essentiel de vérifier la syntaxe et le formatage du playbook Ansible ou du fichier de configuration pour s'assurer qu'il est valide. De plus, la vérification de la connectivité entre le nœud de contrôle Ansible et les hôtes gérés est cruciale, car des problèmes de réseau ou de pare-feu peuvent entraver la communication.
L'examen des journaux Ansible et des messages d'erreur fournit des informations précieuses sur le problème spécifique à résoudre. Ces journaux sont accessibles sur le nœud de contrôle ou les hôtes gérés, selon le contexte. Une autre approche de dépannage courante consiste à exécuter des commandes Ansible avec une verbosité accrue ou à utiliser l'indicateur `--check` pour effectuer des simulations sans apporter de modifications réelles, permettant aux utilisateurs d'identifier les problèmes potentiels avant d'exécuter des actions.
De plus, comprendre l'infrastructure cible et les capacités des hôtes gérés peut aider à résoudre les problèmes liés à des configurations incompatibles ou à des fonctionnalités non prises en charge. Dans l'ensemble, une approche systématique du dépannage d'Ansible, associée à la connaissance des concepts de base d'Ansible, peut résoudre efficacement la plupart des problèmes pouvant survenir lors des tâches d'automatisation.
## Identification des problèmes courants, leurs causes et solutions potentielles
Voici quelques problèmes courants dans Ansible, leurs causes possibles et leurs solutions potentielles:
### **Problèmes de Syntaxe :**
Les erreurs de syntaxe de playbook dans Ansible font référence à des erreurs ou des incohérences dans la structure, le formatage ou la syntaxe des fichiers de playbook. Ces erreurs empêchent Ansible d'interpréter et d'exécuter correctement le playbook. Certaines erreurs courantes de syntaxe de playbook incluent :
1. Erreurs d'indentation : Ansible s'appuie fortement sur l'indentation pour définir des blocs de tâches, des conditions ou des boucles. Ne pas aligner correctement les tâches ou les blocs peut entraîner des erreurs de syntaxe.
2. Crochets ou parenthèses manquants ou incompatibles : les manuels utilisent des crochets et des parenthèses pour encadrer des variables, des listes, des dictionnaires et des expressions. Oublier d'inclure des crochets fermants ou des parenthèses, ou utiliser des paires non concordantes, peut entraîner des erreurs de syntaxe.
3. Utilisation incorrecte des deux-points et des tirets : les deux-points (`:`) sont utilisés pour séparer les clés des valeurs dans les fichiers YAML, tandis que les tirets (`-`) indiquent un élément de la liste. Le fait de placer ou d'omettre ces symboles peut entraîner des erreurs de syntaxe.
4. Citations ou échappements incorrects : les valeurs de playbook qui contiennent des caractères spéciaux ou des mots-clés YAML réservés doivent être correctement citées ou échappées. Ne pas le faire peut entraîner des erreurs de syntaxe.
5. Fautes de frappe ou mots-clés mal orthographiés : Ansible attend des mots-clés et des noms de modules spécifiques dans sa syntaxe de playbook. Les fautes de frappe ou les mots mal orthographiés peuvent provoquer des erreurs de syntaxe lorsqu'Ansible ne parvient pas à reconnaître les mots-clés prévus.
6. Citations ou commentaires déséquilibrés ou non fermés : si les citations ou les commentaires ne sont pas correctement équilibrés ou fermés, cela peut entraîner des erreurs de syntaxe.
Pour identifier les erreurs de syntaxe du playbook, Ansible fournit des messages d'erreur détaillés qui pointent vers la ligne et la colonne spécifiques où l'erreur s'est produite. Il est essentiel d'examiner attentivement ces messages d'erreur et d'inspecter la ligne correspondante dans le fichier playbook pour localiser et résoudre le problème de syntaxe. De plus, l'utilisation d'outils de linting ou de validateurs YAML peut aider à identifier et à mettre en évidence les erreurs de syntaxe avant d'exécuter le playbook.
La commande `ansible-playbook playbook.yaml --syntax-check` permet d'identifier les erreurs de syntaxes dans nos playbooks.
Illustration: Nous avons délibérément mal configurer notre playbook a fin de tester cette commande.
Verification de la syntaxe

Bloc mal configurer

Correction de l'erreur

Reverification de la syntaxe

### **Erreurs de Connexion :**
Les erreurs de connexion dans Ansible se produisent généralement lorsqu'il est impossible d'établir ou de maintenir une connexion entre le nœud de contrôle Ansible et les hôtes gérés. Ces erreurs peuvent empêcher Ansible d'exécuter des tâches ou de collecter des informations à partir des systèmes distants. Il existe plusieurs erreurs de connexion courantes dans Ansible :
1. Erreurs de connexion SSH : Ansible utilise principalement SSH pour la communication à distance. Des erreurs de connexion SSH peuvent survenir en raison de problèmes tels que des informations d'identification SSH incorrectes, des restrictions de pare-feu ou des problèmes de connectivité réseau.
2. Erreurs d'hôte inaccessible : cette erreur indique que le nœud de contrôle Ansible ne peut pas atteindre l'hôte géré. Cela peut être causé par des problèmes de réseau, des noms d'hôte ou des adresses IP incorrects ou des configurations de routage incorrectes.
3. Erreurs d'authentification : Ansible nécessite des informations d'authentification valides (telles que des clés SSH ou des mots de passe) pour se connecter aux hôtes gérés. Des erreurs d'authentification peuvent se produire lorsque les informations d'identification fournies sont incorrectes ou mal configurées.
4. Erreurs de port et de protocole : par défaut, Ansible utilise SSH sur le port 22 pour les connexions à distance. Si le service SSH s'exécute sur un port différent ou si un protocole différent est requis (par exemple, WinRM pour les hôtes Windows), le fait de ne pas spécifier le port ou le protocole correct peut entraîner des erreurs de connexion.
5. Problèmes de pare-feu et de groupe de sécurité : les pare-feu et les groupes de sécurité sur les hôtes gérés ou l'infrastructure réseau peuvent bloquer les ports de communication requis utilisés par Ansible. Cela peut entraîner des erreurs de connexion si les ports nécessaires ne sont pas ouverts.
Pour résoudre les erreurs de connexion dans Ansible, il est conseiller de faire usage du module ping. Le but du ping Ansible est de vérifier la connectivité et l'accessibilité des hôtes distants à partir du nœud de contrôle Ansible. Lors de l'exécution du module Ansible ping, il envoie une commande de test aux hôtes cibles et attend une réponse. Le module ping n'utilise pas nécessairement ICMP (Internet Control Message Protocol) comme les pings réseau traditionnels, mais exécute plutôt une commande ou un module approprié pour le système d'exploitation de l'hôte distant.
Illustration du module ping:
```!yml
---
- hosts: host1
become: yes
tasks:
- ping:
```

- Dans le cas d'un hôte innaccessible ou d'un pare-feu, nous pourrions avoir l'erreur `"No route to host", "unreachable": true` ou alors l'erreur`"Connection timed out", "unreachable": true`

- Dans le cas d'une erreur de port, nous pourrions avoir l'erreur `"Connection refused", "unreachable": true`

- Dans le cas d'une erreur d'authentification liée a la clé publique, nous pourrions avoir l'erreur `"Permission denied (Publickey,password)", "unreachable": true`

### **Erreurs liées aux packages :**
Dans Ansible, les échecs d'installation de packages/modules font référence aux problèmes rencontrés lors de la tentative d'installation de packages logiciels ou de modules sur des hôtes gérés à l'aide de playbooks ou de rôles Ansible. Ces pannes peuvent survenir pour diverses raisons :
1. Nom ou version de package incorrect : fournir un nom ou une version de package incorrect dans le playbook peut entraîner des échecs d'installation. Il est crucial de revérifier les détails du package, y compris le nom et la version corrects du package, en s'assurant qu'ils correspondent au référentiel de packages.
2. Dépendances incompatibles ou manquantes : Certains packages nécessitent l'installation préalable de dépendances spécifiques. Si ces dépendances sont manquantes ou incompatibles, l'installation du package peut échouer.
3. Privilèges insuffisants : l'installation du package peut nécessiter des privilèges d'administrateur ou root. Si l'utilisateur Ansible ne dispose pas des autorisations suffisantes, l'installation peut échouer. L'octroi des privilèges nécessaires à l'utilisateur Ansible peut résoudre ce problème.
4. Compatibilité du système d'exploitation : les packages peuvent être spécifiques à certains systèmes d'exploitation ou versions. Essayer d'installer un package sur un système d'exploitation incompatible peut entraîner des échecs. Il est important de s'assurer que le package est compatible avec le système d'exploitation de l'hôte géré pour éviter les problèmes d'installation.
Pour résoudre les échecs d'installation de packages/modules dans Ansible, il est utile de vérifier le noms des packages et versions disponible pour le système d'exploitation cible.
Vous pouvez vérifier les noms de packages pour les playbooks Ansible sur diverses plates-formes, notamment :
- https://packages.ubuntu.com/
- https://wiki.centos.org/AdditionalResources/Repositories
- https://www.debian.org/distrib/packages
- https://galaxy.ansible.com/
## **Ansible Rescue :**
Dans Ansible, la section "rescue" est un bloc spécial qui peut être inclus dans un playbook ou un rôle. Il est utilisé pour définir les tâches qui doivent être exécutées en cas d'échec ou d'erreur survenant lors de l'exécution du playbook. La section "rescue" agit comme un mécanisme de secours pour gérer les exceptions et effectuer les actions de récupération nécessaires.
La variable `debug` dans Ansible est un outil puissant qui facilite le dépannage et le débogage des playbooks. Il vous permet d'imprimer des valeurs variables, d'afficher des messages personnalisés et d'effectuer des vérifications conditionnelles lors de l'exécution du playbook.
La variable `debug` peut être appliqué à différents niveaux dans un playbook Ansible, tels que le niveau de la tâche, le niveau du bloc ou même le niveau du playbook. Cela aide à gagner en visibilité sur le flux d'exécution du playbook, à comprendre les valeurs des variables et à vérifier les conditions ou les boucles utilisées.
Certains cas d'utilisation courants du paramètre de débogage incluent :
1. Inspection des variables : le module "debug" vous permet d'inspecter les valeurs des variables à différentes étapes de l'exécution du playbook. Vous pouvez imprimer les valeurs des variables sur la console, les fichiers journaux ou la sortie Ansible, ce qui vous aide à comprendre l'état des variables et à identifier tout comportement inattendu ou incohérence.
2. Vérifications conditionnelles : avec le module `debug`, vous pouvez effectuer des vérifications conditionnelles sur les variables et afficher des messages personnalisés en fonction de leurs valeurs. Cela vous permet de vérifier si des conditions spécifiques sont remplies lors de l'exécution du playbook et d'avoir un aperçu du flux d'exécution.
3. Sortie de dépannage : en utilisant le module "debug" de manière stratégique, vous pouvez générer des informations détaillées ou des instructions de débogage à des points spécifiques de votre playbook. Cela vous aide à suivre la progression de l'exécution, à identifier les problèmes potentiels et à suivre le comportement du playbook pendant le dépannage.
4. Vérification de la logique des playbooks : vous pouvez utiliser le module "debug" pour vérifier la logique de vos playbooks. En imprimant des valeurs de variables intermédiaires ou en vérifiant des conditions, vous pouvez vous assurer que le playbook exécute les tâches souhaitées et prend les décisions attendues.
5. Interpolation variable : le module "debug" prend en charge l'interpolation variable, vous permettant de concaténer dynamiquement des chaînes et des valeurs variables. Ceci est particulièrement utile pour construire des messages de débogage informatifs qui incluent des informations variables.
Dans le cadre de ce cours nous avons écrit un playbook qui installe docker-engine sur des serveurs Ubuntu et en cas de problème d'installation sur un serveur particulier, le paramètre `debug` imprime le nom du serveur.
```!yaml
---
- name: Installation de docker engine
hosts: all
vars_files:
- variables.yml
tasks:
- block:
- name: upgrade repo
apt: update_cache=true force_apt_get=true
- name: add docker GPG key
apt_key:
url: https://download.docker.com/linux/ubuntu/gpg
state: present
keyring: /etc/apt/keyrings/docker.gpg
- name: ubuntu version
shell: echo "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable""
register: ubuntuversion
- name: architecture
shell: echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu"
register: ubuntuarch
- debug: var=ubuntuversion
- debug: var=ubuntuarch
- name: add docker repo
apt_repository:
repo: '{{ ubuntuarch.stdout }} {{ ubuntuversion.stdout }}'
state: present
- name: update repo
apt: update_cache=true force_apt_get=true
- name: install docker and co
apt:
pkg:
- docker-ce
- docker-ce-cli
- containerd.io
- docker-buildx-plugin
- docker-compose-plugin
- name: start docker
service:
name: docker
state: started
enabled: yes
- name: add user to docker group
user:
name: '{{ user }}'
append: yes
groups: docker
when: ansible_distribution == "Ubuntu"
rescue:
- debug:
msg: "Playbook has failed for {{ inventory_hostname}} node"
```

Il est important de noter que la section `rescue` est facultative et qu'elle n'est exécutée qu'en cas d'échec dans les tâches associées. Si l'exécution du playbook ou du rôle se termine avec succès sans aucune erreur, la section "rescue" est ignorée.
La section "rescue" d'Ansible fournit un moyen de gérer avec élégance les échecs dans les playbooks et les rôles, vous permettant de définir des actions spécifiques pour récupérer des erreurs et maintenir l'état souhaité de l'infrastructure.
## Conclusion
En conclusion, un dépannage efficace est une compétence essentielle lorsque vous travaillez avec Ansible. Comprendre les problèmes courants qui peuvent survenir, tels que les erreurs de connexion, les problèmes de syntaxe, la compatibilité des modules ou les erreurs de variables, est essentiel pour identifier et résoudre efficacement les problèmes. Ansible fournit des outils puissants pour le dépannage, y compris le module "debug" pour inspecter les variables et personnaliser la sortie, ainsi que des fonctionnalités telles que la gestion des erreurs et les vérifications conditionnelles. En utilisant ces outils, en examinant les messages d'erreur et en tirant parti de la communauté et de la documentation Ansible, les administrateurs et les développeurs peuvent dépanner et déboguer avec succès les playbooks Ansible, garantissant ainsi l'exécution fluide des tâches d'automatisation et la maintenance d'une infrastructure fiable.