Installer Ansible sur Red Hat Enterprise Linux

Introduction

Dans ce laboratoire, vous apprendrez à installer Ansible Core sur un système Red Hat Enterprise Linux (RHEL). Ansible est un puissant outil d'automatisation qui vous permet de gérer et de configurer des systèmes, de déployer des applications et d'orchestrer des flux de travail informatiques complexes.

Vous utiliserez le gestionnaire de paquets dnf avec les privilèges sudo pour installer le paquet ansible-core, qui fournit le moteur Ansible principal ainsi que les outils en ligne de commande. Après l'installation, vous vérifierez le bon fonctionnement d'Ansible en consultant sa version et en exécutant des commandes de base.

Il s'agit d'une compétence fondamentale pour les administrateurs système et les ingénieurs DevOps travaillant avec des systèmes Red Hat Enterprise Linux.

Installer Ansible Core avec dnf

Dans cette étape, vous allez installer le paquet ansible-core à l'aide du gestionnaire de paquets dnf. Ansible Core fournit le moteur Ansible essentiel, incluant ansible, ansible-playbook et d'autres outils en ligne de commande nécessaires aux tâches d'automatisation.

Le gestionnaire de paquets dnf (Dandified YUM) est l'outil standard pour gérer les logiciels sur Red Hat Enterprise Linux. Comme l'installation de logiciels nécessite des privilèges administratifs, vous devez utiliser la commande sudo.

Exécutez la commande suivante pour installer Ansible Core avec une confirmation automatique :

sudo dnf install ansible-core -y

L'option -y répond automatiquement "yes" à toutes les invites, rendant l'installation non interactive. Le système téléchargera et installera ansible-core ainsi que ses dépendances Python, notamment Jinja2 pour la gestion des modèles et PyYAML pour le traitement des fichiers YAML.

Vous devriez voir une sortie similaire à celle-ci, indiquant la résolution des dépendances et la progression de l'installation :

Updating Subscription Management repositories.
Last metadata expiration check: ...
Dependencies resolved.
================================================================================
 Package                  Arch   Version                Repository         Size
================================================================================
Installing:
 ansible-core             noarch 2.16.x-x.el9            rhel-9-appstream   xx M
Installing dependencies:
 python3-jinja2           noarch x.x.x-x.el9              rhel-9-appstream   xxx k
 python3-yaml             x86_64 x.x.x-x.el9              rhel-9-appstream   xxx k
 ...

Transaction Summary
================================================================================
Install  XX Packages

Complete!

Vérifier l'installation d'Ansible

Maintenant qu'Ansible Core est installé, vérifions que l'installation a réussi en consultant la version et en confirmant que les outils en ligne de commande essentiels sont disponibles.

Tout d'abord, vérifiez la version d'Ansible en exécutant :

ansible --version

Cette commande affiche des informations détaillées sur votre installation d'Ansible, notamment la version du noyau, la version de Python et l'emplacement des différents composants. Vous devriez obtenir une sortie comme celle-ci :

ansible [core 2.14.18]
  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.9/site-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.9.21 (main, Feb 10 2025, 00:00:00) [GCC 11.5.0 20240719 (Red Hat 11.5.0-5)] (/usr/bin/python3)
  jinja version = 3.1.2
  libyaml = True

Comprenons la signification de chaque ligne :

ansible [core 2.14.18] : Affiche la version d'Ansible Core installée.
config file : Indique le fichier de configuration principal d'Ansible contenant les paramètres par défaut.
configured module search path : Répertoires où Ansible recherche les modules personnalisés.
ansible python module location : Emplacement où le code Python principal d'Ansible est installé.
ansible collection location : Répertoires où les collections Ansible (modules et plugins packagés) sont stockées.
executable location : L'emplacement réel du binaire de la commande ansible.
python version : La version de l'interpréteur Python utilisée par Ansible.
jinja version : La version du moteur de templating utilisé par Ansible pour le contenu dynamique.
libyaml = True : Confirme que l'analyseur YAML rapide est disponible pour de meilleures performances.

Cela confirme qu'Ansible est correctement installé et prêt à l'emploi. Vérifions également que la commande ansible-playbook est disponible :

ansible-playbook --version

Vous devriez voir des informations de version similaires pour l'outil ansible-playbook, qui est essentiel pour exécuter des playbooks Ansible.

Tester Ansible avec une commande simple

Dans cette étape, vous allez tester votre installation d'Ansible en exécutant une commande simple sur le système local. Déplacez-vous dans le répertoire du projet et utilisez le fichier d'inventaire préconfiguré pour exécuter une commande ad-hoc Ansible.

Accédez au répertoire du projet et testez la fonctionnalité de ping de base. Enregistrez la sortie dans un fichier afin de pouvoir la consulter ultérieurement et permettre au vérificateur d'étape de confirmer le résultat de manière fiable :

cd /home/labex/project
ansible localhost -m ping | tee ping-output.txt

Le module ping n'envoie pas réellement de paquets ICMP ; il vérifie plutôt qu'Ansible peut se connecter à la cible et exécuter du code Python. Une réponse réussie ressemblera à ceci :

localhost | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false,
    "ping": "pong"
}

Analysons cette sortie :

localhost | SUCCESS : Indique que la commande s'est exécutée avec succès sur la cible localhost.
ansible_facts : Contient les informations système découvertes lors de l'exécution.
discovered_interpreter_python : Le chemin de l'interpréteur Python qu'Ansible a trouvé et utilisera.
changed: false : Indique qu'aucune modification n'a été apportée au système (le ping est en lecture seule).
ping: "pong" : La réponse classique confirmant la connectivité Ansible.

La réponse "pong" confirme qu'Ansible fonctionne correctement et peut communiquer avec le système cible.

Testons également la collecte d'informations système à l'aide du module setup et enregistrons cette sortie :

ansible localhost -m setup -a "filter=ansible_distribution*" | tee setup-output.txt

Cette commande utilise le module setup pour collecter des faits système, en filtrant spécifiquement les informations de distribution. Vous devriez voir une sortie contenant des détails sur votre système Red Hat Enterprise Linux :

localhost | SUCCESS => {
    "ansible_facts": {
        "ansible_distribution": "RedHat",
        "ansible_distribution_file_parsed": true,
        "ansible_distribution_file_path": "/etc/redhat-release",
        "ansible_distribution_file_search_string": "Red Hat",
        "ansible_distribution_file_variety": "RedHat",
        "ansible_distribution_major_version": "9",
        "ansible_distribution_release": "Plow",
        "ansible_distribution_version": "9.6",
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false
}

Comprendre la sortie des faits système :

ansible_distribution : Le nom de la distribution Linux (RedHat).
ansible_distribution_file_parsed : Indique si Ansible a réussi à lire le fichier de distribution.
ansible_distribution_file_path : Le fichier contenant les informations de distribution.
ansible_distribution_file_search_string : Le motif textuel utilisé pour identifier la distribution.
ansible_distribution_file_variety : La famille de distribution (famille RedHat).
ansible_distribution_major_version : Le numéro de version majeure (9).
ansible_distribution_release : Le nom de code de la version (Plow).
ansible_distribution_version : Le numéro de version complet (9.6).
discovered_interpreter_python : L'interpréteur Python découvert par Ansible.

Cela confirme qu'Ansible peut collecter avec succès des informations système depuis l'hôte cible, ce qui est essentiel pour créer une automatisation conditionnelle basée sur les caractéristiques du système.

Explorer les modules Ansible disponibles

Ansible est livré avec des centaines de modules intégrés pour diverses tâches d'automatisation. Explorons quelques-uns des modules disponibles pour comprendre les capacités immédiatement accessibles après l'installation.

Pour voir une liste des modules disponibles, exécutez la commande suivante et enregistrez les premières lignes dans un fichier :

ansible-doc -l | head -20 | tee module-list.txt

La commande ansible-doc -l liste tous les modules disponibles, et l'utilisation de head -20 affiche les 20 premiers. Cela vous donne une idée des vastes capacités d'automatisation offertes par Ansible. Vous verrez une sortie similaire à celle-ci :

ansible.builtin.add_host               Add a host (and alternatively a grou...
ansible.builtin.apt                    Manages apt-packages
ansible.builtin.apt_key                Add or remove an apt key
ansible.builtin.apt_repository         Add and remove APT repositories
ansible.builtin.assemble               Assemble configuration files from fr...
ansible.builtin.assert                 Asserts given expressions are true
ansible.builtin.async_status           Obtain status of asynchronous task
ansible.builtin.blockinfile            Insert/update/remove a text block su...
ansible.builtin.command                Execute commands on targets
ansible.builtin.copy                   Copy files to remote locations
ansible.builtin.cron                   Manage cron.d and crontab entries
ansible.builtin.debconf                Configure a .deb package
ansible.builtin.debug                  Print statements during execution
ansible.builtin.dnf                    Manages packages with the `dnf' pack...
ansible.builtin.dpkg_selections        Dpkg package selection selections
ansible.builtin.expect                 Executes a command and responds to p...
ansible.builtin.fail                   Fail with custom message
ansible.builtin.fetch                  Fetch files from remote nodes
ansible.builtin.file                   Manage files and file properties
ansible.builtin.find                   Return a list of files based on spec...

Comprendre le format de la liste des modules :

ansible.builtin. : Indique qu'il s'agit de modules intégrés fournis avec Ansible Core.
Nom du module : Le nom que vous utilisez lors de l'appel du module dans des playbooks ou des commandes ad-hoc.
Description : Une brève explication de ce que fait le module.

Quelques modules importants que vous utiliserez couramment :

command : Exécuter des commandes shell sur les systèmes cibles.
copy : Copier des fichiers de votre machine de contrôle vers des hôtes distants.
dnf : Installer, mettre à jour ou supprimer des paquets sur les systèmes Red Hat.
file : Créer des répertoires, définir des permissions ou gérer les propriétés de fichiers.
debug : Afficher des messages pendant l'exécution d'un playbook pour le dépannage.

Pour obtenir une documentation détaillée sur un module spécifique, vous pouvez utiliser la commande ansible-doc avec le nom du module. Redirigez la sortie vers un fichier pour que la commande reste non interactive et que vous puissiez l'inspecter plus tard. Par exemple, pour en savoir plus sur le module copy :

ansible-doc copy | tee copy-doc.txt

Cela affichera une documentation complète pour le module copy, incluant des exemples et des descriptions de paramètres, tout en enregistrant une copie dans copy-doc.txt. La commande ansible-doc fournit une documentation détaillée pour n'importe quel module Ansible, facilitant ainsi l'apprentissage des différentes capacités d'automatisation.

Résumé

Dans ce laboratoire, vous avez appris avec succès à installer et à vérifier Ansible Core sur un système Red Hat Enterprise Linux. Voici ce que vous avez accompli :

Installation d'Ansible Core : Vous avez utilisé la commande sudo dnf install ansible-core -y pour installer le paquet Ansible principal et ses dépendances depuis les dépôts officiels Red Hat.
Vérification de l'installation : Vous avez confirmé qu'Ansible était correctement installé en vérifiant la version des commandes ansible et ansible-playbook.
Test des fonctionnalités de base : Vous avez exécuté des commandes Ansible simples pour vérifier que l'installation fonctionne correctement, notamment :
- Utilisation du module ping pour tester la connectivité.
- Utilisation du module setup pour collecter des faits système.
Exploration des modules disponibles : Vous avez appris à découvrir et à lire la documentation de la vaste bibliothèque de modules Ansible à l'aide de ansible-doc.

Vous disposez désormais d'une installation Ansible pleinement fonctionnelle sur RHEL et comprenez les commandes de base nécessaires pour commencer à automatiser votre infrastructure. Cette base vous prépare à des sujets Ansible plus avancés tels que l'écriture de playbooks, la gestion d'inventaires et la mise en œuvre de flux de travail d'automatisation complexes.