Configuration de vos serveurs et déploiement de vos ...

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

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

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

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

54 €

Ans

ible

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é progres-sive. Les premiers mécanismes permettent ainsi d’administrer de façon classique les serveurs (Unix ou Win-dows) 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 ainsi que quelques bonnes pratiques à suivre (analyse de code et test avec Molecule/Docker).À 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). L’optimisation des tâches sera également un point important avec la mise en place de Mitogen.La suite du livre détaille plus particulièrement la personnalisation d’Ansible. La restitution d’informations (mécanismes de callback et découverte de ARA), 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), l’utilisation de containers Docker avec Ansible, le pilotage d’applications dans un cluster Kubernetes ainsi que la création d’un opérateur.Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.

Yannig PERRÉAdministrateur système depuis de nombreuses 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 problé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.

Con

figur

atio

n de

vos

serv

eurs

et

dép

loie

men

t de

vos a

pplic

atio

ns

Ansible

Yannig PERRÉ

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

2e édition

En téléchargement

Fichiers d’exemple

Pour plus d’informations :

+ QUIZVersion en ligne

OFFERTE !pendant 1 an

1Table des matières

Avant-propos1. D’où vient le terme DevOps ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2. Les premiers produits DevOps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

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

4. Prérequis techniques et ressources documentaires . . . . . . . . . . . . . . . 234.1 Prérequis techniques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2 Ressources documentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5. Présentation générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245.1 Les prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255.2 L’utilisation d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255.3 La personnalisation d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . 265.4 Conventions employées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Chapitre 1Démarrer avec Ansible

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271.2 Version de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281.3 Environnement de travail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281.4 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2. Installation d'Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.2 Installation derrière un proxy . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

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

Saisissez la référence de l'ouvrage EP2ANS 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 . . . . . . . . . . . . . . . . . . . . . 302.3.1 Installation sous Debian/Ubuntu . . . . . . . . . . . . . . . . . . . 302.3.2 Installation sur RHEL, CentOS ou Fedora . . . . . . . . . . . 30

2.4 Installation via pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.5 Utilisation des packages releases . . . . . . . . . . . . . . . . . . . . . . . . . 312.6 Utilisation de virtualenv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332.7 Vérification de la version d'Ansible . . . . . . . . . . . . . . . . . . . . . . . 34

3. Le protocole SSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.1 À propos de SSH. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.2 Clé publique et clé privée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.3 Génération de la clé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363.4 Étapes de l’authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.5 Parc important de machines ou hébergement dans le cloud . . . 383.6 Échange de clé par mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . 393.7 Échange de clé sans mot de passe . . . . . . . . . . . . . . . . . . . . . . . . 403.8 Gestion d’une passphrase avec Ansible . . . . . . . . . . . . . . . . . . . . 41

Chapitre 2Utilisation d’Ansible

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431.1 Contexte et prérequis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2. Ansible en mode ad hoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442.1 Création d’un fichier d’inventaire . . . . . . . . . . . . . . . . . . . . . . . . 442.2 Utilisateur non root . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452.3 Utilisateur SSH non root et mécanisme sudo . . . . . . . . . . . . . . 47

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

4. Quelques notions sur le format YAML. . . . . . . . . . . . . . . . . . . . . . . . 544.1 Déclaration de variables simples . . . . . . . . . . . . . . . . . . . . . . . . . 554.2 Les tableaux en YAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.3 Les structures clé/valeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57


4.4 Tableau de tables de hachage. . . . . . . . . . . . . . . . . . . . . . . . . . . . 584.5 Inventaire au format YAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

5. Introduction de la notion de playbook . . . . . . . . . . . . . . . . . . . . . . . . 605.1 Structure d’un playbook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605.2 Lancement d’un playbook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

6. Combinaison avec Git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.1 Création du repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.2 Commandes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

6.2.1 Récupération d’un repository Git . . . . . . . . . . . . . . . . . . 646.2.2 Branche de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656.2.3 État de votre repository . . . . . . . . . . . . . . . . . . . . . . . . . . 666.2.4 Ajout d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666.2.5 Modification d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . 676.2.6 Mise à jour du repository distant. . . . . . . . . . . . . . . . . . . 686.2.7 Récupération des modifications distantes. . . . . . . . . . . . 68

6.3 Mécanisme de hook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696.3.1 Vérification des playbooks avec ansible-lint . . . . . . . . . . 706.3.2 Création du hook pre-commit . . . . . . . . . . . . . . . . . . . . . 706.3.3 Test du fonctionnement du hook . . . . . . . . . . . . . . . . . . 71

Chapitre 3Découverte de l’inventaire

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

2. Structure d’un inventaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742.1 Groupes par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752.2 Mode de connexion aux machines . . . . . . . . . . . . . . . . . . . . . . . 762.3 Regroupement de machines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 772.4 Variables d’inventaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802.5 Hiérarchie des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81


Ansible

2.6 Gestion des différents inventaires . . . . . . . . . . . . . . . . . . . . . . . . 832.7 Création de groupes temporaires. . . . . . . . . . . . . . . . . . . . . . . . . 85

3. Fusion d'inventaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Chapitre 4Inventaires : notions avancées

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891.1 Contexte et prérequis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

2. Chiffrement de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.2 Stockage d’identifiants de connexion . . . . . . . . . . . . . . . . . . . . . 902.3 Chiffrement du fichier entier. . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

2.3.1 Par mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.3.2 Utilisation d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . 922.3.3 Déchiffrement d’un fichier. . . . . . . . . . . . . . . . . . . . . . . . 932.3.4 Changement du mot de passe de chiffrement . . . . . . . . 94

2.4 Chiffrement d’un champ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

3. Les inventaires dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963.2 Machines AWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

3.2.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973.2.2 Récupération du script ec2.py . . . . . . . . . . . . . . . . . . . . . 973.2.3 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983.2.4 Test du script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

3.3 Communication avec Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . 993.3.1 Récupération du script d’inventaire. . . . . . . . . . . . . . . . . 993.3.2 Configuration de la communication avec Docker . . . . 1003.3.3 Test du script d’inventaire . . . . . . . . . . . . . . . . . . . . . . . 1003.3.4 Communication avec les conteneurs Docker . . . . . . . . 1013.3.5 Un petit mot sur le choix de l’image Docker . . . . . . . . 102


3.4 Extraction d’informations en provenance d’ESX . . . . . . . . . . . 1033.5 Extraction d’informations de Nagios/Naemon/Shinken. . . . . 106

4. Fonctionnement des plugins d’inventaires génériques . . . . . . . . . . 1084.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084.2 Connecteur supporté par le format auto . . . . . . . . . . . . . . . . . 1094.3 Exemples de fichiers d’inventaire au format auto . . . . . . . . . . 1104.4 Utilisation de la commande ansible-inventory. . . . . . . . . . . . . 1114.5 Inventaire des instances ec2. . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

5. Écrire son propre inventaire dynamique . . . . . . . . . . . . . . . . . . . . . . 1135.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1135.2 Format en entrée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145.3 Structure du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

5.3.1 En-tête du programme . . . . . . . . . . . . . . . . . . . . . . . . . . 1145.3.2 Chargement du fichier . . . . . . . . . . . . . . . . . . . . . . . . . . 1155.3.3 Transformation et alimentation de l'inventaire . . . . . . 1165.3.4 Test du script d’inventaire . . . . . . . . . . . . . . . . . . . . . . . 1185.3.5 Test de l’inventaire dynamique avec Ansible . . . . . . . . 119

Chapitre 5Administration Windows

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . 1211.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1211.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

2. Ansible et les machines sous Windows. . . . . . . . . . . . . . . . . . . . . . . 1222.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1222.2 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1222.3 Configuration de la machine . . . . . . . . . . . . . . . . . . . . . . . . . . . 1232.4 Création du fichier d’inventaire. . . . . . . . . . . . . . . . . . . . . . . . . 1242.5 Test de la communication Windows . . . . . . . . . . . . . . . . . . . . 1252.6 Installation d’un package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126


Ansible

3. Gestion de service Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283.2 Installation de Prometheus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283.3 Création du playbook. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1293.4 Lancement de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1313.5 Consultation de la console Prometheus . . . . . . . . . . . . . . . . . . 132

4. Création de service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1334.1 Installation de Grafana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

4.1.1 Présentation de Grafana . . . . . . . . . . . . . . . . . . . . . . . . . 1334.1.2 Création du playbook . . . . . . . . . . . . . . . . . . . . . . . . . . . 1344.1.3 Lancement de l’installation . . . . . . . . . . . . . . . . . . . . . . 135

4.2 Création d’un service Windows. . . . . . . . . . . . . . . . . . . . . . . . . 1364.2.1 Recherche du programme de lancement de Grafana . . 1364.2.2 Gestionnaire de services NSSM . . . . . . . . . . . . . . . . . . . 1374.2.3 Création du service Grafana . . . . . . . . . . . . . . . . . . . . . . 1374.2.4 Playbook complet d’installation de Grafana . . . . . . . . . 138

4.3 Mécanismes de secours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1404.4 Consultation de l’interface Grafana . . . . . . . . . . . . . . . . . . . . . 144

Chapitre 6Fonctionnement d’un playbook

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . 1471.1 Contexte et prérequis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1471.2 Fichiers téléchargeables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

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

3. Template Jinja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1523.1 Mécanisme de boucle sur tableau avec Jinja . . . . . . . . . . . . . . . 1533.2 À la recherche de la bonne variable Ansible . . . . . . . . . . . . . . . 1543.3 Affichage des interfaces réseau . . . . . . . . . . . . . . . . . . . . . . . . . 155


4. Délégation de tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1564.1 Changement du type de connexion au niveau d’une tâche. . . 1574.2 Délégation d’une tâche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1584.3 Tâche à exécuter une seule fois . . . . . . . . . . . . . . . . . . . . . . . . . 161

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

6. Réduction des opérations impactantes . . . . . . . . . . . . . . . . . . . . . . . 1656.1 Mécanisme des tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

6.1.1 Déclaration d’un tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1656.1.2 Comment lister les tags d’un playbook ? . . . . . . . . . . . 1666.1.3 Sélection ou exclusion d’un tag . . . . . . . . . . . . . . . . . . . 1666.1.4 Gather facts et le tag always . . . . . . . . . . . . . . . . . . . . . 167

6.2 Utilisation d’une variable sur une tâche . . . . . . . . . . . . . . . . . . 1686.3 Utilisation d’un handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

6.3.1 Pourquoi utiliser un handler ? . . . . . . . . . . . . . . . . . . . . 1726.3.2 Déclaration d’un handler . . . . . . . . . . . . . . . . . . . . . . . . 1736.3.3 Exemple de lancement . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Chapitre 7Introduction à la notion de rôle


2. Introduction aux rôles Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1782.1 Structure d’un rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1782.2 Votre premier rôle : installation d’Apache . . . . . . . . . . . . . . . . 1792.3 Configuration du serveur Apache . . . . . . . . . . . . . . . . . . . . . . . 181

3. Installation de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1833.1 Filtres Jinja et installation d’Apache . . . . . . . . . . . . . . . . . . . . . 1833.2 Gestion des variables dans un rôle. . . . . . . . . . . . . . . . . . . . . . . 1883.3 Installation de MariaDB/MySQL . . . . . . . . . . . . . . . . . . . . . . . 1903.4 Installation de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192


Ansible

3.5 Configuration de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . 1963.5.1 Décompression de l’archive . . . . . . . . . . . . . . . . . . . . . . 1963.5.2 Mutualisation de la base MariaDB

et du serveur Apache (SELinux) . . . . . . . . . . . . . . . . . . . 1983.5.3 Commande de configuration de MediaWiki . . . . . . . . . 1993.5.4 Dépendances et variables manquantes . . . . . . . . . . . . . 2003.5.5 Lancement de l’installation et configuration

de MediaWiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2033.5.6 Changement de version de PHP. . . . . . . . . . . . . . . . . . . 2053.5.7 Boucle et affectation des accès distants

vers la base MariaDB . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

4. Finalisation de l’installation de MediaWiki . . . . . . . . . . . . . . . . . . . 2124.1 Réentrance et script shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2124.2 Problème de redirection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

Chapitre 8Playbooks, rôles et notions avancées


2. Gestion de Python sur les machines distantes . . . . . . . . . . . . . . . . . 2162.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2162.2 Préparation de l’inventaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2172.3 Gestion d’une machine sans Python . . . . . . . . . . . . . . . . . . . . . 2182.4 Détection automatique de l’interpréteur . . . . . . . . . . . . . . . . . 2202.5 Positionnement de l'emplacement de l'interpréteur Python . . 2212.6 Python3 et Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

3. Scalabilité et répartition de charge . . . . . . . . . . . . . . . . . . . . . . . . . . 2233.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2233.2 Origine du besoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2243.3 Ajout de nouveaux serveurs Apache . . . . . . . . . . . . . . . . . . . . . 2253.4 Lancement d’une opération de manière séquentielle . . . . . . . . 227


4. Ajout d’un répartiteur de charge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2304.1 Pourquoi ajouter un répartiteur de charge ? . . . . . . . . . . . . . . . 2304.2 Différence entre Ubuntu/Debian et Centos/Red Hat . . . . . . . 2314.3 Installation du serveur Haproxy . . . . . . . . . . . . . . . . . . . . . . . . 231

4.3.1 Configuration du serveur Haproxy . . . . . . . . . . . . . . . . 2324.3.2 Mise au point du rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

5. Quelques bonnes pratiques à suivre . . . . . . . . . . . . . . . . . . . . . . . . . 2395.1 Contrôler le lancement des handlers . . . . . . . . . . . . . . . . . . . . . 2395.2 Réduire le temps d’indisponibilité d’un service . . . . . . . . . . . . 241

6. Mise à jour et réentrance de script . . . . . . . . . . . . . . . . . . . . . . . . . . 2416.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2416.2 Gestion de la montée de version du schéma. . . . . . . . . . . . . . . 242

7. Mise à jour par roulement (rolling update). . . . . . . . . . . . . . . . . . . . 2457.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2457.2 Présentation du mécanisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2467.3 Rolling update sur MediaWiki. . . . . . . . . . . . . . . . . . . . . . . . . . 2477.4 Désactivation des machines avant mise à jour . . . . . . . . . . . . . 252

7.4.1 Configuration du Haproxy. . . . . . . . . . . . . . . . . . . . . . . 2537.4.2 Désactivation de l’instance Apache avant mise à jour . 2557.4.3 Utilisation de l'instruction include_role . . . . . . . . . . . . 2607.4.4 Pollution de la trace Apache . . . . . . . . . . . . . . . . . . . . . . 261

8. Inclusion et réutilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2648.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2648.2 Inclusion statique de tâches. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2658.3 Inclusion dynamique de tâches . . . . . . . . . . . . . . . . . . . . . . . . . 2668.4 Gestion du comportement de l’instruction de boucle . . . . . . . 267

8.4.1 Contrôle du nom de la variable de boucle . . . . . . . . . . . 2678.4.2 Autres mots-clés intéressants. . . . . . . . . . . . . . . . . . . . . 268

9. Ansible Galaxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2699.1 Présentation du site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2699.2 Recherche d’un rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2719.3 Utilisation d’un rôle en provenance d’Ansible Galaxy. . . . . . . 273


Ansible

9.4 Utilisation d’un fichier de prérequis . . . . . . . . . . . . . . . . . . . . . 2749.5 Comment lister les rôles d’Ansible Galaxy ? . . . . . . . . . . . . . . 2759.6 Suppression d’un rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2759.7 Collections Ansible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

9.7.1 Origine du besoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2769.7.2 Recherche de collections. . . . . . . . . . . . . . . . . . . . . . . . . 2779.7.3 Installation d’une collection. . . . . . . . . . . . . . . . . . . . . . 2779.7.4 Consultation de la liste des collections . . . . . . . . . . . . . 2789.7.5 Utilisation d’une version spécifique . . . . . . . . . . . . . . . 2789.7.6 Utilisation d’un fichier de dépendances . . . . . . . . . . . . 2799.7.7 Gestion des datasources Grafana . . . . . . . . . . . . . . . . . . 280

Chapitre 9Stratégie d’exécution et optimisation

1. Objectifs du chapitre et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

2. Stratégie d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2832.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2832.2 Gestion du nombre de tâches lancées en parallèle . . . . . . . . . . 2842.3 Stratégie d’exécution : free. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

3. Débogage avec Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2883.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2883.2 Consultation d’informations . . . . . . . . . . . . . . . . . . . . . . . . . . . 2903.3 Modification d'un élément. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2903.4 Relance d’une tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2913.5 Définition d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

4. Étude du fonctionnement d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . 2934.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2934.2 Playbook de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2934.3 Opérations lancées par Ansible . . . . . . . . . . . . . . . . . . . . . . . . . 295


5. Présentation de Mitogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2975.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2975.2 Présentation de Mitogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2985.3 Principe de fonctionnement de Mitogen. . . . . . . . . . . . . . . . . . 2985.4 Activation de Mitogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2995.5 Gains potentiels et limitations . . . . . . . . . . . . . . . . . . . . . . . . . 300

Chapitre 10Tests Ansible


2. Linter Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3012.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3012.2 Lancement de l’analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3022.3 Règles disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3022.4 Désactivation de règles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3032.5 Création de nouvelles règles. . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

3. Présentation de Molecule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3063.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3063.2 Prérequis et installation de Molecule . . . . . . . . . . . . . . . . . . . . 3063.3 Installation de Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

3.3.1 Installation de Docker Community Edition sur Ubuntu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

3.3.2 Installation alternative . . . . . . . . . . . . . . . . . . . . . . . . . . 3083.3.3 Configuration des accès à Docker . . . . . . . . . . . . . . . . . 3083.3.4 Vérification de l’installation de Docker . . . . . . . . . . . . . 309

4. Utilisation de Molecule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3104.1 Fichier de configuration molecule.yml . . . . . . . . . . . . . . . . . . . 3104.2 Création d’un rôle Apache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

4.2.1 Initialisation du rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3104.2.2 Structure du rôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3114.2.3 Intégration du rôle Apache. . . . . . . . . . . . . . . . . . . . . . . 3124.2.4 Playbook de convergence . . . . . . . . . . . . . . . . . . . . . . . . 312


Ansible

4.2.5 Vérification de l’installation. . . . . . . . . . . . . . . . . . . . . . 3134.3 Lancement des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3144.4 Débogage du problème. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

4.4.1 Lancement de Molecule en mode debug . . . . . . . . . . . . 3174.4.2 Connexion au container de tests . . . . . . . . . . . . . . . . . . 317

4.5 Configuration pour le fonctionnement avec System D. . . . . . 3194.5.1 Modification de la définition de la plateforme

(champ platforms) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3194.5.2 Relance des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

4.6 Gestion des scénarios de Molecule . . . . . . . . . . . . . . . . . . . . . . 320

Chapitre 11Sortie Ansible et centralisation


2. Gestion de la sortie standard d’Ansible. . . . . . . . . . . . . . . . . . . . . . . 3242.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3242.2 Fichier de configuration et cowsay . . . . . . . . . . . . . . . . . . . . . . 3242.3 Gestion de la colorisation de la sortie . . . . . . . . . . . . . . . . . . . . 327

3. Gestion du callback d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3293.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3293.2 Quelques plugins d’affichage alternatifs. . . . . . . . . . . . . . . . . . 3303.3 Profiling des opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

4. Centralisation des résultats d’exécution . . . . . . . . . . . . . . . . . . . . . . 3334.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3334.2 Centralisation via Syslog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3344.3 Centralisation via Logstash (Elasticsearch) . . . . . . . . . . . . . . . 3354.4 Centralisation des appels à l'aide d'Ara . . . . . . . . . . . . . . . . . . . 339

4.4.1 Origine de la création d'Ara . . . . . . . . . . . . . . . . . . . . . . 3394.4.2 Installation d'Ara. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3404.4.3 Activation d'Ara avec Ansible . . . . . . . . . . . . . . . . . . . . 340


4.4.4 Test de lancement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3404.4.5 Lancement du serveur de consultation Ara. . . . . . . . . . 341

5. Écriture de son propre callback d’affichage. . . . . . . . . . . . . . . . . . . . 3435.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3435.2 Structure du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3435.3 Exposition du callback à Ansible . . . . . . . . . . . . . . . . . . . . . . . . 3445.4 Nomenclature des fonctions de callback. . . . . . . . . . . . . . . . . . 3465.5 Exemple de surcharge de la sortie en cas d’erreur. . . . . . . . . . . 347

Chapitre 12Écriture de modules


2. Mécanisme d’appel des modules Python . . . . . . . . . . . . . . . . . . . . . 3522.1 Principe de fonctionnement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3522.2 Activation des traces d’exécution . . . . . . . . . . . . . . . . . . . . . . . 3532.3 Contenu du fichier temporaire . . . . . . . . . . . . . . . . . . . . . . . . . 3542.4 Extraction du programme autoporteur. . . . . . . . . . . . . . . . . . . 355

3. Pourquoi écrire un module ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3563.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3563.2 Consultation du schéma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

4. Création d’un module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3594.1 Emplacement du programme. . . . . . . . . . . . . . . . . . . . . . . . . . . 3594.2 En-tête du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3604.3 Spécification des arguments du module . . . . . . . . . . . . . . . . . . 3604.4 Gestion des arguments du module . . . . . . . . . . . . . . . . . . . . . . 3614.5 Récupération de la valeur des arguments . . . . . . . . . . . . . . . . . 3624.6 Connexion à la base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3634.7 Transmission du résultat à Ansible . . . . . . . . . . . . . . . . . . . . . . 3644.8 Test du module. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365


Ansible

4.9 Temps d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3664.10 Gestion de l’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

4.10.1 Variable DOCUMENTATION . . . . . . . . . . . . . . . . . . . 3684.10.2 Variable EXAMPLES . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3694.10.3 Variable RETURN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3694.10.4 Variable ANSIBLE METADATA . . . . . . . . . . . . . . . . . . 3704.10.5 Test d’affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370

4.11 Cas particulier des modules facts . . . . . . . . . . . . . . . . . . . . . . . 371

5. Réentrance sur la création d’un schéma de base. . . . . . . . . . . . . . . . 3735.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3735.2 Limitations du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3745.3 Dépendances Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3745.4 En-tête du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3745.5 Gestion de la base de données . . . . . . . . . . . . . . . . . . . . . . . . . . 3755.6 Python 2 et 3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3765.7 Algorithme du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3785.8 Création d’un playbook de test . . . . . . . . . . . . . . . . . . . . . . . . . 379

6. Gestion de l’option diff d’Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . 3826.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3826.2 Principe de fonctionnement du diff . . . . . . . . . . . . . . . . . . . . . 3826.3 Implémentation du diff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

7. Gestion de l’option test (check mode) . . . . . . . . . . . . . . . . . . . . . . . 3857.1 Activation du check mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3857.2 Prise en charge du mode check . . . . . . . . . . . . . . . . . . . . . . . . . 386

Chapitre 13Écriture de filtres Jinja et mécanisme de lookup



2. Les filtres Jinja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3902.1 Retour sur les filtres Jinja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3902.2 Quelques exemples d’utilisation des filtres Jinja . . . . . . . . . . . 391

2.2.1 Comment tester un filtre ?. . . . . . . . . . . . . . . . . . . . . . . 3912.2.2 Valeur par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3912.2.3 Conversion de type simple . . . . . . . . . . . . . . . . . . . . . . . 3912.2.4 Chargement de YAML/JSON. . . . . . . . . . . . . . . . . . . . . 3922.2.5 Gestion de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3932.2.6 Calcul de somme de hachage . . . . . . . . . . . . . . . . . . . . . 3942.2.7 Combinaison de table de hachage . . . . . . . . . . . . . . . . . 395

3. Test de comparaison de mots de passe salés. . . . . . . . . . . . . . . . . . . 3963.1 Quelques mots sur le stockage des mots de passe . . . . . . . . . . 3963.2 Réentrance sur un mot de passe . . . . . . . . . . . . . . . . . . . . . . . . 3973.3 Récupération du hash du mot de passe. . . . . . . . . . . . . . . . . . . 3983.4 Écriture du filtre de comparaison . . . . . . . . . . . . . . . . . . . . . . . 399

3.4.1 Emplacement du programme . . . . . . . . . . . . . . . . . . . . . 3993.4.2 Fonction de comparaison des mots de passe . . . . . . . . . 4003.4.3 Mapping Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4003.4.4 Tests du filtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

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

4. Génération de mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4054.1 Origine du besoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4054.2 Principe de fonctionnement du générateur de mots de passe . 405

4.2.1 Écriture du générateur de mots de passe . . . . . . . . . . . . 4064.3 Playbook de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407

5. Récupération d'informations (lookup/query). . . . . . . . . . . . . . . . . . 4085.1 Principe de fonctionnement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 4085.2 Présentation des lookups Ansible natifs . . . . . . . . . . . . . . . . . . 409

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

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


Ansible

6. Écriture de son propre lookup : KeePass . . . . . . . . . . . . . . . . . . . . . . 4126.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4126.2 Dépendance Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4126.3 Récupération du mot de passe. . . . . . . . . . . . . . . . . . . . . . . . . . 4126.4 Intégration avec Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414

6.4.1 Emplacement du fichier Python. . . . . . . . . . . . . . . . . . . 4146.4.2 Exposition de l’objet lookup. . . . . . . . . . . . . . . . . . . . . . 4146.4.3 Code du plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

6.5 Test du plugin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4156.5.1 Contenu base KeePass et présentation de KeePassX . . 4166.5.2 Création du test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

Chapitre 14Les actions Ansible


2. Découverte des actions Ansible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4202.1 Fonctionnement des actions Ansible . . . . . . . . . . . . . . . . . . . . 4202.2 Certificats SSL avec Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4202.3 Importation d’un certificat avec Ansible . . . . . . . . . . . . . . . . . 421

3. Création du module d’action java_cert . . . . . . . . . . . . . . . . . . . . . . . 4243.1 Emplacement du fichier d’action. . . . . . . . . . . . . . . . . . . . . . . . 4243.2 Structure du module d’action java_cert . . . . . . . . . . . . . . . . . . 4253.3 En-tête du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4263.4 Contenu de la méthode run. . . . . . . . . . . . . . . . . . . . . . . . . . . . 4263.5 Test du module action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428


Chapitre 15Ansible : virtualisation et cloud


2. Gestion de machines virtuelles sous ESX/VMware . . . . . . . . . . . . . 4322.1 Contexte et prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4322.2 Installation des bibliothèques requises . . . . . . . . . . . . . . . . . . . 4322.3 Caractéristiques de l’ESX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4322.4 Création de la VM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4332.5 Customisation des machines . . . . . . . . . . . . . . . . . . . . . . . . . . . 4352.6 Gestion du démarrage de la machine . . . . . . . . . . . . . . . . . . . . 4372.7 Suppression de la VM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

3. Gestion cloud AWS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4413.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4413.2 Configuration des accès à l’API Amazon . . . . . . . . . . . . . . . . . 4433.3 Création d’une instance EC2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 4483.4 Comment taguer ses instances ? . . . . . . . . . . . . . . . . . . . . . . . . 4513.5 Suppression d’une instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4533.6 Accès réseau aux machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4543.7 Configuration de la clé SSH. . . . . . . . . . . . . . . . . . . . . . . . . . . . 4563.8 Modification de la déclaration de l'instance ec2 . . . . . . . . . . . . 457

Chapitre 16Tester Ansible avec Docker


2. Ansible, Docker et Systemd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4622.1 Comment faire cohabiter Docker et Systemd ? . . . . . . . . . . . . 4632.2 Choix des images à lancer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463


Ansible

2.3 Alimentation du fichier d’inventaire. . . . . . . . . . . . . . . . . . . . . 4642.4 Playbook de création des conteneurs. . . . . . . . . . . . . . . . . . . . . 4652.5 Playbook de suppression des conteneurs . . . . . . . . . . . . . . . . . 468

3. Les images Docker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4693.1 Présence de l’interpréteur Python . . . . . . . . . . . . . . . . . . . . . . . 4693.2 Pilotage de Docker à l’aide d’Ansible. . . . . . . . . . . . . . . . . . . . . 470

3.2.1 Avant propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4703.2.2 Idempotence et immutabilité. . . . . . . . . . . . . . . . . . . . . 4703.2.3 Image à déployer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4713.2.4 Compilation de l’image Docker . . . . . . . . . . . . . . . . . . . 4723.2.5 Utilisation de l’image Docker. . . . . . . . . . . . . . . . . . . . . 473

Chapitre 17Pilotage de Kubernetes à l’aide d’Ansible


2. Introduction au déploiement d’éléments dans Kubernetes . . . . . . . 4782.1 Containers et pods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4782.2 Mécanismes de déploiement dans Kubernetes . . . . . . . . . . . . . 4782.3 Déploiement de pods dans Kubernetes . . . . . . . . . . . . . . . . . . . 478

2.3.1 À propos de Keycloak . . . . . . . . . . . . . . . . . . . . . . . . . . . 4782.3.2 Configuration de Keycloak. . . . . . . . . . . . . . . . . . . . . . . 4792.3.3 Définition d’un objet StatefulSet. . . . . . . . . . . . . . . . . . 4792.3.4 Création d’une entrée de service . . . . . . . . . . . . . . . . . . 4802.3.5 Playbook de déploiement . . . . . . . . . . . . . . . . . . . . . . . . 4812.3.6 Test du playbook de déploiement . . . . . . . . . . . . . . . . . 482

2.4 Création d’un opérateur pour Keycloak . . . . . . . . . . . . . . . . . . 4832.4.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4832.4.2 Installation des prérequis . . . . . . . . . . . . . . . . . . . . . . . . 4832.4.3 Initialisation de l’opérateur . . . . . . . . . . . . . . . . . . . . . . 4842.4.4 Description de la structure de l’opérateur . . . . . . . . . . . 485


2.5 Création de l’opérateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4862.5.1 Patron de l’objet StatefulSet. . . . . . . . . . . . . . . . . . . . . . 4862.5.2 Variables par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4882.5.3 Patron de l’objet Service . . . . . . . . . . . . . . . . . . . . . . . . . 4882.5.4 Création des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489

3. Test de l’opérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4893.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4893.2 Définition du nouveau type d’objet . . . . . . . . . . . . . . . . . . . . . 4903.3 Installation des prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4913.4 Création d’un playbook de test . . . . . . . . . . . . . . . . . . . . . . . . . 4923.5 Vérification et suppression des objets de test. . . . . . . . . . . . . . 4923.6 Lancement de l’opérateur depuis l’extérieur du cluster . . . . . . 4933.7 Test de création d’un objet Keycloak . . . . . . . . . . . . . . . . . . . . 4943.8 Vérification des objets créés. . . . . . . . . . . . . . . . . . . . . . . . . . . . 495

4. Déploiement de l’opérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4974.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4974.2 Configuration du registre Docker . . . . . . . . . . . . . . . . . . . . . . . 4974.3 Construction de l’image de l’opérateur . . . . . . . . . . . . . . . . . . . 4984.4 Déploiement de l’opérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4994.5 Vérification de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . 5024.6 Test de l’opérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5034.7 Journaux d’activité de l’opérateur . . . . . . . . . . . . . . . . . . . . . . . 503

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

Chapitre 3Découverte de l’inventaire

Découverte de l’inventaire1. Objectifs du chapitre et prérequisDans 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

diti

ons

ENI -

All

righ

ts r

eser

ved


Ansible

2. Structure d’un inventaireL’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

À noter qu'il est également possible de stocker cette déclaration sous la formed'un fichier YAML. Dans ce cas, la déclaration prendra la forme suivante :

apache: hosts: rec-apache-1: {}

mysql: hosts: 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 (au format INI) ourecette.yml (format YAML).

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

75Découverte de l’inventaireChapitre 3

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

$ ansible -i recette.yml -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"

}

2.1 Groupes par défautEn 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 renvoie alors le résultat suivant :

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

localhost | SUCCESS => { "changed": false, "groups": {

"all": [], "ungrouped": [

"localhost" ]

} }

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Ansible

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 ;

– 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 valeur ansible_connec-tion=winrm et pour un conteneur docker, vous utiliserez ansible_-connection=docker. Ce changement de mode peut se faire en ajoutant lavariable 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"

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

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 deregrouper des machines dans des ensembles plus grands et d’éviter de les redé-clarer.

dReprenez le cas de l'inventaire recette.inv/recette.yml et ajoutez-y denouvelles machines :– 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 groupemicroservices.

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

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Ansible

Ci-dessous le fichier d’inventaire correspondant au format INI :

[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]apachemysql

[windows:children]active-directory

[container:children]microservices

[windows:vars]ansible_connection=winrm

[container:vars]ansible_connection=localhost

Cette déclaration peut également prendre la forme d’une structure YAML enrespectant les adaptations suivantes :

– un champ par groupe à déclarer

– rattachement des machines dans le champ hosts– rattachement des déclarations de variables dans le champ vars– possibilité de composer des groupes à l’aide du champ children– affectation de variables aux machines en ajoutant des sous-champs au

niveau de leur déclaration


Ainsi, la même déclaration au format YAML prendra la forme suivante :

all : vars: ansible_connection: local

linux: children: apache: hosts: rec-apache-1: apache_url: “rec.wiki.localdomain”

mysql: hosts: rec-mysql-1: mysql_user_password: “MyPassWord!”

windows: children: active-directory: hosts: active-directory-1: {} vars: ansible_connection: “winrm”

container: children : microservices : hosts : container-1 : ansible_connection : "docker" vars : ansible_connection : "localhost"

RemarqueDans le cas où la machine n’aurait pas de variable rattachée, prenez l’habi-tude de la déclarer en tant que tableau de hachage vide (machine : {}).Cette habitude évitera certaines erreurs de déclaration.

Configuration de vos serveurs et déploiement de vos ...

Documents

Transcript of Configuration de vos serveurs et déploiement de vos ...