Loading search data...

Apprendre et Maitriser Ansible l'outil de gestion de configuration

Publié le : 25 septembre 2019 | Mis à jour le : 25 septembre 2022

logo ansible

Le premier billet de la formation ansible qui sera je l’espère une longue série.

Maj: c’est une longue série. Tous les liens en bas de ce billet

Introduction

Ansible est au départ un outil gestion de configuration. La gestion de configuration est un processus dont l’objectif est de définir un état, et de le conserver, des ressources d’une infrastructure informatique : les serveurs, les réseaux, les utilisateurs/groupes, les logiciels et la sécurité.

Mais Ansible a bien évolué et ses modules permettent de prendre en charge aussi les taches de la boucle Devops, comme le :

  • Continuous Delivery : La production et le stockage des artefacts doit être aussi automatisé permettant ainsi de fiabiliser leur mise en production.
  • Provisioning : Le provisioning est le processus qui permet de créer les ressources d’une Infrastructure Informatique : un serveur, réseau, des utilisateurs, des services, …
  • Continuous Deployment : Le déploiement des applications doit être fait de manière fiable et cohérente à partir des artefacts.

Ansible fait partie d’un ensemble d’application appelé Ansible Automation Platform qui étend son champ d’action à la gestion de WorkFlows Complexes.

Dans ce billet, nous n’aborderons que Ansible. Si vous voulez plus d’informations sur AWX, en bas de ce billet vous trouverez une belle série de liens.

Présentation d’Ansible

La première version d’Ansible est sorti en 2012 et son créateur s’appelle Michael DeHaan. Initialement appelée AnsibleWorks Inc, la société finançant l’outil ansible a été acquise en 2015 par RedHat qui lui a été racheté par IBM en 2018.

Principe de fonctionnement

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 taches à réaliser.

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éfinit 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 nodes de l’inventaire.
  • 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 les mêmes playbooks, les rôles Ansible apportent la possibilité de regrouper des fonctionnalités spécifiques dans ce qu’on appelle des rôles. Ils seront ensuite intégrés aux playbooks Ansible.
  • Inventory: La liste des systèmes cibles gérés par Ansible est appelé un inventaire. On distingue deux types d’inventaire : l’inventaire statique constitué d’un fichier décrivant la hiérarchie des serveurs et l’inventaire dynamique fourni par un système centralisé recensant tous les nodes de l’infrastructure (ex NoCMDB)
  • Module: Les tâches et les rôles font appel à des modules installés avec Ansible. Je vous invite à consulter la 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 ?

La manière la plus propre pour installer d’Ansible sur le node manager 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 les versions d’Ansible, de python, mais aussi de tous ces modules.

Sur Ubuntu 22.04

Dans votre répertoire de projets :

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 Centos ou Fedora

sudo yum install epel-release
sudo yum install python3-pip
sudo pip3 install -U pip --upgrade
pip3 install ansible --user

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 il suffit d’installer le package python argcomplete :

sudo pip 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 vocubulaire Ansible, le fait d’utiliser le binaire ansible pour exécuter une simple tache 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 crypter 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 noeud d’execution ansible-doc -l -t [type] type parmi: become, cache, callback, cliconf, connection,httpapi, inventory, lookup, netconf, shell, vars, module, strategy.

Comment construire un inventaire ansible ?

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

L’inventaire statique sous Ansible est un fichier 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 rsa
ssh-copy-id -i ~/.ssh/id_rsa.pub server1
ssh-copy-id -i ~/.ssh/id_rsa.pub server2

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

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

À 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 a all qui exécute le module ping sur toutes 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. Ces playbooks utilisent la syntaxe YAML, prend cette forme :

---
- 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 :

  • dont la description (name) est update web servers
  • cible les hosts du groupe webservers
  • demande l’élévation de privilège (become)
  • lance une tache qui vérifie que la dernière version d’apache est bien installé

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 —.

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 les modules ansible avec la commande ansible-doc :

ansible-doc --list

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

Pour quitter votre environnement virtuel il suffit de taper la commande suivante :

deactivate

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 les valeurs par défaut.

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

ansible --version
ansible [core 2.12.4]
  config file = None
  configured module search path = ['/home/vagrant/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /home/vagrant/.local/lib/python3.9/site-packages/ansible
  ansible collection location = /home/vagrant/.ansible/collections:/usr/share/ansible/collections
  executable location = /home/vagrant/.local/bin/ansible
  python version = 3.9.7 (default, Sep 10 2021, 14:59:43) [GCC 11.2.0]
  jinja version = 2.11.3
  libyaml = True

Dans mon cas, il n’en utilise pas !

Je vous conseille de créer dans les cas spécifiques, pour surcharger les valeurs par défaut, 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é :

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

Et la suite…

Ce billet 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 un monde où la technologie évolue continuellement à un rythme rapide et croît incroyablement vite en même temps, les administrateurs système doivent réfléchir à différentes approches pour automatiser les tâches de routine et orchestrer de grands pools de serveurs.

Bien qu’il existe de nombreux outils (Chef, Puppet) qui font la même chose avec quelques différences, Ansible a réussi à les dépasser tous avec sa simplicité, sa sécurité et, surtout sa courbe d’apprentissage fluide.

Dans cette introduction sur les bases d'Ansible, j’ai décris Ansible, é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.

Je vous propose aussi de poursuivre en parcourant d’autres tutoriels qui abordent les sujets suivants :

Les principaux modules Ansible :

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

Si vous voulez trouver des exemples je vous conseille de parcourir Ansible-Galaxy. Ansible-Galaxy est un Hub ou la communauté Ansible partage des rôles et des collections. Il existe aussi de beaux projets comme KubeSpray permettant de déployer des clusters Kubernetes.


Si vous avez apprécié cet article de blog, vous pouvez m'encourager à produire plus de contenu en m'offrant un café sur   Ko-Fi  . Vous pouvez aussi passer votre prochaine commande sur amazon, sans que cela ne nous coûte plus cher, via   ce lien  . Vous pouvez aussi partager le lien sur twitter ou linkedin via les boutons ci-dessous. Je vous remercie de votre soutien


Mots clés :

devops ansible tutorials infra as code formation ansible

Autres Articles


Commentaires: