Introduction
Ansible est un outil d'automatisation open-source puissant qui a connu une large adoption dans l'industrie informatique. Au fur et à mesure qu'Ansible évolue, il est important de maintenir votre installation à jour pour profiter des dernières fonctionnalités et améliorations. Ce tutoriel vous guidera à travers le processus de mise à niveau d'Ansible vers la dernière version sur Ubuntu, qui est le système d'exploitation utilisé dans cet environnement de laboratoire.
Comprendre Ansible et Vérifier Votre Version Actuelle
Avant de mettre à niveau Ansible, il est utile de comprendre ce qu'est Ansible et de vérifier quelle version vous avez actuellement installée.
Qu'est-ce qu'Ansible ?
Ansible est une plateforme d'automatisation open-source qui simplifie la gestion de la configuration, le déploiement d'applications et l'automatisation des tâches. Il utilise la syntaxe YAML pour créer des playbooks, qui sont des documents décrivant l'état souhaité de vos systèmes.
Certains avantages clés d'Ansible incluent :
- Architecture sans agent (Agentless architecture) : Pas besoin d'installer d'agents sur les nœuds gérés
- Syntaxe simple : Utilise des fichiers YAML lisibles par l'homme
- Exécution idempotente (Idempotent execution) : L'exécution du même playbook plusieurs fois produit le même résultat
- Extensible : Prend en charge les modules et plugins personnalisés
Vérification de Votre Version Ansible Actuelle
Commençons par vérifier si Ansible est déjà installé et, si oui, quelle version vous avez. Ouvrez un terminal et exécutez :
ansible --version
Vous devriez voir une sortie similaire à celle-ci :
ansible [core 2.12.0]
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.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0]
jinja version = 3.0.3
libyaml = True
La première ligne affiche votre version Ansible actuelle. Si vous ne voyez pas de sortie comme celle-ci, Ansible n'est peut-être pas encore installé, ce qui est normal car nous allons l'installer à l'étape suivante.
Comprendre le Versioning d'Ansible
Ansible suit le versioning sémantique avec trois chiffres : major.minor.patch
- Version majeure (Major version) : Changements importants qui peuvent nécessiter des modifications de vos playbooks
- Version mineure (Minor version) : Nouvelles fonctionnalités sans changements majeurs
- Version de correctif (Patch version) : Corrections de bogues et améliorations mineures
Maintenant que nous comprenons ce qu'est Ansible et que nous avons vérifié notre version actuelle, nous sommes prêts à procéder à l'installation ou à la mise à niveau d'Ansible à l'étape suivante.
Installation ou Mise à Niveau d'Ansible sur Ubuntu
Dans cette étape, nous allons installer ou mettre à niveau Ansible sur le système Ubuntu 22.04. Nous utiliserons le PPA (Personal Package Archive) officiel d'Ansible pour obtenir la dernière version stable.
Ajout du Dépôt PPA Ansible
Tout d'abord, nous devons nous assurer que nous avons la dépendance nécessaire pour ajouter des PPA :
sudo apt update
sudo apt install -y software-properties-common
Cette commande met à jour votre index de paquets et installe le paquet software-properties-common, qui fournit la commande add-apt-repository.
Maintenant, ajoutons le dépôt PPA officiel d'Ansible :
sudo add-apt-repository --yes --update ppa:ansible/ansible
Vous verrez une sortie indiquant que le dépôt a été ajouté à votre système. L'option --yes confirme automatiquement l'ajout, et --update actualise immédiatement la liste des paquets.
Installation de la Dernière Version d'Ansible
Avec le dépôt ajouté, nous pouvons maintenant installer la dernière version d'Ansible :
sudo apt install -y ansible
L'option -y confirme automatiquement l'installation sans demander de confirmation.
Cette commande installera Ansible s'il n'est pas déjà présent ou le mettra à niveau vers la dernière version disponible dans le PPA.
Vérification de l'Installation ou de la Mise à Niveau
Une fois l'installation terminée, vérifions qu'Ansible est installé correctement et vérifions sa version :
ansible --version
La sortie devrait afficher la dernière version d'Ansible disponible dans le PPA. Si vous aviez précédemment une ancienne version installée, vous devriez maintenant voir un numéro de version plus récent.
Pour suivre notre progression pour le script de vérification, créons un fichier marqueur :
touch /tmp/ansible_version_checked
touch /tmp/ansible_installed
Nous avons maintenant installé ou mis à niveau avec succès Ansible sur notre système Ubuntu. À l'étape suivante, nous explorerons comment utiliser quelques commandes Ansible de base pour vérifier que notre installation fonctionne correctement.
Vérification de Votre Installation Ansible avec un Playbook Simple
Maintenant qu'Ansible est installé, confirmons qu'il fonctionne correctement en créant et en exécutant un playbook Ansible simple. Les playbooks sont des fichiers YAML qui décrivent l'état souhaité de vos systèmes et les tâches qu'Ansible doit effectuer pour atteindre cet état.
Création d'un Playbook de Test
Tout d'abord, créons un répertoire pour notre projet Ansible :
mkdir -p ~/project/ansible-test
cd ~/project/ansible-test
Maintenant, créons un playbook simple en utilisant l'éditeur de code intégré. Dans le WebIDE, cliquez sur l'icône "Explorer" dans la barre latérale gauche, accédez au répertoire ansible-test que nous venons de créer et créez un nouveau fichier appelé test-playbook.yml.
Ajoutez le contenu suivant à ce fichier :
---
- name: Test Ansible Installation
hosts: localhost
connection: local
gather_facts: no
tasks:
- name: Print a message
debug:
msg: "Ansible is installed and working correctly!"
- name: Get Ansible version
command: ansible --version
register: ansible_version_output
- name: Display Ansible version
debug:
msg: "{{ ansible_version_output.stdout_lines[0] }}"
- name: Create a test file
file:
path: /tmp/ansible-test-file.txt
state: touch
mode: "0644"
Ce playbook fait ce qui suit :
- Cible la machine locale (
localhost) - Affiche un message de succès
- Récupère et affiche la version d'Ansible
- Crée un fichier de test à
/tmp/ansible-test-file.txt
Exécution du Playbook
Exécutons maintenant le playbook pour vérifier qu'Ansible fonctionne correctement :
cd ~/project/ansible-test
ansible-playbook test-playbook.yml
Vous devriez voir une sortie similaire à celle-ci :
PLAY [Test Ansible Installation] ***********************************************
TASK [Print a message] *********************************************************
ok: [localhost] => {
"msg": "Ansible is installed and working correctly!"
}
TASK [Get Ansible version] *****************************************************
changed: [localhost]
TASK [Display Ansible version] *************************************************
ok: [localhost] => {
"msg": "ansible [core 2.12.0]"
}
TASK [Create a test file] ******************************************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=4 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
La sortie montre que toutes les tâches se sont terminées avec succès. changed=2 dans le récapitulatif indique que deux tâches ont apporté des modifications au système (obtenir la version et créer le fichier).
Vérification du Fichier de Test
Vérifions si le fichier de test a été créé :
ls -l /tmp/ansible-test-file.txt
Vous devriez voir le fichier répertorié avec les permissions que nous avons spécifiées :
-rw-r--r-- 1 labex labex 0 Aug 30 12:34 /tmp/ansible-test-file.txt
Marquons cette étape comme terminée pour notre script de vérification :
touch /tmp/ansible_playbook_tested
Félicitations ! Vous avez installé avec succès la dernière version d'Ansible et vérifié qu'elle fonctionne correctement en exécutant un playbook simple. Cela confirme que votre installation Ansible est entièrement fonctionnelle et prête à être utilisée.
Comprendre la Configuration et les Modules Ansible
Maintenant qu'Ansible est installé et fonctionne, explorons sa configuration et le concept de modules.
Configuration Ansible
Ansible utilise des fichiers de configuration pour contrôler son comportement. Le principal fichier de configuration est ansible.cfg, qui peut exister à plusieurs emplacements. Examinons le fichier de configuration par défaut :
ls -la /etc/ansible/
Vous devriez voir la structure de répertoire Ansible par défaut :
total 20
drwxr-xr-x 2 root root 4096 Aug 30 12:00 .
drwxr-xr-x 85 root root 4096 Aug 30 12:00 ..
-rw-r--r-- 1 root root 8669 Aug 30 12:00 ansible.cfg
-rw-r--r-- 1 root root 1021 Aug 30 12:00 hosts
Jetons un coup d'œil au fichier hosts, qui est le fichier d'inventaire par défaut :
cat /etc/ansible/hosts
Le fichier d'inventaire contient une liste des hôtes qu'Ansible peut gérer. Par défaut, il contient des exemples qui sont commentés.
Création d'une Configuration Personnalisée
Créons notre propre fichier de configuration Ansible dans notre répertoire de projet. Dans le WebIDE, créez un nouveau fichier appelé ansible.cfg dans le répertoire ~/project/ansible-test avec le contenu suivant :
[defaults]
inventory = ./inventory
host_key_checking = False
stdout_callback = yaml
Maintenant, créons un fichier d'inventaire simple. Dans le WebIDE, créez un nouveau fichier appelé inventory dans le répertoire ~/project/ansible-test avec le contenu suivant :
[local]
localhost ansible_connection=local
Exploration des Modules Ansible
Les modules Ansible sont des unités de code réutilisables qui effectuent des tâches spécifiques. Explorons certains des modules disponibles :
ansible-doc -l | wc -l
Cette commande liste tous les modules disponibles et les compte. Vous devriez voir un grand nombre, généralement plus de 1000 modules.
Visualisons la documentation d'un module spécifique, tel que le module file que nous avons utilisé dans notre playbook :
ansible-doc file
Vous pouvez appuyer sur q pour quitter l'afficheur de documentation.
Création d'un Playbook Plus Complexe
Maintenant, créons un playbook plus avancé qui démontre quelques modules Ansible supplémentaires. Dans le WebIDE, créez un nouveau fichier appelé modules-demo.yml dans le répertoire ~/project/ansible-test avec le contenu suivant :
---
- name: Ansible Modules Demo
hosts: localhost
connection: local
gather_facts: yes
tasks:
- name: Display system information
debug:
msg: "System: {{ ansible_distribution }} {{ ansible_distribution_version }}"
- name: Create a directory
file:
path: /tmp/ansible-demo
state: directory
mode: "0755"
- name: Copy a file
copy:
content: "Created by Ansible modules demo playbook\n"
dest: /tmp/ansible-demo/info.txt
mode: "0644"
- name: Gather information about a file
stat:
path: /tmp/ansible-demo/info.txt
register: file_info
- name: Show file information
debug:
msg: "File created at {{ file_info.stat.mtime }}"
Exécutons ce playbook :
cd ~/project/ansible-test
ansible-playbook modules-demo.yml
Le playbook fait ce qui suit :
- Affiche des informations sur votre système
- Crée un répertoire à
/tmp/ansible-demo - Crée un fichier avec un contenu personnalisé
- Rassemble des informations sur le fichier
- Affiche l'heure de modification du fichier
Marquons cette étape comme terminée pour notre script de vérification :
touch /tmp/ansible_modules_explored
Vous avez maintenant appris la configuration Ansible, les fichiers d'inventaire et exploré divers modules. Ce sont des composants essentiels pour travailler efficacement avec Ansible.
Résumé
Dans ce lab, vous avez appris avec succès comment installer et mettre à niveau Ansible vers la dernière version sur un système Ubuntu. Vous avez accompli plusieurs tâches clés :
- Compris les bases d'Ansible et son système de versioning
- Installé ou mis à niveau Ansible en utilisant le référentiel PPA officiel
- Vérifié votre installation en créant et en exécutant un playbook simple
- Exploré les fichiers de configuration Ansible et la gestion de l'inventaire
- Appris les modules Ansible et leur documentation
- Créé et exécuté des playbooks plus complexes pour effectuer diverses tâches
Ces compétences fournissent une base solide pour travailler avec Ansible dans des projets d'automatisation. En maintenant votre installation Ansible à jour, vous pouvez profiter des dernières fonctionnalités, corrections de bogues et mises à jour de sécurité.
Au fur et à mesure que vous poursuivez votre parcours Ansible, vous pouvez explorer des sujets plus avancés tels que les rôles, les collections et Ansible AWX/Tower pour la gestion d'entreprise. Ces outils vous aideront à construire des flux de travail d'automatisation plus sophistiqués et à gérer l'infrastructure à grande échelle.
