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 d’applications. À l’aide d’exemples concrets, l’auteur apporte au lecteur les connaissances nécessaires pour bien comprendre 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é progressive. Les premiers mécanismes permettent ainsi d’administrer de façon classique les serveurs (Unix ou Windows) 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 à l'aide de Podman ou Docker).

À côté des notions purement orientées Ansible, certains chapitres sont consacrés au déroulement du déploiement 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 Podman/Docker avec Ansible, le pilotage d’applications dans un cluster Kubernetes ainsi que la création d’un opérateur.

Téléchargements

• Des fichiers complémentaires (159 Ko)

Avant-propos

1. 1. D’où vient le terme DevOps ?
2. 2. Les premiers produits DevOps
3. 3. Cibles et objectifs de l’ouvrage
4. 4. Prérequis techniques et ressources documentaires
   1. 4.1 Prérequis techniques
   2. 4.2 Ressources documentaires
5. 5. Présentation générale
   1. 5.1 Les prérequis
   2. 5.2 L’utilisation d’Ansible
   3. 5.3 La personnalisation d’Ansible
   4. 5.4 Conventions employées

Démarrer avec Ansible

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Version de Python
   3. 1.3 Environnement de travail
   4. 1.4 Fichiers téléchargeables
2. 2. Installation d'Ansible
   1. 2.1 Contexte
   2. 2.2 Installation derrière un proxy
   3. 2.3 Installation via les packages système
      1. 2.3.1 Installation sous Debian/Ubuntu
      2. 2.3.2 Installation sur RHEL, CentOS ou Fedora
   4. 2.4 Installation via pip
   5. 2.5 Utilisation de virtualenv
   6. 2.6 Vérification de la version d'Ansible
3. 3. Le protocole SSH
   1. 3.1 À propos de SSH
   2. 3.2 Clé publique et clé privée
   3. 3.3 Génération de la clé
   4. 3.4 Étapes de l’authentification
   5. 3.5 Parc important de machines ou hébergement dans le cloud
   6. 3.6 Échange de clé par mot de passe
   7. 3.7 Échange de clé sans mot de passe
   8. 3.8 Gestion d’une passphrase avec Ansible

Utilisation d’Ansible

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Ansible en mode ad hoc
   1. 2.1 Création d’un fichier d’inventaire
   2. 2.2 Utilisateur non root
   3. 2.3 Utilisateur SSH non root et mécanisme sudo
3. 3. Les autres outils d’Ansible : playbook et doc
4. 4. Quelques notions sur le format YAML
   1. 4.1 Déclaration de variables simples
   2. 4.2 Les tableaux en YAML
   3. 4.3 Les structures clé/valeur
   4. 4.4 Tableau de tables de hachage
   5. 4.5 Inventaire au format YAML
5. 5. Introduction de la notion de playbook
   1. 5.1 Structure d’un playbook
   2. 5.2 Lancement d’un playbook
6. 6. Combinaison avec Git
   1. 6.1 Création du repository
   2. 6.2 Commandes de base
      1. 6.2.1 Récupération d’un repository Git
      2. 6.2.2 Branche de travail
      3. 6.2.3 État de votre repository
      4. 6.2.4 Ajout d’un fichier
      5. 6.2.5 Modification d’un fichier
      6. 6.2.6 Mise à jour du repository distant
      7. 6.2.7 Récupération des modifications distantes
   3. 6.3 Mécanisme de hook
      1. 6.3.1 Vérification des playbooks avec ansible-lint
      2. 6.3.2 Création du hook pre-commit
      3. 6.3.3 Test du fonctionnement du hook

Découverte de l’inventaire

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Structure d’un inventaire
   1. 2.1 Groupes par défaut
   2. 2.2 Mode de connexion aux machines
   3. 2.3 Regroupement de machines
   4. 2.4 Variables d’inventaire
   5. 2.5 Hiérarchie des variables
   6. 2.6 Gestion des différents inventaires
   7. 2.7 Création de groupes temporaires
3. 3. Fusion d'inventaires

Inventaires : notions avancées

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Chiffrement de fichiers
   1. 2.1 Contexte
   2. 2.2 Stockage d’identifiants de connexion
   3. 2.3 Chiffrement du fichier entier
      1. 2.3.1 Par mot de passe
      2. 2.3.2 Utilisation d’un fichier
      3. 2.3.3 Déchiffrement d’un fichier
      4. 2.3.4 Changement du mot de passe de chiffrement
   4. 2.4 Chiffrement d’un champ
   5. 2.5 Mécanismes de chiffrements alternatifs
      1. 2.5.1 Sélection et recherche d’un module lookup
3. 3. Les inventaires dynamiques
   1. 3.1 Contexte
   2. 3.2 Machines AWS
      1. 3.2.1 Prérequis
      2. 3.2.2 Récupération du script ec2.py
      3. 3.2.3 Configuration
      4. 3.2.4 Test du script
   3. 3.3 Communication avec Docker
      1. 3.3.1 Récupération du script d’inventaire
      2. 3.3.2 Configuration de la communication avec Docker
      3. 3.3.3 Test du script d’inventaire
      4. 3.3.4 Communication avec les conteneurs Docker
      5. 3.3.5 Un petit mot sur le choix de l’image Docker
   4. 3.4 Extraction d’informations en provenance d’ESX
   5. 3.5 Extraction d’informations de Nagios/Naemon/Shinken
4. 4. Fonctionnement des plugins d’inventaires génériques
   1. 4.1 Contexte
   2. 4.2 Connecteur supporté par le format auto
   3. 4.3 Exemples de fichiers d’inventaire au format auto
   4. 4.4 Utilisation de la commande ansible-inventory
   5. 4.5 Inventaire des instances ec2
5. 5. Écrire son propre inventaire dynamique
   1. 5.1 Contexte
   2. 5.2 Format en entrée
   3. 5.3 Structure du programme
      1. 5.3.1 En-tête du programme
      2. 5.3.2 Chargement du fichier
      3. 5.3.3 Transformation et alimentation de l'inventaire
      4. 5.3.4 Test du script d’inventaire
      5. 5.3.5 Test de l’inventaire dynamique avec Ansible

Administration Windows

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Ansible et les machines sous Windows
   1. 2.1 Contexte
   2. 2.2 Prérequis
   3. 2.3 Configuration de la machine
   4. 2.4 Création du fichier d’inventaire
   5. 2.5 Test de la communication Windows
   6. 2.6 Installation d’un package
3. 3. Gestion de service Windows
   1. 3.1 Contexte
   2. 3.2 Installation de Prometheus
   3. 3.3 Création du playbook
   4. 3.4 Lancement de l’installation
   5. 3.5 Consultation de la console Prometheus
4. 4. Création de service
   1. 4.1 Installation de Grafana
      1. 4.1.1 Présentation de Grafana
      2. 4.1.2 Création du playbook
      3. 4.1.3 Lancement de l’installation
   2. 4.2 Création d’un service Windows
      1. 4.2.1 Recherche du programme de lancement de Grafana
      2. 4.2.2 Gestionnaire de services NSSM
      3. 4.2.3 Création du service Grafana
      4. 4.2.4 Playbook complet d’installation de Grafana
   3. 4.3 Mécanismes de secours
   4. 4.4 Consultation de l’interface Grafana

Fonctionnement d’un playbook

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Le moteur de template Jinja : principe de fonctionnement
3. 3. Template Jinja
   1. 3.1 Mécanisme de boucle sur tableau avec Jinja
   2. 3.2 À la recherche de la bonne variable Ansible
   3. 3.3 Affichage des interfaces réseau
4. 4. Délégation de tâche
   1. 4.1 Changement du type de connexion au niveau d’une tâche
   2. 4.2 Délégation d’une tâche
   3. 4.3 Tâche à exécuter une seule fois
5. 5. Gestion d’un serveur Apache
6. 6. Réduction des opérations impactantes
   1. 6.1 Mécanisme des tags
      1. 6.1.1 Déclaration d’un tag
      2. 6.1.2 Comment lister les tags d’un playbook ?
      3. 6.1.3 Sélection ou exclusion d’un tag
      4. 6.1.4 Gather facts et le tag always
   2. 6.2 Mise en cache du résultat d’analyse (module setup)
   3. 6.3 Utilisation d’une variable sur une tâche
   4. 6.4 Utilisation d’un handler
      1. 6.4.1 Pourquoi utiliser un handler ?
      2. 6.4.2 Déclaration d’un handler
      3. 6.4.3 Exemple de lancement

Introduction à la notion de rôle

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Introduction aux rôles Ansible
   1. 2.1 Structure d’un rôle
   2. 2.2 Votre premier rôle : installation d’Apache
   3. 2.3 Configuration du serveur Apache
3. 3. Installation de MediaWiki
   1. 3.1 Filtres Jinja et installation d’Apache
   2. 3.2 Gestion des variables dans un rôle
   3. 3.3 Installation de MariaDB/MySQL
   4. 3.4 Installation de MediaWiki
   5. 3.5 Configuration de MediaWiki
      1. 3.5.1 Décompression de l’archive
      2. 3.5.2 Mutualisation de la base MariaDB et du serveur Apache (SELinux)
      3. 3.5.3 Commande de configuration de MediaWiki
      4. 3.5.4 Dépendances et variables manquantes
      5. 3.5.5 Lancement de l’installation et configuration de MediaWiki
      6. 3.5.6 Changement de version de PHP
      7. 3.5.7 Itération sur la liste des clés GPG des paquets RPM
      8. 3.5.8 Activation des accès distants sur la base MariaDB
      9. 3.5.9 Configuration de l’accès distant
      10. 3.5.10 Activation de l’accès distant des utilisateurs
4. 4. Finalisation de l’installation de MediaWiki
   1. 4.1 Réentrance et script shell
   2. 4.2 Problème de redirection

Playbooks, rôles et notions avancées

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Gestion de Python sur les machines distantes
   1. 2.1 Introduction
   2. 2.2 Préparation de l’inventaire
   3. 2.3 Gestion d’une machine sans Python
   4. 2.4 Détection automatique de l’interpréteur
   5. 2.5 Positionnement de l'emplacement de l'interpréteur Python
   6. 2.6 Python3 et Ansible
3. 3. Scalabilité et répartition de charge
   1. 3.1 Contexte
   2. 3.2 Origine du besoin
   3. 3.3 Ajout de nouveaux serveurs Apache
   4. 3.4 Lancement d’une opération de manière séquentielle
4. 4. Ajout d’un répartiteur de charge
   1. 4.1 Pourquoi ajouter un répartiteur de charge ?
   2. 4.2 Différence entre Ubuntu/Debian et Centos/Red Hat
   3. 4.3 Installation du serveur Haproxy
      1. 4.3.1 Configuration du serveur Haproxy
      2. 4.3.2 Mise au point du rôle
5. 5. Quelques bonnes pratiques à suivre
   1. 5.1 Contrôler le lancement des handlers
   2. 5.2 Réduire le temps d’indisponibilité d’un service
6. 6. Mise à jour et réentrance de script
   1. 6.1 Contexte
   2. 6.2 Gestion de la montée de version du schéma
7. 7. Mise à jour par roulement (rolling update)
   1. 7.1 Contexte
   2. 7.2 Présentation du mécanisme
   3. 7.3 Rolling update sur MediaWiki
   4. 7.4 Désactivation des machines avant mise à jour
      1. 7.4.1 Configuration du Haproxy
      2. 7.4.2 Désactivation de l’instance Apache avant mise à jour
      3. 7.4.3 Utilisation de l'instruction include_role
      4. 7.4.4 Pollution de la trace Apache
8. 8. Inclusion et réutilisation
   1. 8.1 Contexte
   2. 8.2 Inclusion statique de tâches
   3. 8.3 Inclusion dynamique de tâches
   4. 8.4 Gestion du comportement de l’instruction de boucle
      1. 8.4.1 Contrôle du nom de la variable de boucle
      2. 8.4.2 Autres mots-clés intéressants
9. 9. Ansible Galaxy
   1. 9.1 Présentation du site
   2. 9.2 Recherche d’un rôle
   3. 9.3 Utilisation d’un rôle en provenance d’Ansible Galaxy
   4. 9.4 Utilisation d’un fichier de prérequis
   5. 9.5 Comment lister les rôles d’Ansible Galaxy ?
   6. 9.6 Suppression d’un rôle
   7. 9.7 Collections Ansible
      1. 9.7.1 Origine du besoin
      2. 9.7.2 Recherche de collections
      3. 9.7.3 Installation d’une collection
      4. 9.7.4 Consultation de la liste des collections
      5. 9.7.5 Utilisation d’une version spécifique
      6. 9.7.6 Utilisation d’un fichier de dépendances
      7. 9.7.7 Gestion des datasources Grafana

Stratégie d’exécution et optimisation

1. 1. Objectifs du chapitre et prérequis
2. 2. Stratégie d’exécution
   1. 2.1 Contexte
   2. 2.2 Gestion du nombre de tâches lancées en parallèle
   3. 2.3 Stratégie d’exécution : free
3. 3. Débogage avec Ansible
   1. 3.1 Contexte
   2. 3.2 Consultation d’informations
   3. 3.3 Modification d'un élément
   4. 3.4 Relance d’une tâche
   5. 3.5 Définition d'une variable
4. 4. Étude du fonctionnement d’Ansible
   1. 4.1 Contexte
   2. 4.2 Playbook de test
   3. 4.3 Opérations lancées par Ansible
5. 5. Présentation de Mitogen
   1. 5.1 Contexte
   2. 5.2 Présentation de Mitogen
   3. 5.3 Principe de fonctionnement de Mitogen
   4. 5.4 Activation de Mitogen
   5. 5.5 Gains potentiels et limitations

Tests Ansible

1. 1. Objectifs du chapitre et prérequis
2. 2. Linter Ansible
   1. 2.1 Contexte
   2. 2.2 Lancement de l’analyse
   3. 2.3 Règles disponibles
   4. 2.4 Désactivation de règles
   5. 2.5 Création de nouvelles règles
3. 3. Présentation de Molecule
   1. 3.1 Contexte
   2. 3.2 Prérequis et installation de Molecule
   3. 3.3 Mise en place de Podman
      1. 3.3.1 Installation de Podman
      2. 3.3.2 Nom des images dans Podman
      3. 3.3.3 Test du fonctionnement de Podman
   4. 3.4 Installation de Docker
      1. 3.4.1 Installation de Docker Community Edition sur Ubuntu
      2. 3.4.2 Installation alternative
      3. 3.4.3 Configuration des accès à Docker
      4. 3.4.4 Vérification de l’installation de Docker
4. 4. Utilisation de Molecule
   1. 4.1 Fichier de configuration molecule.yml
   2. 4.2 Création d’un rôle Apache
      1. 4.2.1 Initialisation du rôle
      2. 4.2.2 Structure du rôle
      3. 4.2.3 Intégration du rôle Apache
      4. 4.2.4 Playbook de convergence
      5. 4.2.5 Vérification de l’installation
   3. 4.3 Lancement des tests
   4. 4.4 Débogage du problème
      1. 4.4.1 Lancement de Molecule en mode debug
      2. 4.4.2 Connexion au conteneur de tests
   5. 4.5 Configuration pour le fonctionnement avec System D
      1. 4.5.1 Modification de la définition de la plateforme (champ platforms)
      2. 4.5.2 Relance des tests
   6. 4.6 Gestion des scénarios de Molecule

Sortie Ansible et centralisation

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Gestion de la sortie standard d’Ansible
   1. 2.1 Contexte
   2. 2.2 Fichier de configuration et cowsay
   3. 2.3 Gestion de la colorisation de la sortie
3. 3. Gestion du callback d’affichage
   1. 3.1 Contexte
   2. 3.2 Quelques plugins d’affichage alternatifs
   3. 3.3 Profiling des opérations
4. 4. Centralisation des résultats d’exécution
   1. 4.1 Contexte
   2. 4.2 Centralisation via Syslog
   3. 4.3 Centralisation via Logstash (Elasticsearch)
   4. 4.4 Centralisation des appels à l'aide d'Ara
      1. 4.4.1 Origine de la création d'Ara
      2. 4.4.2 Installation d'Ara
      3. 4.4.3 Activation d'Ara avec Ansible
      4. 4.4.4 Test de lancement
      5. 4.4.5 Lancement du serveur de consultation Ara
5. 5. Écriture de son propre callback d’affichage
   1. 5.1 Contexte
   2. 5.2 Structure du programme
   3. 5.3 Exposition du callback à Ansible
   4. 5.4 Nomenclature des fonctions de callback
   5. 5.5 Exemple de surcharge de la sortie en cas d’erreur

Écriture de modules

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Mécanisme d’appel des modules Python
   1. 2.1 Principe de fonctionnement
   2. 2.2 Activation des traces d’exécution
   3. 2.3 Contenu du fichier temporaire
   4. 2.4 Extraction du programme autoporteur
3. 3. Pourquoi écrire un module ?
   1. 3.1 Contexte
   2. 3.2 Consultation du schéma
4. 4. Création d’un module
   1. 4.1 Emplacement du programme
   2. 4.2 En-tête du programme
   3. 4.3 Spécification des arguments du module
   4. 4.4 Gestion des arguments du module
   5. 4.5 Récupération de la valeur des arguments
   6. 4.6 Connexion à la base
   7. 4.7 Transmission du résultat à Ansible
   8. 4.8 Test du module
   9. 4.9 Temps d’exécution
   10. 4.10 Gestion de l’aide
       1. 4.10.1 Variable DOCUMENTATION
       2. 4.10.2 Variable EXAMPLES
       3. 4.10.3 Variable RETURN
       4. 4.10.4 Variable ANSIBLE METADATA
       5. 4.10.5 Test d’affichage
   11. 4.11 Cas particulier des modules facts
5. 5. Réentrance sur la création d’un schéma de base
   1. 5.1 Contexte
   2. 5.2 Limitations du module
   3. 5.3 Dépendances Python
   4. 5.4 En-tête du module
   5. 5.5 Gestion de la base de données
   6. 5.6 Python 2 et 3
   7. 5.7 Algorithme du module
   8. 5.8 Création d’un playbook de test
6. 6. Gestion de l’option diff d’Ansible
   1. 6.1 Contexte
   2. 6.2 Principe de fonctionnement du diff
   3. 6.3 Implémentation du diff
7. 7. Gestion de l’option test (check mode)
   1. 7.1 Activation du check mode
   2. 7.2 Prise en charge du mode check

Écriture de filtres Jinja et mécanisme de lookup

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Les filtres Jinja
   1. 2.1 Retour sur les filtres Jinja
   2. 2.2 Quelques exemples d’utilisation des filtres Jinja
      1. 2.2.1 Comment tester un filtre ?
      2. 2.2.2 Valeur par défaut
      3. 2.2.3 Conversion de type simple
      4. 2.2.4 Chargement de YAML/JSON
      5. 2.2.5 Gestion de listes
      6. 2.2.6 Calcul de somme de hachage
      7. 2.2.7 Combinaison de table de hachage
3. 3. Test de comparaison de mots de passe salés
   1. 3.1 Quelques mots sur le stockage des mots de passe
   2. 3.2 Réentrance sur un mot de passe
   3. 3.3 Récupération du hash du mot de passe
   4. 3.4 Écriture du filtre de comparaison
      1. 3.4.1 Emplacement du programme
      2. 3.4.2 Fonction de comparaison des mots de passe
      3. 3.4.3 Mapping Ansible
      4. 3.4.4 Tests du filtre
   5. 3.5 Utilisation du filtre dans le playbook
4. 4. Génération de mot de passe
   1. 4.1 Origine du besoin
   2. 4.2 Principe de fonctionnement du générateur de mots de passe
      1. 4.2.1 Écriture du générateur de mots de passe
   3. 4.3 Playbook de test
5. 5. Récupération d'informations (lookup/query)
   1. 5.1 Principe de fonctionnement
   2. 5.2 Présentation des lookups Ansible natifs
      1. 5.2.1 Lecture de fichiers : file
      2. 5.2.2 Récupération du résultat d’un template
      3. 5.2.3 Réalisation d'une requête DNS : dig
   3. 5.3 Le mécanisme de lookup et les boucles
6. 6. Écriture de son propre lookup : KeePass
   1. 6.1 Contexte
   2. 6.2 Dépendance Python
   3. 6.3 Récupération du mot de passe
   4. 6.4 Intégration avec Ansible
      1. 6.4.1 Emplacement du fichier Python
      2. 6.4.2 Exposition de l’objet lookup
      3. 6.4.3 Code du plugin
   5. 6.5 Test du plugin
      1. 6.5.1 Contenu base KeePass et présentation de KeePassX
      2. 6.5.2 Création du test

Les actions Ansible

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Découverte des actions Ansible
   1. 2.1 Fonctionnement des actions Ansible
   2. 2.2 Certificats SSL avec Java
   3. 2.3 Importation d’un certificat avec Ansible
3. 3. Création du module d’action java_cert
   1. 3.1 Emplacement du fichier d’action
   2. 3.2 Structure du module d’action java_cert
   3. 3.3 En-tête du module
   4. 3.4 Contenu de la méthode run
   5. 3.5 Test du module action

Ansible : virtualisation et cloud

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Gestion de machines virtuelles sous ESX/VMware
   1. 2.1 Contexte et prérequis
   2. 2.2 Installation des bibliothèques requises
   3. 2.3 Caractéristiques de l’ESX
   4. 2.4 Création de la VM
   5. 2.5 Customisation des machines
   6. 2.6 Gestion du démarrage de la machine
   7. 2.7 Suppression de la VM
3. 3. Mise au point de tests à l’aide de Monkeyble
   1. 3.1 Contexte
   2. 3.2 Installation de Monkeyble
   3. 3.3 Configuration d’Ansible avec Monkeyble
   4. 3.4 Configuration des scénarios
4. 4. Gestion cloud AWS
   1. 4.1 Contexte
   2. 4.2 Configuration des accès à l’API Amazon
   3. 4.3 Création d’une instance EC2
   4. 4.4 Comment taguer ses instances ?
   5. 4.5 Suppression d’une instance
   6. 4.6 Accès réseau aux machines
   7. 4.7 Configuration de la clé SSH
   8. 4.8 Modification de la déclaration de l'instance ec2

Tester Ansible avec Podman

1. 1. Objectifs du chapitre et prérequis
   1. 1.1 Contexte et prérequis
   2. 1.2 Fichiers téléchargeables
2. 2. Installation de Podman
3. 3. Ansible, Podman et Systemd
   1. 3.1 Comment faire cohabiter les conteneurs et Systemd ?
   2. 3.2 Choix des images à lancer
   3. 3.3 Alimentation du fichier d’inventaire
   4. 3.4 Playbook de création des conteneurs
   5. 3.5 Playbook de suppression des conteneurs
4. 4. Les images de conteneurs
   1. 4.1 Présence de l’interpréteur Python
   2. 4.2 Installation et connexion à Mediawiki
      1. 4.2.1 Prérequis pour l’installation de Mediawiki
      2. 4.2.2 Solutions de connexions aux conteneurs
      3. 4.2.3 Lancement d’un proxy Squid
      4. 4.2.4 Utilisation du proxy
   3. 4.3 Pilotage de Podman à l’aide d’Ansible
      1. 4.3.1 Avant-propos
      2. 4.3.2 Idempotence et immutabilité
      3. 4.3.3 Image à déployer
      4. 4.3.4 Compilation de l’image
      5. 4.3.5 Utilisation de l’image

Pilotage de Kubernetes à l’aide d’Ansible

1. 1. Objectifs du chapitre et prérequis
2. 2. Introduction au déploiement d’éléments dans Kubernetes
   1. 2.1 Containers et pods
   2. 2.2 Mécanismes de déploiement dans Kubernetes
   3. 2.3 Déploiement de pods dans Kubernetes
      1. 2.3.1 À propos de Keycloak
      2. 2.3.2 Configuration de Keycloak
      3. 2.3.3 Définition d’un objet StatefulSet
      4. 2.3.4 Création d’une entrée de service
      5. 2.3.5 Playbook de déploiement
      6. 2.3.6 Test du playbook de déploiement
   4. 2.4 Création d’un opérateur pour Keycloak
      1. 2.4.1 Contexte
      2. 2.4.2 Installation des prérequis
      3. 2.4.3 Initialisation de l’opérateur
      4. 2.4.4 Description de la structure de l’opérateur
   5. 2.5 Création de l’opérateur
      1. 2.5.1 Patron de l’objet StatefulSet
      2. 2.5.2 Variables par défaut
      3. 2.5.3 Patron de l’objet Service
      4. 2.5.4 Création des objets
3. 3. Test de l’opérateur
   1. 3.1 Contexte
   2. 3.2 Définition du nouveau type d’objet
   3. 3.3 Installation des prérequis
   4. 3.4 Création d’un playbook de test
   5. 3.5 Vérification et suppression des objets de test
   6. 3.6 Lancement de l’opérateur depuis l’extérieur du cluster
   7. 3.7 Test de création d’un objet Keycloak
   8. 3.8 Vérification des objets créés
4. 4. Déploiement de l’opérateur
   1. 4.1 Contexte
   2. 4.2 Configuration du registre Docker
   3. 4.3 Construction de l’image de l’opérateur
   4. 4.4 Déploiement de l’opérateur
   5. 4.5 Vérification de l’installation
   6. 4.6 Test de l’opérateur
   7. 4.7 Journaux d’activité de l’opérateur
   8.  
   9.  
5. Index