Maîtriser Ansible

Ansible est devenu un outil incontournable dans le domaine du DevOps et il suffit de regarder le nombre d’offres d’emploi exigeant sa connaissance pour s’en convaincre. Conçu pour être simple et efficace, Ansible se distingue par sa capacité à simplifier des processus complexes, rendant l’automatisation accessible même aux débutants.

Ce qui n’était au départ qu’un simple pense-bête pour moi est devenu, au fil du temps, une Formation Ansible complète, conçue pour vous guider dans la maîtrise de cet outil d’automatisation. Mon amour pour Ansible est né dès ses débuts en 2012, lorsqu’il a été créé pour répondre au besoin d’un outil capable de faciliter la vie des administrateurs système tout en étant facilement compréhensible par ceux qui débutent dans le domaine de l’automatisation.

C’est pour cette raison que j’ai décidé de consacrer une partie de mon parcours à partager mon expertise à travers une Formation Ansible approfondie, afin de transmettre non seulement les compétences techniques, mais aussi la passion que j’ai pour cet outil qui transforme le monde du DevOps.

Origine et Evolution d’Ansible

La genèse d’Ansible est un récit fascinant de réponse à un besoin croissant dans le domaine de l’IT. Créé en 2012 par Michael DeHaan, Ansible est né de la volonté de fournir un outil d’automatisation plus simple et plus sécurisé que ceux existants à l’époque. DeHaan, ayant déjà une expérience notable dans le développement d’outils d’automatisation, a su identifier les lacunes des solutions existantes et a conçu Ansible pour les combler.

Dès ses débuts, Ansible s’est distingué par sa facilité d’utilisation. Contrairement à d’autres outils nécessitant une installation complexe et une configuration lourde, Ansible a été développé dans l’optique d’être léger et facile à mettre en œuvre. Cette approche a rapidement séduit la communauté IT et l’outil a gagné en popularité, se forgeant une réputation de solution d’automatisation fiable et efficace.

L’évolution d’Ansible a été marquée par un engagement constant envers la sécurité et la simplicité, tout en s’adaptant aux besoins changeants des professionnels de l’IT. Son développement a été fortement influencé par sa communauté d’utilisateurs, une communauté active et engagée qui a contribué à l’enrichissement constant du logiciel par de nouvelles fonctionnalités et améliorations.

En 2015, Red Hat, une grande entreprise dans le monde du logiciel libre, a acquis Ansible, marquant une étape importante dans son histoire. Cette acquisition a non seulement renforcé la position d’Ansible sur le marché, mais a également ouvert la voie à de nouvelles opportunités de développement et d’intégration avec d’autres produits et services de Red Hat.

Aujourd’hui, Ansible est considéré comme une solution clé dans le domaine de l’automatisation des IT. Sa capacité à évoluer tout en restant fidèle à ses principes de base – simplicité, efficacité et sécurité – continue de lui valoir la confiance et la fidélité des professionnels à travers le monde.

Cas d’Usage d’Ansible

Dans cette formation, nous n’aborderons qu’Ansible. Ansible fait partie d’un ensemble d’application appelé Ansible Automation Platform ↗ qui étend son champ d’action à la gestion de WorkFlows Complexes, mais pas que.

En effet, Ansible offre une grande flexibilité et s’adapte à divers scénarios. Ses applications vont de l’automatisation de déploiements à la gestion de configurations, en passant par l’orchestration de tâches et la gestion d’événements.

1. Automatisation des Déploiements Ansible est largement utilisé pour automatiser les déploiements d’applications et de services. Il permet aux équipes de réduire les erreurs humaines et d’accélérer les processus de déploiement, grâce à une automatisation cohérente et fiable.
2. Gestion de Configuration La gestion de configuration avec Ansible assure une cohérence et une répétabilité des configurations des serveurs et des applications à travers différents environnements. Cette approche unifiée aide à maintenir l’intégrité et la stabilité des systèmes informatiques.
3. Orchestration L’orchestration de tâches IT complexes est facilitée par Ansible. Il permet de définir avec précision l’ordre et la manière d’exécution des tâches, optimisant ainsi la gestion de workflows complexes dans les environnements IT.
4. Gestion des Événements Un aspect innovant de l’utilisation d’Ansible est sa capacité à gérer les événements de manière “event-driven”. Cette approche permet à Ansible de réagir automatiquement à des événements spécifiques dans l’environnement IT. Par exemple, Ansible peut être configuré pour répondre à des changements de configuration, à des alertes de sécurité, ou à d’autres déclencheurs dans le système. Cette réactivité rend les systèmes gérés par Ansible non seulement plus efficaces, mais aussi plus adaptatifs aux conditions changeantes, un atout clé dans les environnements IT dynamiques d’aujourd’hui.

Comment fonctionne Ansible ?

Contrairement aux idées reçues pour apprendre à développer du code Ansible, il n’y a pas besoin de déployer un serveur Ansible !

La grande force d’Ansible est qu’il est facile à mettre en œuvre, car il est agent-less et ne nécessite qu’une connexion SSH et la présence d’une installation minimale de python pour exécuter les tâches décrites.

Lorsqu’il y a plusieurs machines à gérer, Ansible exécute les opérations en parallèle. Cela permet de gagner un temps considérable. Cependant, les tâches sont effectuées dans un ordre défini par l’utilisateur lors du choix de la stratégie : Par défaut Ansible attendra d’avoir fini une tâche (sur tous les hôtes) pour passer à la suivante.

Ansible et plus particulièrement ses modules sont idempotents. Cela signifie qu’une opération donnera le même résultat qu’on l’exécute une ou plusieurs fois. Par exemple, on va vérifier si un utilisateur existe, si c’est le cas, on ne fera rien, mais si l’utilisateur n’existe pas alors, on viendra le créer.

Composants clés

• Node Manager : ou control node, est le poste depuis lequel tout est exécuté via des connexions, essentiellement en SSH, aux nœuds cibles.
• Playbook : Un playbook Ansible décrit une suite de tâches ou de rôles écrits dans un fichier ou format YAML.
• Rôle : Afin d’éviter d’écrire encore et encore le même code dans les playbooks, Ansible permet d’utiliser des librairies regroupant des fonctionnalités spécifiques. Ces librairies sont appelées des rôles qui peuvent donc être utilisés dans les playbooks.
• Inventaire : La description des systèmes cibles gérés par Ansible est appelé un inventaire. À chaque node de l’inventaire, on peut attribuer des variables. On distingue deux types d’inventaire :
  • l’inventaire statique constitué de fichier(s) plats.
  • l’inventaire dynamique fourni par un système centralisé. Exemple L’inventaire AWS EC2.
• Module : Les tâches et les rôles font appel à des modules installés avec Ansible. Je vous invite à consulter leur liste sur le site d’Ansible ↗.
• Template : Comme son nom l’indique, un template est un modèle permettant de générer un fichier cible. Ansible utilise jinja, un gestionnaire de modèles écrit pour Python. Les « Templates » jinja permettent de gérer des boucles, des tests logiques, des listes ou des variables.
• Notifier : indique que si une tâche change d’état (et uniquement si la tâche a engendré un changement), notify fait appel au handler associé pour exécuter une autre tâche.
• Handler : Tâche qui n’est appelée que dans l’éventualité où un notifier est invoqué
• Tag : Nom défini sur une ou plusieurs tâches qui peuvent être utilisé plus tard pour exécuter exclusivement cette ou ces tâches Ansible.

Comment Installer Ansible ?

Ansible ne peut être installé, en théorie, que sur des ordinateurs fonctionnant sur les systèmes d’exploitation Linux et MacOS. La manière la plus propre pour installer d’Ansible se fait via l’utilisation d’un environnement virtuel python ou dans l’espace utilisateur. En effet, ce moyen permet de choisir précisément la version d’ansible à installer.

Je ne décrie ici que l’installation d’Ansible dans l’espace python de l’utilisateur :

sudo apt update
sudo apt -y upgrade
sudo apt install -y build-essential libssl-dev libffi-dev python3-dev python3-pip
pip3 install ansible --user

Pour installer une version spécifique :

pip3 install --user ansible==6.5.0

Installation de l’autocompletion bash

Depuis la version 2.9 d’Ansible, il est possible d’avoir de l’autocomplétion bash des commandes ansible. Pour cela, il suffit d’installer le package python argcomplete :

sudo pip3 install argcomplete
sudo activate-global-python-argcomplete

Test après installation d’Ansible

Comment exécuter Ansible ? Il suffit de taper la commande suivante qui va simplement lancer en local (-c local) un shell qui exécutera la commande echo 'salut B0B':

ansible all -i "localhost," -c local -m shell -a 'echo Salut B0B'

localhost | success | rc=0 >>
salut B0B

Dans le vocabulaire Ansible, le fait d’utiliser le binaire ansible pour exécuter une simple tâche est une commande ‘ad hoc’. En effet, nous utiliserons plus souvent la commande ansible-playbook qui permet elle d’orchestrer un ensemble de taches. Un exemple de commande ad hoc : rebooter un ensemble de machines.

Comment apprendre à utiliser Ansible ?

Écrire du code Ansible consiste d’abord à comprendre son approche déclarative et ses concepts de base. Contrairement à un langage de programmation traditionnel, où l’on décrit étape par étape ce que le programme doit faire, Ansible permet de déclarer un état final pour une infrastructure ou une application. Le rôle d’Ansible est ensuite de s’assurer que cet état est atteint.

Voici comment aborder l’apprentissage de l’écriture du code Ansible étape par étape.

Maîtriser SSH

L’un des aspects les plus fondamentaux d’Ansible est son fonctionnement sans agent. Cela signifie qu’Ansible n’a pas besoin d’installer un logiciel sur les machines distantes pour les gérer. À la place, il utilise SSH (Secure Shell) pour se connecter aux serveurs et exécuter des tâches. C’est pourquoi il est indispensable de bien maîtriser SSH pour utiliser Ansible de manière efficace.

Comprendre le langage YAML

Ansible utilise le YAML pour écrire ses playbooks, ce qui en fait un langage très lisible, même pour ceux qui ne sont pas développeurs.

Voici un exemple de playbook basique en YAML :

---
- name: Installation de Nginx sur un serveur
  hosts: webservers
  tasks:
    - name: Installer Nginx
      ansible.builtin.apt:
        name: nginx
        state: present

Dans cet exemple, nous déclarons que le paquet nginx doit être présent sur les machines du groupe webservers. L’apprentissage du YAML est essentiel, car c’est la base syntaxique des playbooks Ansible.

Comprendre les inventaires Ansible

Ansible fonctionne en exécutant des tâches sur des hôtes distants. Ces hôtes sont définis dans un inventaire, qui peut être statique ou dynamique. Ici, nous allons nous concentrer sur l’utilisation des inventaires statiques, qui sont des fichiers simples listant les serveurs sur lesquels Ansible doit agir.

Un inventaire statique est un fichier, généralement appelé inventory ou hosts, qui contient une liste d’hôtes ou de groupes d’hôtes sur lesquels Ansible va exécuter les playbooks. Ce fichier peut être écrit en format INI avec des groupes d’hôtes et leurs adresses IP ou noms d’hôtes.

Voici un exemple d’un fichier d’inventaire simple, où nous avons deux groupes : webservers et dbservers.

[webservers]
webserver1 ansible_host=192.168.1.10
webserver2 ansible_host=192.168.1.11

[dbservers]
dbserver1 ansible_host=192.168.1.20
dbserver2 ansible_host=192.168.1.21

Dans cet exemple :

• Le groupe webservers contient deux serveurs (webserver1 et webserver2).
• Le groupe dbservers contient également deux serveurs (dbserver1 et dbserver2).
• Chaque serveur est identifié par son nom d’hôte et son adresse IP (via le paramètre ansible_host).

Ansible va utiliser cet inventaire pour savoir sur quels serveurs exécuter les tâches définies dans le playbook.

Comprendre la structure d’un Playbook

Un playbook est une collection de tâches qu’Ansible doit exécuter pour atteindre un état souhaité. Voici les éléments clés d’un playbook à comprendre dès le début :

• hosts : définit sur quels hôtes ou groupes d’hôtes les tâches vont être exécutées.
• tasks : chaque tâche est une action à exécuter, par exemple, installer un paquet, copier un fichier ou redémarrer un service.

Un bon moyen d’apprendre est de lire et de comprendre des playbooks existants. Par exemple, l’installation de Docker pourrait ressembler à ceci :

---
- name: Installer Docker sur les serveurs
  hosts: servers
  become: true
  tasks:
    - name: Mettre à jour la liste des paquets
      ansible.builtin.apt:
        update_cache: yes

    - name: Installer les dépendances
      ansible.builtin.apt:
        name:
          - apt-transport-https
          - ca-certificates
          - curl
          - software-properties-common
        state: present

    - name: Ajouter la clé GPG officielle de Docker
      ansible.builtin.apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

    - name: Ajouter le dépôt APT Docker
      ansible.builtin.apt_repository:
        repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable

    - name: Installer Docker
      ansible.builtin.apt:
        name: docker-ce
        state: present

    - name: S'assurer que Docker est démarré
      ansible.builtin.service:
        name: docker
        state: started

Explication des tâches :

1. La première tâche utilise le module de gestion de package ansible.builtin.apt pour mettre à jour la liste des paquets disponibles sur le système. Cela permet de s’assurer que l’ordinateur connaît les dernières versions des paquets. Cela correspond à un apt update sur un système basé sur Debian ou Ubuntu.
2. La tâche suivante installe plusieurs paquets nécessaires pour installer et utiliser Docker. Les paquets comme apt-transport-https, ca-certificates, curl et software-properties-common permettent à Ubuntu de gérer les dépôts sur HTTPS et d’ajouter de nouveaux dépôts. Cela correspond à apt install apt-transport-https ca-certificates curl software-properties-common.
3. La troisième tâche utilise le module ansible.builtin.apt_key pour ajouter la clé GPG officielle de Docker. Cela permet de vérifier que les paquets installés depuis le dépôt Docker sont bien authentiques. La clé est téléchargée à partir de l’URL donnée.
4. Ensuite on ajoute le dépôt officiel Docker aux sources APT d’Ubuntu avec le module ansible.builtin.apt_repository. Cela permet à APT (le gestionnaire de paquets) de trouver et installer Docker directement depuis le dépôt officiel Docker. Le dépôt est spécifié avec son URL et les informations nécessaires.
5. On installe Docker avec le module ansible.builtin.apt, en spécifiant que le paquet docker-ce (Docker Community Edition) doit être installé. Cela correspond à un apt install docker-ce sur un système Ubuntu.
6. On finit par utiliser le module ansible.builtin.service pour s’assurer que le service Docker est bien démarré. Si Docker n’est pas déjà en cours d’exécution, cette tâche va démarrer le service. Cela correspond à une commande systemctl start docker.

Tester ses Playbooks

Tester ses playbooks est une partie essentielle du processus d’apprentissage. On peut commencer par tester les playbooks sur des machines locales ou virtuelles avant de les déployer dans des environnements de production. Ansible permet l’utilisation du module check pour simuler l’exécution d’un playbook sans apporter de réelles modifications :

ansible-playbook -i inventory playbook.yaml --check

Cela permet de vérifier que le code fonctionne correctement avant de l’appliquer.

Gestion des erreurs et débogage

Lors de l’exécution des playbooks, il peut y avoir des erreurs. Apprendre à lire les messages d’erreur et à comprendre leur origine est indispensable. Ansible fournit plusieurs options pour déboguer les playbooks, comme l’ajout de plus de détails avec l’option -v ou -vvv pour augmenter le niveau de verbosité :

ansible-playbook playbook.yaml -vvv

Cela permet de voir en détail chaque commande exécutée et d’identifier où un playbook échoue.

Ecrire des rôles pour organiser son code

À mesure que vous progressez, il devient important d’apprendre à structurer et organiser le code Ansible de manière plus professionnelle. C’est là qu’entrent en jeu les rôles. Un rôle permet de regrouper des tâches, des fichiers, des variables et des templates pour des fonctionnalités spécifiques. Cela facilite la réutilisation et la maintenance du code Ansible.

Développer des collections

Pour les utilisateurs avancés d’Ansible, le développement de collections représente une étape importante dans l’extension et la personnalisation des fonctionnalités d’Ansible. Une collection est un ensemble de rôles, de modules, de plugins, de playbooks et de divers contenus Ansible regroupés dans une structure organisée et réutilisable.

Conclusion : Un apprentissage progressif et pratique

Le processus d’apprentissage pour écrire du code Ansible passe par la pratique régulière et l’expérimentation. En comprenant les bases comme la syntaxe YAML, la structure des playbooks et en se familiarisant avec les modules et les rôles, on peut rapidement monter en compétence. Une bonne façon de progresser est de commencer par des playbooks simples, puis de les complexifier en utilisant des variables, des rôles et des fonctionnalités avancées comme le chiffrement avec Ansible Vault.

Et la suite…

Cette introduction avait pour simple objectif de présenter Ansible et de montrer en quoi il peut vous aider à gérer la configuration de vos serveurs. J’espère que cela vous aura donné envie d’aller plus loin dans la gestion de configurations avec Ansible.

Dans cette introduction sur les bases d’Ansible, j’ai décris Ansible, j’ai évoqué ses points forts et les avantages qu’il peut apporter à l’automatisation et à l’orchestration de votre infrastructure. J’ai défini les termes essentiels utilisés et expliciter la structure des playbooks Ansible.

Si vous voulez continuer votre apprentissage d’ansible, je conseille de lire les billets suivants :

• L’écriture de playbooks Ansible plus évolués permettant de configurer et d’installer une application. Mais nous y arborerons aussi d’autres notions comme les variables Ansible, les boucles et conditions Ansible et les templates Ansible.
• Pour vous assister dans l’écriture de playbooks, je vous conseille d’utiliser l’outil Ansible-Lint et l’extension vscode Ansible
• Pour écrire correctement des playbooks Ansible, il faut le faire avec du TDD (Test-Driven Development) qui consistent à écrire un playbook par itération, en écrivant chaque test avant d’écrire la solution.
• Maitriser la configuration d’Ansible
• Dans certains cas vous pouvez être obligé de recourir aux modules de commandes comme shell et command. Comment les utiliser correctement ?
• Pour éviter de vous répéter sans cesse, il faut développer des rôles. Voyons comment écrire vos propres rôles Ansible
• Un billet expliquant comment structurer ses developpements Ansible ↗
• Pour éviter de subir une attaque, protégez vos secrets avec Ansible Vault
• Maintenant que vous connaissez une grande partie des concepts important d’Ansible, il est temps de lire mes bonnes pratiques.

Plus d’infos

• Site officiel : Ansible.com ↗
• Documentation : Documentation ↗