Aller au contenu principal

Maîtriser Ansible

Logo Ansible

Ansible est devenu un outil incontournable de nos jours, il suffit de regarder le nombre d'offres d'emplois exigeant sa connaissance. Conçu pour être simple et efficace, il se distingue par sa capacité à simplifier des processus complexes, rendant l'Automatisation accessible même aux débutants.

Sa création, remontant à 2012, fut motivée par le besoin d'un outil qui pourrait non seulement faciliter la vie des administrateurs système, mais aussi être facilement compris par ceux qui débutent dans le domaine de l'automatisation. Ce qui rend Ansible particulièrement attrayant, c'est sa polyvalence et sa facilité d'utilisation. Que ce soit pour le déploiement d'applications, la gestion de configuration ou l'orchestration de tâches complexes, Ansible offre une solution élégante et intuitive.

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 ce billet, 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.

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.

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.

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.

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.

Ansible

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.
  • Inventory : La description des systèmes cibles gérés par Ansible est appelé un inventaire. A 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 Jinja2, un gestionnaire de modèles écrit pour Python. Les « Templates » Jinja2 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 et de python à installer.

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

Sur des machines à base de Debian

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

Sur des machines à base de RedHat

sudo yum install epel-release
sudo yum install python3-pip
sudo pip3 install -U pip --upgrade
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'autocompletion 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'

Ce qui donne à l’écran :

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.

Pour tester vos playbooks Ansible je vous conseille de créer des machines virtuelles en utilisant vagrant.

Comment utiliser Ansible ?

Les principales commandes Ansible

Ansible est livré avec un certain nombre de commandes permettant soit de lancer des actions ou, soit d'obtenir de l'information sur l'environnement d'exécution Ansible :

  • ansible : Permet d'exécuter un simple module ansible sur un inventaire. Vu ci-dessus dans le premier test.
  • ansible-console : Ouvre une console interactive permettant de lancer plusieurs actions sur un inventaire.
  • ansible-config : Affiche l'ensemble des paramètres Ansible. ansible-config [list|dump|view].
    • list : affiche la liste complète des options d'Ansible à disposition.
    • dump : affiche la configuration dans le contexte actuel.
    • view : affiche le contenu d'un fichier de configuration Ansible
  • ansible-playbook : Exécute un playbook Ansible sur un inventaire. La plus connue.
  • ansible-vault : Permet de chiffrer des données qui ne doivent être divulgué.
  • ansible-inventory : Affiche l'ensemble des données d'un inventaire Ansible.
  • ansible-galaxy : permet d'installer des roles et des collections Ansible
  • ansible-doc : Permet de lister l'ensemble des composants Ansible à disposition sur le nœud d'execution ansible-doc -l -t [type] type parmi: become, cache, callback, cliconf, connection,httpapi, inventory, lookup, netconf, shell, vars, module, strategy.

Qu'est-ce qu'un inventaire ansible ?

Ici ne sera abordé que la notion d’inventaire statique ansible.

L’inventaire statique sous Ansible est un fichier lu souvent au format INI. La déclaration d’un groupe se fait en utilisant le nom du groupe entre crochets. Les machines rattachées à ce groupe sont simplement ajoutées à la suite de la déclaration du groupe (une machine par ligne).

Prenez un exemple avec les éléments suivants que vous pouvez instancier avec vagrant :

  • un groupe apache constitué de la machine server1
  • un groupe Mysql avec la machine server2

Ci-dessous un fichier d’inventaire correspondant à cette déclaration premier_inventaire.ini :

[apache]
server1
[mysql]
server2

Il faut dans un premier temps créer une clé SSH et diffuser la clé publique sur les machines clientes d'Ansible:

ssh-keygen -t ed25519
ssh-copy-id -i ~/.ssh/id_ed25519.pub server1
ssh-copy-id -i ~/.ssh/id_ed25519.pub server2

Démarrons l’agent SSH qui évitera de rentrer la paraphrase à chaque commande :

ssh-agent bash
ssh-add ~/.ssh/id_ed25519

À partir de maintenant, il est possible de lancer des commandes unitaires sur l’inventaire au moyen de la commande Ansible (nous en verrons d’autres). ansible -i premier_inventaire.ini -m ping all

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

Le premier paramètre est l’inventaire d'ansible à utiliser, le second le module à lancer et le dernier la cible. Ici, on exécute le module ping sur toutes (all) les machines se trouvant dans l’inventaire. Il est possible de se limiter à un groupe ou à une salle machine. ansible -i inventories/premier_inventaire.ini -m ping apache

On peut associer des arguments aux modules avec l’argument (-a).

ansible localhost -m shell -a "python --version"
localhost | CHANGED | rc=0 >>
Python 3.10.7

La commande a fonctionné avec succès. Cet exemple est assez simple, mais pour des tâches plus évoluées, nous allons faire appel au playbook (livre de recette) d’Ansible.

Comment écrire des playbooks Ansible ?

Pour écrire les playbooks, Ansible s'appuie sur le langage YAML. Je vois déjà les critiques fusées, c'est compliqué fastidieux ! Et bien non si vous utilisez un IDE intégrant une extension Ansible.

Revenons à l'écriture de notre premier playbooks :

---
- name: update web servers
hosts: webservers
become: true

tasks:
- name: ensure apache is at the latest version
ansible.builtin.package:
name: httpd
state: latest
...

Donc dans l'exemple ci-dessus, nous avons un playbook ansible :

  • dont la description (name) est update web servers
  • qui cible les hosts du groupe webservers
  • qui demande l'élévation de privilège (become) pour exécuter des tâches les nécessitant.
  • qui lance une tache qui vérifie que la dernière version d'apache est bien installé si ce n'est pas le cas, elle l'installe.

Voici les principales règles de syntaxe des fichiers YAML :

  • YAML accepte l'ensemble du jeu de caractères Unicode, à l'exception de certains caractères de contrôle et peut être codé en UTF-8, UTF-16 et UTF-32 (fortement conseillé).
  • L'indentation est faite avec l'utilisation des espaces et non les caractères de tabulation.
  • Les commentaires commencent par le signe dièse #, peuvent commencer n'importe où sur une ligne puis continuer jusqu'à la fin de la ligne. Par contre, Si le caractère # apparaît à l'intérieur d'une chaîne, alors ce sont des # littéraux.
  • Les membres de la liste sont indiqués par un tiret - avec un membre par ligne. Une liste peut également être spécifiée en plaçant le texte entre crochets [...], chaque entrée étant séparée par une virgule.
  • Une entrée de tableau associatif est représentée en utilisant l'espace suivi de deux-points clé : valeur avec une entrée par ligne.
  • Plusieurs documents dans un même flux sont séparés par trois tirets ---.

Plus d'infos sur le langage YAML

Les taches font appel aux modules ansible. Tous les principaux modules Ansible sont installés avec Ansible. Mais il est possible d'en ajouter via des collections Ansible.

Pour exécuter ce playbook ansible, il faut utiliser la commande ansible-playbook.

ansible-playbook -i "localhost," -c local playbook.yml

L’affichage est un peu différent :

PLAY [localhost] **************************************************************

GATHERING FACTS ***************************************************************
ok: [localhost]

TASK: [shell echo ’Salut B0B’] ************************************************
changed: [localhost]

PLAY RECAP ********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0

Vous pouvez lister tous les modules ansible installés avec la commande ansible-doc :

ansible-doc --list

Vous pouvez retrouver leur documentation sur le site officielle d'Ansible

Comment configurer Ansible ?

Le fichier de configuration par défaut se trouve dans le répertoire /etc/ansible. Si vous avez installé Ansible avec pip ce fichier n'existe pas, mais pas de souci Ansible dans ce cas utilisera des valeurs par défaut.

Pour vérifier qu'Ansible utilise un éventuel fichier de configuration, vous pouvez utiliser la commande suivante :

ansible [core 2.14.0]
config file = None
configured module search path = ['/home/vagrant/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
ansible python module location = /home/vagrant/.pyenv/versions/3.10.8/lib/python3.10/site-packages/ansible
ansible collection location = /home/vagrant/.ansible/collections:/usr/share/ansible/collections
executable location = /home/vagrant/.pyenv/versions/3.10.8/bin/ansible
python version = 3.10.8 (main, Oct 20 2022, 07:56:05) [GCC 11.2.0] (/home/vagrant/.pyenv/versions/3.10.8/bin/python3.10)
jinja version = 3.1.2
libyaml = False

Dans mon cas, il n'en utilise pas : config file = None !

Je vous conseille d'en créer un dans les cas spécifiques, pour surcharger les valeurs par défaut. Placez ce fichier dans le répertoire où se trouvent les playbooks à exécuter.

Ce fichier est écrit au format ini et comprend différentes sections :

[defaults] [privilege_escalation] [paramiko_connection] [ssh_connection] [accelerate] [selinux] [colors]

La commande ansible-config list la liste de tous les paramètres et de leur équivalent à mettre dans le fichier ansible.cfg:

Par exemple, pour paramétrer la localisation de l'inventaire :

DEFAULT_HOST_LIST:
default: /etc/ansible/hosts
description: Comma separated list of Ansible inventory sources
env:
- name: ANSIBLE_INVENTORY
expand_relative_paths: true
ini:
- key: inventory
section: defaults
name: Inventory Source
type: pathlist
yaml:
key: defaults.inventory

Il faudra ajouter dans la section [defaults] la clé (key) inventory comme ceci :

[defaults]
inventory = ./inventory/prod1

La commande view d'ansible-config d'afficher les valeurs courantes. La commande dump d'ansible-config permet de retrouver les valeurs qui ont été modifiés :

ansible-config dump  --only-changed
DEFAULT_HOST_LIST(/home/vagrant/.local/ansible.cfg) = ['/home/vagrant/.local/inventory/prod1']

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.

Poursuivre votre formation Ansible

Sur l'écriture de code Ansible

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

Développer des modules et des plugins à Ansible

  • Il se peut, c'est de plus en plus rare, que vous ne trouviez pas de modules répondant à votre besoin. Alors, plutôt que de recourir au module shell, vous pouvez développer vos propres modules Ansible
  • Pour adapter Ansible à vos besoins, il est possible de développer vos propres plugins de filtres et lookup

Installer et Utiliser Ansible AWX

Quelques outils complémentaires à Ansible

Quelques cas d'utilisations d'Ansible

Vous avez aussi à votre disposition quelques exemples d'utilisation d'Ansible pour :

Plus d'infos

Livres Gratuits

Livres

MOOC

Sites

Videos