Ansible Ubuntu · 12 min read · Dec 20, 2025

Comment installer et configurer Ansible sur Ubuntu 22.04

Ansible est un outil de gestion de configuration très populaire conçu pour rationaliser le processus de contrôle d’un grand nombre de serveurs. Il peut automatiser le processus de configuration de nouveaux serveurs et d’installation d’applications avec une seule commande ou un seul fichier. Vous pouvez contrôler autant de serveurs et exécuter des processus sur eux simultanément depuis un seul nœud. Ansible ne nécessite aucun logiciel spécial à installer sur les nœuds du serveur et peut les contrôler via SSH.

Dans ce guide, nous allons apprendre à installer et configurer Ansible sur un serveur Ubuntu 22.04.

Prérequis

  • Deux systèmes serveurs ou plus exécutant Ubuntu 22.04 avec le serveur OpenSSH installé.
  • Les serveurs et les nœuds sont accessibles via des adresses IP publiques.
  • Un utilisateur non-root avec des privilèges sudo est configuré sur le serveur Ansible et un utilisateur root avec un mot de passe est configuré sur les clients Ansible.

Étape 1 - Installer Ansible

Nous allons utiliser le dépôt officiel d’Ansible pour installer sa dernière version. Ajoutez le dépôt officiel d’Ansible au serveur.

$ sudo add-apt-repository ppa:ansible/ansible

Heureusement, Ubuntu est livré avec Ansible 2.9, qui est ce que nous allons installer. Exécutez la commande suivante pour installer Ansible.

$ sudo apt install ansible -y

Testez votre installation en exécutant la commande suivante.

$ ansible --version
ansible [core 2.13.3rc1]
  fichier de configuration = /etc/ansible/ansible.cfg
  chemin de recherche des modules configurés = ['/home/navjot/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  emplacement du module python ansible = /usr/lib/python3/dist-packages/ansible
  emplacement de la collection ansible = /home/navjot/.ansible/collections:/usr/share/ansible/collections
  emplacement exécutable = /usr/bin/ansible
  version python = 3.10.4 (main, 29 juin 2022, 12:14:53) [GCC 11.2.0]
  version jinja = 3.0.3
  libyaml = True

Installez et activez le package python3-argcomplete pour configurer le support de complétion bash d’Ansible.

$ sudo apt install python3-argcomplete
$ sudo activate-global-python-argcomplete3

Vous pouvez maintenant appuyer sur la touche Tab pour obtenir une liste d’options pour le shell bash.

Étape 2 - Configuration du fichier d’inventaire

Pour pouvoir se connecter à plusieurs hôtes, vous avez besoin d’un fichier qui enregistrera les détails des nœuds. Ce fichier s’appelle le fichier d’inventaire.

En fonction du nombre de serveurs que vous souhaitez contrôler, le fichier d’inventaire d’Ansible vous permet également de les organiser en groupes et sous-groupes. Vous pouvez également définir des variables personnalisées applicables à des hôtes ou groupes sélectionnés qui peuvent être utilisées ultérieurement lors de la transmission des instructions.

Ansible est livré avec un fichier d’inventaire par défaut disponible à /etc/ansible/hosts. Ouvrez-le avec l’éditeur Nano.

$ sudo nano /etc/ansible/hosts

Collez le code suivant au bas du fichier.

[servers]
server1 ansible_host=203.0.113.111
server2 ansible_host=203.0.113.112
server3 ansible_host=203.0.113.113

[all:vars]
ansible_python_interpreter=/usr/bin/python3

La section servers définit la liste des nœuds auxquels vous souhaitez vous connecter. Vous pouvez créer autant de groupes pour organiser les serveurs en plusieurs groupes.

Le groupe all:vars définit le paramètre ansible_python_interpreter sur tous les hôtes de l’inventaire. Cela garantit qu’Ansible utilise l’exécutable Python 3 au lieu de Python 2, qui a été supprimé des versions récentes d’Ubuntu.

Lorsque vous avez terminé, enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité pour confirmer vos modifications.

Remarque : Vous pouvez également créer votre fichier d’inventaire à n’importe quel emplacement de votre choix que vous pouvez ensuite passer en utilisant le paramètre -i lors de l’exécution des commandes Ansible.

Vous pouvez vérifier votre liste d’inventaire avec la commande suivante.

$ ansible-inventory --list -y
all:
  children:
    servers:
      hosts:
        server1:
          ansible_host: 203.0.113.111
          ansible_python_interpreter: /usr/bin/python3
        server2:
          ansible_host: 203.0.113.112
          ansible_python_interpreter: /usr/bin/python3
        server3:
          ansible_host: 203.0.113.113
          ansible_python_interpreter: /usr/bin/python3
    ungrouped: {}

Organisation des serveurs en groupes et sous-groupes

C’est un conseil utile si vous avez beaucoup de serveurs avec certains serveurs effectuant des fonctions spécifiques. Par exemple, vous pouvez utiliser cette méthode pour regrouper les serveurs web et les serveurs de base de données séparément. Vous pouvez même faire partie d’un hôte de plusieurs groupes. Pour y parvenir, votre fichier d’inventaire devrait ressembler à ceci.

[webservers]
203.0.113.111
203.0.113.112

[dbservers]
203.0.113.113
server_hostname

[development]
203.0.113.111
203.0.113.113

[production]
203.0.113.112
server_hostname

Étape 3 - Configurer les clés SSH

Pour qu’Ansible puisse se connecter aux serveurs, vous devez configurer des clés SSH entre votre serveur Ansible et les hôtes spécifiés dans le fichier d’inventaire. Cela ne fonctionnera que si les clients Ansible n’ont pas de clé publique activée et ont un compte root activé avec un mot de passe.

Utilisez les étapes suivantes pour créer et configurer une clé SSH pour Ansible et ses nœuds.

Créez la clé pour Ansible.

$ ssh-keygen -t rsa -b 4096 -C "Clé Ansible"

Copiez la clé publique sur vos comptes sur les serveurs distants. Pour cela, nous utiliserons la commande ssh-copy-id.

$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]

C’est tout. Maintenant, Ansible devrait être capable de communiquer avec vos serveurs.

Configurer les clés SSH sur les nœuds avec une clé publique existante

Si les clients ont déjà des clés publiques activées, vous devrez suivre certaines étapes supplémentaires. Pour cela, vous devez créer un nouvel utilisateur accessible uniquement par Ansible sur chaque serveur nœud. Cet utilisateur aura des privilèges sudo accessibles sans mot de passe et pourra être accessible uniquement depuis votre serveur Ansible.

Pour créer un utilisateur ansible, exécutez la commande suivante.

$ sudo adduser ansible

Choisissez un mot de passe fort et laissez tous les autres champs vides.

Maintenant, configurez l’accès sudo sans mot de passe pour cet utilisateur via la commande suivante.

$ echo "ansible ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/ansible

Maintenant que vous avez ajouté et configuré le nouvel utilisateur, vous pouvez copier la clé SSH de votre serveur Ansible vers le serveur nœud en utilisant la commande suivante.

$ ssh-copy-id [email protected]

Vous serez invité à entrer le mot de passe pour l’utilisateur ansible. Entrez-le et la clé SSH sera copiée.

Ensuite, désactivez la connexion par mot de passe pour l’utilisateur ansible sur le serveur nœud.

$ sudo usermod -L ansible

Maintenant, votre serveur nœud n’est accessible que depuis le serveur Ansible, car seul ce serveur a la clé publique pour celui-ci et vous ne pouvez pas l’utiliser avec des privilèges sudo sur le serveur nœud directement, car la connexion par mot de passe est désactivée.

Vous devrez répéter ces étapes pour chaque serveur nœud. De plus, remplacez l’utilisateur root par l’utilisateur ansible dans ce tutoriel.

Étape 4 - Tester la connexion

Après avoir configuré le fichier d’inventaire et les clés SSH, nous devrions vérifier si Ansible peut se connecter aux serveurs.

Tapez la commande suivante pour vérifier la connexion. Cette commande testera la connexion à tous les serveurs du fichier d’inventaire.

$ ansible all -m ping -u root

Cette commande utilise le module ping d’Ansible pour exécuter un test de connectivité sur tous les serveurs. Vous devriez obtenir une sortie comme suit.

server1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
server3 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Si c’est la première fois que vous utilisez Ansible, vous serez invité à confirmer l’authenticité de tous les serveurs. Lorsque vous y êtes invité, tapez yes et appuyez sur ENTER pour confirmer.

Étape 5 - Exécuter quelques commandes de base

Exécutons quelques commandes de base sur les serveurs en utilisant Ansible. Pour exécuter une commande sur le serveur, le format suivant est utilisé.

$ ansible all -a "commande" -u

Vérifier l’utilisation du disque

Tout d’abord, vérifions l’utilisation du disque sur tous nos serveurs.

$ ansible all -a "df -h" -u root
server1 | CHANGED | rc=0 >>
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           198M  972K  197M   1% /run
/dev/sda2        50G  3.9G   44G   9% /
tmpfs           989M     0  989M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           198M  4.0K  198M   1% /run/user/1000

server2 | CHANGED | rc=0 >>
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           198M  922K  197M   1% /run
/dev/sda2        50G  4.9G   43G  10% /
tmpfs           989M     0  989M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           198M  4.0K  198M   1% /run/user/1000

Cibler des hôtes et des groupes individuels

Jusqu’à présent, nous avons exécuté des commandes sur tous les serveurs distants à la fois. Mais ce n’est pas toujours le cas. Pour exécuter une commande sur un seul serveur, vous devez utiliser le format suivant.

$ ansible server1 -a "uptime" -u root
server1 | CHANGED | rc=0 >>
 21:38:26 up 11 min,  2 users,  load average: 0.00, 0.20, 0.19

La commande ci-dessus vérifie le temps de fonctionnement sur server1 depuis le groupe d’inventaire.

Vous pouvez également cibler plusieurs serveurs en utilisant le format suivant.

$ ansible server1:server2 -m ping -u root

Vous pouvez également cibler des groupes ou des sous-groupes directement à partir du fichier d’inventaire.

$ ansible groupname -m ping -u

Mettre à jour tous les serveurs

Pour ce tutoriel, nous supposons que tous les serveurs distants exécutent un système d’exploitation Debian ou Ubuntu.

Exécutez la commande suivante pour mettre à jour le logiciel sur tous vos serveurs.

$ ansible all -m apt -a "update_cache=yes upgrade=yes" -u root

Le paramètre -m définit le module qu’Ansible doit exécuter. Le paramètre -a fait référence aux arguments ou commandes pour le module associé. Ici, nous utilisons le module apt d’Ansible pour mettre à jour les serveurs tout comme nous avons utilisé le module ping dans notre dernier exemple. Le update_cache met à jour le cache APT sur le serveur et upgrade=yes indique à Ansible d’exécuter la commande apt upgrade.

Si vous utilisez l’utilisateur ansible comme documenté ci-dessus, vous devez modifier la commande ansible pour qu’elle s’exécute avec des privilèges sudo élevés.

$ ansible server2 -m apt -a "update_cache=yes upgrade=yes" -K -b -u ansible

Ici, -K demande un mot de passe d’escalade de privilèges. -b exécute l’opération ansible avec become, ce qui vous permet d’être un autre utilisateur. Les deux variables combinées permettent à ansible de s’exécuter avec des privilèges sudo élevés. Vous devrez utiliser cela pour toutes les commandes qui nécessitent des privilèges sudo.

Parfois, certaines de ces commandes de mise à jour peuvent nécessiter un redémarrage, alors exécutez la commande suivante pour redémarrer tous vos serveurs.

$ ansible all -a "reboot" -u root

Ce ne sont là que quelques-unes des commandes de base que vous pouvez exécuter en utilisant Ansible.

Étape 6 - Introduction aux Playbooks

Les commandes ci-dessus vous permettent d’exécuter des tâches ponctuelles, mais si vous souhaitez configurer plusieurs serveurs ou exécuter la même séquence de commandes sur plusieurs serveurs, vous devez configurer des playbooks. Les playbooks sont des fichiers écrits en YAML et contiennent des instructions pour automatiser une séquence de tâches pour configurer des applications et des services.

Nous allons maintenant créer un playbook pour installer Nginx et configurer une page HTML sur le nœud Ansible. Créez un répertoire pour Ansible dans votre répertoire personnel.

$ mkdir ~/ansible

Créez et ouvrez le fichier de playbook pour l’édition.

$ cd ~/ansible
$ nano testplaybook.yml

Les playbooks utilisent le format YAML pour définir une ou plusieurs plays. Une play est un ensemble de tâches ordonnées disposées de manière à automatiser un processus. Les plays sont définies comme une liste YAML.

La première étape pour définir une play est de déterminer quels hôtes sont la cible en utilisant la directive hosts: all. La directive become est utilisée pour indiquer que les tâches suivantes doivent être exécutées par un super utilisateur.

Nous allons définir trois tâches : une pour ajouter un utilisateur, une pour mettre à niveau tous les packages, et la dernière pour installer le serveur Nginx. La section vars du playbook est utilisée pour définir des variables personnalisées. Nous définissons deux variables, une pour l’utilisateur que nous devons ajouter, et la seconde pour définir l’état du package que nous devons installer. Pour utiliser la variable, nous devons entourer le nom de la variable entre doubles accolades.

Le module ansible.builtin.user est utilisé pour ajouter un nouvel utilisateur avec des privilèges sudo. Pour ajouter l’utilisateur, nous utilisons les variables name, password et group. La variable group est définie sur sudo pour donner des permissions de super utilisateur à l’utilisateur. Vous ne pouvez pas mettre le mot de passe en texte clair dans le fichier de playbook, par conséquent, nous ajouterons un secret haché SHA. Nous utiliserons l’utilitaire mkpasswd pour cela. Pour l’installer, exécutez la commande suivante pour installer le package whois.

$ sudo apt install whois

Générez le mot de passe haché. On vous demandera le mot de passe habituel et vous obtiendrez une chaîne hachée pour cela. Notez la clé hachée à utiliser dans le fichier de playbook.

$ mkpasswd --method=sha-512
Password:
$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1

La directive update_cache est pour mettre à jour la liste des dépôts du système tout comme la commande apt update et la directive upgrade: dist indique à Ansible d’effectuer la mise à niveau du système. La troisième tâche est explicite qui installe la dernière version du serveur Nginx.

En fonction des informations que nous avons discutées, collez le code suivant dans le fichier. Collez la clé hachée que vous avez obtenue comme valeur pour la variable password.

---
- name: Test playbook
  hosts: all
  become: true
  vars:
      state: latest
      user: navjot
  tasks:
  - name: Add the user {{ user }}
    ansible.builtin.user:
      name: "{{ user }}"
      password: '$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1'
      group: sudo
  - name: Upgrade all apt packages
    apt:
      update_cache: yes
      upgrade: dist
  - name: Install the {{ state }} of package "nginx"
    apt:
      name: "nginx"
      state: "{{ state }}"

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité pour confirmer vos modifications.

Pour exécuter le playbook, exécutez la commande suivante. Le drapeau --ask-become-pass demandera votre mot de passe root pour effectuer une opération élevée.

$ ansible-playbook testplaybook.yml --ask-become-pass

Vous obtiendrez la sortie suivante.

BECOME password:

PLAY [Test playbook] *************************************************************************************************

TASK [Gathering Facts] *********************************************************************************************
ok: [server1]
ok: [server2]
ok: [server3]

TASK [Add the user casablanca] *************************************************************************************
changed: [server3]
changed: [server2]
changed: [server1]

TASK [Upgrade all apt packages] ************************************************************************************
changed: [server1]
changed: [server2]
changed: [server3]

TASK [Install the latest of package "nginx"] ***********************************************************************
changed: [server3]
changed: [server2]
changed: [server1]

PLAY RECAP ***********************************************************************************************************
server1                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
server2                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
server3                    : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Cela confirme que votre playbook a été exécuté avec succès.

Si vous utilisez un fichier d’inventaire personnalisé, vous devez inclure l’emplacement du fichier dans la commande comme suit.

$ ansible-playbook -i /etc/ansible/custominventory testplaybook.yml --ask-become-pass

Conclusion

Cela conclut notre tutoriel sur l’installation et la configuration d’Ansible sur le serveur Ubuntu 22.04. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Share: X/Twitter LinkedIn
#Ansible Ubuntu

Recevez de nouveaux articles dans votre boîte de réception.

Aucun spam. Désabonnez-vous à tout moment.