Kubernetes : gérez la plateforme de déploiement de vos applications conteneurisées

Auteur(s) :

Perré, Yannig Découvrir l'auteur

Résumé

Illustré d'exemples simples et concrets, ce guide dévoile les concepts sous-jacents et avancés permettant l'installation de cette plate-forme gérée en open source (pods, services, dashboards). Les polices réseaux, la sécurisation SSL, les montées en charge et la surveillance applicative sont détaillées. Avec un accès gratuit à la version numérique.

Éditeur(s)
- Éditions ENI
Date
- C 2022
Notes
- La couv. porte en plus : "Informatique technique" ; "En téléchargement : code source, fichiers de configuration, exemples" ; "+ quiz" ; "Version en ligne offerte ! pendant 1 an"
- La 4e de couv. indique : "Sur www.editions-eni.fr : fichiers de configuration, exemples utilisés pour le déploiement, code source des applications"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (864 p.) : ill. ; 22 cm
Collections
- Expert IT
Sujet(s)
ISBN
- 978-2-409-03560-9
Indice
- 681.5 Réseaux informatiques
Quatrième de couverture
- Kubernetes
  Gérez la plateforme de déploiement de vos applications conteneurisées
  Ce livre s'adresse aux administrateurs système qui souhaitent maîtriser le déploiement de Kubernetes et comprendre en quoi il répond aux nouveaux enjeux informatiques liés à l'arrivée des containers. Le lecteur découvre ainsi les différentes fonctionnalités de Kubernetes qui lui permettront de gérer des containers et leur cycle de vie et de mettre en place toutes les briques indispensables à un cluster de production.
  Pour appréhender au mieux la lecture de ce livre, des notions sur l'administration d'un système Linux, sur le principe de fonctionnement des couches réseau, sur l'utilisation de Git ainsi que la connaissance d'un environnement Cloud sont recommandées. Tout au long du livre, l'auteur s'appuie sur des exemples concrets pour aider le lecteur dans sa découverte de Kubernetes et dans l'assimilation des concepts étudiés.
  Après l'installation de l'environnement et des outils indispensables pour suivre les exemples du livre, l'auteur familiarise le lecteur avec les concepts propres à Kubernetes tels que le cycle de vie d'un container, les pods, les services ou le tableau de bord. Au fur et à mesure, le lecteur découvre des concepts plus avancés comme la persistance des données, l'hébergement d'applications en cluster, la mise en place de réplications entre plusieurs pods, l'utilisation de règles de haute disponibilité, la gestion des briques internes de Kubernetes ou le gestionnaire de paquets Helm.
  Puis l'auteur présente comment installer et configurer Kubernetes afin d'aider le lecteur à mettre en place un cluster, dans le cloud ou sur des machines classiques, avant de détailler l'exposition d'une application sur Internet, les polices réseau, la sécurisation SSL, les montées en charge, le choix des machines dans le cloud ou encore la surveillance applicative. Pour finir, le lecteur trouve dans les derniers chapitres une introduction au maillage de services avec Istio, ainsi que des informations sur la gestion des droits d'accès, sur la notion d'opérateur ou encore sur la gestion de l'application dans un système d'intégration continue.
Tables des matières
- - Kubernetes
  - Gérez la plateforme de déploiement de vos applications conteneurisées
  - 2e édition
  - Editions Eni
  - Avant-propos
  - 1. Présentation de Kubernetes43
  - 1.1 Un peu d'histoire43
  - 1.2 Qu'est-ce qu'un container ?44
  - 1.3 Les containers avant Docker44
  - 1.4 Pourquoi utiliser des containers ?45
  - 1.5 Problèmes introduits avec les containers46
  - 1.6 À quoi va servir Kubernetes ?46
  - 1.7 Ressources externes47
  - 2. Un mot sur l'application47
  - 2.1 Rien ne sert de courir47
  - 2.2 Les douze facteurs applicatifs48
  - 2.3 Microservices vs Monolithes48
  - Chapitre 1
  - Introduction
  - 1. Cibles et objectifs de l'ouvrage49
  - 2. Prérequis techniques et ressources documentaires50
  - 2.1 Prérequis techniques50
  - 2.2 Ressources documentaires50
  - 2.3 Récupération des fichiers d'exemples51
  - 3. Présentation générale51
  - 3.1 Prérequis51
  - 3.2 Utilisation de Kubernetes52
  - 3.3 Installation et configuration de Kubernetes52
  - 3.4 Extension du cluster Kubernetes et notions avancées53
  - 3.5 Déploiement et intégration continue53
  - 3.6 Conventions utilisées54
  - Chapitre 2
  - Installation de l'environnement Kubernetes
  - 1. Objectifs du chapitre et prérequis55
  - 2. Alternative à l'installation en local56
  - 2.1 Pourquoi ces alternatives ?56
  - 2.2 Utilisation d'un service managé56
  - 2.3 Service Katacoda57
  - 3. Mise en place de la commande kubectl57
  - 3.1 À quoi sert kubectl 457
  - 3.2 Installation de kubectl58
  - 3.2.1 Installation sous Debian/Ubuntu58
  - 3.2.2 Installation sous CentOS/RHEL ou Fedora58
  - 3.2.3 Installation à l'aide d'Arkade59
  - 3.3 Vérification de l'installation62
  - 3.4 Configuration de l'autocomplétion62
  - 3.4.1 Présentation du mécanisme d'autocomplétion62
  - 3.4.2 Fichier profile à modifier62
  - 3.4.3 Autocomplétion sur kubectl63
  - 3.4.4 Utilisation de la variable SHELL63
  - 3.4.5 Mise en place d'un alias64
  - 4. Mise en place de Minikube64
  - 4.1 Pourquoi faire appel à Minikube ?64
  - 4.2 Téléchargement et installation de Minikube65
  - 4.3 Vérification de l'installation de Minikube65
  - 4.4 Mise en place de l'autocomplétion66
  - 5. Installation du cluster Kubernetes avec Minikube66
  - 5.1 Options de lancement66
  - 5.2 Installation de Docker67
  - 5.2.1 Installation de Docker Community Edition sur Ubuntu67
  - 5.2.2 Installation alternative68
  - 5.2.3 Configuration des accès à Docker68
  - 5.2.4 Vérification de l'installation de Docker68
  - 5.3 Installation de l'hyperviseur VirtualBox69
  - 5.4 Installation de l'hyperviseur KVM/libvirt70
  - 5.5 Configuration de l'utilisateur courant70
  - 5.6 Déploiement du cluster avec Minikube71
  - 5.6.1 Création de la machine Minikube71
  - 5.6.2 Arrêt/démarrage de la machine Minikube75
  - 5.6.3 Choix du container runtime76
  - 5.6.4 Extensions de Minikube76
  - 5.6.5 Suppression de la machine Minikube78
  - 6. Quelques notions sur le format YAML79
  - 6.1 Déclaration de couples clés/valeurs79
  - 6.2 Les tableaux en YAML80
  - 6.3 Les structures clé/valeur ou table de hachage81
  - 6.4 Tableau de table de hachage83
  - Chapitre 3
  - Tableau de bord et ligne de commande
  - 1. Objectifs du chapitre et prérequis85
  - 2. Préambule86
  - 2.1 Origine du nom et du logo86
  - 2.2 Pourquoi utiliser Kubernetes ?86
  - 2.3 Origine de Kubernetes87
  - 2.4 Fondation CNCF87
  - 2.5 Les orchestrateurs du marché88
  - 3. Le tableau de bord de Kubernetes (dashboard)89
  - 3.1 Présentation89
  - 3.2 Tableau de bord Kubernetes sur service managé89
  - 3.3 Déploiement du dashboard sur Minikube89
  - 3.4 Accès au dashboard sur Minikube90
  - 3.5 Structure du tableau de bord91
  - 3.6 Création d'un déploiement92
  - 3.6.1 Un petit mot sur MailHog92
  - 3.6.2 Lancement du déploiement93
  - 3.7 État d'un déploiement95
  - 3.7.1 Consultation de l'état du déploiement95
  - 3.7.2 Consultation du gestionnaire de réplicats96
  - 3.7.3 Consultation de l'état d'un pod98
  - 3.7.4 Journal d'activité du container99
  - 3.7.5 Scalabilité99
  - 3.7.6 Mise à jour de l'application101
  - 3.7.7 Pour résumer103
  - 4. Présentation de l'outil kubectl103
  - 4.1 Préambule103
  - 4.2 Consultation des éléments103
  - 4.3 Liste des pods105
  - 4.4 Liste des machines d'un cluster105
  - 4.4.1 Connexion à la machine Minikube106
  - 4.4.2 Liste des nouds d'un cluster106
  - 4.4.3 Affichage des caractéristiques étendues107
  - 5. Le moteur Containerd de Minikube108
  - 5.1 Initialisation de l'environnement108
  - 5.2 Les containers associés aux pods108
  - Chapitre 4
  - Automatisation et publication d'une application
  - 1. Objectifs du chapitre et prérequis111
  - 2. Gestion par kubectl d'une application111
  - 2.1 Suppression d'un déploiement111
  - 2.2 Création d'un déploiement112
  - 2.3 État du déploiement113
  - 2.4 Mécanisme des réplicats115
  - 2.4.1 Consultation des réplicats115
  - 2.4.2 Description des réplicats116
  - 2.5 État du pod118
  - 2.5.1 Liste des pods118
  - 2.5.2 Détails de l'état d'un pod118
  - 2.6 Accès aux logs des containers120
  - 2.7 Accéder à l'application MailHog120
  - 3. Exposition de services122
  - 3.1 Pourquoi utiliser un service ?122
  - 3.2 Exposition d'un déploiement via un service123
  - 3.3 Vérification du service mailhog123
  - 3.4 Que faire en cas d'absence de shell ?125
  - 3.4.1 Contexte125
  - 3.4.2 Utilisation d'un pod éphémère126
  - 3.4.3 Lancement d'un pod de test127
  - 3.5 Résilience et scalabilité128
  - 3.5.1 Origine du besoin128
  - 3.5.2 Scalabilité manuelle128
  - 3.5.3 Nombre de pods associés à un déploiement129
  - 3.5.4 Arrêter temporairement une application129
  - 4. Automatisation de déploiement par fichier YAML130
  - 4.1 Mécanisme de création et mise à jour130
  - 4.2 Structure YAML d'un déploiement131
  - 4.2.1 Quelques rappels131
  - 4.2.2 Récupération d'une structure au format YAML131
  - 4.2.3 Édition d'un déploiement133
  - 4.2.4 Squelette pour un déploiement133
  - 4.2.5 Création d'un déploiement à l'aide d'un fichier135
  - 4.2.6 Suppression des éléments d'un fichier136
  - 4.2.7 Gestion de l'idempotence et de la réentrance136
  - 4.3 Création du service138
  - 4.3.1 Définition du service138
  - 4.3.2 Application de la définition du service139
  - 4.3.3 Gestion de la réentrance139
  - 4.4 Mécanisme de sélecteur et labels140
  - 4.5 Regroupement de la création des éléments141
  - 4.5.1 Création d'un groupe d'objets141
  - 4.5.2 Consultation de l'état d'un groupe d'objets142
  - 4.6 Structure des objets143
  - 4.6.1 Interrogation de Kubernetes avec kubectl143
  - 4.6.2 Référence de l'API en ligne144
  - 5. Ingress et reverse proxy144
  - 5.1 Origine du besoin144
  - 5.2 Rôle d'un proxy inverse145
  - 5.3 Activation du contrôleur Ingress dans Minikube145
  - 5.4 Déclaration d'une règle Ingress147
  - 5.5 Consultation des règles Ingress148
  - 5.6 Hôte virtuel et nip.io149
  - 5.6.1 Hôte virtuel par défaut149
  - 5.6.2 Présentation du mécanisme de nip.io150
  - 5.6.3 Configuration du serveur DNS150
  - 5.6.4 Création d'un hôte virtuel pour MailHog153
  - Chapitre 5
  - Cycle de vie d'un container dans Kubernetes
  - 1. Objectifs du chapitre et prérequis155
  - 2. Gestion des crashs d'application156
  - 2.1 Consultation de l'état des pods156
  - 2.2 Connexion au pod156
  - 2.3 Container associé à MailHog157
  - 2.4 Comportement en cas de crash159
  - 2.5 État du container après redémarrage du pod160
  - 2.6 Container vu depuis Containerd (Minikube)160
  - 2.7 Attention au nettoyage162
  - 3. État d'un container162
  - 3.1 Pourquoi scruter l'état d'un container ?162
  - 3.2 Readiness vs Liveness163
  - 3.3 Utilisation et bonne pratique164
  - 3.4 Structure des champs de surveillance164
  - 3.5 Vérification de la présence d'un port166
  - 3.5.1 Définition de la surveillance166
  - 3.5.2 Test d'indisponibilité sur un pod non prêt167
  - 3.5.3 État des pods en cas d'indisponibilité168
  - 3.5.4 Test d'indisponibilité sur un pod en mauvaise santé168
  - 3.5.5 État des pods en cas de problème sur un pod169
  - 3.5.6 Attention à la consistance des tests169
  - 3.5.7 Uniformisation des tests171
  - 3.6 Surveillance HTTP172
  - 3.6.1 Pourquoi privilégier ce type de surveillance ?172
  - 3.6.2 Surveillance de l'application MailHog172
  - 3.7 Point d'entrée de surveillance HTTP d'une application173
  - 3.7.1 Un mot sur les frameworks modernes173
  - 3.7.2 Présentation de l'application Flask173
  - 3.7.3 Exemple de déclaration174
  - 3.7.4 Déploiement de l'application Flask175
  - 3.7.5 Consultation de l'état de l'application175
  - 3.8 Lancement d'un shell177
  - 3.8.1 Principe de fonctionnement177
  - 3.8.2 Exemple de surveillance d'une base Postgres177
  - 3.8.3 Déclaration de la commande178
  - 4. Définition de la capacité d'un pod178
  - 4.1 Pourquoi définir une capacité ?178
  - 4.2 Réservation et surallocation179
  - 4.3 Allocation de ressources à un container179
  - 4.4 Allocation de ressources à l'application MailHog180
  - 4.5 Comportement en cas de saturation des ressources181
  - 4.5.1 Demande trop importante de CPU181
  - 4.5.2 Dépassement de la mémoire allouée182
  - 4.6 Priorité d'un pod183
  - 4.6.1 Présentation du mécanisme183
  - 4.6.2 Consultation des types par défaut184
  - 4.6.3 Consultation des priorités des pods184
  - 4.6.4 Création d'une classe de priorité186
  - 4.6.5 Affectation d'une classe de priorité personnalisée187
  - 4.6.6 Remarque sur les classes de priorité par défaut188
  - Chapitre 6
  - Persistance des données
  - 1. Objectifs du chapitre et prérequis189
  - 2. Persistance des données 189
  - 2.1 Origine du besoin189
  - 2.2 Utilisation d'un volume persistant externe190
  - 2.3 Volumes persistants191
  - 2.3.1 Structure du volume persistant191
  - 2.3.2 Création du volume persistant192
  - 2.4 Persistance de données avec MailHog192
  - 2.4.1 Opérations à réaliser192
  - 2.4.2 Déclaration de l'objet PersistentVolumeClaim193
  - 2.4.3 État des objets de volume persistant194
  - 2.4.4 État de la demande de volume persistant195
  - 2.4.5 Déclaration du point de montage195
  - 2.4.6 Ajout d'un point de montage sur le container196
  - 2.4.7 Options de lancement de MailHog196
  - 2.4.8 Déclaration entière suite aux modifications197
  - 2.5 Test de la persistance199
  - 2.5.1 Installation de mhsendmail199
  - 2.5.2 Ouverture de la communication avec le port SMTP200
  - 2.5.3 Envoi d'un mail200
  - 2.5.4 Droits du répertoire de persistance des données201
  - 2.5.5 Consultation de l'interface MailHog202
  - 2.5.6 Suppression des pods203
  - 2.5.7 Vérification du fonctionnement de la persistance203
  - 3. Classes de stockage204
  - 3.1 Origine du besoin204
  - 3.2 Liste des classes de stockage205
  - 3.3 Détail d'une classe de stockage206
  - 3.4 Classe de stockage par défaut206
  - 3.5 Les différentes classes de stockage207
  - 3.5.1 Les différentes familles207
  - 3.5.2 Origine de ces familles207
  - 3.6 Caractéristiques des classes de stockage208
  - 3.6.1 Modes d'accès208
  - 3.6.2 Caractéristiques de certains pilotes209
  - 3.6.3 Liste des pilotes chargés210
  - 3.7 Déclaration d'une classe de stockage211
  - 3.7.1 Structure de la déclaration211
  - 3.7.2 Exemple de déclaration212
  - 3.8 Test de création automatique d'un volume persistant213
  - Chapitre 7
  - Hébergement d'application en cluster
  - 1. Objectifs du chapitre et prérequis217
  - 2. Déploiement d'une base de données MariaDB217
  - 2.1 Origine du besoin217
  - 2.2 Déploiement218
  - 2.2.1 Choix de l'image Docker218
  - 2.2.2 Version initiale du fichier de déploiement218
  - 2.2.3 Gestion de la réentrance219
  - 2.3 Volume persistant220
  - 2.3.1 Demande de volume persistant220
  - 2.3.2 État de la demande de volume persistant220
  - 2.3.3 Ajout d'une persistance sur le container de MariaDB221
  - 2.3.4 Consultation de l'état du déploiement222
  - 2.4 Configuration de la base de données223
  - 2.5 Consultation de l'état du pod224
  - 2.5.1 Liste des pods224
  - 2.5.2 Connexion au container225
  - 2.5.3 Création de l'entrée de service225
  - 2.6 Surveillance de la base de données226
  - 2.6.1 Définition des commandes de surveillance226
  - 2.6.2 Application de la modification228
  - 2.6.3 Vérification du déploiement228
  - 2.7 Mécanisme de déploiement229
  - 3. Mise en place d'un StatefulSet231
  - 3.1 Augmentation du nombre de pods associés au déploiement231
  - 3.2 Présentation du type StatefulSet233
  - 3.2.1 Caractéristiques233
  - 3.2.2 Limitations233
  - 3.3 Déclaration du premier objet StatefulSet234
  - 3.3.1 Purge de l'ancien déploiement234
  - 3.3.2 Modifications à réaliser234
  - 3.3.3 Création du StatefulSet236
  - 3.3.4 État des volumes persistants236
  - 3.3.5 Suppression des anciens objets PV/PVC237
  - 3.4 Scalabilité de l'objet StatefulSet237
  - 3.5 Pods et volumes persistants d'un objet StatefulSet238
  - 3.6 Réduction de la taille du StatefulSet239
  - 4. Base et compte de test240
  - 4.1 Variables d'environnement du container240
  - 4.2 ConfigMap et secret240
  - 4.2.1 Pourquoi y faire appel ?240
  - 4.2.2 Structure d'un objet ConfigMap241
  - 4.2.3 Déclaration d'un objet Secret241
  - 4.2.4 Rattachement au container243
  - Chapitre 8
  - Mise en place d'une réplication entre pods
  - 1. Objectifs du chapitre et prérequis245
  - 2. Synchronisation des pods MariaDB246
  - 2.1 Exposition de la problématique246
  - 2.2 Principe de fonctionnement de la synchronisation246
  - 2.2.1 Opérations à réaliser246
  - 2.2.2 Nombre de réplicats247
  - 2.3 Identifiants des serveurs247
  - 2.3.1 Connexion aux pods247
  - 2.3.2 Connexion à la base de données247
  - 2.3.3 Identifiants des serveurs248
  - 2.3.4 ID du maître248
  - 2.3.5 Création du compte de réplication sur le maître249
  - 2.3.6 Configuration de l'esclave250
  - 2.4 Activation de la synchronisations.-250
  - 2.4.1 Activer les journaux pour la réplication250
  - 2.4.2 Commande docker-entrypoint.sh251
  - 2.4.3 Consultation de l'état du maître252
  - 2.4.4 Configuration de l'esclave253
  - 2.5 Test de la réplication254
  - 2.5.1 Connexion au maître254
  - 2.5.2 Création d'une table255
  - 2.5.3 Connexion à l'esclave255
  - 3. Automatisation de la synchronisation256
  - 3.1 Scripts de démarrage et synchronisation256
  - 3.1.1 Script de démarrage256
  - 3.1.2 Configuration de la synchronisation257
  - 3.1.3 Scripts SQL additionnels258
  - 3.1.4 Script d'arrêt de la base258
  - 3.2 Scripts et objet ConfigMap259
  - 3.3 Création du ConfigMap259
  - 3.4 Montage du ConfigMap262
  - 3.4.1 Référencement du ConfigMap dans la liste des volumes262
  - 3.4.2 Point de montage du ConfigMap263
  - 3.5 Démarrage et arrêt du container263
  - 3.5.1 Commande de démarrage263
  - 3.5.2 Commande d'arrêt de la base264
  - 3.6 Résumé des modifications264
  - 3.7 État du déploiement266
  - 3.7.1 État des pods266
  - 3.7.2 Journaux d'activité du pod esclave266
  - 3.7.3 Test de la synchronisation266
  - 3.7.4 Vérification du fonctionnement de la synchronisation.267
  - Chapitre 9
  - Gestion des briques Internes de Kuberneîes
  - 1. Objectifs du chapitre et prérequis269
  - 2. Espace de noms kube-system269
  - 2.1 Pods présents dans l'espace de noms kube-system269
  - 2.2 CoreDNS270
  - 2.3 etcd271
  - 2.4 Le gestionnaire de réseau Kindnet271
  - 2.5 Le gestionnaire d'extensions de Minikube271
  - 2.6 Le serveur d'API272
  - 2.7 Le proxy Kubernetes (kube-proxy)272
  - 2.8 Le gestionnaire de tâches (scheduler)272
  - 2.9 Le gestionnaire de contrôle (controller manager)272
  - 2.10 Kubelet272
  - 3. Configuration des serveurs maîtres273
  - 3.1 Principe de lancement des pods système273
  - 3.2 Contenu du répertoire /etc/kubernetes/manifests273
  - 3.3 Contenu des fichiers274
  - 3.4 Désactivation d'un pod système275
  - 3.5 Réactivation du pod système276
  - 4. Monitoring des containers du cluster avec Glances277
  - 4.1 Origine du besoin277
  - 4.2 Consultation des DaemonSets277
  - 4.3 Présentation de Glances278
  - 4.4 Définition du DaemonSet278
  - 4.4.1 Structure de la déclaration278
  - 4.4.2 Champ volumes279
  - 4.4.3 Champ containers279
  - 4.5 Création du DaemonSet280
  - 4.5.1 Déclaration complète280
  - 4.5.2 Création du DaemonSet281
  - 4.5.3 Consultation des pods281
  - 4.6 Annotations de tolérance282
  - 4.6.1 Présentation du mécanisme282
  - 4.6.2 Récupération des annotations taints282
  - 4.6.3 Tolérances de lancement284
  - 4.6.4 Modification du DaemonSet284
  - 4.7 Connexion à Glances286
  - Chapitre 10
  - Helm - Gestionnaire de package
  - 1. Objectifs du chapitre et prérequis287
  - 2. Présentation de Helm287
  - 2.1 Pourquoi faire appel à Helm ?287
  - 2.2 Principe de fonctionnement288
  - 3. Déploiement de Helm288
  - 3.1 Installation du client Helm288
  - 3.1.1 Installation à l'aide d'Arkade288
  - 3.1.2 Installation manuelle289
  - 3.2 Consultation de la version de Helm290
  - 3.3 Configuration du client Helm290
  - 4. Déploiement d'une application avec Helm291
  - 4.1 Déterminer le package à déployer291
  - 4.1.1 Recherche d'un chart Helm291
  - 4.1.2 Gestion des sources de charts Helm291
  - 4.1.3 Recherche et gestion du cache de Helm293
  - 4.2 Installation du package WordPress294
  - 4.2.1 Un peu de vocabulaire294
  - 4.2.2 Lancement de l'installation294
  - 4.2.3 Installation sans accès direct296
  - 4.3 Corrections de l'installation296
  - 4.3.1 Quelques remarques296
  - 4.3.2 Spécification du nom et espace de noms296
  - 4.3.3 Lancement de l'installation297
  - 4.3.4 Mise à jour et réentrance297
  - 4.3.5 Généralisation des options d'installation303
  - 4.4 Éléments déployés avec Helm304
  - 4.5 Suppression d'un déploiement305
  - 4.6 Annulation de la suppression306
  - 4.7 Purge d'un chart Helm307
  - 5. Cycle de vie d'une application déployée avec Helm308
  - 5.1 Ouverture du port vers WordPress308
  - 5.2 Connexion à WordPress309
  - 5.3 Configuration d'un chart Helm310
  - 5.3.1 Consultation des options d'un chart310
  - 5.3.2 Configuration de la publication (Minikube)312
  - 5.4 Historique de déploiement315
  - 5.5 Visualisation des différences avant installation315
  - 5.5.1 Origine du besoin315
  - 5.5.2 Installation de l'extension diff pour Helm316
  - 5.5.3 Visualisation des modifications dans l'historique317
  - 5.5.4 Visualisation des modifications avant installation319
  - 5.6 Retour arrière319
  - 5.7 Portail Artifact Hub321
  - Chapitre 11
  - Contextes et outils tiers Kubernetes
  - 1. Objectifs du chapitre et prérequis323
  - 2. Gestion des contextes avec kubectl324
  - 2.1 Origine du besoin324
  - 2.2 Lister les contextes324
  - 2.3 Variable d'environnement KUBECONFIG325
  - 2.3.1 Spécifier l'emplacement du fichier325
  - 2.3.2 Spécifier plusieurs fichiers325
  - 2.4 Changement de contexte326
  - 2.5 Créer un contexte326
  - 2.6 Supprimer un contexte328
  - 2.7 Outils de gestion de contexte328
  - 2.7.1 Présentation de kubectx et kubens328
  - 2.7.2 Installation de kubectx et kubens329
  - 2.7.3 Mise en place de l'autocomplétion330
  - 2.7.4 Test des commandes330
  - 2.8 Contexte dans le prompt utilisateur331
  - 2.8.1 Pourquoi afficher le contexte ?331
  - 2.8.2 Activation à l'aide de oh-my-zsh331
  - 2.8.3 Activation avec bash332
  - 2.8.4 Exemple d'affichage332
  - 2.9 Changement des couleurs du terminal avec Konsole332
  - 2.9.1 Principe de fonctionnement332
  - 2.9.2 Création de la fonction333
  - 2.9.3 Ajout de l'appel dans l'invite de commandes334
  - 3. Utilitaires Kubernetes335
  - 3.1 k9s : interface texte de suivi335
  - 3.1.1 Contexte335
  - 3.1.2 Installation de k9s335
  - 3.1.3 Lancement de k9s335
  - 3.2 Kubespy : espionnage de l'activité337
  - 3.2.1 Présentation de Kubespy337
  - 3.2.2 Installation de Kubespy337
  - 3.2.3 Observation d'un déploiement avec Kubespy337
  - 3.3 Krew : gestionnaire d'extensions338
  - 3.3.1 Présentation du mécanisme d'extensions338
  - 3.3.2 Installation de Krew338
  - 3.3.3 Test de l'extension339
  - 3.4 Sniff : capture du trafic réseau d'un pod340
  - 3.4.1 Principe de fonctionnement340
  - 3.4.2 Installation de Sniff et Wireshark340
  - 3.4.3 Lancement d'une séance de capture341
  - 3.5 Kube Hunter : outil d'analyse du cluster343
  - 3.5.1 Présentation de Kube Hunter343
  - 3.5.2 Lancement de l'analyse343
  - 3.5.3 Résultat de l'analyse344
  - 3.5.4 Publication de rapports HTML345
  - 3.5.5 Lancement à intervalles réguliers346
  - Chapitre 12
  - Services managés Kubenetes
  - 1. Objectifs du chapitre et prérequis349
  - 2. Service managé de Google : GKE350
  - 2.1 Présentation du service Google350
  - 2.2 Administration depuis la console Google350
  - 2.3 Installation de la commande gcloud en local352
  - 2.3.1 Installation sur Debian/Ubuntu352
  - 2.3.2 Mise en place de l'autocomplétion353
  - 2.4 Configuration de l'environnement354
  - 2.4.1 Authentification auprès de Google Cloud354
  - 2.4.2 Projet associé avec le contexte courant356
  - 2.4.3 Activation de l'API356
  - 2.5 Gestion du cluster GKE357
  - 2.5.1 Consultation de la liste des clusters357
  - 2.5.2 Versions et régions disponibles358
  - 2.6 Création d'un cluster358
  - 2.6.1 Options de création358
  - 2.6.2 Lancement de la création du cluster359
  - 2.6.3 Récupération du fichier d'accès au cluster360
  - 2.7 Consultation du cluster360
  - 2.7.1 Liste des nouds360
  - 2.7.2 Services démarrés361
  - 2.8 Délégation des droits d'accès363
  - 2.8.1 Configuration des accès363
  - 2.8.2 Principe du mécanisme sous-jacent364
  - 2.9 Suppression d'un cluster GKE365
  - 3. Service managé Microsoft Azure : AKS366
  - 3.1 Présentation du service Azure366
  - 3.2 Administration depuis la console Azure366
  - 3.2.1 Présentation de la console366
  - 3.2.2 Consultation du tableau de bord Kubernetes368
  - 3.3 Installation de la commande az en local368
  - 3.3.1 Installation sur Debian/Ubuntu369
  - 3.3.2 Mise en place de l'autocomplétion369
  - 3.4 Authentification auprès du service Azure370
  - 3.5 Emplacement de déploiement371
  - 3.5.1 Liste des emplacements371
  - 3.5.2 Versions disponibles de Kubernetes372
  - 3.6 Création d'un cluster373
  - 3.6.1 Création d'un groupe de ressources373
  - 3.6.2 Lancement de la création du cluster373
  - 3.6.3 Récupération du fichier de connexion375
  - 3.6.4 Zone DNS par défaut376
  - 3.7 Consultation de la liste des clusters377
  - 3.8 Délégation des droits d'accès377
  - 3.9 Suppression d'un cluster AKS377
  - 4. Service managé d'Amazon : EKS378
  - 4.1 Présentation du service Amazon AWS378
  - 4.2 Introduction de la commande eksctl379
  - 4.3 Configuration des accès Amazon379
  - 4.4 Installation des binaires383
  - 4.4.1 Installation d'eksctl383
  - 4.4.2 Installation de l'outil aws cli383
  - 4.4.3 Vérification de la communication avec AWS384
  - 4.5 Création du cluster EKS385
  - 4.5.1 Aide en ligne d'eksctl385
  - 4.5.2 Options intéressantes à la création d'un cluster386
  - 4.5.3 Lancement de la création du cluster387
  - 4.6 Configuration des accès kubectl391
  - 4.7 Mécanisme de communication391
  - 4.8 Délégation des droits d'accès392
  - 4.8.1 Configuration des accès392
  - 4.8.2 Principe du mécanisme sous-jacent393
  - 4.9 Suppression du cluster394
  - 5. Service Kubernetes OVHcloud396
  - 5.1 Présentation d'OVHcloud396
  - 5.2 Méthode de création du cluster et prérequis396
  - 5.3 Réseau des nouds du cluster397
  - 5.4 Création du cluster Kubernetes398
  - 5.5 Suppression du cluster Kubernetes399
  - 6. Accès en lecture-écriture multiple400
  - 6.1 Origine du besoin400
  - 6.2 Serveur NFS déployé dans Kubernetes400
  - 6.2.1 Limitations400
  - 6.2.2 Déploiement d'un serveur NFS401
  - 6.2.3 Vérification du déploiement402
  - 6.2.4 Test de création de volume persistant (PVC)402
  - 6.3 Service managé Amazon : EFS403
  - 6.3.1 Consultation des instances EFS403
  - 6.3.2 Création d'une instance EFS403
  - 6.4 Service managé Google : Filestore404
  - 6.4.1 Consultation des instances Filestore404
  - 6.4.2 Création d'une instance Filestore405
  - 6.5 Classe de stockage NFS406
  - 6.5.1 Installation du chart406
  - 6.5.2 Vérification de l'installation du chart406
  - 6.5.3 Test de création d'une demande de volume persistant (PVC)407
  - 6.6 Classe de stockage Azure407
  - Chapitre 13
  - Installation de Kubernetes en interne
  - 1. Objectifs du chapitre et prérequis409
  - 2. Installation à l'aide de Kubespray410
  - 2.1 Origine du besoin410
  - 2.2 Pourquoi Kubespray ?410
  - 2.3 Principe de Kubespray410
  - 2.4 Prérequis des machines à administrer avec Ansible411
  - 2.4.1 Échange de clés SSH411
  - 2.4.2 Escalade de droits sudo411
  - 2.5 Structure du cluster413
  - 2.5.1 Architecture du cluster Kubespray413
  - 2.5.2 Groupes de machines413
  - 2.6 Préparation des éléments d'installation414
  - 2.6.1 Clonage du dépôt Git414
  - 2.6.2 Installation des prérequis414
  - 2.7 Préparation de l'inventaire Ansible415
  - 2.7.1 Qu'est-ce qu'un inventaire ?415
  - 2.7.2 Fichier d'inventaire d'exemple415
  - 2.7.3 Test de la communication Ansible/SSH417
  - 2.8 Installation du cluster418
  - 2.8.1 Configuration du cluster418
  - 2.8.2 Lancement de l'installation419
  - 2.8.3 Mise à jour du cluster420
  - 2.9 Accès au cluster420
  - 2.9.1 Configuration de l'accès au cluster420
  - 2.9.2 Utilisation d'un répartiteur de charge420
  - 2.9.3 Vérification de la communication avec le cluster421
  - 3. Environnement embarqué avec k3s422
  - 3.1 Présentation et but du projet422
  - 3.2 Installation de k3s423
  - 3.3 Communication avec le cluster424
  - 3.4 Ajout de nouds au cluster425
  - Chapitre 14
  - Exposition des applications sur Internet
  - 1. Objectifs du chapitre et prérequis427
  - 2. Gestion des entrées DNS428
  - 2.1 Principe de fonctionnement428
  - 2.2 Prérequis429
  - 2.3 Retour sur le fonctionnement du domaine DNS nip.io429
  - 2.4 Activation du service DNS430
  - 2.4.1 Console Cloud DNS Google430
  - 2.4.2 Service DNS Zones d'Azure433
  - 2.4.3 Service Route 53 d'AWS434
  - 2.5 Configuration DNS435
  - 2.5.1 Opération à réaliser435
  - 2.5.2 Console DNS OVH435
  - 2.5.3 Vérification de la délégation437
  - 2.6 Gestionnaire de DNS438
  - 2.6.1 Présentation de la brique external-dns438
  - 2.6.2 Création du compte d'administration DNS de Google Cloud438
  - 2.6.3 Création du compte d'administration DNS service Azure440
  - 2.6.4 Création du compte d'administration DNS Amazon (Route 53)442
  - 2.6.5 Création d'un secret (Google et Azure)444
  - 2.6.6 Déploiement d'external-dns445
  - 2.6.7 Vérification du fonctionnement d'external-dns447
  - 3. Exposition de services et répartition de charge448
  - 3.1 Présentation du mécanisme448
  - 3.2 Retour sur la notion de service448
  - 3.2.1 Rôle d'un service448
  - 3.2.2 Structure d'un service449
  - 3.2.3 Type ClusterIP449
  - 3.2.4 Type NodePort et LoadBalancer450
  - 3.2.5 Type ExternalName450
  - 3.3 Service associé au proxy inverse450
  - 4. Le contrôleur Ingress451
  - 4.1 Principe de fonctionnement451
  - 4.2 Le rôle du contrôleur Ingress452
  - 4.3 Structure d'une règle Ingress452
  - 4.4 Droits nécessaires pour un contrôleur453
  - 5. Le contrôleur Ingress Google454
  - 5.1 Prérequis454
  - 5.2 Présentation du contrôleur GLBC455
  - 5.3 Déploiement de MailHog455
  - 5.3.1 Préparation de la règle Ingress455
  - 5.3.2 Déploiement de l'application MailHog456
  - 5.3.3 Consultation de l'état de l'objet Ingress456
  - 5.3.4 Consultation du journal d'activité d'external-dns456
  - 5.3.5 Consultation de MailHog457
  - 6. Le contrôleur Ingress Nginx461
  - 6.1 Pourquoi changer de contrôleur Ingress ?461
  - 6.2 Présentation du logiciel Nginx461
  - 6.3 Installation d'Ingress Nginx sur GKE (Google)462
  - 6.3.1 Détermination du chart Helm à installer462
  - 6.3.2 Espace de noms et configuration du chart462
  - 6.4 Utilisation du contrôleur463
  - 6.4.1 Utilisation du champ spec.ingressClassName463
  - 6.4.2 Vérification du déploiement464
  - 6.5 Annotations Ingress Nginx465
  - 6.6 Ajustement de la configuration du contrôleur Nginx466
  - 6.6.1 Récupération de l'origine du trafic466
  - 6.6.2 Haute disponibilité et règles d'affinité/anti-affinité468
  - 6.6.3 Gestion des contrôleurs Ingress471
  - 6.6.4 Réservation et limitation des ressources disponibles473
  - 7. Le contrôleur Ingress Traefik475
  - 7.1 Présentation de Traefik475
  - 7.2 Installation du chart Helm475
  - 7.3 Utilisation du nouveau contrôleur Ingress478
  - 7.3.1 Sélectionner le contrôleur Ingress Traefik478
  - 7.3.2 Création de la règle Ingress faisant appel à Traefik478
  - 7.3.3 État des règles Ingress479
  - 7.4 Tableau de bord de Traefik480
  - 7.5 Annotations Ingress Traefik482
  - 7.6 Distribution de la charge et haute disponibilité483
  - 7.7 Réservation et limitation des ressources disponibles484
  - 7.8 Pour aller plus loin484
  - Chapitre 15
  - Sécurisation : accès aux applications
  - 1. Objectifs du chapitre et prérequis487
  - 2. Mise en place de Let's Encrypt488
  - 2.1 Présentation de Let's Encrypt488
  - 2.2 Installation du chart Helm cert-manager488
  - 2.2.1 Présentation du chart Helm488
  - 2.2.2 Prérequis avant installation489
  - 2.3 L'émetteur de certificats (issuer)490
  - 2.3.1 Principe du protocole ACME490
  - 2.3.2 Structure de la déclaration d'un émetteur491
  - 2.3.3 Exemple de déclaration Issuer Google493
  - 2.3.4 Exemple de déclaration Issuer Azure494
  - 2.3.5 Exemple de déclaration Issuer Amazon494
  - 2.3.6 Limitations et certificats avec joker495
  - 2.4 Exemples de déclarations496
  - 2.4.1 Serveur Let's Encrypt de test496
  - 2.4.2 Serveur Let's Encrypt de production497
  - 2.5 Déclaration des certificats498
  - 2.5.1 Etat des émetteurs de certificats498
  - 2.5.2 Structure d'un certificat498
  - 2.5.3 Certificat de test499
  - 2.5.4 État du certificat500
  - 2.5.5 Journal d'activité de cert-manager500
  - 2.5.6 Consultation du secret502
  - 2.5.7 Certificat de production503
  - 2.5.8 Marche à suivre en cas de problèmes504
  - 2.6 Rattachement du certificat à la règle Ingress505
  - 2.7 Automatisation de la gestion des certificats507
  - 2.7.1 Certificat par défaut du contrôleur Ingress Nginx507
  - 2.7.2 Mécanisme d'annotations508
  - 2.7.3 Émetteur de certificats par défaut509
  - 3. Protection de l'accès aux applications509
  - 3.1 Origine du besoin509
  - 3.2 Mot de passe simple (HTTP basic)510
  - 3.2.1 Principe de fonctionnement510
  - 3.2.2 Création du secret à l'aide de htpasswd510
  - 3.2.3 Import du secret511
  - 3.2.4 Configuration de l'authentification512
  - 4. Authentification basée sur OAuth2515
  - 4.1 À propos du protocole OAuth2515
  - 4.2 Principe de la solution516
  - 4.3 Création d'un identifiant GitHub517
  - 4.4 Déploiement du proxy518
  - 4.4.1 À propos du proxy518
  - 4.4.2 Configuration du chart Helm519
  - 4.4.3 Déploiement du chart Helm520
  - 4.4.4 État du déploiement520
  - 4.5 Déclaration des règles Ingress521
  - 4.5.1 Description des règles Ingress521
  - 4.5.2 Annotations Ingress de MailHog521
  - 4.5.3 Description Ingress du proxy OAuth521
  - 4.5.4 Déclaration des règles Ingress521
  - 4.6 Tests de connexion523
  - 4.7 Restriction des accès524
  - 4.7.1 Mécanisme d'autorisation524
  - 4.7.2 Restriction par domaine e-mail525
  - 4.7.3 Restriction par organisation GitHub525
  - Chapitre 16
  - Polices réseau
  - 1. Objectifs du chapitre et prérequis527
  - 2. Les polices réseau (network policies)527
  - 2.1 Présentation du mécanisme527
  - 2.2 Kubernetes Network Plugins528
  - 2.3 Polices réseau sur services managés et installation maison528
  - 2.4 Installation de Calico sur Minikube529
  - 2.4.1 Activation de CNI sur Minikube529
  - 2.4.2 Installation de Calico529
  - 2.5 Connexions entrantes529
  - 2.5.1 Test de la connexion en interne529
  - 2.5.2 Bloquer les accès internes530
  - 2.5.3 Test de la règle532
  - 2.6 Connexions sortantes532
  - 2.6.1 Test des connexions externes532
  - 2.6.2 Restriction sur les règles sortantes533
  - 2.6.3 Test de la règle533
  - 3. Protection de l'application WordPress534
  - 3.1 Contexte534
  - 3.2 Déploiement de WordPress534
  - 3.3 Restriction des accès535
  - 3.3.1 Référencement de l'ensemble des flux535
  - 3.3.2 Restriction de tous les accès535
  - 3.3.3 Autorisation de l'accès du contrôleur Ingress sur WordPress536
  - 3.3.4 Autorisation de l'accès entre WordPress et MariaDB538
  - 3.3.5 Test des règles réseau539
  - 3.4 Ressources externes541
  - Chapitre 17
  - Montée en charge automatique
  - 1. Objectifs du chapitre et prérequis543
  - 2. Le serveur de métriques544
  - 2.1 Présentation de la brique metrics-server544
  - 2.2 Activation du serveur de métriques544
  - 2.2.1 Vérification de la présence du serveur de métriques544
  - 2.2.2 Activation sous Minikube545
  - 2.2.3 Activation sur Amazon EKS545
  - 2.3 Consultation de la consommation des pods et des nouds546
  - 2.3.1 État des nouds d'un cluster546
  - 2.3.2 État des pods546
  - 3. Activation de la montée en charge automatique547
  - 3.1 Test avec l'application MailHog547
  - 3.2 Lancement d'un bench548
  - 3.2.1 Présentation d'Apache Bench548
  - 3.2.2 Installation d'Apache Bench549
  - 3.2.3 Lancement du test initial549
  - 3.3 Gestion de la montée en charge.550
  - 3.4 Lancement du test551
  - 3.4.1 Test à froid : montée en charge des pods551
  - 3.4.2 Test à chaud552
  - 3.4.3 Diminution du nombre de pods553
  - 4. Scalabilité des nouds d'un cluster553
  - 4.1 Contexte553
  - 4.2 Présentation de l'autoscaler554
  - 4.3 Activation de l'autoscaler avec Google Cloud554
  - 4.4 Activation de l'autoscaler avec Azure AKS555
  - 4.5 Activation de l'autoscaler avec Amazon EKS555
  - 4.5.1 Présentation du mécanisme de l'ASG555
  - 4.5.2 Affichage des tags d'un groupe ASG556
  - 4.5.3 Activation de l'autoscaler557
  - 4.5.4 Vérification de l'activation du mécanisme de l'autoscaler558
  - 4.6 Test de montée en charge558
  - 4.6.1 Déploiement de WordPress558
  - 4.6.2 Pods en attente de ressources559
  - 4.6.3 État des nouds559
  - 4.6.4 Démarrage du pod560
  - 4.6.5 Nettoyage des déploiements560
  - 5. Définition de groupes de machines561
  - 5.1 Contexte561
  - 5.2 Les différents types de machines562
  - 5.2.1 Les machines préemptives (Spot)562
  - 5.2.2 Réservation d'instances563
  - 5.2.3 Familles de machines563
  - 5.2.4 Quelques exemples de familles de machines564
  - 5.2.5 Utilisation d'accélérateurs graphiques (GPU)566
  - 5.2.6 Quelques exemples de coûts567
  - 5.3 Création de groupes de machines569
  - 5.3.1 Contexte569
  - 5.3.2 Création d'un groupe avec Google570
  - 5.3.3 Création d'un groupe avec Azuré571
  - 5.3.4 Création d'un groupe avec AWS EKS573
  - 5.3.5 Création d'un groupe avec OVH575
  - 5.4 Mécanisme de tolérance et sélection de nouds577
  - Chapitre 18
  - Surveillance à l'aide de Prometheus
  - 1. Objectifs du chapitre et prérequis581
  - 2. Mise en place de Prometheus582
  - 2.1 À propos de Prometheus582
  - 2.2 Fonctionnement de Prometheus583
  - 2.2.1 Architecture de Prometheus583
  - 2.2.2 Le moteur Prometheus583
  - 2.2.3 Les exporteurs Prometheus584
  - 2.3 Installation de Prometheus585
  - 2.3.1 Choix du chart Prometheus585
  - 2.3.2 Qu'est-ce qu'un opérateur ?585
  - 2.3.3 Déploiement de l'opérateur Prometheus586
  - 2.3.4 Pods démarrés588
  - 2.3.5 Objets déploiements588
  - 2.3.6 Nouvelles ressources Prometheus589
  - 2.3.7 DaemonSet : node exporter590
  - 2.4 Priorisation des briques de surveillance590
  - 2.4.1 Problème de la surveillance590
  - 2.4.2 Déclaration des classes de priorité591
  - 2.4.3 Modification du déploiement de Prometheus591
  - 3. Utilisation de Prometheus592
  - 3.1 Fonctionnement des métriques592
  - 3.1.1 Consultation des métriques de Prometheus592
  - 3.1.2 Présentation de l'interface de Prometheus593
  - 3.1.3 Métriques de Kubernetes595
  - 3.1.4 Déclaration des points de collecte dans Kubernetes596
  - 3.1.5 Consultation des points de collecte dans Prometheus597
  - 3.2 Définition des alertes598
  - 3.2.1 Consultation de la liste des alertes598
  - 3.2.2 Structure d'une règle d'alerte599
  - 3.2.3 Définition d'alertes600
  - 3.3 Gestionnaire d'alertes601
  - 3.3.1 Rôle du gestionnaire d'alertes601
  - 3.3.2 Consultation du gestionnaire d'alertes602
  - 3.3.3 Configuration des alertes602
  - 3.3.4 Désactivation des alertes scheduler et manager (clusters managés)603
  - 3.3.5 Configuration de l'envoi des notifications605
  - 3.3.6 Adresse de l'API de Slack606
  - 4. Tableaux de bord Grafana609
  - 4.1 Présentation de Grafana609
  - 4.2 Configuration de Grafana609
  - 4.2.1 Branchement au moteur Prometheus609
  - 4.2.2 Définition des tableaux de bord610
  - 4.3 Interface Grafana611
  - 4.4 Sécurisation de l'accès à Grafana612
  - 5. Suppression du chart de Prometheus613
  - Chapitre 19
  - Centralisation des journaux d'activité
  - 1. Objectifs du chapitre et prérequis615
  - 2. Principe de la centralisation des journaux616
  - 2.1 Architecture616
  - 2.2 Caractéristiques de l'agent déployé617
  - 2.3 Mécanisme de centralisation des journaux617
  - 3. Centralisation dans le cloud618
  - 3.1 Centralisation à l'aide d'un service managé618
  - 3.2 Google Stackdriver618
  - 3.2.1 Présentation de Stackdriver618
  - 3.2.2 Pod Fluentbit (cluster GKE)619
  - 3.2.3 Consultation des journaux619
  - 3.3 Azure Monitor620
  - 3.3.1 Présentation d'Azure Monitor620
  - 3.3.2 Consultation des journaux620
  - 3.4 Amazon Cloudwatch621
  - 3.4.1 Présentation de Cloudwatch621
  - 3.4.2 Activation de Cloudwatch sur le centre de contrôle621
  - 3.4.3 Configuration de Cloudwatch623
  - 3.4.4 Création de la police de communication avec Cloudwatch623
  - 3.4.5 Création d'un compte et rattachement à la police625
  - 3.4.6 Création d'une clé d'accès625
  - 3.4.7 Envoi des journaux dans Cloudwatch626
  - 3.4.8 Etat des pods déployés627
  - 3.4.9 Consultation des journaux dans Cloudwatch628
  - 4. Centralisation des journaux avec Loki630
  - 4.1 Présentation de Loki630
  - 4.1.1 Origine de Loki630
  - 4.1.2 Loki vs Elasticsearch630
  - 4.1.3 Conseil d'utilisation630
  - 4.2 Installation de Loki631
  - 4.3 Configuration de la source de données Grafana631
  - 4.4 Consultation des journaux dans Grafana633
  - 4.4.1 Vérification des sources de données633
  - 4.4.2 Consultation des journaux634
  - 5. Centralisation des journaux avec Elasticsearch635
  - 5.1 Avertissements et limitations635
  - 5.2 À propos d'Elasticsearch635
  - 5.3 Déploiement des briques Elasticsearch635
  - 5.3.1 Installation d'Elasticsearch635
  - 5.3.2 Installation de l'agent Filebeat637
  - 5.3.3 Installation de Kibana638
  - 5.3.4 Installation de Cerebro638
  - 5.4 Etat des différentes briques638
  - 5.4.1 Etat du moteur Elasticsearch638
  - 5.4.2 Agent Filebeat639
  - 6. Gestion d'Elasticsearch639
  - 6.1 Accès à l'interface Cerebro639
  - 6.2 Utilisation de Kibana641
  - 6.2.1 Accéder à l'interface de Kibana641
  - 6.2.2 Création de l'index643
  - 6.3 Branchement sur Grafana645
  - 6.3.1 Source de données Elasticsearch645
  - 6.3.2 Création d'un objet ConfigMap645
  - Chapitre 20
  - Maillage de services avec Istio
  - 1. Objectifs du chapitre et prérequis647
  - 2. Présentation d'Istio648
  - 2.1 Micro-services et mise en réseau de services648
  - 2.2 Présentation d'Istio649
  - 2.3 Principe de fonctionnement649
  - 3. Installation d'Istio651
  - 3.1 Configuration d'external-dns651
  - 3.2 Dépôt des charts Istio652
  - 3.3 Installation d'istio653
  - 3.4 Configuration d'istio653
  - 3.4.1 Activation des tableaux de bord653
  - 3.4.2 Configuration d'istio654
  - 3.5 Configuration du composant Gateway Istio655
  - 3.5.1 Présentation du mécanisme655
  - 3.5.2 Installation du composant Gateway655
  - 3.5.3 Génération du certificat657
  - 4. Utilisation d'Istio658
  - 4.1 Injection de pods dans le maillage de services658
  - 4.1.1 Installation d'istioctl658
  - 4.1.2 Injection du sidecar à l'aide d'istioctl659
  - 4.1.3 Injection du sidecar par annotation660
  - 4.1.4 Désactivation du sidecar par annotation660
  - 4.2 Déploiement d'une application de test661
  - 4.2.1 Principe de l'exposition d'application avec Istio661
  - 4.2.2 Préparation du fichier de déploiement MailHog661
  - 4.2.3 Déclaration du service MailHog663
  - 4.2.4 Création de l'objet Gateway664
  - 4.2.5 Création du service virtuel (VirtualService)665
  - 4.3 Sécurisation des flux666
  - 4.3.1 Activation de Mutual TLS (mTLS)666
  - 4.3.2 Consultation des polices du service MailHog667
  - 4.3.3 Forcer l'utilisation de mTLS669
  - 5. Tableaux de bord672
  - 5.1 Présentation des différentes briques672
  - 5.2 Interface Kiali673
  - 5.3 Interface Grafana674
  - 5.4 Interface Jaeger676
  - Chapitre 21
  - Compilation et stockage d'images Docker
  - 1. Objectifs du chapitre et prérequis679
  - 2. Création d'une image Docker680
  - 2.1 Application d'exemple Flask HealthCheck680
  - 2.1.1 Présentation de l'application680
  - 2.1.2 Présentation des dépendances680
  - 2.1.3 Description des dépendances680
  - 2.1.4 Installation des dépendances681
  - 2.1.5 Initialisation de l'application681
  - 2.1.6 Fonction racine682
  - 2.1.7 Lancement du programme682
  - 2.2 Environnement de compilation685
  - 2.3 Le fichier Dockerfile685
  - 2.3.1 Présentation du format685
  - 2.3.2 Création de l'image686
  - 2.3.3 Compilation et tag de l'image687
  - 2.3.4 Authentification sur le registre d'images Docker688
  - 2.3.5 Pousser l'image sur le registre688
  - 3. Image Docker multi-étape (multi-stage)690
  - 3.1 Origine du besoin690
  - 3.2 Exemple de compilation avec Maven690
  - 4. Analyse d'images691
  - 4.1 Historique des commandes691
  - 4.2 Analyse de l'image : Dive692
  - 4.2.1 Présentation de Dive692
  - 4.2.2 Installation de Dive692
  - 4.2.3 Consultation du contenu d'une image692
  - 5. Utilisation de registres Docker privés693
  - 5.1 Origine du besoin693
  - 5.2 Déploiement d'image d'un registre privé694
  - 5.2.1 Exposition de la problématique694
  - 5.2.2 Création du secret694
  - 5.2.3 Utilisation du secret695
  - 5.2.4 Utilisation d'un compte de service696
  - 5.2.5 Recopie d'un secret entre espaces de noms698
  - 5.3 Erreurs de récupération des images699
  - 5.3.1 Détection des erreurs699
  - 5.3.2 Erreur sur le nom de l'image699
  - 5.3.3 Secret absent ou non spécifié699
  - 5.3.4 Identifiants invalides700
  - 5.4 Services de registres managés700
  - 5.4.1 Solutions managées700
  - 5.4.2 Service Google Container Registry701
  - 5.4.3 GitLab.com702
  - Chapitre 22
  - Usine logicielle
  - 1. Objectifs du chapitre et prérequis705
  - 2. Compilation à l'aide de GitLab706
  - 2.1 Application à compiler706
  - 2.2 Mécanisme de pipeline GitLab706
  - 2.3 Adresse et contenu du dépôt706
  - 2.4 Structure du fichier .gitlab-ci.yml707
  - 2.5 Exemple de fichier .gitlab-ci.yml de compilation d'image708
  - 2.6 Construction d'image à l'aide de Kaniko710
  - 2.7 Pour la suite712
  - 3. Déploiement continu avec Jenkins712
  - 3.1 À propos de Jenkins712
  - 3.2 Installation de Jenkins713
  - 3.2.1 Configuration du chart713
  - 3.2.2 Vérification de l'installation715
  - 3.2.3 Connexion à l'interface de Jenkins715
  - 3.2.4 Installation d'extensions716
  - 4. Pipeline de déploiement continu avec Jenkins717
  - 4.1 Prérequis717
  - 4.2 Présentation du mécanisme de déploiement continu717
  - 4.3 Stockage des identifiants Docker718
  - 4.4 Création de l'environnement develop718
  - 4.5 Création du pipeline719
  - 4.5.1 Création du pod de compilation719
  - 4.5.2 Squelette du pipeline de déploiement721
  - 4.5.3 Récupération du code source722
  - 4.5.4 Vérifications et tests722
  - 4.5.5 Compilation de l'image Docker723
  - 4.5.6 Connexion au registre et publication723
  - 4.5.7 Mise à jour du déploiement de test724
  - 4.5.8 Programme complet725
  - 4.6 Lancement de la compilation727
  - 4.6.1 Création du job727
  - 4.6.2 Lancement du build728
  - 4.7 Compte de service729
  - 4.7.1 Opérations à réaliser729
  - 4.7.2 Création d'un compte de service729
  - 4.7.3 Création du rôle de mise à jour730
  - 4.7.4 Affectation du rôle au compte de service730
  - 4.7.5 Affectation du compte de service731
  - 4.7.6 Relance de la compilation732
  - 4.8 Utilisation de Kaniko avec Jenkins732
  - 4.9 Mécanisme de Webhook734
  - 4.9.1 Présentation du mécanisme734
  - 4.9.2 Déclenchement du Webhook734
  - 4.9.3 Création du Webhook735
  - 5. Un mot sur Jenkins X736
  - Chapitre 23
  - Packager son application avec Helm
  - 1. Objectifs du chapitre et prérequis737
  - 2. Helm738
  - 2.1 Origine du besoin738
  - 2.2 Création d'un chart738
  - 2.3 Contenu d'un package739
  - 2.3.1 Structure d'un package739
  - 2.3.2 Variables .Values, .Chart et .Release739
  - 2.4 Adaptation à l'application MailHog740
  - 2.4.1 Résumé des travaux à réaliser740
  - 2.4.2 Utilisation de l'image de MailHog740
  - 2.4.3 Correction sur les ports de service740
  - 2.4.4 Ajout d'un ConfigMap741
  - 2.4.5 Ajout du volume persistant742
  - 2.4.6 Montage du volume dans le container743
  - 2.4.7 Test de déploiement744
  - 2.5 Dépendances745
  - 2.5.1 Déclaration des dépendances745
  - 2.5.2 Récupération des dépendances746
  - 2.5.3 Déploiement du chart avec les dépendances747
  - 3. Template Go748
  - 3.1 Principe de fonctionnement748
  - 3.2 Substitution du contenu d'une variable748
  - 3.3 Blocs conditionnels749
  - 3.4 Gestion des conditions749
  - 3.4.1 Les valeurs de vrai ou faux749
  - 3.4.2 Opérateurs de comparaison750
  - 3.4.3 Conditions multiples et négation750
  - 3.5 Itération751
  - 3.5.1 Affichage du contenu d'un tableau751
  - 3.5.2 Suppression des sauts de lignes surnuméraires752
  - 3.5.3 Itération sur un groupe fixe d'éléments752
  - 3.5.4 Itération sur un tableau de hachage753
  - 3.5.5 Accéder à une variable globale depuis une boucle753
  - 3.6 Filtres754
  - 3.7 Valeurs par défaut754
  - 3.8 Fonction template755
  - 3.8.1 Exemple de définition de fonction755
  - 3.8.2 Passage de paramètres et contexte global756
  - 3.9 Redéploiement sur changement de configuration756
  - 3.9.1 Exposition de la problématique756
  - 3.9.2 Principe de la solution757
  - 3.9.3 Exemple d'implémentation757
  - 3.10 Génération de secret aléatoire « stable »759
  - 3.10.1 Exposition de la problématique759
  - 3.10.2 Principe de la solution et mise en ouvre759
  - Chapitre 24
  - Restriction et délégation d'accès
  - 1. Objectifs du chapitre et prérequis761
  - 2. Mise en place de quotas762
  - 2.1 Origine du besoin762
  - 2.2 Quotas par défaut sur un espace de noms762
  - 2.2.1 Création d'un espace de noms762
  - 2.2.2 Structure d'un objet LimitRange763
  - 2.2.3 Exemple de définition de limitations764
  - 2.2.4 Vérification de l'application des limitations765
  - 2.2.5 Test du mécanisme766
  - 2.2.6 Analyse du problème766
  - 2.3 Quotas globaux sur un espace de noms767
  - 2.3.1 Présentation des quotas de ressources (ResourceQuota)767
  - 2.3.2 Structure d'un quota de ressources768
  - 2.3.3 Exemples de restriction de consommation CPU et mémoire768
  - 2.3.4 Champs pour positionner des limitations (champ hard)769
  - 2.3.5 Test du mécanisme770
  - 2.3.6 Nettoyage en fin d'exercice771
  - 3. Authentification et autorisation772
  - 3.1 Origine du besoin772
  - 3.2 Prérequis773
  - 3.3 Activation des accès anonymes774
  - 3.3.1 Activation des accès anonymes sur Minikube774
  - 3.3.2 Création du fichier d'accès775
  - 3.3.3 Affectation des droits en lecture776
  - 3.3.4 Suppression des droits d'accès anonymes777
  - 3.4 Principe de l'authentification par certificat777
  - 3.5 Problème de la révocation des certificats778
  - 3.6 Génération du certificat778
  - 3.6.1 Création de la clé et du certificat client778
  - 3.6.2 Emplacement de la PKI779
  - 3.6.3 Signature du certificat780
  - 3.7 Authentification par certificat781
  - 3.7.1 Récupération des informations de connexion au cluster781
  - 3.7.2 Utilisation du certificat pour l'authentification782
  - 3.7.3 Test de la connexion784
  - 3.8 Quelques exemples d'erreurs de manipulation784
  - 3.8.1 Problème d'autorité de certification785
  - 3.8.2 Problème de couple clé/certificat785
  - 3.8.3 Pas d'identifiant renseigné785
  - 3.8.4 Utilisation de la demande de certificat à la place du certificat785
  - 3.9 Attributions de droits administrateur sur le cluster786
  - 3.9.1 Contexte et opérations à réaliser786
  - 3.9.2 Affectation des droits administrateur à un utilisateur786
  - 3.9.3 Test du nouvel administrateur788
  - 3.9.4 Création de nouveaux utilisateurs788
  - 3.9.5 Affectation des droits administrateur à un groupe789
  - 3.9.6 Administrateur d'un espace de noms789
  - 4. Mécanismes d'authentification externes791
  - 4.1 Présentation du mécanisme791
  - 4.2 Communication entre le fournisseur OAuth2 et le cluster792
  - 4.3 Création des identifiants793
  - 4.4 Modification des options de démarrage (Minikube)794
  - 4.5 Configuration des accès clients796
  - 4.5.1 Présentation de l'outil k8s-oidc-helper796
  - 4.5.2 Installation du compilateur Go796
  - 4.5.3 Installation de k8s-oidc-helper796
  - 4.5.4 Génération des identifiants d'accès796
  - 4.5.5 Renseignement du cluster et contexte798
  - 4.5.6 Test de connexion799
  - 4.6 Attribution des droits d'accès800
  - 5. Mise en place de comptes de service801
  - 5.1 Contexte801
  - 5.2 Création du compte de service801
  - 5.3 Attribution des droits d'administrateur au compte de service802
  - 5.4 Création du fichier Kubeconfig804
  - 5.4.1 Recopie des informations de connexion804
  - 5.4.2 Jeton de connexion du compte de service804
  - 5.4.3 Affectation de l'utilisateur805
  - 5.4.4 Test de la connexion806
  - 5.4.5 Révocation des accès806
  - Chapitre 25
  - Les opérateurs Kubernetes
  - 1. Objectifs du chapitre et prérequis809
  - 2. Utilisation des opérateurs810
  - 2.1 Présentation du principe810
  - 2.2 L'opérateur de Prometheus810
  - 2.2.1 Retour sur le chart prometheus-operator810
  - 2.2.2 Structure d'un objet Prometheus811
  - 2.3 Ressources externes sur les opérateurs existants812
  - 2.4 Présentation de l'opérateur MySQL813
  - 2.4.1 Justification du choix de MySQL813
  - 2.4.2 Choix de l'opérateur813
  - 2.5 Déploiement de l'opérateur814
  - 2.6 Création d'une instance MysqlCluster815
  - 2.6.1 Création d'un secret pour l'instance MysqlCluster815
  - 2.6.2 Création du cluster816
  - 2.6.3 Problèmes de droits sur le volume persistant818
  - 2.7 Objets créés au déploiement du cluster818
  - 2.7.1 Volumes persistants819
  - 2.7.2 Services MySQL819
  - 2.8 Tableau de bord de l'opérateur819
  - 2.9 Test de la réplication822
  - 2.9.1 Connexion les instances maîtresses et esclave822
  - 2.9.2 Création d'une table823
  - 2.9.3 Alimentation de la table823
  - 2.9.4 Changement du nombre de réplicats824
  - 2.10 Pour conclure825
  - Annexes
  - 1. bash vs zsh827
  - 1.1 Les shells Unix827
  - 1.2 zsh et oh-my-zsh828
  - 1.3 Tester zsh et oh-my-zsh828
  - 1.4 Configurer zsh comme shell pour l'utilisateur courant829
  - 2. Déploiement du tableau de bord Kubernetes830
  - 2.1 Installation du tableau de bord (application dashboard)830
  - 2.2 Création du compte d'accès831
  - 2.3 Récupération du jeton de connexion832
  - 2.4 Décodage du contenu du jeton833
  - 2.5 Connexion au tableau de bord835
  - Index837
Origine de la notice:
- Electre