Les modules Ansible pour gérer les packages

Mise à jour : 16/09/2024

La gestion des packages est une tâche essentielle pour tout administrateur système. Que ce soit pour installer de nouvelles applications, maintenir les logiciels à jour où désinstaller des programmes obsolètes, l’utilisation de gestionnaires de paquets est incontournable sur toutes les distributions Linux. Cependant, lorsque l’on administre plusieurs serveurs, cette gestion peut vite devenir fastidieuse si elle est réalisée manuellement. C’est là qu’Ansible intervient.

Dans ce guide, je vais vous montrer comment tirer parti des différents modules Ansible pour automatiser la gestion des packages. Vous découvrirez comment installer, mettre à jour ou encore supprimer des logiciels sur vos systèmes, le tout en utilisant des playbooks simples et efficaces. Pas besoin d’avoir une connaissance préalable de l’installation d’Ansible : nous allons nous concentrer uniquement sur l’utilisation des modules pour la gestion des packages.

Ansible propose une approche simple et efficace pour gérer les packages sur une variété de systèmes d’exploitation. Le concept de base est de définir une série de tâches dans un playbook, où chaque tâche utilise un module Ansible pour accomplir une action spécifique. Lorsqu’il s’agit de gestion des packages, Ansible dispose de plusieurs modules qui correspondent aux différents gestionnaires de paquets natifs des systèmes d’exploitation (comme apt pour Debian, yum pour Red Hat, etc.).

Utilisation du module `package` pour la gestion des packages multiplateforme

Le module ansible.builtin.package est un module générique qui permet de gérer les packages sur différentes distributions sans se soucier du gestionnaire de paquets spécifique à chaque système d’exploitation. Cela signifie que vous n’avez pas besoin de spécifier explicitement des modules comme apt, yum, dnf, ou pacman dans vos playbooks. Le module package se charge automatiquement d’utiliser le bon gestionnaire de paquets en fonction de la distribution de la machine cible. Il est particulièrement utile dans des environnements hétérogènes où vous devez gérer des serveurs avec des systèmes d’exploitation différents (Debian, Red Hat, Arch, etc.).

Le module package fonctionne comme une interface unifiée pour tous les gestionnaires de paquets. Il offre les mêmes fonctionnalités que les modules spécifiques à chaque distribution, à savoir l’installation, la mise à jour, ou la suppression de packages. Ce module vous permet d’écrire des playbooks plus génériques et simplifie la gestion des packages lorsque vous ne voulez pas vous soucier de la distribution sous-jacente.

Limites du module `package`

Bien que le module package soit très utile pour simplifier la gestion des packages dans des environnements multiplateformes, il présente quelques limitations :

Il ne permet pas de gérer des fonctionnalités avancées propres à chaque gestionnaire de paquets (comme les groupes de packages avec yum ou dnf, ou la gestion des dépôts avec apt).
Il peut ne pas être idéal dans des situations où vous avez besoin de fine-tuning ou de fonctionnalités spécifiques à un gestionnaire de paquets particulier. Dans ces cas, il est préférable d’utiliser les modules spécifiques (apt, yum, dnf, pacman) pour un meilleur contrôle.

Installation d’un package avec le module `package`

Voici un exemple d’installation du package git avec le module package. Ce même playbook fonctionnera sur une machine Debian, Red Hat, ou Arch Linux, en utilisant le gestionnaire de paquets approprié à la distribution (APT, YUM, DNF, Pacman, etc.).

---
- name: Installer un package avec package
  hosts: all
  tasks:
    - name: Installer git
      ansible.builtin.package:
        name: git
        state: present

Dans cet exemple, le module package détecte automatiquement le gestionnaire de paquets à utiliser en fonction du système d’exploitation. Sur une machine Debian, il utilisera apt ; sur une machine Red Hat, il utilisera yum ou dnf, et ainsi de suite.

Si vous souhaitez traiter plusieurs packages dans une seule tâche, n’utilisez pas de boucles loop ou with_items, cela rallonge le temps d’exécution de votre playbook. Le paramêtre name est une list :

---
- name: Installer plusieurs packages avec package
  hosts: serveur_debian
  tasks:
    - name: Installer git et vim
      ansible.builtin.package:
        name:
          - git
          - vim
        state: present

Mise à jour d’un package avec le module `package`

Vous pouvez également mettre à jour un package à sa dernière version disponible en utilisant state: latest. Voici un exemple pour mettre à jour git à la dernière version :

---
- name: Mettre à jour un package avec package
  hosts: all
  tasks:
    - name: Mettre à jour git
      ansible.builtin.package:
        name: git
        state: latest

Dans cet exemple, quel que soit le système d’exploitation, le package git sera mis à jour à sa version la plus récente, en fonction des dépôts configurés pour la distribution.

Suppression d’un package avec le module `package`

Comme avec les autres modules de gestion de paquets, vous pouvez utiliser package pour désinstaller des logiciels. Voici un exemple pour supprimer nginx :

---
- name: Supprimer un package avec package
  hosts: all
  tasks:
    - name: Supprimer nginx
      ansible.builtin.package:
        name: nginx
        state: absent

Le package nginx sera désinstallé quel que soit le système, en utilisant le gestionnaire de paquets adéquat.

Gérer les packages sur les systèmes basés sur Debian avec les modules APT

En plus de gérer les packages, le module ansible.builtin.apt permet de gérer les dépôts de packages sur les systèmes basés sur Debian et Ubuntu. La gestion des dépôts est essentielle, car elle vous permet de définir où Ansible doit chercher les packages à installer ou à mettre à jour. Par défaut, Debian et Ubuntu utilisent des dépôts officiels, mais il est souvent nécessaire d’ajouter des dépôts tiers pour accéder à des logiciels plus récents ou non disponibles dans les dépôts standards.

Pour cela, Ansible fournit le module ansible.builtin.apt_repository, qui permet d’ajouter, supprimer ou configurer des dépôts externes. Ce module simplifie l’ajout de sources de logiciels, souvent combiné avec l’ajout de clés GPG pour vérifier l’authenticité des packages provenant de ces dépôts.

Gérer les clés GPG associées aux dépôts

Lorsque vous ajoutez un dépôt tiers, il est souvent nécessaire d’importer sa clé GPG afin de vérifier l’authenticité des packages téléchargés. Ansible gère cela via le module ansible.builtin.apt_key, qui permet d’ajouter des clés GPG au système. Voici comment ajouter la clé GPG pour Docker :

---
- name: Ajouter la clé GPG pour le dépôt Docker
  hosts: serveur_debian
  tasks:
    - name: Ajouter la clé GPG pour Docker
      ansible.builtin.apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

Ici, la clé GPG est téléchargée depuis l’URL spécifiée et installée sur le système pour garantir que les packages provenant du dépôt Docker sont vérifiés et authentifiés.

Ajouter un dépôt de packages

Lorsque vous souhaitez installer des logiciels depuis un dépôt tiers, il est nécessaire d’ajouter ce dépôt au système. Voici un exemple pour ajouter le dépôt officiel de Docker sur un système Ubuntu :

---
- name: Ajouter le dépôt Docker
  hosts: serveur_debian
  tasks:
    - name: Ajouter le dépôt officiel Docker
      ansible.builtin.apt_repository:
        repo: "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
        state: present

Dans cet exemple, j’utilise le module ansible.builtin.apt_repository pour ajouter le dépôt Docker à la liste des sources de packages de la machine. Le paramètre repo spécifie l’URL du dépôt et son architecture, et state: present assure que le dépôt est bien ajouté. Si le dépôt est déjà présent, Ansible ne fait rien, ce qui garantit un comportement idempotent.

Suppression d’un dépôt de packages

Il peut arriver que vous deviez supprimer un dépôt, par exemple si un dépôt tiers n’est plus nécessaire ou si vous migrez vers une autre source. Voici un exemple pour retirer un dépôt précédemment ajouté :

---
- name: Supprimer un dépôt tiers
  hosts: serveur_debian
  tasks:
    - name: Supprimer le dépôt Docker
      ansible.builtin.apt_repository:
        repo: "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
        state: absent

Ce playbook utilise state: absent pour retirer le dépôt Docker du système. Une fois supprimé, les packages provenant de ce dépôt ne pourront plus être mis à jour, et Ansible ne tentera plus de l’utiliser lors des installations de logiciels.

Mettre à jour le cache APT

Après avoir ajouté ou supprimé des dépôts, il est important de mettre à jour le cache APT pour que le système prenne en compte les modifications des sources de packages. Cela garantit que les nouveaux packages disponibles dans les dépôts sont correctement référencés et prêts à être installés. Voici comment rafraîchir le cache avec Ansible :

---
- name: Mettre à jour le cache des dépôts
  hosts: serveur_debian
  tasks:
    - name: Rafraîchir le cache APT
      ansible.builtin.apt:
        update_cache: yes

Ce playbook utilise l’option update_cache: yes pour forcer la mise à jour du cache APT après toute modification des dépôts.

Lors de l’installation de certains packages via apt, les services associés démarrent souvent automatiquement par défaut. Cela peut poser des problèmes si vous souhaitez configurer ou tester ces services avant qu’ils ne soient opérationnels. Pour empêcher ce démarrage automatique, vous pouvez utiliser le paramètre rc_policy_d dans le module ansible.builtin.apt.

Voici un exemple pour installer nginx tout en empêchant son démarrage automatique :

---
- name: Installer nginx sans démarrage automatique
  hosts: serveur_debian
  tasks:
    - name: Installer nginx avec la politique rc_policy
      ansible.builtin.apt:
        name: nginx
        state: present
        rc_policy_d: 101

Dans cet exemple, le paramètre rc_policy_d: 101 désactive le démarrage automatique du service nginx après son installation. Cela vous permet d’installer le package sans risquer que le service soit lancé avant que vous ayez configuré ou personnalisé le serveur. Vous pouvez ensuite démarrer le service manuellement une fois que tout est en place :

- name: Démarrer le service nginx manuellement
  ansible.builtin.service:
    name: nginx
    state: started

Ce petit tip est particulièrement utile pour les services critiques que vous souhaitez configurer avant leur lancement ou la construction d’images avec Packer.

Gérer les dépôts de packages avec le module DNF

Sur les systèmes basés sur Red Hat, CentOS et Fedora, le gestionnaire de paquets dnf (Dandified YUM) est utilisé pour installer et mettre à jour les logiciels. En plus de gérer les packages, le module ansible.builtin.dnf permet de gérer les dépôts de packages, ce qui est essentiel pour contrôler l’origine des logiciels installés sur le système. La gestion des dépôts avec dnf est similaire à celle effectuée avec yum, l’ancien gestionnaire de paquets. Toutefois, dnf apporte des améliorations en termes de gestion des dépendances et de performance.

Ansible fournit le module ansible.builtin.yum_repository pour ajouter, supprimer et configurer des dépôts externes dans dnf, tout comme il le faisait pour yum.

Ajouter un dépôt de packages

Pour installer des logiciels à partir de dépôts tiers, il est souvent nécessaire d’ajouter ces dépôts à la configuration du gestionnaire de paquets. Voici un exemple pour ajouter le dépôt officiel de Docker sur un système CentOS 8 ou Fedora :

---
- name: Ajouter le dépôt Docker
  hosts: serveur_redhat
  tasks:
    - name: Ajouter le dépôt Docker pour CentOS 8 ou Fedora
      ansible.builtin.yum_repository:
        name: docker-ce
        description: "Docker CE Stable - x86_64"
        baseurl: https://download.docker.com/linux/centos/8/x86_64/stable
        gpgcheck: yes
        gpgkey: https://download.docker.com/linux/centos/gpg
        enabled: yes
        state: present

Dans cet exemple, le module ansible.builtin.yum_repository est utilisé pour ajouter le dépôt docker-ce. Le paramètre baseurl définit l’URL du dépôt, et gpgcheck: yes active la vérification de la clé GPG pour garantir l’intégrité des packages. L’option enabled: yes active ce dépôt pour l’installation des packages.

Ajouter la clé GPG associée

Comme pour apt, les dépôts dnf nécessitent souvent une clé GPG pour vérifier les packages téléchargés. Cela peut être géré via l’option gpgkey dans yum_repository. Si vous devez importer manuellement une clé GPG, vous pouvez utiliser ansible.builtin.rpm_key pour ajouter la clé avant de configurer le dépôt.

Voici un exemple pour ajouter la clé GPG manuellement pour Docker :

---
- name: Ajouter la clé GPG pour Docker
  hosts: serveur_redhat
  tasks:
    - name: Ajouter la clé GPG Docker
      ansible.builtin.rpm_key:
        state: present
        key: https://download.docker.com/linux/centos/gpg

Ce playbook utilise ansible.builtin.rpm_key pour télécharger et installer la clé GPG depuis l’URL spécifiée.

Suppression d’un dépôt de packages

Si un dépôt tiers n’est plus nécessaire, il peut être facilement supprimé. Voici un exemple pour retirer le dépôt Docker d’un système CentOS ou Fedora :

---
- name: Supprimer un dépôt de packages
  hosts: serveur_redhat
  tasks:
    - name: Supprimer le dépôt Docker
      ansible.builtin.yum_repository:
        name: docker-ce
        state: absent

Dans cet exemple, le dépôt docker-ce est supprimé du système en utilisant state: absent. Après cette suppression, les packages provenant de ce dépôt ne seront plus disponibles pour l’installation ou la mise à jour.

Mise à jour des métadonnées DNF

Après avoir ajouté, supprimé ou modifié des dépôts, il est nécessaire de mettre à jour les métadonnées DNF afin que le système prenne en compte les nouveaux dépôts et packages disponibles. Voici comment rafraîchir les métadonnées avec Ansible :

---
- name: Mettre à jour le cache DNF
  hosts: serveur_redhat
  tasks:
    - name: Rafraîchir les métadonnées des dépôts
      ansible.builtin.dnf:
        update_cache: yes

Ce playbook utilise update_cache: yes pour rafraîchir les métadonnées des dépôts, garantissant ainsi que les nouveaux packages ou mises à jour des dépôts sont disponibles pour les installations futures.

Gérer les dépôts multiples

Si vous gérez plusieurs dépôts tiers, vous pouvez les ajouter tous en une seule fois dans un playbook. Voici un exemple où nous ajoutons les dépôts EPEL et Remi, souvent utilisés sur les systèmes Red Hat et CentOS pour accéder à des versions plus récentes de logiciels :

---
- name: Ajouter plusieurs dépôts tiers
  hosts: serveur_redhat
  tasks:
    - name: Ajouter le dépôt EPEL
      ansible.builtin.yum_repository:
        name: epel
        description: "Extra Packages for Enterprise Linux"
        baseurl: https://dl.fedoraproject.org/pub/epel/$releasever/Everything/x86_64
        gpgcheck: yes
        gpgkey: https://dl.fedoraproject.org/pub/epel/RPM-GPG-KEY-EPEL-$releasever
        enabled: yes
        state: present

    - name: Ajouter le dépôt Remi
      ansible.builtin.yum_repository:
        name: remi
        description: "Remi's RPM repository"
        baseurl: http://rpms.remirepo.net/enterprise/$releasever/remi/x86_64/
        gpgcheck: yes
        gpgkey: http://rpms.remirepo.net/RPM-GPG-KEY-remi
        enabled: yes
        state: present

Dans cet exemple, deux dépôts, EPEL et Remi, sont ajoutés au système, chacun avec ses propres URL, clé GPG et paramètres. Cela permet d’installer des packages supplémentaires qui ne sont pas disponibles dans les dépôts officiels de Red Hat ou CentOS.

Gérer les dépôts de packages avec le module Pacman

Sur les systèmes basés sur Arch Linux, le gestionnaire de paquets pacman est utilisé pour gérer l’installation, la mise à jour, et la suppression des packages. Contrairement aux gestionnaires de paquets comme dnf ou apt, la gestion des dépôts de packages sur Arch Linux est un peu différente, car pacman ne possède pas d’équivalent direct aux modules comme apt_repository ou yum_repository. Cependant, Ansible permet tout de même de gérer les dépôts de manière simple à travers la gestion des fichiers de configuration et l’édition de /etc/pacman.conf pour ajouter ou supprimer des repositories.

Ajouter un dépôt de packages

Pour ajouter un dépôt sur un système Arch Linux, il faut généralement éditer le fichier de configuration /etc/pacman.conf. Bien qu’il n’existe pas de module dédié à la gestion des dépôts dans pacman, vous pouvez utiliser le module ansible.builtin.blockinfile pour insérer un bloc de configuration dans ce fichier. Voici un exemple pour ajouter le dépôt BlackArch, un dépôt populaire pour les outils de sécurité sur Arch Linux :

---
- name: Ajouter le dépôt BlackArch
  hosts: serveur_arch
  tasks:
    - name: Ajouter la configuration du dépôt BlackArch dans pacman.conf
      ansible.builtin.blockinfile:
        path: /etc/pacman.conf
        block: |
          [blackarch]
          Server = https://mirror.blackarch.org/$repo/os/$arch
        state: present

Dans cet exemple, j’utilise le module ansible.builtin.blockinfile pour ajouter la configuration du dépôt BlackArch dans le fichier /etc/pacman.conf. Cette approche permet de gérer les dépôts en modifiant directement le fichier de configuration de pacman.

Rafraîchir le cache Pacman

Après avoir ajouté un nouveau dépôt, il est indispensable de rafraîchir le cache de pacman afin de prendre en compte les nouveaux packages disponibles dans les dépôts. Voici comment procéder avec Ansible :

---
- name: Mettre à jour le cache Pacman
  hosts: serveur_arch
  tasks:
    - name: Rafraîchir les dépôts
      ansible.builtin.pacman:
        update_cache: yes

Cette tâche utilise le module ansible.builtin.pacman avec l’option update_cache: yes pour forcer le rafraîchissement du cache des dépôts, garantissant ainsi que les packages du nouveau dépôt sont disponibles pour l’installation.

Suppression d’un dépôt de packages

Pour supprimer un dépôt sur Arch Linux, il faut également modifier le fichier /etc/pacman.conf. Voici comment retirer le dépôt BlackArch du fichier de configuration :

---
- name: Supprimer le dépôt BlackArch
  hosts: serveur_arch
  tasks:
    - name: Supprimer la configuration du dépôt BlackArch dans pacman.conf
      ansible.builtin.blockinfile:
        path: /etc/pacman.conf
        block: |
          [blackarch]
          Server = https://mirror.blackarch.org/$repo/os/$arch
        state: absent

Dans cet exemple, j’utilise encore ansible.builtin.blockinfile, mais cette fois avec state: absent pour retirer le dépôt BlackArch du fichier de configuration.

Gérer des dépôts AUR

L’un des aspects uniques d’Arch Linux est l’AUR (Arch User Repository), un dépôt maintenu par la communauté pour les logiciels qui ne sont pas inclus dans les dépôts officiels. Bien que pacman ne gère pas directement l’AUR, vous pouvez utiliser des assistants comme yay pour installer des packages depuis l’AUR.

Voici un exemple d’installation de yay, un gestionnaire de l’AUR, puis d’installation de packages depuis l’AUR :

---
- name: Installer yay et gérer les packages AUR
  hosts: serveur_arch
  tasks:
    - name: Installer yay depuis l'AUR
      ansible.builtin.pacman:
        name: yay
        state: present

    - name: Installer un package depuis l'AUR avec yay
      ansible.builtin.command:
        cmd: yay -Syu google-chrome

Dans cet exemple, j’installe d’abord yay avec pacman, puis j’utilise yay pour installer google-chrome depuis l’AUR via le module ansible.builtin.command.

Gestion des packages Python avec le module `pip`

En plus de gérer les packages système, Ansible permet également de gérer les packages Python à l’aide du module ansible.builtin.pip. Ce module utilise l’outil pip, le gestionnaire de paquets standard pour Python, pour installer, mettre à jour, ou supprimer des packages Python dans des environnements virtuels ou directement sur le système. Cela est particulièrement utile pour déployer et gérer des applications Python sur vos serveurs, tout en garantissant que les dépendances nécessaires sont correctement installées et gérées.

Installation d’un package avec `pip`

Pour installer un package Python avec pip, vous pouvez utiliser le module ansible.builtin.pip de manière similaire aux autres modules de gestion de paquets. Voici un exemple pour installer Flask, un framework web léger pour Python :

---
- name: Installer un package Python avec pip
  hosts: serveur_python
  tasks:
    - name: Installer Flask
      ansible.builtin.pip:
        name: flask
        state: present

Dans cet exemple, Ansible utilise pip pour installer le package Flask. Si Flask est déjà installé, Ansible ne fait rien, garantissant l’idempotence de la tâche.

Installation d’une version spécifique de package

Comme avec les autres gestionnaires de paquets, il peut être important d’installer une version spécifique d’un package Python pour éviter les problèmes de compatibilité. Voici comment installer une version spécifique de Flask :

---
- name: Installer une version spécifique de Flask
  hosts: serveur_python
  tasks:
    - name: Installer Flask version 2.0.0
      ansible.builtin.pip:
        name: flask==2.0.0
        state: present

Dans cet exemple, la version 2.0.0 de Flask sera installée. Cette approche permet de verrouiller une version précise pour garantir que le bon fonctionnement de l’application Python reste stable.

Installation de packages depuis un fichier `requirements.txt`

Dans les environnements Python, il est courant de gérer les dépendances d’un projet dans un fichier requirements.txt. Ce fichier liste tous les packages et leurs versions à installer. Avec Ansible, vous pouvez facilement installer tous les packages définis dans ce fichier :

---
- name: Installer des packages depuis un fichier requirements.txt
  hosts: serveur_python
  tasks:
    - name: Installer les dépendances Python
      ansible.builtin.pip:
        requirements: /path/to/requirements.txt

Dans cet exemple, Ansible lit le fichier requirements.txt et installe tous les packages listés avec leurs versions spécifiques. Cela est particulièrement utile pour gérer des environnements de développement ou de production où toutes les dépendances doivent être précises.

Utilisation de `pip` dans un environnement virtuel

L’une des meilleures pratiques en Python est l’utilisation d’environnements virtuels pour isoler les dépendances de chaque projet. Le module ansible.builtin.pip permet d’installer des packages dans un environnement virtuel en utilisant l’option virtualenv :

---
- name: Installer des packages Python dans un environnement virtuel
  hosts: serveur_python
  tasks:
    - name: Créer et installer dans un virtualenv
      ansible.builtin.pip:
        name: flask
        virtualenv: /path/to/venv
        state: present

Dans cet exemple, Ansible crée ou utilise l’environnement virtuel spécifié par le chemin /path/to/venv et y installe Flask. Cette approche garantit que les dépendances de votre application ne polluent pas l’environnement système global.

Suppression d’un package avec `pip`

Si vous avez besoin de désinstaller un package Python, vous pouvez le faire en définissant state: absent dans le module pip :

---
- name: Supprimer un package Python avec pip
  hosts: serveur_python
  tasks:
    - name: Supprimer Flask
      ansible.builtin.pip:
        name: flask
        state: absent

Cet exemple désinstalle Flask du système ou de l’environnement virtuel si celui-ci est spécifié.

Idempotence

L’idempotence est un concept clé en automatisation avec Ansible. Elle garantit qu’une même action, exécutée plusieurs fois, produit toujours le même résultat, sans effets secondaires imprévus. Cela permet d’exécuter un playbook autant de fois que nécessaire sans provoquer de changements inutiles, ce qui est particulièrement important dans la gestion des packages. L’ajout, la suppression ou la mise à jour de packages doit être parfaitement contrôlé pour garantir la stabilité des systèmes, surtout dans un environnement de production.

L’un des paramètres les plus importants pour assurer l’idempotence est la gestion des versions de packages. Dans certains cas, vous voudrez peut-être installer une version spécifique d’un package, car certaines mises à jour peuvent introduire des changements non souhaités ou des incompatibilités avec vos applications.

Utilisation du paramètre version pour assurer l’idempotence

Lorsqu’il est important que le système utilise une version spécifique d’un package, vous pouvez utiliser le paramètre version dans les modules de gestion des packages. Cela permet de s’assurer que le package ne sera ni mis à jour ni rétrogradé automatiquement à chaque exécution du playbook, préservant ainsi le bon fonctionnement de vos applications qui dépendent de cette version précise.

Sur les systèmes basés sur Debian ou Ubuntu, vous pouvez spécifier une version précise d’un package à installer avec le module apt. Voici un exemple pour installer une version spécifique de nginx :

---
- name: Installer une version spécifique de nginx
  hosts: serveur_debian
  tasks:
    - name: Installer nginx version 1.18.0
      ansible.builtin.apt:
        name: nginx=1.18.0-0ubuntu1
        state: present

Dans cet exemple, Ansible installe exactement la version 1.18.0 de nginx, et s’assure que cette version reste en place lors des prochaines exécutions du playbook. Si une autre version est déjà installée, elle sera rétrogradée ou mise à jour en conséquence.

Exemple avec le module `yum`

Sur les systèmes basés sur Red Hat et CentOS, vous pouvez utiliser le module yum pour installer une version spécifique d’un package. Voici un exemple avec httpd (Apache) :

---
- name: Installer une version spécifique de httpd
  hosts: serveur_redhat
  tasks:
    - name: Installer httpd version 2.4.37
      ansible.builtin.yum:
        name: httpd-2.4.37-21.el8
        state: present

Ici, la version 2.4.37-21 de httpd sera installée. Ansible s’assure que cette version reste en place, même si une nouvelle version est disponible dans les dépôts.

Exemple avec le module `dnf`

De la même manière, sur les systèmes plus récents utilisant dnf, vous pouvez spécifier la version du package à installer :

---
- name: Installer une version spécifique de nginx avec dnf
  hosts: serveur_fedora
  tasks:
    - name: Installer nginx version 1.20.0
      ansible.builtin.dnf:
        name: nginx-1.20.0-1.fc34
        state: present

Cet exemple garantit que la version 1.20.0-1 de nginx est installée et maintenue.

Exemple avec le module `pacman`

Pour Arch Linux, la gestion des versions de packages peut être un peu plus complexe, car pacman fonctionne en rolling release. Toutefois, vous pouvez également verrouiller une version en spécifiant le nom complet du package avec sa version dans un fichier personnalisé ou en utilisant des outils comme yay pour gérer les versions spécifiques depuis l’AUR.

---
- name: Installer une version spécifique de vim sur Arch Linux
  hosts: serveur_arch
  tasks:
    - name: Installer vim version 8.2.3451
      ansible.builtin.pacman:
        name: vim-8.2.3451-1
        state: present

Dans ce cas, vim version 8.2.3451 sera installé et bloqué à cette version, évitant toute mise à jour involontaire.

Importance de la gestion des versions pour les applications critiques

La gestion des versions de packages est particulièrement importante lorsque vos applications dépendent d’une version précise d’une bibliothèque ou d’un serveur. Par exemple :

Une application peut nécessiter une version spécifique de PostgreSQL pour éviter des régressions ou des changements de comportement introduits dans les nouvelles versions.
Une version de nginx peut comporter des modules ou des configurations qui ne sont pas compatibles avec les nouvelles versions.
Une mise à jour de Node.js peut introduire des changements qui cassent la compatibilité avec le code existant.

Dans tous ces cas, utiliser le paramètre version dans les modules Ansible garantit que votre environnement de production reste stable et prévisible. Il est recommandé de documenter clairement les versions utilisées et de tester minutieusement toute mise à jour dans un environnement de pré-production avant de les appliquer en production.

Conclusion

La gestion des packages avec Ansible est un outil puissant pour les administrateurs systèmes qui cherchent à automatiser les tâches de maintenance sur leurs infrastructures. Que vous travailliez sur des systèmes Debian, Red Hat, Fedora, Arch Linux, ou d’autres distributions, Ansible offre une large gamme de modules dédiés permettant de gérer l’installation, la mise à jour, et la suppression des packages de manière simple et efficace. Les modules comme apt, yum, dnf, et pacman fournissent des interfaces spécifiques à chaque gestionnaire de paquets, tandis que le module package permet une approche plus générique et multiplateforme.

Un point central de ce guide est l’importance de l’idempotence, un concept fondamental en automatisation. L’utilisation des version dans les modules de gestion des packages permet de s’assurer que vos serveurs conservent des versions spécifiques de logiciels critiques, assurant ainsi la stabilité et la compatibilité des applications. Cela est particulièrement indispensable dans des environnements de production où des changements inattendus peuvent entraîner des perturbations majeures.

En conclusion, la gestion des packages et des dépôts avec Ansible vous permet d’automatiser des processus qui seraient autrement fastidieux, tout en garantissant la cohérence et la stabilité de vos infrastructures.

Les modules Ansible pour gérer les packages

Utilisation du module package pour la gestion des packages multiplateforme

Limites du module package

Installation d’un package avec le module package

Mise à jour d’un package avec le module package

Suppression d’un package avec le module package

Gérer les packages sur les systèmes basés sur Debian avec les modules APT

Gérer les clés GPG associées aux dépôts

Ajouter un dépôt de packages

Suppression d’un dépôt de packages

Mettre à jour le cache APT

Gérer les dépôts de packages avec le module DNF

Ajouter un dépôt de packages

Ajouter la clé GPG associée

Suppression d’un dépôt de packages

Mise à jour des métadonnées DNF

Gérer les dépôts multiples

Gérer les dépôts de packages avec le module Pacman

Ajouter un dépôt de packages

Rafraîchir le cache Pacman

Suppression d’un dépôt de packages

Gérer des dépôts AUR

Gestion des packages Python avec le module pip

Installation d’un package avec pip

Installation d’une version spécifique de package

Installation de packages depuis un fichier requirements.txt

Utilisation de pip dans un environnement virtuel

Suppression d’un package avec pip

Idempotence

Utilisation du paramètre version pour assurer l’idempotence

Exemple avec le module yum

Exemple avec le module dnf

Exemple avec le module pacman

Importance de la gestion des versions pour les applications critiques

Conclusion

Utilisation du module `package` pour la gestion des packages multiplateforme

Limites du module `package`

Installation d’un package avec le module `package`

Mise à jour d’un package avec le module `package`

Suppression d’un package avec le module `package`

Gestion des packages Python avec le module `pip`

Installation d’un package avec `pip`

Installation de packages depuis un fichier `requirements.txt`

Utilisation de `pip` dans un environnement virtuel

Suppression d’un package avec `pip`

Exemple avec le module `yum`

Exemple avec le module `dnf`

Exemple avec le module `pacman`