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.


Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (52 Ko)

Avant-propos

1. 1. Présentation de Kubernetes
   1. 1.1 Un peu d’histoire
   2. 1.2 Qu’est-ce qu’un container ?
   3. 1.3 Les containers avant Docker
   4. 1.4 Pourquoi utiliser des containers ?
   5. 1.5 Problèmes introduits avec les containers
   6. 1.6 À quoi va servir Kubernetes ?
   7. 1.7 Ressources externes
2. 2. Un mot sur l’application
   1. 2.1 Rien ne sert de courir
   2. 2.2 Les douze facteurs applicatifs
   3. 2.3 Microservices vs Monolithes

Introduction

1. 1. Cibles et objectifs de l’ouvrage
2. 2. Prérequis techniques et ressources documentaires
   1. 2.1 Prérequis techniques
   2. 2.2 Ressources documentaires
   3. 2.3 Récupération des fichiers d’exemples
3. 3. Présentation générale
   1. 3.1 Prérequis
   2. 3.2 Utilisation de Kubernetes
   3. 3.3 Installation et configuration de Kubernetes
   4. 3.4 Extension du cluster Kubernetes et notions avancées
   5. 3.5 Déploiement et intégration continue
   6. 3.6 Conventions utilisées

Installation de l’environnement Kubernetes

1. 1. Objectifs du chapitre et prérequis
2. 2. Alternative à l’installation en local
   1. 2.1 Pourquoi ces alternatives ?
   2. 2.2 Utilisation d’un service managé
   3. 2.3 Service Katacoda
3. 3. Mise en place de la commande kubectl
   1. 3.1 À quoi sert kubectl ?
   2. 3.2 Installation de kubectl
      1. 3.2.1 Installation sous Debian/Ubuntu
      2. 3.2.2 Installation sous CentOS/RHEL ou Fedora
      3. 3.2.3 Installation à l’aide d’Arkade
   3. 3.3 Vérification de l’installation
   4. 3.4 Configuration de l’autocomplétion
      1. 3.4.1 Présentation du mécanisme d’autocomplétion
      2. 3.4.2 Fichier profile à modifier
      3. 3.4.3 Autocomplétion sur kubectl
      4. 3.4.4 Utilisation de la variable SHELL
      5. 3.4.5 Mise en place d’un alias
4. 4. Mise en place de Minikube
   1. 4.1 Pourquoi faire appel à Minikube ?
   2. 4.2 Téléchargement et installation de Minikube
   3. 4.3 Vérification de l'installation de Minikube
   4. 4.4 Mise en place de l’autocomplétion
5. 5. Installation du cluster Kubernetes avec Minikube
   1. 5.1 Options de lancement
   2. 5.2 Installation de Docker
      1. 5.2.1 Installation de Docker Community Edition sur Ubuntu
      2. 5.2.2 Installation alternative
      3. 5.2.3 Configuration des accès à Docker
      4. 5.2.4 Vérification de l’installation de Docker
   3. 5.3 Installation de l’hyperviseur VirtualBox
   4. 5.4 Installation de l’hyperviseur KVM/libvirt
   5. 5.5 Configuration de l’utilisateur courant
   6. 5.6 Déploiement du cluster avec Minikube
      1. 5.6.1 Création de la machine Minikube
      2. 5.6.2 Arrêt/démarrage de la machine Minikube
      3. 5.6.3 Choix du container runtime
      4. 5.6.4 Extensions de Minikube
      5. 5.6.5 Suppression de la machine Minikube
6. 6. Quelques notions sur le format YAML
   1. 6.1 Déclaration de couples clés/valeurs
   2. 6.2 Les tableaux en YAML
   3. 6.3 Les structures clé/valeur ou table de hachage
   4. 6.4 Tableau de table de hachage

Tableau de bord et ligne de commande

1. 1. Objectifs du chapitre et prérequis
2. 2. Préambule
   1. 2.1 Origine du nom et du logo
   2. 2.2 Pourquoi utiliser Kubernetes ?
   3. 2.3 Origine de Kubernetes
   4. 2.4 Fondation CNCF
   5. 2.5 Les orchestrateurs du marché
3. 3. Le tableau de bord de Kubernetes (dashboard)
   1. 3.1 Présentation
   2. 3.2 Tableau de bord Kubernetes sur service managé
   3. 3.3 Déploiement du dashboard sur Minikube
   4. 3.4 Accès au dashboard sur Minikube
   5. 3.5 Structure du tableau de bord
   6. 3.6 Création d’un déploiement
      1. 3.6.1 Un petit mot sur MailHog
      2. 3.6.2 Lancement du déploiement
   7. 3.7 État d’un déploiement
      1. 3.7.1 Consultation de l’état du déploiement
      2. 3.7.2 Consultation du gestionnaire de réplicats
      3. 3.7.3 Consultation de l’état d’un pod
      4. 3.7.4 Journal d’activité du container
      5. 3.7.5 Scalabilité
      6. 3.7.6 Mise à jour de l’application
      7. 3.7.7 Pour résumer
4. 4. Présentation de l’outil kubectl
   1. 4.1 Préambule
   2. 4.2 Consultation des éléments
   3. 4.3 Liste des pods
   4. 4.4 Liste des machines d’un cluster
      1. 4.4.1 Connexion à la machine Minikube
      2. 4.4.2 Liste des nœuds d’un cluster
      3. 4.4.3 Affichage des caractéristiques étendues
5. 5. Le moteur Containerd de Minikube
   1. 5.1 Initialisation de l'environnement
   2. 5.2 Les containers associés aux pods

Automatisation et publication d’une application

1. 1. Objectifs du chapitre et prérequis
2. 2. Gestion par kubectl d’une application
   1. 2.1 Suppression d’un déploiement
   2. 2.2 Création d’un déploiement
   3. 2.3 État du déploiement
   4. 2.4 Mécanisme des réplicats
      1. 2.4.1 Consultation des réplicats
      2. 2.4.2 Description des réplicats
   5. 2.5 État du pod
      1. 2.5.1 Liste des pods
      2. 2.5.2 Détails de l’état d’un pod
   6. 2.6 Accès aux logs des containers
   7. 2.7 Accéder à l’application MailHog
3. 3. Exposition de services
   1. 3.1 Pourquoi utiliser un service ?
   2. 3.2 Exposition d’un déploiement via un service
   3. 3.3 Vérification du service mailhog
   4. 3.4 Que faire en cas d’absence de shell ?
      1. 3.4.1 Contexte
      2. 3.4.2 Utilisation d’un pod éphémère
      3. 3.4.3 Lancement d’un pod de test
   5. 3.5 Résilience et scalabilité
      1. 3.5.1 Origine du besoin
      2. 3.5.2 Scalabilité manuelle
      3. 3.5.3 Nombre de pods associés à un déploiement
      4. 3.5.4 Arrêter temporairement une application
4. 4. Automatisation de déploiement par fichier YAML
   1. 4.1 Mécanisme de création et mise à jour
   2. 4.2 Structure YAML d’un déploiement
      1. 4.2.1 Quelques rappels
      2. 4.2.2 Récupération d’une structure au format YAML
      3. 4.2.3 Édition d’un déploiement
      4. 4.2.4 Squelette pour un déploiement
      5. 4.2.5 Création d’un déploiement à l’aide d’un fichier
      6. 4.2.6 Suppression des éléments d’un fichier
      7. 4.2.7 Gestion de l’idempotence et de la réentrance
   3. 4.3 Création du service
      1. 4.3.1 Définition du service
      2. 4.3.2 Application de la définition du service
      3. 4.3.3 Gestion de la réentrance
   4. 4.4 Mécanisme de sélecteur et labels
   5. 4.5 Regroupement de la création des éléments
      1. 4.5.1 Création d’un groupe d’objets
      2. 4.5.2 Consultation de l’état d’un groupe d’objets
   6. 4.6 Structure des objets
      1. 4.6.1 Interrogation de Kubernetes avec kubectl
      2. 4.6.2 Référence de l’API en ligne
5. 5. Ingress et reverse proxy
   1. 5.1 Origine du besoin
   2. 5.2 Rôle d’un proxy inverse
   3. 5.3 Activation du contrôleur Ingress dans Minikube
   4. 5.4 Déclaration d’une règle Ingress
   5. 5.5 Consultation des règles Ingress
   6. 5.6 Hôte virtuel et nip.io
      1. 5.6.1 Hôte virtuel par défaut
      2. 5.6.2 Présentation du mécanisme de nip.io
      3. 5.6.3 Configuration du serveur DNS
      4. 5.6.4 Création d’un hôte virtuel pour MailHog

Cycle de vie d’un container dans Kubernetes

1. 1. Objectifs du chapitre et prérequis
2. 2. Gestion des crashs d’application
   1. 2.1 Consultation de l'état des pods
   2. 2.2 Connexion au pod
   3. 2.3 Container associé à MailHog
   4. 2.4 Comportement en cas de crash
   5. 2.5 État du container après redémarrage du pod
   6. 2.6 Container vu depuis Containerd (Minikube)
   7. 2.7 Attention au nettoyage
3. 3. État d’un container
   1. 3.1 Pourquoi scruter l’état d’un container ?
   2. 3.2 Readiness vs Liveness
   3. 3.3 Utilisation et bonne pratique
   4. 3.4 Structure des champs de surveillance
   5. 3.5 Vérification de la présence d’un port
      1. 3.5.1 Définition de la surveillance
      2. 3.5.2 Test d’indisponibilité sur un pod non prêt
      3. 3.5.3 État des pods en cas d’indisponibilité
      4. 3.5.4 Test d’indisponibilité sur un pod en mauvaise santé
      5. 3.5.5 État des pods en cas de problème sur un pod
      6. 3.5.6 Attention à la consistance des tests
      7. 3.5.7 Uniformisation des tests
   6. 3.6 Surveillance HTTP
      1. 3.6.1 Pourquoi privilégier ce type de surveillance ?
      2. 3.6.2 Surveillance de l’application MailHog
   7. 3.7 Point d’entrée de surveillance HTTP d’une application
      1. 3.7.1 Un mot sur les frameworks modernes
      2. 3.7.2 Présentation de l’application Flask
      3. 3.7.3 Exemple de déclaration
      4. 3.7.4 Déploiement de l’application Flask
      5. 3.7.5 Consultation de l’état de l’application
   8. 3.8 Lancement d’un shell
      1. 3.8.1 Principe de fonctionnement
      2. 3.8.2 Exemple de surveillance d’une base Postgres
      3. 3.8.3 Déclaration de la commande
4. 4. Définition de la capacité d’un pod
   1. 4.1 Pourquoi définir une capacité ?
   2. 4.2 Réservation et surallocation
   3. 4.3 Allocation de ressources à un container
   4. 4.4 Allocation de ressources à l’application MailHog
   5. 4.5 Comportement en cas de saturation des ressources
      1. 4.5.1 Demande trop importante de CPU
      2. 4.5.2 Dépassement de la mémoire allouée
   6. 4.6 Priorité d’un pod
      1. 4.6.1 Présentation du mécanisme
      2. 4.6.2 Consultation des types par défaut
      3. 4.6.3 Consultation des priorités des pods
      4. 4.6.4 Création d’une classe de priorité
      5. 4.6.5 Affectation d’une classe de priorité personnalisée
      6. 4.6.6 Remarque sur les classes de priorité par défaut

Persistance des données

1. 1. Objectifs du chapitre et prérequis
2. 2. Persistance des données
   1. 2.1 Origine du besoin
   2. 2.2 Utilisation d’un volume persistant externe
   3. 2.3 Volumes persistants
      1. 2.3.1 Structure du volume persistant
      2. 2.3.2 Création du volume persistant
   4. 2.4 Persistance de données avec MailHog
      1. 2.4.1 Opérations à réaliser
      2. 2.4.2 Déclaration de l’objet PersistentVolumeClaim
      3. 2.4.3 État des objets de volume persistant
      4. 2.4.4 État de la demande de volume persistant
      5. 2.4.5 Déclaration du point de montage
      6. 2.4.6 Ajout d’un point de montage sur le container
      7. 2.4.7 Options de lancement de MailHog
      8. 2.4.8 Déclaration entière suite aux modifications
   5. 2.5 Test de la persistance
      1. 2.5.1 Installation de mhsendmail
      2. 2.5.2 Ouverture de la communication avec le port SMTP
      3. 2.5.3 Envoi d’un mail
      4. 2.5.4 Droits du répertoire de persistance des données
      5. 2.5.5 Consultation de l’interface MailHog
      6. 2.5.6 Suppression des pods
      7. 2.5.7 Vérification du fonctionnement de la persistance
3. 3. Classes de stockage
   1. 3.1 Origine du besoin
   2. 3.2 Liste des classes de stockage
   3. 3.3 Détail d’une classe de stockage
   4. 3.4 Classe de stockage par défaut
   5. 3.5 Les différentes classes de stockage
      1. 3.5.1 Les différentes familles
      2. 3.5.2 Origine de ces familles
   6. 3.6 Caractéristiques des classes de stockage
      1. 3.6.1 Modes d’accès
      2. 3.6.2 Caractéristiques de certains pilotes
      3. 3.6.3 Liste des pilotes chargés
   7. 3.7 Déclaration d’une classe de stockage
      1. 3.7.1 Structure de la déclaration
      2. 3.7.2 Exemple de déclaration
   8. 3.8 Test de création automatique d’un volume persistant

Hébergement d’application en cluster

1. 1. Objectifs du chapitre et prérequis
2. 2. Déploiement d’une base de données MariaDB
   1. 2.1 Origine du besoin
   2. 2.2 Déploiement
      1. 2.2.1 Choix de l’image Docker
      2. 2.2.2 Version initiale du fichier de déploiement
      3. 2.2.3 Gestion de la réentrance
   3. 2.3 Volume persistant
      1. 2.3.1 Demande de volume persistant
      2. 2.3.2 État de la demande de volume persistant
      3. 2.3.3 Ajout d’une persistance sur le container de MariaDB
      4. 2.3.4 Consultation de l'état du déploiement
   4. 2.4 Configuration de la base de données
   5. 2.5 Consultation de l’état du pod
      1. 2.5.1 Liste des pods
      2. 2.5.2 Connexion au container
      3. 2.5.3 Création de l’entrée de service
   6. 2.6 Surveillance de la base de données
      1. 2.6.1 Définition des commandes de surveillance
      2. 2.6.2 Application de la modification
      3. 2.6.3 Vérification du déploiement
   7. 2.7 Mécanisme de déploiement
3. 3. Mise en place d’un StatefulSet
   1. 3.1 Augmentation du nombre de pods associés au déploiement
   2. 3.2 Présentation du type StatefulSet
      1. 3.2.1 Caractéristiques
      2. 3.2.2 Limitations
   3. 3.3 Déclaration du premier objet StatefulSet
      1. 3.3.1 Purge de l’ancien déploiement
      2. 3.3.2 Modifications à réaliser
      3. 3.3.3 Création du StatefulSet
      4. 3.3.4 État des volumes persistants
      5. 3.3.5 Suppression des anciens objets PV/PVC
   4. 3.4 Scalabilité de l’objet StatefulSet
   5. 3.5 Pods et volumes persistants d’un objet StatefulSet
   6. 3.6 Réduction de la taille du StatefulSet
4. 4. Base et compte de test
   1. 4.1 Variables d’environnement du container
   2. 4.2 ConfigMap et secret
      1. 4.2.1 Pourquoi y faire appel ?
      2. 4.2.2 Structure d’un objet ConfigMap
      3. 4.2.3 Déclaration d’un objet Secret
      4. 4.2.4 Rattachement au container

Mise en place d’une réplication entre pods

1. 1. Objectifs du chapitre et prérequis
2. 2. Synchronisation des pods MariaDB
   1. 2.1 Exposition de la problématique
   2. 2.2 Principe de fonctionnement de la synchronisation
      1. 2.2.1 Opérations à réaliser
      2. 2.2.2 Nombre de réplicats
   3. 2.3 Identifiants des serveurs
      1. 2.3.1 Connexion aux pods
      2. 2.3.2 Connexion à la base de données
      3. 2.3.3 Identifiants des serveurs
      4. 2.3.4 ID du maître
      5. 2.3.5 Création du compte de réplication sur le maître
      6. 2.3.6 Configuration de l’esclave
   4. 2.4 Activation de la synchronisation
      1. 2.4.1 Activer les journaux pour la réplication
      2. 2.4.2 Commande docker-entrypoint.sh
      3. 2.4.3 Consultation de l’état du maître
      4. 2.4.4 Configuration de l’esclave
   5. 2.5 Test de la réplication
      1. 2.5.1 Connexion au maître
      2. 2.5.2 Création d’une table
      3. 2.5.3 Connexion à l’esclave
3. 3. Automatisation de la synchronisation
   1. 3.1 Scripts de démarrage et synchronisation
      1. 3.1.1 Script de démarrage
      2. 3.1.2 Configuration de la synchronisation
      3. 3.1.3 Scripts SQL additionnels
      4. 3.1.4 Script d’arrêt de la base
   2. 3.2 Scripts et objet ConfigMap
   3. 3.3 Création du ConfigMap
   4. 3.4 Montage du ConfigMap
      1. 3.4.1 Référencement du ConfigMap dans la liste des volumes
      2. 3.4.2 Point de montage du ConfigMap
   5. 3.5 Démarrage et arrêt du container
      1. 3.5.1 Commande de démarrage
      2. 3.5.2 Commande d’arrêt de la base
   6. 3.6 Résumé des modifications
   7. 3.7 État du déploiement
      1. 3.7.1 État des pods
      2. 3.7.2 Journaux d’activité du pod esclave
      3. 3.7.3 Test de la synchronisation
      4. 3.7.4 Vérification du fonctionnement de la synchronisation

Gestion des briques internes de Kubernetes

1. 1. Objectifs du chapitre et prérequis
2. 2. Espace de noms kube-system
   1. 2.1 Pods présents dans l’espace de noms kube-system
   2. 2.2 CoreDNS
   3. 2.3 etcd
   4. 2.4 Le gestionnaire de réseau Kindnet
   5. 2.5 Le gestionnaire d’extensions de Minikube
   6. 2.6 Le serveur d'API
   7. 2.7 Le proxy Kubernetes (kube-proxy)
   8. 2.8 Le gestionnaire de tâches (scheduler)
   9. 2.9 Le gestionnaire de contrôle (controller manager)
   10. 2.10 Kubelet
3. 3. Configuration des serveurs maîtres
   1. 3.1 Principe de lancement des pods système
   2. 3.2 Contenu du répertoire /etc/kubernetes/manifests
   3. 3.3 Contenu des fichiers
   4. 3.4 Désactivation d’un pod système
   5. 3.5 Réactivation du pod système
4. 4. Monitoring des containers du cluster avec Glances
   1. 4.1 Origine du besoin
   2. 4.2 Consultation des DaemonSets
   3. 4.3 Présentation de Glances
   4. 4.4 Définition du DaemonSet
      1. 4.4.1 Structure de la déclaration
      2. 4.4.2 Champ volumes
      3. 4.4.3 Champ containers
   5. 4.5 Création du DaemonSet
      1. 4.5.1 Déclaration complète
      2. 4.5.2 Création du DaemonSet
      3. 4.5.3 Consultation des pods
   6. 4.6 Annotations de tolérance
      1. 4.6.1 Présentation du mécanisme
      2. 4.6.2 Récupération des annotations taints
      3. 4.6.3 Tolérances de lancement
      4. 4.6.4 Modification du DaemonSet
   7. 4.7 Connexion à Glances

Helm - Gestionnaire de package

1. 1. Objectifs du chapitre et prérequis
2. 2. Présentation de Helm
   1. 2.1 Pourquoi faire appel à Helm ?
   2. 2.2 Principe de fonctionnement
3. 3. Déploiement de Helm
   1. 3.1 Installation du client Helm
      1. 3.1.1 Installation à l’aide d’Arkade
      2. 3.1.2 Installation manuelle
   2. 3.2 Consultation de la version de Helm
   3. 3.3 Configuration du client Helm
4. 4. Déploiement d’une application avec Helm
   1. 4.1 Déterminer le package à déployer
      1. 4.1.1 Recherche d’un chart Helm
      2. 4.1.2 Gestion des sources de charts Helm
      3. 4.1.3 Recherche et gestion du cache de Helm
   2. 4.2 Installation du package WordPress
      1. 4.2.1 Un peu de vocabulaire
      2. 4.2.2 Lancement de l’installation
      3. 4.2.3 Installation sans accès direct
   3. 4.3 Corrections de l’installation
      1. 4.3.1 Quelques remarques
      2. 4.3.2 Spécification du nom et espace de noms
      3. 4.3.3 Lancement de l’installation
      4. 4.3.4 Mise à jour et réentrance
      5. 4.3.5 Généralisation des options d’installation
   4. 4.4 Éléments déployés avec Helm
   5. 4.5 Suppression d’un déploiement
   6. 4.6 Annulation de la suppression
   7. 4.7 Purge d’un chart Helm
5. 5. Cycle de vie d’une application déployée avec Helm
   1. 5.1 Ouverture du port vers WordPress
   2. 5.2 Connexion à WordPress
   3. 5.3 Configuration d’un chart Helm
      1. 5.3.1 Consultation des options d’un chart
      2. 5.3.2 Configuration de la publication (Minikube)
   4. 5.4 Historique de déploiement
   5. 5.5 Visualisation des différences avant installation
      1. 5.5.1 Origine du besoin
      2. 5.5.2 Installation de l’extension diff pour Helm
      3. 5.5.3 Visualisation des modifications dans l’historique
      4. 5.5.4 Visualisation des modifications avant installation
   6. 5.6 Retour arrière
   7. 5.7 Portail Artifact Hub

Contextes et outils tiers Kubernetes

1. 1. Objectifs du chapitre et prérequis
2. 2. Gestion des contextes avec kubectl
   1. 2.1 Origine du besoin
   2. 2.2 Lister les contextes
   3. 2.3 Variable d’environnement KUBECONFIG
      1. 2.3.1 Spécifier l’emplacement du fichier
      2. 2.3.2 Spécifier plusieurs fichiers
   4. 2.4 Changement de contexte
   5. 2.5 Créer un contexte
   6. 2.6 Supprimer un contexte
   7. 2.7 Outils de gestion de contexte
      1. 2.7.1 Présentation de kubectx et kubens
      2. 2.7.2 Installation de kubectx et kubens
      3. 2.7.3 Mise en place de l’autocomplétion
      4. 2.7.4 Test des commandes
   8. 2.8 Contexte dans le prompt utilisateur
      1. 2.8.1 Pourquoi afficher le contexte ?
      2. 2.8.2 Activation à l’aide de oh-my-zsh
      3. 2.8.3 Activation avec bash
      4. 2.8.4 Exemple d’affichage
   9. 2.9 Changement des couleurs du terminal avec Konsole
      1. 2.9.1 Principe de fonctionnement
      2. 2.9.2 Création de la fonction
      3. 2.9.3 Ajout de l’appel dans l’invite de commandes
3. 3. Utilitaires Kubernetes
   1. 3.1 k9s : interface texte de suivi
      1. 3.1.1 Contexte
      2. 3.1.2 Installation de k9s
      3. 3.1.3 Lancement de k9s
   2. 3.2 Kubespy : espionnage de l’activité
      1. 3.2.1 Présentation de Kubespy
      2. 3.2.2 Installation de Kubespy
      3. 3.2.3 Observation d’un déploiement avec Kubespy
   3. 3.3 Krew : gestionnaire d’extensions
      1. 3.3.1 Présentation du mécanisme d’extensions
      2. 3.3.2 Installation de Krew
      3. 3.3.3 Test de l’extension
   4. 3.4 Sniff : capture du trafic réseau d’un pod
      1. 3.4.1 Principe de fonctionnement
      2. 3.4.2 Installation de Sniff et Wireshark
      3. 3.4.3 Lancement d’une séance de capture
   5. 3.5 Kube Hunter : outil d’analyse du cluster
      1. 3.5.1 Présentation de Kube Hunter
      2. 3.5.2 Lancement de l’analyse
      3. 3.5.3 Résultat de l’analyse
      4. 3.5.4 Publication de rapports HTML
      5. 3.5.5 Lancement à intervalles réguliers

Services managés Kubernetes

1. 1. Objectifs du chapitre et prérequis
2. 2. Service managé de Google : GKE
   1. 2.1 Présentation du service Google
   2. 2.2 Administration depuis la console Google
   3. 2.3 Installation de la commande gcloud en local
      1. 2.3.1 Installation sur Debian/Ubuntu
      2. 2.3.2 Mise en place de l’autocomplétion
   4. 2.4 Configuration de l'environnement
      1. 2.4.1 Authentification auprès de Google Cloud
      2. 2.4.2 Projet associé avec le contexte courant
      3. 2.4.3 Activation de l’API
   5. 2.5 Gestion du cluster GKE
      1. 2.5.1 Consultation de la liste des clusters
      2. 2.5.2 Versions et régions disponibles
   6. 2.6 Création d’un cluster
      1. 2.6.1 Options de création
      2. 2.6.2 Lancement de la création du cluster
      3. 2.6.3 Récupération du fichier d’accès au cluster
   7. 2.7 Consultation du cluster
      1. 2.7.1 Liste des nœuds
      2. 2.7.2 Services démarrés
   8. 2.8 Délégation des droits d’accès
      1. 2.8.1 Configuration des accès
      2. 2.8.2 Principe du mécanisme sous-jacent
   9. 2.9 Suppression d’un cluster GKE
3. 3. Service managé Microsoft Azure : AKS
   1. 3.1 Présentation du service Azure
   2. 3.2 Administration depuis la console Azure
      1. 3.2.1 Présentation de la console
      2. 3.2.2 Consultation du tableau de bord Kubernetes
   3. 3.3 Installation de la commande az en local
      1. 3.3.1 Installation sur Debian/Ubuntu
      2. 3.3.2 Mise en place de l'autocomplétion
   4. 3.4 Authentification auprès du service Azure
   5. 3.5 Emplacement de déploiement
      1. 3.5.1 Liste des emplacements
      2. 3.5.2 Versions disponibles de Kubernetes
   6. 3.6 Création d’un cluster
      1. 3.6.1 Création d’un groupe de ressources
      2. 3.6.2 Lancement de la création du cluster
      3. 3.6.3 Récupération du fichier de connexion
      4. 3.6.4 Zone DNS par défaut
   7. 3.7 Consultation de la liste des clusters
   8. 3.8 Délégation des droits d’accès
   9. 3.9 Suppression d’un cluster AKS
4. 4. Service managé d’Amazon : EKS
   1. 4.1 Présentation du service Amazon AWS
   2. 4.2 Introduction de la commande eksctl
   3. 4.3 Configuration des accès Amazon
   4. 4.4 Installation des binaires
      1. 4.4.1 Installation d’eksctl
      2. 4.4.2 Installation de l’outil aws cli
      3. 4.4.3 Vérification de la communication avec AWS
   5. 4.5 Création du cluster EKS
      1. 4.5.1 Aide en ligne d’eksctl
      2. 4.5.2 Options intéressantes à la création d’un cluster
      3. 4.5.3 Lancement de la création du cluster
   6. 4.6 Configuration des accès kubectl
   7. 4.7 Mécanisme de communication
   8. 4.8 Délégation des droits d’accès
      1. 4.8.1 Configuration des accès
      2. 4.8.2 Principe du mécanisme sous-jacent
   9. 4.9 Suppression du cluster
5. 5. Service Kubernetes OVHcloud
   1. 5.1 Présentation d’OVHcloud
   2. 5.2 Méthode de création du cluster et prérequis
   3. 5.3 Réseau des nœuds du cluster
   4. 5.4 Création du cluster Kubernetes
   5. 5.5 Suppression du cluster Kubernetes
6. 6. Accès en lecture-écriture multiple
   1. 6.1 Origine du besoin
   2. 6.2 Serveur NFS déployé dans Kubernetes
      1. 6.2.1 Limitations
      2. 6.2.2 Déploiement d’un serveur NFS
      3. 6.2.3 Vérification du déploiement
      4. 6.2.4 Test de création de volume persistant (PVC)
   3. 6.3 Service managé Amazon : EFS
      1. 6.3.1 Consultation des instances EFS
      2. 6.3.2 Création d’une instance EFS
   4. 6.4 Service managé Google : Filestore
      1. 6.4.1 Consultation des instances Filestore
      2. 6.4.2 Création d’une instance Filestore
   5. 6.5 Classe de stockage NFS
      1. 6.5.1 Installation du chart
      2. 6.5.2 Vérification de l'installation du chart
      3. 6.5.3 Test de création d’une demande de volume persistant (PVC)
   6. 6.6 Classe de stockage Azure

Installation de Kubernetes en interne

1. 1. Objectifs du chapitre et prérequis
2. 2. Installation à l’aide de Kubespray
   1. 2.1 Origine du besoin
   2. 2.2 Pourquoi Kubespray ?
   3. 2.3 Principe de Kubespray
   4. 2.4 Prérequis des machines à administrer avec Ansible
      1. 2.4.1 Échange de clés SSH
      2. 2.4.2 Escalade de droits sudo
   5. 2.5 Structure du cluster
      1. 2.5.1 Architecture du cluster Kubespray
      2. 2.5.2 Groupes de machines
   6. 2.6 Préparation des éléments d’installation
      1. 2.6.1 Clonage du dépôt Git
      2. 2.6.2 Installation des prérequis
   7. 2.7 Préparation de l’inventaire Ansible
      1. 2.7.1 Qu’est-ce qu’un inventaire ?
      2. 2.7.2 Fichier d’inventaire d’exemple
      3. 2.7.3 Test de la communication Ansible/SSH
   8. 2.8 Installation du cluster
      1. 2.8.1 Configuration du cluster
      2. 2.8.2 Lancement de l’installation
      3. 2.8.3 Mise à jour du cluster
   9. 2.9 Accès au cluster
      1. 2.9.1 Configuration de l’accès au cluster
      2. 2.9.2 Utilisation d’un répartiteur de charge
      3. 2.9.3 Vérification de la communication avec le cluster
3. 3. Environnement embarqué avec k3s
   1. 3.1 Présentation et but du projet
   2. 3.2 Installation de k3s
   3. 3.3 Communication avec le cluster
   4. 3.4 Ajout de nœuds au cluster

Exposition des applications sur Internet

1. 1. Objectifs du chapitre et prérequis
2. 2. Gestion des entrées DNS
   1. 2.1 Principe de fonctionnement
   2. 2.2 Prérequis
   3. 2.3 Retour sur le fonctionnement du domaine DNS nip.io
   4. 2.4 Activation du service DNS
      1. 2.4.1 Console Cloud DNS Google
      2. 2.4.2 Service DNS Zones d’Azure
      3. 2.4.3 Service Route 53 d’AWS
   5. 2.5 Configuration DNS
      1. 2.5.1 Opération à réaliser
      2. 2.5.2 Console DNS OVH
      3. 2.5.3 Vérification de la délégation
   6. 2.6 Gestionnaire de DNS
      1. 2.6.1 Présentation de la brique external-dns
      2. 2.6.2 Création du compte d’administration DNS de Google Cloud
      3. 2.6.3 Création du compte d’administration DNS service Azure
      4. 2.6.4 Création du compte d’administration DNS Amazon (Route 53)
      5. 2.6.5 Création d’un secret (Google et Azure)
      6. 2.6.6 Déploiement d’external-dns
      7. 2.6.7 Vérification du fonctionnement d’external-dns
3. 3. Exposition de services et répartition de charge
   1. 3.1 Présentation du mécanisme
   2. 3.2 Retour sur la notion de service
      1. 3.2.1 Rôle d’un service
      2. 3.2.2 Structure d’un service
      3. 3.2.3 Type ClusterIP
      4. 3.2.4 Type NodePort et LoadBalancer
      5. 3.2.5 Type ExternalName
   3. 3.3 Service associé au proxy inverse
4. 4. Le contrôleur Ingress
   1. 4.1 Principe de fonctionnement
   2. 4.2 Le rôle du contrôleur Ingress
   3. 4.3 Structure d’une règle Ingress
   4. 4.4 Droits nécessaires pour un contrôleur
5. 5. Le contrôleur Ingress Google
   1. 5.1 Prérequis
   2. 5.2 Présentation du contrôleur GLBC
   3. 5.3 Déploiement de MailHog
      1. 5.3.1 Préparation de la règle Ingress
      2. 5.3.2 Déploiement de l’application MailHog
      3. 5.3.3 Consultation de l’état de l’objet Ingress
      4. 5.3.4 Consultation du journal d'activité d’external-dns
      5. 5.3.5 Consultation de MailHog
6. 6. Le contrôleur Ingress Nginx
   1. 6.1 Pourquoi changer de contrôleur Ingress ?
   2. 6.2 Présentation du logiciel Nginx
   3. 6.3 Installation d’Ingress Nginx sur GKE (Google)
      1. 6.3.1 Détermination du chart Helm à installer
      2. 6.3.2 Espace de noms et configuration du chart
   4. 6.4 Utilisation du contrôleur
      1. 6.4.1 Utilisation du champ spec.ingressClassName
      2. 6.4.2 Vérification du déploiement
   5. 6.5 Annotations Ingress Nginx
   6. 6.6 Ajustement de la configuration du contrôleur Nginx
      1. 6.6.1 Récupération de l’origine du trafic
      2. 6.6.2 Haute disponibilité et règles d’affinité/anti-affinité
      3. 6.6.3 Gestion des contrôleurs Ingress
      4. 6.6.4 Réservation et limitation des ressources disponibles
7. 7. Le contrôleur Ingress Traefik
   1. 7.1 Présentation de Traefik
   2. 7.2 Installation du chart Helm
   3. 7.3 Utilisation du nouveau contrôleur Ingress
      1. 7.3.1 Sélectionner le contrôleur Ingress Traefik
      2. 7.3.2 Création de la règle Ingress faisant appel à Traefik
      3. 7.3.3 État des règles Ingress
   4. 7.4 Tableau de bord de Traefik
   5. 7.5 Annotations Ingress Traefik
   6. 7.6 Distribution de la charge et haute disponibilité
   7. 7.7 Réservation et limitation des ressources disponibles
   8. 7.8 Pour aller plus loin

Sécurisation : accès aux applications

1. 1. Objectifs du chapitre et prérequis
2. 2. Mise en place de Let’s Encrypt
   1. 2.1 Présentation de Let’s Encrypt
   2. 2.2 Installation du chart Helm cert-manager
      1. 2.2.1 Présentation du chart Helm
      2. 2.2.2 Prérequis avant installation
   3. 2.3 L’émetteur de certificats (issuer)
      1. 2.3.1 Principe du protocole ACME
      2. 2.3.2 Structure de la déclaration d’un émetteur
      3. 2.3.3 Exemple de déclaration Issuer Google
      4. 2.3.4 Exemple de déclaration Issuer Azure
      5. 2.3.5 Exemple de déclaration Issuer Amazon
      6. 2.3.6 Limitations et certificats avec joker
   4. 2.4 Exemples de déclarations
      1. 2.4.1 Serveur Let’s Encrypt de test
      2. 2.4.2 Serveur Let’s Encrypt de production
   5. 2.5 Déclaration des certificats
      1. 2.5.1 État des émetteurs de certificats
      2. 2.5.2 Structure d’un certificat
      3. 2.5.3 Certificat de test
      4. 2.5.4 État du certificat
      5. 2.5.5 Journal d’activité de cert-manager
      6. 2.5.6 Consultation du secret
      7. 2.5.7 Certificat de production
      8. 2.5.8 Marche à suivre en cas de problèmes
   6. 2.6 Rattachement du certificat à la règle Ingress
   7. 2.7 Automatisation de la gestion des certificats
      1. 2.7.1 Certificat par défaut du contrôleur Ingress Nginx
      2. 2.7.2 Mécanisme d’annotations
      3. 2.7.3 Émetteur de certificats par défaut
3. 3. Protection de l’accès aux applications
   1. 3.1 Origine du besoin
   2. 3.2 Mot de passe simple (HTTP basic)
      1. 3.2.1 Principe de fonctionnement
      2. 3.2.2 Création du secret à l’aide de htpasswd
      3. 3.2.3 Import du secret
      4. 3.2.4 Configuration de l’authentification
4. 4. Authentification basée sur OAuth2
   1. 4.1 À propos du protocole OAuth2
   2. 4.2 Principe de la solution
   3. 4.3 Création d’un identifiant GitHub
   4. 4.4 Déploiement du proxy
      1. 4.4.1 À propos du proxy
      2. 4.4.2 Configuration du chart Helm
      3. 4.4.3 Déploiement du chart Helm
      4. 4.4.4 État du déploiement
   5. 4.5 Déclaration des règles Ingress
      1. 4.5.1 Description des règles Ingress
      2. 4.5.2 Annotations Ingress de MailHog
      3. 4.5.3 Description Ingress du proxy OAuth
      4. 4.5.4 Déclaration des règles Ingress
   6. 4.6 Tests de connexion
   7. 4.7 Restriction des accès
      1. 4.7.1 Mécanisme d’autorisation
      2. 4.7.2 Restriction par domaine e-mail
      3. 4.7.3 Restriction par organisation GitHub

Polices réseau

1. 1. Objectifs du chapitre et prérequis
2. 2. Les polices réseau (network policies)
   1. 2.1 Présentation du mécanisme
   2. 2.2 Kubernetes Network Plugins
   3. 2.3 Polices réseau sur services managés et installation maison
   4. 2.4 Installation de Calico sur Minikube
      1. 2.4.1 Activation de CNI sur Minikube
      2. 2.4.2 Installation de Calico
   5. 2.5 Connexions entrantes
      1. 2.5.1 Test de la connexion en interne
      2. 2.5.2 Bloquer les accès internes
      3. 2.5.3 Test de la règle
   6. 2.6 Connexions sortantes
      1. 2.6.1 Test des connexions externes
      2. 2.6.2 Restriction sur les règles sortantes
      3. 2.6.3 Test de la règle
3. 3. Protection de l’application WordPress
   1. 3.1 Contexte
   2. 3.2 Déploiement de WordPress
   3. 3.3 Restriction des accès
      1. 3.3.1 Référencement de l’ensemble des flux
      2. 3.3.2 Restriction de tous les accès
      3. 3.3.3 Autorisation de l'accès du contrôleur Ingress sur WordPress
      4. 3.3.4 Autorisation de l'accès entre WordPress et MariaDB
      5. 3.3.5 Test des règles réseau
   4. 3.4 Ressources externes

Montée en charge automatique

1. 1. Objectifs du chapitre et prérequis
2. 2. Le serveur de métriques
   1. 2.1 Présentation de la brique metrics-server
   2. 2.2 Activation du serveur de métriques
      1. 2.2.1 Vérification de la présence du serveur de métriques
      2. 2.2.2 Activation sous Minikube
      3. 2.2.3 Activation sur Amazon EKS
   3. 2.3 Consultation de la consommation des pods et des nœuds
      1. 2.3.1 État des nœuds d’un cluster
      2. 2.3.2 État des pods
3. 3. Activation de la montée en charge automatique
   1. 3.1 Test avec l’application MailHog
   2. 3.2 Lancement d’un bench
      1. 3.2.1 Présentation d’Apache Bench
      2. 3.2.2 Installation d'Apache Bench
      3. 3.2.3 Lancement du test initial
   3. 3.3 Gestion de la montée en charge
   4. 3.4 Lancement du test
      1. 3.4.1 Test à froid : montée en charge des pods
      2. 3.4.2 Test à chaud
      3. 3.4.3 Diminution du nombre de pods
4. 4. Scalabilité des nœuds d’un cluster
   1. 4.1 Contexte
   2. 4.2 Présentation de l’autoscaler
   3. 4.3 Activation de l’autoscaler avec Google Cloud
   4. 4.4 Activation de l'autoscaler avec Azure AKS
   5. 4.5 Activation de l'autoscaler avec Amazon EKS
      1. 4.5.1 Présentation du mécanisme de l’ASG
      2. 4.5.2 Affichage des tags d’un groupe ASG
      3. 4.5.3 Activation de l’autoscaler
      4. 4.5.4 Vérification de l'activation du mécanisme de l’autoscaler
   6. 4.6 Test de montée en charge
      1. 4.6.1 Déploiement de WordPress
      2. 4.6.2 Pods en attente de ressources
      3. 4.6.3 État des nœuds
      4. 4.6.4 Démarrage du pod
      5. 4.6.5 Nettoyage des déploiements
5. 5. Définition de groupes de machines
   1. 5.1 Contexte
   2. 5.2 Les différents types de machines
      1. 5.2.1 Les machines préemptives (Spot)
      2. 5.2.2 Réservation d’instances
      3. 5.2.3 Familles de machines
      4. 5.2.4 Quelques exemples de familles de machines
      5. 5.2.5 Utilisation d’accélérateurs graphiques (GPU)
      6. 5.2.6 Quelques exemples de coûts
   3. 5.3 Création de groupes de machines
      1. 5.3.1 Contexte
      2. 5.3.2 Création d’un groupe avec Google
      3. 5.3.3 Création d’un groupe avec Azure
      4. 5.3.4 Création d’un groupe avec AWS EKS
      5. 5.3.5 Création d’un groupe avec OVH
   4. 5.4 Mécanisme de tolérance et sélection de nœuds

Surveillance à l’aide de Prometheus

1. 1. Objectifs du chapitre et prérequis
2. 2. Mise en place de Prometheus
   1. 2.1 À propos de Prometheus
   2. 2.2 Fonctionnement de Prometheus
      1. 2.2.1 Architecture de Prometheus
      2. 2.2.2 Le moteur Prometheus
      3. 2.2.3 Les exporteurs Prometheus
   3. 2.3 Installation de Prometheus
      1. 2.3.1 Choix du chart Prometheus
      2. 2.3.2 Qu’est-ce qu’un opérateur ?
      3. 2.3.3 Déploiement de l’opérateur Prometheus
      4. 2.3.4 Pods démarrés
      5. 2.3.5 Objets déploiements
      6. 2.3.6 Nouvelles ressources Prometheus
      7. 2.3.7 DaemonSet : node exporter
   4. 2.4 Priorisation des briques de surveillance
      1. 2.4.1 Problème de la surveillance
      2. 2.4.2 Déclaration des classes de priorité
      3. 2.4.3 Modification du déploiement de Prometheus
3. 3. Utilisation de Prometheus
   1. 3.1 Fonctionnement des métriques
      1. 3.1.1 Consultation des métriques de Prometheus
      2. 3.1.2 Présentation de l’interface de Prometheus
      3. 3.1.3 Métriques de Kubernetes
      4. 3.1.4 Déclaration des points de collecte dans Kubernetes
      5. 3.1.5 Consultation des points de collecte dans Prometheus
   2. 3.2 Définition des alertes
      1. 3.2.1 Consultation de la liste des alertes
      2. 3.2.2 Structure d’une règle d’alerte
      3. 3.2.3 Définition d’alertes
   3. 3.3 Gestionnaire d’alertes
      1. 3.3.1 Rôle du gestionnaire d’alertes
      2. 3.3.2 Consultation du gestionnaire d’alertes
      3. 3.3.3 Configuration des alertes
      4. 3.3.4 Désactivation des alertes scheduler et manager (clusters managés)
      5. 3.3.5 Configuration de l'envoi des notifications
      6. 3.3.6 Adresse de l’API de Slack
4. 4. Tableaux de bord Grafana
   1. 4.1 Présentation de Grafana
   2. 4.2 Configuration de Grafana
      1. 4.2.1 Branchement au moteur Prometheus
      2. 4.2.2 Définition des tableaux de bord
   3. 4.3 Interface Grafana
   4. 4.4 Sécurisation de l'accès à Grafana
5. 5. Suppression du chart de Prometheus

Centralisation des journaux d’activité

1. 1. Objectifs du chapitre et prérequis
2. 2. Principe de la centralisation des journaux
   1. 2.1 Architecture
   2. 2.2 Caractéristiques de l’agent déployé
   3. 2.3 Mécanisme de centralisation des journaux
3. 3. Centralisation dans le cloud
   1. 3.1 Centralisation à l’aide d’un service managé
   2. 3.2 Google Stackdriver
      1. 3.2.1 Présentation de Stackdriver
      2. 3.2.2 Pod Fluentbit (cluster GKE)
      3. 3.2.3 Consultation des journaux
   3. 3.3 Azure Monitor
      1. 3.3.1 Présentation d'Azure Monitor
      2. 3.3.2 Consultation des journaux
   4. 3.4 Amazon Cloudwatch
      1. 3.4.1 Présentation de Cloudwatch
      2. 3.4.2 Activation de Cloudwatch sur le centre de contrôle
      3. 3.4.3 Configuration de Cloudwatch
      4. 3.4.4 Création de la police de communication avec Cloudwatch
      5. 3.4.5 Création d’un compte et rattachement à la police
      6. 3.4.6 Création d’une clé d’accès
      7. 3.4.7 Envoi des journaux dans Cloudwatch
      8. 3.4.8 État des pods déployés
      9. 3.4.9 Consultation des journaux dans Cloudwatch
4. 4. Centralisation des journaux avec Loki
   1. 4.1 Présentation de Loki
      1. 4.1.1 Origine de Loki
      2. 4.1.2 Loki vs Elasticsearch
      3. 4.1.3 Conseil d’utilisation
   2. 4.2 Installation de Loki
   3. 4.3 Configuration de la source de données Grafana
   4. 4.4 Consultation des journaux dans Grafana
      1. 4.4.1 Vérification des sources de données
      2. 4.4.2 Consultation des journaux
5. 5. Centralisation des journaux avec Elasticsearch
   1. 5.1 Avertissements et limitations
   2. 5.2 À propos d’Elasticsearch
   3. 5.3 Déploiement des briques Elasticsearch
      1. 5.3.1 Installation d’Elasticsearch
      2. 5.3.2 Installation de l’agent Filebeat
      3. 5.3.3 Installation de Kibana
      4. 5.3.4 Installation de Cerebro
   4. 5.4 État des différentes briques
      1. 5.4.1 État du moteur Elasticsearch
      2. 5.4.2 Agent Filebeat
6. 6. Gestion d’Elasticsearch
   1. 6.1 Accès à l’interface Cerebro
   2. 6.2 Utilisation de Kibana
      1. 6.2.1 Accéder à l’interface de Kibana
      2. 6.2.2 Création de l’index
   3. 6.3 Branchement sur Grafana
      1. 6.3.1 Source de données Elasticsearch
      2. 6.3.2 Création d’un objet ConfigMap

Maillage de services avec Istio

1. 1. Objectifs du chapitre et prérequis
2. 2. Présentation d'Istio
   1. 2.1 Micro-services et mise en réseau de services
   2. 2.2 Présentation d’Istio
   3. 2.3 Principe de fonctionnement
3. 3. Installation d’Istio
   1. 3.1 Configuration d'external-dns
   2. 3.2 Dépôt des charts Istio
   3. 3.3 Installation d’istio
   4. 3.4 Configuration d’Istio
      1. 3.4.1 Activation des tableaux de bord
      2. 3.4.2 Configuration d'Istio
   5. 3.5 Configuration du composant Gateway Istio
      1. 3.5.1 Présentation du mécanisme
      2. 3.5.2 Installation du composant Gateway
      3. 3.5.3 Génération du certificat
4. 4. Utilisation d’Istio
   1. 4.1 Injection de pods dans le maillage de services
      1. 4.1.1 Installation d’istioctl
      2. 4.1.2 Injection du sidecar à l’aide d’istioctl
      3. 4.1.3 Injection du sidecar par annotation
      4. 4.1.4 Désactivation du sidecar par annotation
   2. 4.2 Déploiement d’une application de test
      1. 4.2.1 Principe de l’exposition d’application avec Istio
      2. 4.2.2 Préparation du fichier de déploiement MailHog
      3. 4.2.3 Déclaration du service MailHog
      4. 4.2.4 Création de l’objet Gateway
      5. 4.2.5 Création du service virtuel (VirtualService)
   3. 4.3 Sécurisation des flux
      1. 4.3.1 Activation de Mutual TLS (mTLS)
      2. 4.3.2 Consultation des polices du service MailHog
      3. 4.3.3 Forcer l’utilisation de mTLS
5. 5. Tableaux de bord
   1. 5.1 Présentation des différentes briques
   2. 5.2 Interface Kiali
   3. 5.3 Interface Grafana
   4. 5.4 Interface Jaeger

Compilation et stockage d’images Docker

1. 1. Objectifs du chapitre et prérequis
2. 2. Création d’une image Docker
   1. 2.1 Application d’exemple Flask HealthCheck
      1. 2.1.1 Présentation de l’application
      2. 2.1.2 Présentation des dépendances
      3. 2.1.3 Description des dépendances
      4. 2.1.4 Installation des dépendances
      5. 2.1.5 Initialisation de l’application
      6. 2.1.6 Fonction racine
      7. 2.1.7 Lancement du programme
   2. 2.2 Environnement de compilation
   3. 2.3 Le fichier Dockerfile
      1. 2.3.1 Présentation du format
      2. 2.3.2 Création de l’image
      3. 2.3.3 Compilation et tag de l’image
      4. 2.3.4 Authentification sur le registre d’images Docker
      5. 2.3.5 Pousser l’image sur le registre
3. 3. Image Docker multi-étape (multi-stage)
   1. 3.1 Origine du besoin
   2. 3.2 Exemple de compilation avec Maven
4. 4. Analyse d’images
   1. 4.1 Historique des commandes
   2. 4.2 Analyse de l’image : Dive
      1. 4.2.1 Présentation de Dive
      2. 4.2.2 Installation de Dive
      3. 4.2.3 Consultation du contenu d’une image
5. 5. Utilisation de registres Docker privés
   1. 5.1 Origine du besoin
   2. 5.2 Déploiement d’image d’un registre privé
      1. 5.2.1 Exposition de la problématique
      2. 5.2.2 Création du secret
      3. 5.2.3 Utilisation du secret
      4. 5.2.4 Utilisation d’un compte de service
      5. 5.2.5 Recopie d’un secret entre espaces de noms
   3. 5.3 Erreurs de récupération des images
      1. 5.3.1 Détection des erreurs
      2. 5.3.2 Erreur sur le nom de l’image
      3. 5.3.3 Secret absent ou non spécifié
      4. 5.3.4 Identifiants invalides
   4. 5.4 Services de registres managés
      1. 5.4.1 Solutions managées
      2. 5.4.2 Service Google Container Registry
      3. 5.4.3 GitLab.com

Usine logicielle

1. 1. Objectifs du chapitre et prérequis
2. 2. Compilation à l’aide de GitLab
   1. 2.1 Application à compiler
   2. 2.2 Mécanisme de pipeline GitLab
   3. 2.3 Adresse et contenu du dépôt
   4. 2.4 Structure du fichier .gitlab-ci.yml
   5. 2.5 Exemple de fichier .gitlab-ci.yml de compilation d’image
   6. 2.6 Construction d’image à l’aide de Kaniko
   7. 2.7 Pour la suite
3. 3. Déploiement continu avec Jenkins
   1. 3.1 À propos de Jenkins
   2. 3.2 Installation de Jenkins
      1. 3.2.1 Configuration du chart
      2. 3.2.2 Vérification de l’installation
      3. 3.2.3 Connexion à l’interface de Jenkins
      4. 3.2.4 Installation d’extensions
4. 4. Pipeline de déploiement continu avec Jenkins
   1. 4.1 Prérequis
   2. 4.2 Présentation du mécanisme de déploiement continu
   3. 4.3 Stockage des identifiants Docker
   4. 4.4 Création de l’environnement develop
   5. 4.5 Création du pipeline
      1. 4.5.1 Création du pod de compilation
      2. 4.5.2 Squelette du pipeline de déploiement
      3. 4.5.3 Récupération du code source
      4. 4.5.4 Vérifications et tests
      5. 4.5.5 Compilation de l’image Docker
      6. 4.5.6 Connexion au registre et publication
      7. 4.5.7 Mise à jour du déploiement de test
      8. 4.5.8 Programme complet
   6. 4.6 Lancement de la compilation
      1. 4.6.1 Création du job
      2. 4.6.2 Lancement du build
   7. 4.7 Compte de service
      1. 4.7.1 Opérations à réaliser
      2. 4.7.2 Création d’un compte de service
      3. 4.7.3 Création du rôle de mise à jour
      4. 4.7.4 Affectation du rôle au compte de service
      5. 4.7.5 Affectation du compte de service
      6. 4.7.6 Relance de la compilation
   8. 4.8 Utilisation de Kaniko avec Jenkins
   9. 4.9 Mécanisme de Webhook
      1. 4.9.1 Présentation du mécanisme
      2. 4.9.2 Déclenchement du Webhook
      3. 4.9.3 Création du Webhook
5. 5. Un mot sur Jenkins X

Packager son application avec Helm

1. 1. Objectifs du chapitre et prérequis
2. 2. Helm
   1. 2.1 Origine du besoin
   2. 2.2 Création d’un chart
   3. 2.3 Contenu d’un package
      1. 2.3.1 Structure d’un package
      2. 2.3.2 Variables .Values, .Chart et .Release
   4. 2.4 Adaptation à l’application MailHog
      1. 2.4.1 Résumé des travaux à réaliser
      2. 2.4.2 Utilisation de l’image de MailHog
      3. 2.4.3 Correction sur les ports de service
      4. 2.4.4 Ajout d’un ConfigMap
      5. 2.4.5 Ajout du volume persistant
      6. 2.4.6 Montage du volume dans le container
      7. 2.4.7 Test de déploiement
   5. 2.5 Dépendances
      1. 2.5.1 Déclaration des dépendances
      2. 2.5.2 Récupération des dépendances
      3. 2.5.3 Déploiement du chart avec les dépendances
3. 3. Template Go
   1. 3.1 Principe de fonctionnement
   2. 3.2 Substitution du contenu d’une variable
   3. 3.3 Blocs conditionnels
   4. 3.4 Gestion des conditions
      1. 3.4.1 Les valeurs de vrai ou faux
      2. 3.4.2 Opérateurs de comparaison
      3. 3.4.3 Conditions multiples et négation
   5. 3.5 Itération
      1. 3.5.1 Affichage du contenu d’un tableau
      2. 3.5.2 Suppression des sauts de lignes surnuméraires
      3. 3.5.3 Itération sur un groupe fixe d’éléments
      4. 3.5.4 Itération sur un tableau de hachage
      5. 3.5.5 Accéder à une variable globale depuis une boucle
   6. 3.6 Filtres
   7. 3.7 Valeurs par défaut
   8. 3.8 Fonction template
      1. 3.8.1 Exemple de définition de fonction
      2. 3.8.2 Passage de paramètres et contexte global
   9. 3.9 Redéploiement sur changement de configuration
      1. 3.9.1 Exposition de la problématique
      2. 3.9.2 Principe de la solution
      3. 3.9.3 Exemple d’implémentation
   10. 3.10 Génération de secret aléatoire « stable »
       1. 3.10.1 Exposition de la problématique
       2. 3.10.2 Principe de la solution et mise en œuvre

Restriction et délégation d’accès

1. 1. Objectifs du chapitre et prérequis
2. 2. Mise en place de quotas
   1. 2.1 Origine du besoin
   2. 2.2 Quotas par défaut sur un espace de noms
      1. 2.2.1 Création d’un espace de noms
      2. 2.2.2 Structure d’un objet LimitRange
      3. 2.2.3 Exemple de définition de limitations
      4. 2.2.4 Vérification de l’application des limitations
      5. 2.2.5 Test du mécanisme
      6. 2.2.6 Analyse du problème
   3. 2.3 Quotas globaux sur un espace de noms
      1. 2.3.1 Présentation des quotas de ressources (ResourceQuota)
      2. 2.3.2 Structure d’un quota de ressources
      3. 2.3.3 Exemples de restriction de consommation CPU et mémoire
      4. 2.3.4 Champs pour positionner des limitations (champ hard)
      5. 2.3.5 Test du mécanisme
      6. 2.3.6 Nettoyage en fin d’exercice
3. 3. Authentification et autorisation
   1. 3.1 Origine du besoin
   2. 3.2 Prérequis
   3. 3.3 Activation des accès anonymes
      1. 3.3.1 Activation des accès anonymes sur Minikube
      2. 3.3.2 Création du fichier d’accès
      3. 3.3.3 Affectation des droits en lecture
      4. 3.3.4 Suppression des droits d’accès anonymes
   4. 3.4 Principe de l’authentification par certificat
   5. 3.5 Problème de la révocation des certificats
   6. 3.6 Génération du certificat
      1. 3.6.1 Création de la clé et du certificat client
      2. 3.6.2 Emplacement de la PKI
      3. 3.6.3 Signature du certificat
   7. 3.7 Authentification par certificat
      1. 3.7.1 Récupération des informations de connexion au cluster
      2. 3.7.2 Utilisation du certificat pour l’authentification
      3. 3.7.3 Test de la connexion
   8. 3.8 Quelques exemples d’erreurs de manipulation
      1. 3.8.1 Problème d’autorité de certification
      2. 3.8.2 Problème de couple clé/certificat
      3. 3.8.3 Pas d’identifiant renseigné
      4. 3.8.4 Utilisation de la demande de certificat à la place du certificat
   9. 3.9 Attributions de droits administrateur sur le cluster
      1. 3.9.1 Contexte et opérations à réaliser
      2. 3.9.2 Affectation des droits administrateur à un utilisateur
      3. 3.9.3 Test du nouvel administrateur
      4. 3.9.4 Création de nouveaux utilisateurs
      5. 3.9.5 Affectation des droits administrateur à un groupe
      6. 3.9.6 Administrateur d’un espace de noms
4. 4. Mécanismes d’authentification externes
   1. 4.1 Présentation du mécanisme
   2. 4.2 Communication entre le fournisseur OAuth2 et le cluster
   3. 4.3 Création des identifiants
   4. 4.4 Modification des options de démarrage (Minikube)
   5. 4.5 Configuration des accès clients
      1. 4.5.1 Présentation de l’outil k8s-oidc-helper
      2. 4.5.2 Installation du compilateur Go
      3. 4.5.3 Installation de k8s-oidc-helper
      4. 4.5.4 Génération des identifiants d’accès
      5. 4.5.5 Renseignement du cluster et contexte
      6. 4.5.6 Test de connexion
   6. 4.6 Attribution des droits d’accès
5. 5. Mise en place de comptes de service
   1. 5.1 Contexte
   2. 5.2 Création du compte de service
   3. 5.3 Attribution des droits d’administrateur au compte de service
   4. 5.4 Création du fichier Kubeconfig
      1. 5.4.1 Recopie des informations de connexion
      2. 5.4.2 Jeton de connexion du compte de service
      3. 5.4.3 Affectation de l’utilisateur
      4. 5.4.4 Test de la connexion
      5. 5.4.5 Révocation des accès

Les opérateurs Kubernetes

1. 1. Objectifs du chapitre et prérequis
2. 2. Utilisation des opérateurs
   1. 2.1 Présentation du principe
   2. 2.2 L’opérateur de Prometheus
      1. 2.2.1 Retour sur le chart prometheus-operator
      2. 2.2.2 Structure d’un objet Prometheus
   3. 2.3 Ressources externes sur les opérateurs existants
   4. 2.4 Présentation de l’opérateur MySQL
      1. 2.4.1 Justification du choix de MySQL
      2. 2.4.2 Choix de l’opérateur
   5. 2.5 Déploiement de l’opérateur
   6. 2.6 Création d’une instance MysqlCluster
      1. 2.6.1 Création d’un secret pour l’instance MysqlCluster
      2. 2.6.2 Création du cluster
      3. 2.6.3 Problèmes de droits sur le volume persistant
   7. 2.7 Objets créés au déploiement du cluster
      1. 2.7.1 Volumes persistants
      2. 2.7.2 Services MySQL
   8. 2.8 Tableau de bord de l’opérateur
   9. 2.9 Test de la réplication
      1. 2.9.1 Connexion aux instances maître et esclave
      2. 2.9.2 Création d’une table
      3. 2.9.3 Alimentation de la table
      4. 2.9.4 Changement du nombre de réplicats
   10. 2.10 Pour conclure

Annexes

1. 1. bash vs zsh
   1. 1.1 Les shells Unix
   2. 1.2 zsh et oh-my-zsh
   3. 1.3 Tester zsh et oh-my-zsh
   4. 1.4 Configurer zsh comme shell pour l’utilisateur courant
2. 2. Déploiement du tableau de bord Kubernetes
   1. 2.1 Installation du tableau de bord (application dashboard)
   2. 2.2 Création du compte d’accès
   3. 2.3 Récupération du jeton de connexion
   4. 2.4 Décodage du contenu du jeton
   5. 2.5 Connexion au tableau de bord
   9. Index