Ansible : Résoudre les problèmes de mot de passe Sudo manquant

Introduction

Ansible est un outil d'automatisation puissant qui aide à gérer et configurer des serveurs sans intervention manuelle. Cependant, de nombreuses tâches Ansible nécessitent des permissions élevées pour s'exécuter correctement. Lors de l'exécution de commandes qui requièrent des privilèges d'administrateur, Ansible utilise le mécanisme sudo, qui peut demander un mot de passe.

Dans ce lab, vous apprendrez comment configurer correctement les paramètres de mot de passe sudo dans les playbooks Ansible, comprendre les problèmes courants liés à sudo, et implémenter les meilleures pratiques pour garantir que votre automatisation s'exécute sans problème avec les permissions nécessaires.

Installation d'Ansible et création d'un playbook de base

Dans cette première étape, nous allons installer Ansible et créer un playbook simple qui nécessite des privilèges sudo. Cela nous aidera à comprendre les exigences de base pour l'exécution des tâches Ansible avec des permissions élevées.

Installation d'Ansible

Commençons par installer Ansible sur notre système. Ouvrez un terminal et exécutez les commandes suivantes :

sudo apt update
sudo apt install -y ansible

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

ansible --version

Vous devriez voir une sortie similaire à celle-ci, affichant la version d'Ansible et les informations 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 (main, Ubuntu, linux/x86_64)
  jinja version = 3.0.3
  libyaml = True

Créer un playbook Ansible de base

Maintenant, créons un playbook Ansible simple qui nécessite des privilèges sudo. Ce playbook installera le paquet htop sur le système local.

Créez un nouveau répertoire pour votre projet Ansible :

mkdir -p ~/project/ansible-sudo-lab
cd ~/project/ansible-sudo-lab

Ensuite, créez le fichier d'inventaire qui définit les hôtes qu'Ansible gérera. Pour ce lab, nous utiliserons localhost :

echo "localhost ansible_connection=local" > inventory

Maintenant, créez un playbook de base qui nécessite des privilèges sudo. Ouvrez l'éditeur VSCode et créez un nouveau fichier nommé basic_playbook.yml :

Cliquez sur "File" dans le menu WebIDE
Sélectionnez "New File"
Copiez et collez le contenu suivant :

---
- name: Basic sudo operation
  hosts: localhost
  become: true ## This enables sudo

  tasks:
    - name: Install htop
      apt:
        name: htop
        state: present
        update_cache: yes

Enregistrez le fichier sous ~/project/ansible-sudo-lab/basic_playbook.yml

Ce playbook contient la directive become: true, qui indique à Ansible d'utiliser sudo pour exécuter les tâches. La tâche elle-même tente d'installer le paquet htop en utilisant le module apt.

Exécuter le Playbook

Maintenant, exécutons notre playbook et observons ce qui se passe :

cd ~/project/ansible-sudo-lab
ansible-playbook -i inventory basic_playbook.yml

Étant donné que l'utilisateur labex a un accès sudo sans mot de passe, le playbook devrait s'exécuter avec succès sans demander de mot de passe. Vous devriez voir une sortie similaire à celle-ci :

PLAY [Basic sudo operation] ******************************************

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

TASK [Install htop] ************************************************
ok: [localhost]

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

Le playbook s'est exécuté avec succès car notre utilisateur actuel (labex) est déjà configuré avec un accès sudo sans mot de passe. Dans les prochaines étapes, nous explorerons comment gérer les scénarios où un mot de passe sudo est requis.

Comprendre la configuration du mot de passe Sudo dans Ansible

Dans l'étape précédente, nous avons créé un playbook de base qui utilisait les privilèges sudo sans demander de mot de passe. Cependant, dans de nombreux scénarios réels, vous devrez fournir un mot de passe sudo pour exécuter des commandes privilégiées. Explorons comment gérer les mots de passe sudo dans Ansible.

Comment Ansible gère les mots de passe Sudo

Quand Ansible doit exécuter une commande avec des privilèges élevés sur un système distant, il utilise la fonctionnalité become. Par défaut, Ansible utilise la commande sudo pour l'élévation des privilèges, mais vous pouvez le configurer pour utiliser d'autres méthodes comme su, pbrun ou pfexec.

Si l'utilisateur exécutant Ansible a besoin d'un mot de passe pour utiliser sudo, Ansible doit connaître ce mot de passe. Il existe plusieurs façons de fournir le mot de passe sudo à Ansible :

Option de ligne de commande : -K ou --ask-become-pass
Variable de playbook : become_password
Fichier de configuration : ansible.cfg
Ansible Vault : Pour stocker les mots de passe en toute sécurité

Création d'un utilisateur de test avec l'exigence de mot de passe Sudo

Pour démontrer comment gérer les mots de passe sudo, créons un utilisateur de test qui nécessite un mot de passe pour les opérations sudo :

sudo adduser ansible_test

Lorsque vous y êtes invité, entrez le mot de passe ansible123 et terminez le processus de création de l'utilisateur.

Ensuite, donnons à cet utilisateur les privilèges sudo mais exigeons un mot de passe :

echo "ansible_test ALL=(ALL) ALL" | sudo tee /etc/sudoers.d/ansible_test

Cette configuration permet à l'utilisateur ansible_test d'utiliser sudo, mais elle exigera le mot de passe de l'utilisateur à chaque fois.

Création d'un playbook avec la gestion des mots de passe Sudo

Maintenant, créons un playbook qui démontre comment gérer les mots de passe sudo. Créez un nouveau fichier nommé sudo_password_playbook.yml dans le WebIDE :

---
- name: Playbook with sudo password handling
  hosts: localhost
  become: true
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Get current user
      command: whoami
      register: current_user
      become: false ## This task doesn't need sudo

    - name: Print current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
      become: false ## This task doesn't need sudo

    - name: Run a command with sudo
      command: apt update
      register: sudo_output

    - name: Print sudo command result
      debug:
        msg: "Command ran with sudo: {{ sudo_output.rc == 0 }}"

Enregistrez ce fichier sous ~/project/ansible-sudo-lab/sudo_password_playbook.yml

Exécution du playbook avec saisie du mot de passe

Lorsque vous souhaitez exécuter un playbook en tant qu'utilisateur qui nécessite un mot de passe sudo, vous pouvez utiliser l'option -K (ou --ask-become-pass) pour demander le mot de passe :

ansible-playbook -i inventory sudo_password_playbook.yml -K

Puisque nous exécutons en tant qu'utilisateur labex qui a sudo sans mot de passe, vous ne serez pas réellement invité à entrer un mot de passe. Cependant, dans un environnement de production où sudo sans mot de passe n'est pas configuré, Ansible vous demanderait d'entrer le mot de passe sudo.

Pour simuler ce scénario avec notre utilisateur de test, vous pouvez exécuter la commande suivante (bien qu'elle ne fonctionne pas complètement dans cet environnement de lab en raison de la configuration SSH manquante) :

ansible-playbook -i inventory sudo_password_playbook.yml -u ansible_test -K

Lorsque vous êtes invité pour le mot de passe BECOME, vous entreriez ansible123.

Spécification du mot de passe Sudo dans une variable Ansible

Au lieu d'entrer le mot de passe de manière interactive, vous pouvez fournir le mot de passe sudo en tant que variable lors de l'exécution du playbook :

ansible-playbook -i inventory sudo_password_playbook.yml -e "ansible_become_password=ansible123"

Cette approche est utile pour les scripts automatisés où la saisie interactive n'est pas possible. Cependant, elle expose le mot de passe dans l'historique de la ligne de commande, ce qui constitue un risque de sécurité. Dans un environnement de production, vous devez utiliser Ansible Vault pour stocker en toute sécurité les informations sensibles.

Utilisation d'Ansible Vault pour la gestion sécurisée des mots de passe

Dans l'étape précédente, nous avons exploré différentes façons de fournir des mots de passe sudo aux playbooks Ansible. Cependant, stocker des mots de passe dans des fichiers en texte clair ou les passer sur la ligne de commande n'est pas sécurisé. Dans cette étape, nous allons apprendre à utiliser Ansible Vault pour gérer en toute sécurité les informations sensibles telles que les mots de passe sudo.

Qu'est-ce qu'Ansible Vault ?

Ansible Vault est une fonctionnalité qui vous permet de chiffrer des données sensibles telles que des mots de passe, des clés API ou des certificats. Les fichiers chiffrés peuvent être stockés en toute sécurité dans des systèmes de contrôle de version sans exposer les informations sensibles. Ansible peut automatiquement déchiffrer ces fichiers lors de l'exécution du playbook.

Création d'un fichier Vault chiffré

Créons un fichier chiffré pour stocker notre mot de passe sudo :

cd ~/project/ansible-sudo-lab
ansible-vault create vault.yml

Vous serez invité à créer un nouveau mot de passe de coffre-fort. Entrez vaultpassword123 et confirmez-le.

Après avoir défini le mot de passe du coffre-fort, un éditeur s'ouvrira. Entrez le contenu suivant dans l'éditeur :

---
vault_sudo_password: ansible123

Enregistrez le fichier et quittez l'éditeur.

Maintenant, si vous essayez d'afficher le contenu du fichier du coffre-fort, vous verrez qu'il est chiffré :

cat vault.yml

Vous devriez voir une sortie similaire à :

$ANSIBLE_VAULT;1.1;AES256
32623438613466396238613731623338376461653866353031313632316237613561393639613131
3562626166616332386265373761653835356134613561380a363761333362323238663136633439
32343032333832313562353261333530666639643239303436643363393630643639316232303564
3962356162356361370a313038333432353162333462323035323262396233333039326535356662
31363539613432656362326565613232336535393232653939323466323131393362

Utilisation des variables Vault dans un playbook

Maintenant, créons un playbook qui utilise le mot de passe sudo chiffré. Créez un nouveau fichier nommé secure_sudo_playbook.yml :

---
- name: Playbook with secure sudo password
  hosts: localhost
  become: true
  become_password: "{{ vault_sudo_password }}"
  vars_files:
    - vault.yml

  tasks:
    - name: Get sudo user
      command: whoami
      register: sudo_user

    - name: Print sudo user
      debug:
        msg: "Running as {{ sudo_user.stdout }}"

    - name: Check sudo access
      command: apt update
      register: apt_result
      failed_when: false

    - name: Print result
      debug:
        msg: "Sudo access successful: {{ apt_result.rc == 0 }}"

Enregistrez ce fichier sous ~/project/ansible-sudo-lab/secure_sudo_playbook.yml

Exécution d'un playbook avec Vault

Lorsque vous exécutez un playbook qui inclut un fichier de coffre-fort chiffré, vous devez fournir le mot de passe du coffre-fort. Il existe plusieurs façons de le faire :

En utilisant l'option --ask-vault-pass :

ansible-playbook -i inventory secure_sudo_playbook.yml --ask-vault-pass

Lorsque vous y êtes invité, entrez le mot de passe du coffre-fort : vaultpassword123

En utilisant un fichier de mot de passe de coffre-fort :

Tout d'abord, créez un fichier contenant le mot de passe du coffre-fort :

echo "vaultpassword123" > vault_password_file
chmod 600 vault_password_file

Ensuite, exécutez le playbook avec le fichier de mot de passe :

ansible-playbook -i inventory secure_sudo_playbook.yml --vault-password-file vault_password_file

Vous devriez voir une sortie similaire à :

PLAY [Playbook with secure sudo password] ***************************

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

TASK [Get sudo user] ***********************************************
changed: [localhost]

TASK [Print sudo user] *********************************************
ok: [localhost] => {
    "msg": "Running as root"
}

TASK [Check sudo access] *******************************************
changed: [localhost]

TASK [Print result] ************************************************
ok: [localhost] => {
    "msg": "Sudo access successful: True"
}

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

Bonnes pratiques pour la gestion des mots de passe Sudo

Voici quelques bonnes pratiques à suivre lors de la gestion des mots de passe sudo dans Ansible :

Utilisez toujours Ansible Vault pour chiffrer les informations sensibles
Ne stockez jamais les mots de passe du coffre-fort dans le contrôle de version
Utilisez une méthode sécurisée pour distribuer les mots de passe du coffre-fort (par exemple, un gestionnaire de mots de passe)
Envisagez d'utiliser un ID de coffre-fort pour différents environnements (dev, staging, production)
Faites pivoter les mots de passe du coffre-fort régulièrement

Dans un environnement de production, vous pourriez également envisager d'utiliser un outil comme HashiCorp Vault ou AWS Secrets Manager pour une gestion des secrets encore plus sécurisée.

Dépannage des problèmes courants de mot de passe Sudo

Même avec une configuration correcte, vous pourriez rencontrer des problèmes avec les mots de passe sudo dans Ansible. Dans cette étape, nous allons explorer les problèmes courants et leurs solutions.

Problèmes courants de mot de passe Sudo

Voici quelques problèmes courants que vous pourriez rencontrer lors de l'utilisation de sudo avec Ansible :

Mot de passe sudo manquant : Ansible ne trouve pas le mot de passe sudo pour exécuter les commandes privilégiées.
Mot de passe sudo incorrect : Le mot de passe sudo fourni est incorrect.
Problèmes de configuration Sudo : L'utilisateur cible n'a pas les autorisations sudo correctes.
Sudo nécessite un TTY : Certains systèmes nécessitent qu'un TTY soit alloué pour les commandes sudo.

Explorons chacun de ces problèmes et leurs solutions.

Création d'un environnement problématique pour les tests

Pour mieux comprendre ces problèmes, créons un scénario où sudo nécessite un TTY. Modifiez le fichier sudoers pour notre utilisateur de test :

sudo cp /etc/sudoers.d/ansible_test /etc/sudoers.d/ansible_test.bak
echo 'Defaults:ansible_test requiretty' | sudo tee -a /etc/sudoers.d/ansible_test

Cette configuration fait que sudo exige un TTY lorsque l'utilisateur ansible_test exécute des commandes sudo, ce qui peut causer des problèmes avec Ansible.

Création d'un playbook de dépannage

Créez un nouveau playbook nommé troubleshoot_sudo.yml qui inclut quelques techniques courantes de dépannage sudo :

---
- name: Troubleshoot sudo issues
  hosts: localhost
  become: true
  become_method: sudo
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Check sudo version
      command: sudo --version
      register: sudo_version
      become: false

    - name: Print sudo version
      debug:
        msg: "{{ sudo_version.stdout_lines[0] }}"
      become: false

    - name: Check sudo configuration
      command: sudo -l
      register: sudo_config
      become: false
      failed_when: false

    - name: Print sudo configuration
      debug:
        msg: "{{ sudo_config.stdout_lines }}"
      become: false
      when: sudo_config.rc == 0

    - name: Test sudo command with pty
      command: apt update
      register: sudo_test
      failed_when: false
      vars:
        ansible_become_flags: "-H"

    - name: Print sudo test result
      debug:
        msg: "Sudo command {{ 'succeeded' if sudo_test.rc == 0 else 'failed' }}"

Enregistrez ce fichier sous ~/project/ansible-sudo-lab/troubleshoot_sudo.yml

Exécution du playbook de dépannage

Exécutez le playbook de dépannage :

ansible-playbook -i inventory troubleshoot_sudo.yml -K

Puisque nous exécutons en tant qu'utilisateur labex qui a sudo sans mot de passe, le playbook devrait s'exécuter avec succès.

Solutions courantes aux problèmes de mot de passe Sudo

Voici les solutions aux problèmes courants de mot de passe sudo :

1. Mot de passe sudo manquant

Si Ansible échoue avec un message tel que "Missing sudo password", vous pouvez :

Utiliser l'option -K pour demander le mot de passe sudo
Définir la variable ansible_become_password dans votre inventaire ou playbook
Utiliser Ansible Vault pour stocker et fournir en toute sécurité le mot de passe sudo

2. Mot de passe sudo incorrect

Si le mot de passe sudo est incorrect :

Vérifiez le mot de passe que vous fournissez
Vérifiez que le mot de passe de l'utilisateur n'a pas expiré ou été modifié
Vérifiez si la configuration sudo a été modifiée sur le système cible

3. Problèmes de configuration Sudo

Si l'utilisateur n'a pas les autorisations sudo correctes :

Vérifiez le fichier sudoers sur le système cible
Vérifiez que l'utilisateur est dans les groupes corrects
Utilisez sudo -l pour vérifier les privilèges sudo de l'utilisateur

4. Sudo nécessite un TTY

Si sudo nécessite un TTY :

Ajoutez ansible_become_flags: "-H" à votre playbook ou inventaire
Modifiez le fichier sudoers pour supprimer l'option requiretty
Utilisez l'option pty: true dans vos tâches

Restaurer la configuration Sudo d'origine

Restaurons la configuration sudo d'origine pour notre utilisateur de test :

sudo cp /etc/sudoers.d/ansible_test.bak /etc/sudoers.d/ansible_test
sudo rm /etc/sudoers.d/ansible_test.bak

Cela supprime l'option requiretty que nous avons ajoutée précédemment.

Résumé

Dans ce lab, vous avez appris à gérer les mots de passe sudo dans les playbooks Ansible, un défi courant pour de nombreux administrateurs et ingénieurs DevOps. Voici un résumé de ce que vous avez accompli :

Vous avez installé Ansible et créé un playbook de base qui utilise les privilèges sudo
Vous avez appris différentes méthodes pour fournir des mots de passe sudo aux playbooks Ansible
Vous avez utilisé Ansible Vault pour stocker et gérer en toute sécurité les informations sensibles
Vous avez exploré les problèmes courants de mot de passe sudo et appris à les dépanner

Ces compétences vous aideront à créer des playbooks Ansible plus sécurisés et fiables, capables de gérer diverses configurations sudo dans différents environnements.

Points clés à retenir de ce lab :

Utilisez toujours des méthodes sécurisées comme Ansible Vault pour stocker les informations sensibles
Comprenez les différentes façons de fournir des mots de passe sudo à Ansible
Sachez comment dépanner les problèmes courants de mot de passe sudo
Suivez les meilleures pratiques pour la gestion des mots de passe sudo dans Ansible

Grâce à ces compétences, vous pouvez désormais utiliser Ansible en toute confiance pour les tâches qui nécessitent des privilèges élevés, en vous assurant que votre automatisation s'exécute de manière fluide et sécurisée.

Résoudre les problèmes de mot de passe Sudo manquant dans Ansible