Comment corriger l'erreur 'Permission denied' dans le module script Ansible

AnsibleAnsibleBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Ansible est un outil d'automatisation puissant qui simplifie la gestion et la configuration de l'infrastructure. Le module script d'Ansible vous permet d'exécuter des scripts personnalisés au sein de vos playbooks, étendant ainsi les fonctionnalités d'Ansible au-delà de ses modules intégrés. Cependant, les utilisateurs rencontrent souvent l'erreur "Permission denied" (Permission refusée) lors de l'utilisation de ce module, ce qui peut entraver les flux de travail d'automatisation.

Ce lab vous guidera à travers la compréhension et la résolution des problèmes liés aux permissions dans le module script d'Ansible. Vous apprendrez à identifier les causes des erreurs de permission et à mettre en œuvre diverses solutions pour garantir que vos scripts Ansible s'exécutent avec succès.

Installation d'Ansible et configuration de l'environnement

Avant de pouvoir explorer les problèmes de permissions avec les scripts Ansible, nous devons configurer notre environnement. Installons Ansible et créons une structure de base pour notre environnement de test.

Installation d'Ansible

Tout d'abord, mettons à jour l'index des paquets et installons Ansible :

sudo apt update
sudo apt install -y ansible

Une fois l'installation terminée, vérifiez qu'Ansible est installé correctement :

ansible --version

Vous devriez voir une sortie similaire à celle-ci, affichant la version d'Ansible et les détails de configuration :

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, Mar 01 2023, 12:34:56) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Configuration de la structure du projet

Maintenant, créons une structure de répertoire de projet pour notre playbook Ansible et nos scripts :

mkdir -p ~/project/ansible-lab/{playbooks,scripts}
cd ~/project/ansible-lab

Dans cette structure :

  • playbooks/ contiendra nos playbooks Ansible
  • scripts/ contiendra nos scripts shell à exécuter par Ansible

Création d'un script simple

Créons un script shell simple que nous utiliserons avec Ansible. Créez un fichier nommé hello.sh dans le répertoire scripts :

cd ~/project/ansible-lab/scripts
touch hello.sh

Ouvrez le fichier hello.sh dans l'éditeur et ajoutez le contenu suivant :

#!/bin/bash
echo "Hello from $(hostname)!"
echo "Current time: $(date)"
echo "Current user: $(whoami)"

Ce script affichera le nom d'hôte, l'heure actuelle et l'utilisateur qui a exécuté le script.

Création d'un fichier d'inventaire

Ensuite, créons un fichier d'inventaire simple pour Ansible. Dans Ansible, un fichier d'inventaire définit les hôtes et les groupes qu'Ansible gérera :

cd ~/project/ansible-lab
touch inventory.ini

Ouvrez le fichier inventory.ini et ajoutez ce qui suit :

[local]
localhost ansible_connection=local

Ce fichier d'inventaire indique à Ansible d'exécuter les commandes sur la machine locale.

Création d'un playbook de base

Maintenant, créons un playbook Ansible de base qui utilise le module script :

cd ~/project/ansible-lab/playbooks
touch run_script.yml

Ouvrez le fichier run_script.yml et ajoutez le contenu suivant :

---
- name: Run a script
  hosts: local
  tasks:
    - name: Execute the hello script
      script: ../scripts/hello.sh

Ce playbook tentera d'exécuter notre script hello.sh sur la machine locale.

Avec cette configuration de base, nous sommes prêts à explorer les problèmes de permissions avec les scripts Ansible dans les étapes suivantes.

Rencontre de l'erreur "Permission denied" (Permission refusée)

Maintenant que nous avons configuré notre environnement, essayons d'exécuter notre playbook Ansible et de comprendre ce qui se passe lorsque nous rencontrons une erreur de permission refusée.

Exécution du Playbook

Essayons d'exécuter notre playbook :

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/run_script.yml

Vous rencontrerez probablement un message d'erreur similaire à celui-ci :

TASK [Execute the hello script] *******************************
fatal: [localhost]: FAILED! => {"changed": false, "msg": "failed to execute the script: /bin/sh: 1: /home/labex/.ansible/tmp/ansible-tmp-1234567890.12-123456789012345/AnsiballZ_script.py: Permission denied"}

Il s'agit d'une erreur de permission refusée courante lors de l'utilisation du module script d'Ansible. L'erreur se produit parce que notre script n'a pas la permission d'exécution, qui est requise pour qu'il s'exécute.

Comprendre les permissions des fichiers sous Linux

Sous Linux, chaque fichier possède des permissions qui déterminent qui peut le lire, l'écrire ou l'exécuter. Il existe trois types de permissions :

  1. Read (r) (Lecture) : Permet de lire le contenu du fichier
  2. Write (w) (Écriture) : Permet de modifier le fichier
  3. Execute (x) (Exécution) : Permet d'exécuter le fichier en tant que programme

Ces permissions sont attribuées à trois catégories d'utilisateurs différentes :

  1. User (owner) (Utilisateur (propriétaire)) : Le propriétaire du fichier
  2. Group (Groupe) : Les utilisateurs qui sont membres du groupe du fichier
  3. Others (Autres) : Tous les autres utilisateurs

Vous pouvez afficher les permissions d'un fichier à l'aide de la commande ls -l :

ls -l ~/project/ansible-lab/scripts/hello.sh

Vous pourriez voir une sortie comme celle-ci :

-rw-rw-r-- 1 labex labex 95 Jun 10 12:34 /home/labex/project/ansible-lab/scripts/hello.sh

Dans cette sortie, le premier ensemble de caractères (-rw-rw-r--) représente les permissions du fichier :

  • Le premier caractère (-) indique qu'il s'agit d'un fichier régulier
  • Les trois caractères suivants (rw-) sont les permissions du propriétaire (lecture, écriture, pas d'exécution)
  • Les trois suivants (rw-) sont les permissions du groupe
  • Les trois derniers (r--) sont les permissions pour les autres

Notez que la permission d'exécution (x) est manquante pour toutes les catégories d'utilisateurs, c'est pourquoi nous obtenons l'erreur de permission refusée.

Vérification des permissions actuelles

Examinons les permissions actuelles de notre script :

ls -l ~/project/ansible-lab/scripts/hello.sh

Vous verrez que le script n'a pas la permission d'exécution, qui est nécessaire pour qu'Ansible l'exécute.

Dans l'étape suivante, nous apprendrons comment corriger ce problème de permission et exécuter avec succès notre playbook Ansible.

Correction des problèmes de permissions avec chmod

La méthode la plus courante pour corriger l'erreur "Permission denied" (Permission refusée) consiste à ajouter les permissions d'exécution au fichier de script. Nous pouvons le faire en utilisant la commande chmod.

Comprendre la commande chmod

La commande chmod est utilisée pour modifier les permissions des fichiers ou des répertoires sous Linux. La commande dispose de plusieurs façons de spécifier les permissions :

  1. Symbolic mode (Mode symbolique) : Utilise des lettres (r, w, x) pour représenter les permissions
  2. Numeric mode (Mode numérique) : Utilise des nombres (4, 2, 1) pour représenter les permissions

Pour notre objectif, nous utiliserons le mode symbolique pour ajouter les permissions d'exécution.

Ajout des permissions d'exécution au script

Ajoutons les permissions d'exécution à notre script :

chmod +x ~/project/ansible-lab/scripts/hello.sh

L'option +x ajoute la permission d'exécution pour toutes les catégories d'utilisateurs (utilisateur, groupe et autres).

Vérifions que les permissions ont été mises à jour :

ls -l ~/project/ansible-lab/scripts/hello.sh

Vous devriez maintenant voir une sortie similaire à celle-ci :

-rwxrwxr-x 1 labex labex 95 Jun 10 12:34 /home/labex/project/ansible-lab/scripts/hello.sh

Notez le x dans la chaîne de permissions, indiquant que la permission d'exécution a été ajoutée.

Exécution du playbook à nouveau

Maintenant que nous avons ajouté les permissions d'exécution à notre script, exécutons à nouveau le playbook Ansible :

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/run_script.yml

Cette fois, le playbook devrait s'exécuter avec succès :

PLAY [Run a script] ******************************************

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

TASK [Execute the hello script] *****************************
changed: [localhost]

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

Affichage de la sortie du script

Vérifions la sortie de notre script. Ansible capture la sortie du script et l'inclut dans les résultats de la tâche. Pour voir la sortie détaillée, modifions notre playbook pour enregistrer et afficher la sortie :

cd ~/project/ansible-lab/playbooks

Modifiez le fichier run_script.yml pour inclure les tâches d'enregistrement et de débogage :

---
- name: Run a script
  hosts: local
  tasks:
    - name: Execute the hello script
      script: ../scripts/hello.sh
      register: script_output

    - name: Display script output
      debug:
        var: script_output.stdout_lines

Maintenant, exécutons à nouveau le playbook :

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/run_script.yml

Vous devriez voir une sortie comme celle-ci :

PLAY [Run a script] ******************************************

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

TASK [Execute the hello script] *****************************
changed: [localhost]

TASK [Display script output] ********************************
ok: [localhost] => {
    "script_output.stdout_lines": [
        "Hello from localhost!",
        "Current time: Wed Jun 10 12:34:56 UTC 2023",
        "Current user: labex"
    ]
}

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

Maintenant, vous pouvez voir la sortie complète de notre script. Le script s'est exécuté en tant qu'utilisateur labex, qui est notre utilisateur actuel.

En ajoutant les permissions d'exécution avec chmod +x, nous avons réussi à corriger l'erreur "Permission denied" (Permission refusée) et pouvons maintenant exécuter notre script via Ansible.

Utilisation de Become pour l'élévation de privilèges

Parfois, vous devez exécuter des scripts avec des privilèges élevés, comme l'exécution de commandes qui nécessitent un accès root. Dans ces cas, le simple ajout de permissions d'exécution au script peut ne pas suffire. Ansible fournit la directive become pour exécuter des tâches avec l'élévation de privilèges.

Comprendre la directive Become

La directive become dans Ansible vous permet d'exécuter des tâches en tant qu'utilisateur différent, généralement avec des privilèges élevés. Cela est similaire à l'utilisation de sudo dans la ligne de commande.

Les options clés pour la directive become incluent :

  • become: yes : Active l'élévation de privilèges
  • become_user: <username> : Spécifie l'utilisateur à devenir (la valeur par défaut est root)
  • become_method: <method> : Spécifie comment devenir l'utilisateur (la valeur par défaut est sudo)

Création d'un script qui nécessite des privilèges root

Créons un script qui nécessite des privilèges root pour s'exécuter avec succès :

cd ~/project/ansible-lab/scripts
touch system_info.sh

Ajoutez le contenu suivant au fichier system_info.sh :

#!/bin/bash
echo "System information - requires root privileges"
echo "Hostname: $(hostname)"
echo "Kernel version: $(uname -r)"
echo "Available disk space:"
df -h /
echo "User executing the script: $(whoami)"

Rendez le script exécutable :

chmod +x ~/project/ansible-lab/scripts/system_info.sh

Création d'un playbook avec Become

Maintenant, créons un playbook qui utilise la directive become :

cd ~/project/ansible-lab/playbooks
touch root_script.yml

Ajoutez le contenu suivant au fichier root_script.yml :

---
- name: Run a script as root
  hosts: local
  tasks:
    - name: Execute the system info script
      script: ../scripts/system_info.sh
      become: yes
      register: script_output

    - name: Display script output
      debug:
        var: script_output.stdout_lines

La directive become: yes indique à Ansible d'exécuter le script avec des privilèges élevés.

Exécution du playbook avec Become

Exécutons notre nouveau playbook :

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/root_script.yml

Le playbook devrait s'exécuter avec succès, et vous devriez voir une sortie similaire à celle-ci :

PLAY [Run a script as root] *********************************

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

TASK [Execute the system info script] **********************
changed: [localhost]

TASK [Display script output] *******************************
ok: [localhost] => {
    "script_output.stdout_lines": [
        "System information - requires root privileges",
        "Hostname: localhost",
        "Kernel version: 5.15.0-1015-aws",
        "Available disk space:",
        "Filesystem      Size  Used Avail Use% Mounted on",
        "/dev/root        59G   17G   42G  29% /",
        "User executing the script: root"
    ]
}

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

Notez que dans la sortie du script, "User executing the script" (Utilisateur exécutant le script) est maintenant root, et non labex. Cela montre que notre script s'est exécuté avec des privilèges élevés grâce à la directive become: yes.

Comprendre quand utiliser Become

Vous devez utiliser la directive become dans les situations suivantes :

  1. Lorsque le script doit accéder à des fichiers ou des répertoires système qui nécessitent des privilèges root
  2. Lorsque le script doit installer des paquets ou modifier des configurations système
  3. Lorsque le script doit exécuter des commandes qui nécessiteraient normalement sudo dans la ligne de commande

En utilisant la directive become de manière appropriée, vous pouvez vous assurer que vos scripts disposent des permissions nécessaires pour s'exécuter avec succès, en évitant les erreurs de permission refusée.

Bonnes pratiques pour éviter les problèmes de permissions

Maintenant que nous comprenons comment corriger les problèmes de permissions en utilisant chmod et become, explorons quelques bonnes pratiques pour empêcher les problèmes de permissions de se produire en premier lieu.

1. Toujours rendre les scripts exécutables avant de les utiliser

Avant d'utiliser un script dans Ansible, assurez-vous toujours qu'il dispose de la permission d'exécution :

chmod +x path/to/script.sh

C'est une bonne pratique de le faire dans le cadre de votre processus de création de script.

2. Utiliser le contrôle de version avec les modes de fichiers appropriés

Si vous utilisez Git ou un autre système de contrôle de version, assurez-vous qu'il conserve les modes de fichiers (permissions). Dans Git, vous pouvez configurer cela avec :

git config core.fileMode true

Pour les dépôts existants, vous devrez peut-être mettre à jour les modes de fichiers :

git update-index --chmod=+x path/to/script.sh

3. Créer un script pour vérifier et corriger les permissions

Créons un script utilitaire qui vérifie et corrige les permissions pour tous les scripts de notre projet :

cd ~/project/ansible-lab
touch fix_permissions.sh

Ajoutez le contenu suivant au fichier fix_permissions.sh :

#!/bin/bash
echo "Fixing permissions for scripts in ansible-lab"

## Find all .sh files and make them executable
find ~/project/ansible-lab -name "*.sh" -type f -exec chmod +x {} \;

echo "Done. All script files now have execute permissions."

Rendez le script exécutable :

chmod +x ~/project/ansible-lab/fix_permissions.sh

Exécutez le script pour vous assurer que tous les scripts de votre projet ont des permissions d'exécution :

./fix_permissions.sh

4. Utiliser le module File d'Ansible pour définir les permissions

Vous pouvez également utiliser le module file d'Ansible pour vous assurer que les fichiers de script ont les permissions correctes. Créons un playbook qui fait cela :

cd ~/project/ansible-lab/playbooks
touch set_permissions.yml

Ajoutez le contenu suivant au fichier set_permissions.yml :

---
- name: Set correct permissions for scripts
  hosts: local
  tasks:
    - name: Find all script files
      find:
        paths: /home/labex/project/ansible-lab
        patterns: "*.sh"
        recurse: yes
      register: script_files

    - name: Make script files executable
      file:
        path: "{{ item.path }}"
        mode: "0755"
      loop: "{{ script_files.files }}"

Exécutez ce playbook pour vous assurer que tous les scripts ont les permissions correctes :

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/set_permissions.yml

5. Créer un playbook de vérification préalable

Enfin, créons un playbook de vérification préalable qui s'exécute avant vos playbooks principaux pour vérifier que tout est configuré correctement :

cd ~/project/ansible-lab/playbooks
touch preflight_check.yml

Ajoutez le contenu suivant au fichier preflight_check.yml :

---
- name: Pre-flight checks
  hosts: local
  tasks:
    - name: Check if scripts are executable
      find:
        paths: /home/labex/project/ansible-lab
        patterns: "*.sh"
        recurse: yes
      register: script_files

    - name: Verify script permissions
      stat:
        path: "{{ item.path }}"
      register: stat_results
      loop: "{{ script_files.files }}"
      failed_when: not stat_results.stat.executable
      ignore_errors: yes

Ce playbook vérifie si tous les fichiers .sh sont exécutables et signale ceux qui ne le sont pas.

Exécutons la vérification préalable :

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/preflight_check.yml

Si tous vos scripts ont les permissions correctes, le playbook devrait se terminer sans erreurs. Si des scripts manquent de permissions d'exécution, vous verrez une notification.

En suivant ces bonnes pratiques, vous pouvez éviter les erreurs de permission refusée dans vos scripts Ansible et vous assurer que votre automatisation s'exécute sans problème.

Résumé

Dans ce lab, vous avez appris à identifier et à résoudre les erreurs "Permission denied" (Permission refusée) lors de l'utilisation du module script d'Ansible.

Les points clés à retenir de ce lab incluent :

  1. Comprendre l'importance des permissions de fichiers dans Linux et comment elles affectent l'exécution des scripts dans Ansible
  2. Utiliser la commande chmod pour ajouter des permissions d'exécution aux fichiers de script
  3. Utiliser la directive become d'Ansible pour l'élévation de privilèges lors de l'exécution de scripts qui nécessitent un accès root
  4. Mettre en œuvre les bonnes pratiques pour prévenir les problèmes de permissions, notamment :
    • Rendre les scripts exécutables avant de les utiliser
    • Maintenir les modes de fichiers appropriés dans le contrôle de version
    • Créer des scripts utilitaires pour vérifier et corriger les permissions
    • Utiliser le module file d'Ansible pour définir les permissions
    • Mettre en œuvre des vérifications préalables pour vérifier votre environnement

En appliquant ces techniques, vous pouvez vous assurer que vos scripts Ansible s'exécutent sans problème, sans erreurs de permission, améliorant ainsi la fiabilité de vos flux de travail d'automatisation.

Les compétences que vous avez acquises dans ce lab sont fondamentales pour travailler efficacement avec Ansible et peuvent être appliquées à un large éventail de scénarios d'automatisation.