gérez la configuration de vos serveurs et le déploiement ... · issn : 1960-3444 ansible isbn :...

Ans

ible

ISSN : 1960-3444ISBN : 978-2-409-01241-9

54 €

Pour plus d’informations :

AnsibleGérez la configuration de vos serveurs et le déploiement de vos applications

Ce livre sur Ansible s’adresse aux administrateurs de systèmes Unix qui souhaitent découvrir les différentes fonctionnalités spécifiques de cet outil DevOps permettant la configuration centralisée de serveurs et appli-cations. À l’aide d’exemples concrets, l’auteur apporte au lecteur les connaissances nécessaires pour bien com-prendre l’intérêt de son utilisation. Certains prérequis sur le langage YAML ou l’utilisation du protocole SSH sont un plus pour une utilisation efficace d’Ansible. Dans les premiers chapitres, l’auteur aide toutefois le lecteur à les acquérir pour qu’il puisse tirer le meilleur profit de la lecture du livre. Les chapitres qui suivent traitent des différents mécanismes d’Ansible avec une approche de difficulté pro-gressive. Les premiers mécanismes permettent ainsi d’administrer de façon classique les serveurs alors que les suivants nécessitent des notions plus avancées, notamment sur la programmation Python. Le lecteur y découvre alors comment créer un inventaire, comment réinjecter des informations provenant de sources existantes (ESX, AWS, Docker…) ou comment créer des playbooks. La création de rôles Ansible est également traitée. A côté des notions purement orientées Ansible, certains chapitres sont consacrés au déroulement du déploie-ment d’une application MediaWiki. Le lecteur étudie ainsi les problématiques de parallélisation des tâches, l’introduction d’un répartiteur de charge Haproxy et le lancement en séquence des opérations permettant de réaliser les mises à jour avec un impact minimal (rolling update).La suite du livre détaille plus particulièrement la personnalisation d’Ansible. La restitution d’informations (mécanismes de callback), l’écriture de modules pour la gestion d’opérations, les filtres Jinja ou encore la création d’actions sont ainsi étudiés.Enfin, l’auteur présente dans les derniers chapitres la problématique de la création de machines virtuelles, classiques (via l’hyperviseur ESX/VMWare/VCenter) ou dans le cloud (avec AWS), ainsi que l’utilisation de containers Docker avec Ansible.Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.

Avant-propos • Démarrer avec Ansible • Utilisation d’Ansible • Découverte de l’inventaire • Inventaires : notions avancées • Fonctionnement d’un playbook • Intro-duction à la notion de rôle • Playbooks, rôles et notions avancées • Sortie Ansible et centralisation • Écriture de modules • Écriture de filtres Jinja et mécanisme de loo-kup • Les actions Ansible • Ansible : virtualisation et cloud • Tester Ansible avec Docker

Les chapitres du livre Yannig PERRÉArchitecte technique SI depuis de nom-breuses années, Yannig PERRÉ est aujourd’hui spécialiste de la configuration de serveurs et du déploiement d’applications web. Il associe naturellement à ce savoir-faire des outils de surveillance pour gérer les pro-blématiques d’installation, de résilience, de scalabilité. Associée à sa longue expérience du monde Opensource, cette expertise lui permet de transmettre au lecteur un livre réellement efficace sur la mise en œuvre d’Ansible.

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Les fichiers des exemples utilisés

dans le livre (fichier YAML, inventaire, programme Python...).

Con

figur

atio

n de

vos

ser

veur

s

et d

éplo

iem

ent d

e vo

s ap

plic

atio

ns

Ansible

Yannig PERRÉ

Gérez la configuration de vos serveurs et le déploiement de vos applications

1Table des matières

Avant-propos

1. D’où vient le terme DevOps ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2. Les premiers produits DevOps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3. Cibles et objectifs de l’ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4. Prérequis techniques et ressources documentaires . . . . . . . . . . . . . . . 174.1 Prérequis techniques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174.2 Ressources documentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

5. Présentation générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185.1 Les prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185.2 L’utilisation d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195.3 La personnalisation d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . 195.4 Conventions employées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Chapitre 1

Démarrer avec Ansible

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211.2 Environnement de travail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221.3 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2. Installation d'Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.2 Installation derrière un proxy . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Les éléments à télécharger sont disponibles à l'adresse suivante : http://www.editions-eni.fr

Saisissez la référence ENI de l'ouvrage EPANS dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

lcroise

Tampon

2Configuration des serveurs, déploiement des applications

Ansible

2.3 Installation via les packages système . . . . . . . . . . . . . . . . . . . . . 242.3.1 Installation sous Debian/Ubuntu . . . . . . . . . . . . . . . . . . 242.3.2 Installation sur RHEL, CentOS ou Fedora. . . . . . . . . . . . 24

2.4 Installation via pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.5 Utilisation des packages releases . . . . . . . . . . . . . . . . . . . . . . . . . 252.6 Utilisation de virtualenv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.7 Vérification de la version d'Ansible . . . . . . . . . . . . . . . . . . . . . . . 28

3. Le protocole SSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.1 À propos de SSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.2 Clé publique et clé privée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.3 Génération de la clé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.4 Étapes de l’authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.5 Échange de clé par mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . 323.6 Échange de clé sans mot de passe . . . . . . . . . . . . . . . . . . . . . . . . 343.7 Gestion d’une passphrase avec Ansible . . . . . . . . . . . . . . . . . . . . 34

Chapitre 2

Utilisation d’Ansible

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

2. Ansible en mode ad hoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382.1 Création d’un fichier d’inventaire . . . . . . . . . . . . . . . . . . . . . . . . 382.2 Utilisateur non root . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392.3 Utilisateur SSH non root et mécanisme sudo . . . . . . . . . . . . . . 40

3. Les autres outils d’Ansible : playbook et doc . . . . . . . . . . . . . . . . . . . 44

4. Quelques notions sur le format YAML. . . . . . . . . . . . . . . . . . . . . . . . 474.1 Déclaration de variables simples . . . . . . . . . . . . . . . . . . . . . . . . . 484.2 Les tableaux en YAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.3 Les structures clé/valeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.4 Tableau de tables de hachage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 51


5. Introduction de la notion de playbook . . . . . . . . . . . . . . . . . . . . . . . . 525.1 Structure d’un playbook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525.2 Lancement d’un playbook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6. Combinaison avec Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556.1 Création du repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556.2 Commandes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

6.2.1 Récupération d’un repository Git. . . . . . . . . . . . . . . . . . . 566.2.2 Branche de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576.2.3 État de votre repository. . . . . . . . . . . . . . . . . . . . . . . . . . . 576.2.4 Ajout d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.2.5 Modification d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . 596.2.6 Mise à jour du repository distant . . . . . . . . . . . . . . . . . . . 596.2.7 Récupération des modifications distantes . . . . . . . . . . . . 60

6.3 Mécanisme de hook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616.3.1 Vérification des playbooks avec ansible-lint . . . . . . . . . . 616.3.2 Création du hook pre-commit . . . . . . . . . . . . . . . . . . . . . 626.3.3 Test du fonctionnement du hook . . . . . . . . . . . . . . . . . . 62

Chapitre 3

Découverte de l’inventaire


2. Structure d’un inventaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662.1 Groupes par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672.2 Mode de connexion aux machines . . . . . . . . . . . . . . . . . . . . . . . 672.3 Regroupement de machines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692.4 Variables d’inventaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702.5 Hiérarchie des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712.6 Gestion des différents inventaires . . . . . . . . . . . . . . . . . . . . . . . . 732.7 Création de groupes temporaires. . . . . . . . . . . . . . . . . . . . . . . . . 75


Ansible

Chapitre 4

Inventaires : notions avancées


2. Chiffrement de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802.2 Stockage d’identifiants de connexion . . . . . . . . . . . . . . . . . . . . . 812.3 Chiffrement du fichier entier. . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

2.3.1 Par mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812.3.2 Utilisation d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . 822.3.3 Déchiffrement d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . 842.3.4 Changement du mot de passe de chiffrement. . . . . . . . . 84

2.4 Chiffrement d’un champ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

3. Les inventaires dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863.2 Machines AWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

3.2.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873.2.2 Récupération du script ec2.py . . . . . . . . . . . . . . . . . . . . . 883.2.3 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883.2.4 Test du script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

3.3 Communication avec Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . 893.3.1 Récupération du script d’inventaire . . . . . . . . . . . . . . . . . 893.3.2 Configuration de la communication avec Docker. . . . . . 903.3.3 Test du script d’inventaire . . . . . . . . . . . . . . . . . . . . . . . . 903.3.4 Communication avec les conteneurs Docker . . . . . . . . . 913.3.5 Un petit mot sur le choix de l’image Docker. . . . . . . . . . 92

3.4 Extraction d’informations en provenance d’ESX . . . . . . . . . . . . 933.5 Extraction d’informations de Nagios/Naemon/Shinken. . . . . . 96

4. Écrire son propre inventaire dynamique . . . . . . . . . . . . . . . . . . . . . . . 984.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984.2 Format en entrée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98


4.3 Structure du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 994.3.1 En-tête du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . 994.3.2 Structure de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004.3.3 Chargement du fichier . . . . . . . . . . . . . . . . . . . . . . . . . . 1014.3.4 Transformation et affichage . . . . . . . . . . . . . . . . . . . . . . 1024.3.5 Test du script d’inventaire . . . . . . . . . . . . . . . . . . . . . . . 1034.3.6 Test de l’inventaire dynamique avec Ansible . . . . . . . . 104

5. Ansible et les machines sous Windows. . . . . . . . . . . . . . . . . . . . . . . 1055.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055.2 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065.3 Configuration de la machine . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065.4 Création du fichier d’inventaire. . . . . . . . . . . . . . . . . . . . . . . . . 1085.5 Test de la communication Windows . . . . . . . . . . . . . . . . . . . . 1095.6 Installation d’un package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Chapitre 5

Fonctionnement d’un playbook

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . 1131.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1131.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

2. Le moteur de template Jinja : principe de fonctionnement . . . . . . . 114

3. Template Jinja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183.1 Mécanisme de boucle sur tableau avec Jinja . . . . . . . . . . . . . . . 1193.2 À la recherche de la bonne variable Ansible . . . . . . . . . . . . . . . 1203.3 Affichage des interfaces réseau . . . . . . . . . . . . . . . . . . . . . . . . . 121

4. Délégation de tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1224.1 Changement du type de connexion au niveau d’une tâche. . . 1234.2 Délégation d’une tâche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244.3 Tâche à exécuter une seule fois . . . . . . . . . . . . . . . . . . . . . . . . . 127

5. Gestion d’un serveur Apache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128


Ansible

6. Réduction des opérations impactantes . . . . . . . . . . . . . . . . . . . . . . . 1306.1 Mécanisme des tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

6.1.1 Déclaration d’un tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1316.1.2 Comment lister les tags d’un playbook ?. . . . . . . . . . . . 1316.1.3 Sélection ou exclusion d’un tag . . . . . . . . . . . . . . . . . . . 1326.1.4 Gather facts et le tag always. . . . . . . . . . . . . . . . . . . . . . 133

6.2 Utilisation d’une variable sur une tâche . . . . . . . . . . . . . . . . . . 1336.3 Utilisation d’un handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

6.3.1 Pourquoi utiliser un handler ? . . . . . . . . . . . . . . . . . . . . 1376.3.2 Déclaration d’un handler . . . . . . . . . . . . . . . . . . . . . . . . 1386.3.3 Exemple de lancement . . . . . . . . . . . . . . . . . . . . . . . . . . 139

Chapitre 6

Introduction à la notion de rôle


2. Introduction aux rôles Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1422.1 Structure d’un rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1422.2 Votre premier rôle : installation d’Apache . . . . . . . . . . . . . . . . 1432.3 Configuration du serveur Apache . . . . . . . . . . . . . . . . . . . . . . . 145

3. Installation de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1473.1 Filtres Jinja et installation d’Apache . . . . . . . . . . . . . . . . . . . . . 1473.2 Gestion des variables dans un rôle. . . . . . . . . . . . . . . . . . . . . . . 1523.3 Installation de MariaDB/MySQL . . . . . . . . . . . . . . . . . . . . . . . 1543.4 Installation de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1553.5 Configuration de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

3.5.1 Décompression de l’archive . . . . . . . . . . . . . . . . . . . . . . 1603.5.2 Commande de configuration de MediaWiki . . . . . . . . . 1623.5.3 Dépendances et variables manquantes . . . . . . . . . . . . . 1633.5.4 Lancement de l’installation et configuration

de MediaWiki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165


3.5.5 Changement de version de PHP . . . . . . . . . . . . . . . . . . . 1683.5.6 Boucle et affectation des accès distants

vers la base MariaDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

4. Finalisation de l’installation de MediaWiki . . . . . . . . . . . . . . . . . . . 1744.1 Réentrance et script shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Chapitre 7

Playbooks, rôles et notions avancées


2. Gestion de Python sur les machines distantes . . . . . . . . . . . . . . . . . 1782.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1782.2 Préparation de l’inventaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1782.3 Gestion d’une machine sans Python . . . . . . . . . . . . . . . . . . . . . 1802.4 Emplacement de l’interpréteur . . . . . . . . . . . . . . . . . . . . . . . . . 1822.5 Python3 et Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

3. Scalabilité et répartition de charge . . . . . . . . . . . . . . . . . . . . . . . . . . 1843.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1843.2 Origine du besoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1853.3 Ajout de nouveaux serveurs Apache . . . . . . . . . . . . . . . . . . . . . 1853.4 Lancement d’une opération de manière séquentielle . . . . . . . . 188

4. Ajout d’un répartiteur de charge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1914.1 Pourquoi ajouter un répartiteur de charge ? . . . . . . . . . . . . . . . 1914.2 Différence entre Ubuntu/Debian et Centos/Red Hat . . . . . . . 1914.3 Installation du serveur Haproxy . . . . . . . . . . . . . . . . . . . . . . . . 192

4.3.1 Configuration du serveur Haproxy . . . . . . . . . . . . . . . . 1924.3.2 Mise au point du rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

5. Quelques bonnes pratiques à suivre . . . . . . . . . . . . . . . . . . . . . . . . . 2005.1 Contrôler le lancement des handlers . . . . . . . . . . . . . . . . . . . . . 2005.2 Réduire le temps d’indisponibilité d’un service . . . . . . . . . . . . 202


Ansible

6. Mise à jour et réentrance de script . . . . . . . . . . . . . . . . . . . . . . . . . . 2026.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2026.2 Gestion de la montée de version du schéma. . . . . . . . . . . . . . . 203

7. Mise à jour par roulement (rolling update). . . . . . . . . . . . . . . . . . . . 2067.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2067.2 Présentation du mécanisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2067.3 Rolling update sur MediaWiki. . . . . . . . . . . . . . . . . . . . . . . . . . 2087.4 Désactivation des machines avant mise à jour. . . . . . . . . . . . . 213

7.4.1 Configuration du Haproxy . . . . . . . . . . . . . . . . . . . . . . . 2147.4.2 Désactivation de l’instance Apache avant mise à jour . 2167.4.3 Pollution de la trace Apache . . . . . . . . . . . . . . . . . . . . . . 221

8. Parallélisation et stratégie d’exécution . . . . . . . . . . . . . . . . . . . . . . . 2248.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2248.2 Gestion du nombre de tâches lancées en parallèle . . . . . . . . . . 2248.3 Stratégie d’exécution : free. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

9. Débogage avec Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2299.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2299.2 Activation du débogueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2309.3 Consultation d’informations . . . . . . . . . . . . . . . . . . . . . . . . . . . 2319.4 Modification d'un élément. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2319.5 Relance d’une tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2329.6 Définition d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

10. Ansible Galaxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23310.1 Présentation du site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23310.2 Recherche d’un rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23610.3 Utilisation d’un rôle en provenance d’Ansible Galaxy. . . . . . . 23810.4 Utilisation d’un fichier de prérequis . . . . . . . . . . . . . . . . . . . . . 23810.5 Comment lister les rôles d’Ansible Galaxy ? . . . . . . . . . . . . . . 24010.6 Suppression d’un rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240


Chapitre 8

Sortie Ansible et centralisation


2. Gestion de la sortie standard d’Ansible . . . . . . . . . . . . . . . . . . . . . . . 2422.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2422.2 Fichier de configuration et cowsay . . . . . . . . . . . . . . . . . . . . . . 2422.3 Gestion de la colorisation de la sortie . . . . . . . . . . . . . . . . . . . . 245

3. Gestion du callback d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2473.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2473.2 Quelques plugins d’affichage alternatifs . . . . . . . . . . . . . . . . . . 2483.3 Profiling des opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

4. Centralisation des résultats d’exécution . . . . . . . . . . . . . . . . . . . . . . 2514.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2514.2 Centralisation via Syslog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2524.3 Centralisation via Logstash (Elasticsearch). . . . . . . . . . . . . . . . 253

5. Écriture de son propre callback d’affichage. . . . . . . . . . . . . . . . . . . . 2575.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2575.2 Structure du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2585.3 Exposition du callback à Ansible . . . . . . . . . . . . . . . . . . . . . . . . 2595.4 Nomenclature des fonctions de callback. . . . . . . . . . . . . . . . . . 2615.5 Exemple de surcharge de la sortie en cas d’erreur. . . . . . . . . . . 261

Chapitre 9

Écriture de modules



Ansible

2. Mécanisme d’appel des modules Python . . . . . . . . . . . . . . . . . . . . . 2662.1 Principe de fonctionnement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2662.2 Activation des traces d’exécution . . . . . . . . . . . . . . . . . . . . . . . 2672.3 Contenu du fichier temporaire . . . . . . . . . . . . . . . . . . . . . . . . . 2682.4 Extraction du programme autoporteur. . . . . . . . . . . . . . . . . . . 269

3. Pourquoi écrire un module ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2703.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2703.2 Consultation du schéma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

4. Création d’un module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2734.1 Emplacement du programme. . . . . . . . . . . . . . . . . . . . . . . . . . . 2734.2 En-tête du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2744.3 Spécification des arguments du module . . . . . . . . . . . . . . . . . . 2744.4 Gestion des arguments du module . . . . . . . . . . . . . . . . . . . . . . 2754.5 Récupération de la valeur des arguments . . . . . . . . . . . . . . . . . 2764.6 Connexion à la base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2774.7 Transmission du résultat à Ansible . . . . . . . . . . . . . . . . . . . . . . 2784.8 Test du module. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2794.9 Temps d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2804.10 Gestion de l’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

4.10.1 Variable DOCUMENTATION . . . . . . . . . . . . . . . . . . . 2824.10.2 Variable EXAMPLES . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2834.10.3 Variable RETURN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2834.10.4 Variable METADATA. . . . . . . . . . . . . . . . . . . . . . . . . . . 2844.10.5 Test d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

4.11 Cas particulier des modules facts . . . . . . . . . . . . . . . . . . . . . . . 285

5. Réentrance sur la création d’un schéma de base. . . . . . . . . . . . . . . . 2875.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2875.2 Limitations du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2885.3 Dépendances Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2885.4 En-tête du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2885.5 Gestion de la base de données . . . . . . . . . . . . . . . . . . . . . . . . . . 2895.6 Python 2 et 3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290


5.7 Algorithme du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2925.8 Création d’un playbook de test . . . . . . . . . . . . . . . . . . . . . . . . . 293

6. Gestion de l’option diff d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . 2966.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2966.2 Principe de fonctionnement du diff. . . . . . . . . . . . . . . . . . . . . . 2966.3 Implémentation du diff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

7. Gestion de l’option test (check mode) . . . . . . . . . . . . . . . . . . . . . . . 2997.1 Activation du check mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2997.2 Prise en charge du mode check . . . . . . . . . . . . . . . . . . . . . . . . . 300

Chapitre 10

Écriture de filtres Jinja et mécanisme de lookup


2. Les filtres Jinja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3042.1 Retour sur les filtres Jinja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3042.2 Quelques exemples d’utilisation des filtres Jinja . . . . . . . . . . . 304

2.2.1 Comment tester un filtre ? . . . . . . . . . . . . . . . . . . . . . . . 3042.2.2 Valeur par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3052.2.3 Conversion de type simple . . . . . . . . . . . . . . . . . . . . . . . 3052.2.4 Chargement de YAML/JSON . . . . . . . . . . . . . . . . . . . . . 3062.2.5 Gestion de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3072.2.6 Calcul de somme de hachage . . . . . . . . . . . . . . . . . . . . . 3082.2.7 Combinaison de table de hachage . . . . . . . . . . . . . . . . . 309

3. Test de comparaison de mots de passe salés. . . . . . . . . . . . . . . . . . . 3093.1 Quelques mots sur le stockage des mots de passe . . . . . . . . . . 3103.2 Réentrance sur un mot de passe . . . . . . . . . . . . . . . . . . . . . . . . 3113.3 Récupération du hash du mot de passe. . . . . . . . . . . . . . . . . . . 312


Ansible

3.4 Écriture du filtre de comparaison . . . . . . . . . . . . . . . . . . . . . . . 3133.4.1 Emplacement du programme . . . . . . . . . . . . . . . . . . . . . 3133.4.2 Fonction de comparaison des mots de passe . . . . . . . . . 3143.4.3 Mapping Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3143.4.4 Tests du filtre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

3.5 Utilisation du filtre dans le playbook . . . . . . . . . . . . . . . . . . . . 317

4. Génération de mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3194.1 Origine du besoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3194.2 Principe de fonctionnement du générateur de mots de passe . 319

4.2.1 Écriture du générateur de mot de passe . . . . . . . . . . . . . 3204.3 Playbook de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

5. Récupération d'informations (lookup) . . . . . . . . . . . . . . . . . . . . . . . 3225.1 Principe de fonctionnement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3225.2 Présentation des lookups Ansible natifs . . . . . . . . . . . . . . . . . . 322

5.2.1 Lecture de fichiers : file . . . . . . . . . . . . . . . . . . . . . . . . . . 3225.2.2 Récupération du résultat d’un template . . . . . . . . . . . . 3235.2.3 Réalisation d'une requête DNS : dig. . . . . . . . . . . . . . . . 323

5.3 Le mécanisme de lookup et les boucles . . . . . . . . . . . . . . . . . . . 324

6. Écriture de son propre lookup : KeePass . . . . . . . . . . . . . . . . . . . . . . 3266.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3266.2 Dépendance Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3266.3 Récupération du mot de passe. . . . . . . . . . . . . . . . . . . . . . . . . . 3266.4 Intégration avec Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

6.4.1 Emplacement du fichier Python . . . . . . . . . . . . . . . . . . . 3286.4.2 Exposition de l’objet lookup . . . . . . . . . . . . . . . . . . . . . . 3286.4.3 Code du plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

6.5 Test du plugin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3296.5.1 Contenu base KeePass et présentation de KeePassX. . . 3306.5.2 Création du test. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330


Chapitre 11

Les actions Ansible


2. Découverte des actions Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3342.1 Fonctionnement des actions Ansible . . . . . . . . . . . . . . . . . . . . 3342.2 Certificats SSL avec Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3342.3 Importation d’un certificat avec Ansible . . . . . . . . . . . . . . . . . 335

3. Création du module d’action java_cert . . . . . . . . . . . . . . . . . . . . . . . 3383.1 Emplacement du fichier d’action. . . . . . . . . . . . . . . . . . . . . . . . 3383.2 Structure du module d’action java_cert . . . . . . . . . . . . . . . . . . 3393.3 En-tête du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3403.4 Contenu de la méthode run . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3403.5 Test du module action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

Chapitre 12

Ansible : virtualisation et cloud


2. Gestion de machines virtuelles sous ESX/VMWare. . . . . . . . . . . . . 3462.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3462.2 Installation des bibliothèques requises . . . . . . . . . . . . . . . . . . . 3462.3 Caractéristiques de l’ESX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3462.4 Création de la VM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3472.5 Customisation des machines . . . . . . . . . . . . . . . . . . . . . . . . . . . 3492.6 Gestion du démarrage de la machine . . . . . . . . . . . . . . . . . . . . 3512.7 Suppression de la VM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354


Ansible

3. Gestion cloud AWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3553.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3553.2 Configuration des accès à l’API Amazon . . . . . . . . . . . . . . . . . 3573.3 Création d’une instance EC2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 3623.4 Comment taguer ses instances ? . . . . . . . . . . . . . . . . . . . . . . . . 3643.5 Suppression d’une instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3673.6 Accès réseau aux machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3683.7 Configuration de la clé SSH. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3703.8 Modification de la déclaration de l'instance ec2 . . . . . . . . . . . . 371

Chapitre 13

Tester Ansible avec Docker


2. Ansible, Docker et Systemd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3762.1 Comment faire cohabiter Docker et Systemd ? . . . . . . . . . . . . 3762.2 Choix des images à lancer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3772.3 Alimentation du fichier d’inventaire. . . . . . . . . . . . . . . . . . . . . 3772.4 Playbook de création des conteneurs. . . . . . . . . . . . . . . . . . . . . 3792.5 Playbook de suppression des conteneurs . . . . . . . . . . . . . . . . . 381

3. Les images Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3833.1 Présence de l’interpréteur Python . . . . . . . . . . . . . . . . . . . . . . . 3833.2 Création d’une image Docker . . . . . . . . . . . . . . . . . . . . . . . . . . 384

3.2.1 D’où vient l’absence de Python ? . . . . . . . . . . . . . . . . . . 3843.2.2 Création du fichier Dockerfile . . . . . . . . . . . . . . . . . . . . 3843.2.3 Compilation de l’image Docker . . . . . . . . . . . . . . . . . . . 3853.2.4 Utilisation de l’image Docker . . . . . . . . . . . . . . . . . . . . . 386

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

Chapitre 3

Découverte de l’inventaire

Découverte de l’inventaire1. Objectifs du chapitre et prérequis

Dans le chapitre précédent, vous avez vu comment installer Ansible et lancerquelques commandes sur la machine locale. Vous allez voir maintenantcomment adresser vos requêtes à différentes machines et profiter de la capaci-té de lancement en parallèle d’Ansible pour l’exécution de vos opérations.

1.1 Contexte et prérequis

Les exemples traités dans ce chapitre partent du principe que :

– vous disposez de machines Linux sur lesquelles vous avez effectué voséchanges de clés SSH (cf. chapitre Démarrer avec Ansible) ;

– vous disposez de droits root sur vos machines.

1.2 Fichiers téléchargeables

Vous pouvez récupérer les exemples des répertoires inventaires et variables surle repository GitHub suivant : https://github.com/EditionsENI/ansible

Vous pouvez également récupérer ces fichiers dans l’archive chapitre-03.tar.gz sur la page du livre sur le site des Éditions ENI.

lcroise

Tampon

© E

dit

ions

EN

I -

All r

ights

rese

rved


Ansible

2. Structure d’un inventaire

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

Prenez un exemple avec les éléments suivants :

– un groupe apache constitué de la machine rec-apache-1 ;

– un groupe mysql avec la machine rec-mysql-1.

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

[apache]

rec-apache-1

[mysql]

rec-mysql-1

Par la suite, ce fichier sera référencé sous le nom de fichier host ou fichierd’inventaire. Il sera accessible sous le nom de recette.inv.

Pour y faire appel, il faudra passer l’option -i à ansible avec le nom dufichier.

dAfin de vérifier que la communication avec les machines distantes se passebien, vous allez appeler ansible avec le module ping (en passant le nomdu module avec l’option -m).

Ci-dessous un exemple d’appel avec l’inventaire :

$ ansible -i recette.inv -m ping all

Si tout se passe bien, Ansible devrait renvoyer le résultat suivant :

rec-mysql-1 | SUCCESS => {

"changed": false,

"ping": "pong"

}

rec-apache-1 | SUCCESS => {

"changed": false,

"ping": "pong"

}

67Découverte de l’inventaireChapitre 3

2.1 Groupes par défaut

En plus des groupes que vous déclarez dans votre inventaire, il existe deuxautres groupes : all et ungrouped. Le premier contient toutes les machinesde l’inventaire sans distinction. Les machines qui ne sont rattachées à aucungroupe (c’est le cas pour localhost si vous ne le déclarez pas dans votre inven-taire) se retrouveront dans ungrouped.

Un moyen simple de consulter cette liste est de faire appel à la commandeansible avec le module debug (-m debug) en lui passant la variablegroups (-a var=groups).

Ci-dessous, la commande à lancer :

$ ansible -m debug -a var=groups localhost

Cette commande vous renvoit alors le résultat suivant :

[WARNING]: provided hosts list is empty, only localhost is available

localhost | SUCCESS => {

"changed": false,

"groups": {

"all": [],

"ungrouped": [

"localhost"

]

}

}

Si vous n'indiquez pas d’inventaire à Ansible, ce dernier mettra toujours àvotre disposition la machine localhost dans le groupe ungrouped.

2.2 Mode de connexion aux machines

Par défaut, vous accédez aux machines avec SSH. Néanmoins, Ansible gèred’autres types de connexion. Vous pouvez retenir les modes suivants :

– ssh : connexion vers tout type d’Unix (Linux, *BSD, AIX, Solaris, etc.) ;

– local : cas de la machine localhost ;

– docker : connexion à des conteneurs ;

© E

dit

ions

EN

I -

All r

ights

rese

rved


Ansible

– chroot/jail : travail dans un environnement isolé ;

– winrm : connexion aux machines Windows.

Il existe de très nombreux plugins. Le mieux est de se référer à la documenta-tion d’Ansible.

Dans le cas où vous voulez changer le mode de connexion par défaut à votremachine, vous devez renseigner la variable ansible_connection. PourWindows, le mode devra être positionné sur la valeuransible_connection=winrm et pour un conteneur docker, vous utilise-rez ansible_connection=docker. Ce changement de mode peut se faireen ajoutant la variable directement après la déclaration de la machine.

Ci-dessous un exemple de déclaration d’une machine Windows et d’un conte-neur Docker :

[active-directory]

active-directory-1 ansible_connection=winrm

[container]

container-1 ansible_connection=docker

Enfin, il est également possible de changer temporairement le mode deconnexion à une machine au niveau d’un playbook en utilisant l’instructionconnection.

Ci-dessous un exemple de playbook utilisant le mode local :

- name: "Retrieve facts and store them locally"

hosts: all

gather_facts: no

connection: local

tasks:

- name: "Create directory for each machine"

file:

path: "/tmp/{{inventory_hostname}}"

state: "directory"

Remarque

Ici, la variable inventory_hostname est une variable « magique » qui vousrenverra le nom de la machine tel que déclaré dans l’inventaire.

69Découverte de l’inventaireChapitre 3

2.3 Regroupement de machines

Il est possible de regrouper des machines à l’aide de sections se terminant par":children" (exemple : linux:children). Ce mécanisme permet de re-grouper des machines dans des ensembles plus grands et d’éviter de les redé-clarer.

dReprenez le cas de l'inventaire recette.inv et ajoutez-y de nouvellesmachines :– La machine active-directory-1 dans le groupe active-

directory.– Le conteneur container-1 dans le groupe microservices.

dVous allez également regrouper les machines de la manière suivante :– Un groupe linux contenant les machines du groupe apache et mysql.– Dans le groupe windows les machines du groupe active-directory.– Enfin un groupe container avec les machines du groupe microser-vices.

dVous profiterez de ces groupes pour affecter le mode de connexion à l’aidede sections groupe:vars (variable ansible_connection positionnéeà winrm ou docker en fonction du type d’OS).

Ci-dessous le fichier d’inventaire correspondant :

[all:vars]

ansible_connection=local

[apache]

rec-apache-1 apache_url=rec.wiki.localdomain

[mysql]

rec-mysql-1 mysql_user_password=MyPassWord!

[active-directory]

active-directory-1

[microservices]

container-1 ansible_connection=docker

[linux:children]

© E

dit

ions

EN

I -

All r

ights

rese

rved


Ansible

apache

mysql

[windows:children]

active-directory

[container:children]

microservices

[windows:vars]

ansible_connection=winrm

[container:vars]

ansible_connection=localhost

2.4 Variables d’inventaire

Vous avez vu comment déclarer vos machines et comment changer le modede connexion à celles-ci avec ansible_connection. Vous allez maintenantvoir comment pousser le mécanisme un peu plus loin. En effet, vous aurezparfois envie de personnaliser vos machines en fonction de variables. Vouspourrez ainsi :

– gérer l’installation de package en fonction de vos variables ;

– personnaliser les messages d’accueil de vos machines ;

– attribuer des mots de passe en fonction des machines ou des groupesauxquels elles appartiennent.

Le nom de ces variables doit être forcément en alphanumérique et commencerpar une lettre ou un tiret-bas (cf. Quelques notions sur le format YAML duchapitre Utilisation d’Ansible).

Ces variables peuvent être positionnées au niveau de la déclaration des ma-chines ou au niveau des groupes. Ci-dessous un exemple de déclaration de lavariable apache_url pour la machine rec-apache-1 :

[apache]

rec-apache-1 apache_url=rec.wiki.localdomain

gérez la configuration de vos serveurs et le déploiement ... · issn : 1960-3444 ansible isbn :...

Documents