Partie 1.
Aperçu de Kubernetes

Chapitre 1.
Introduction à Kubernetes

1.1 Pourquoi un système comme Kubernetes est nécessaire
1.1.1 Transition des applications monolithiques aux microservices
1.1.2 Fournir un environnement cohérent pour les applications
1.1.3 Transition vers la livraison continue : DevOps et NoOps
1.2 Introduction à la technologie des conteneurs
1.2.1 Comprendre les conteneurs
1.2.2 Présentation de la plateforme de conteneurs Docker
1.2.3 Présentation de rkt comme alternative à Docker
1.3 Introduction à Kubernetes
1.3.1 Les origines de Kubernetes
1.3.2 Une vision plus large de Kubernetes
1.3.3 Comprendre l'architecture d'un cluster Kubernetes
1.3.4 Exécution d'applications sur Kubernetes
1.3.5 Avantages de l'utilisation de Kubernetes
1.4 Résumé


Chapitre 2.
Premiers pas avec Docker et Kubernetes

2.1 Création, exécution et partage d'images de conteneurs avec Docker
2.1.1 Installation de Docker et exécution du conteneur Hello World
2.1.2 Création d'une application Node.js simple
2.1.3 Création d'un Dockerfile pour une image
2.1.4 Création d'une image conteneur
2.1.5 Exécution de l'image du conteneur
2.1.6 Exploration de l'intérieur d'un conteneur en cours d'exécution
2.1.7 Arrêt et suppression des conteneurs
2.1.8 Envoi des images au registre d'images
2.2 Installation d'un cluster Kubernetes
2.2.1 Exécution d'un cluster Kubernetes à nœud unique avec Minikube
2.2.2 Utilisation d'un cluster Kubernetes géré avec Google Kubernetes Engine
2.2.3 Configuration des alias kubectl et de la saisie semi-automatique des commandes
2.3 Exécution de votre première application sur Kubernetes
2.3.1 Exécution d'une application Node.js
2.3.2 Accès à l'application Web
2.3.3 Partie logique du système
2.3.4 Mise à l'échelle horizontale de l'application
2.3.5 Vérification du nœud sur lequel l'application est exécutée
2.3.6 Présentation du tableau de bord Kubernetes
2.4 Résumé


Partie 2.
Concepts fondamentaux de Kubernetes

Chapitre 3.
Pods : Exécution de conteneurs dans Kubernetes

3.1 Introduction aux serviettes hygiéniques
3.1.1 Pourquoi les protections sont-elles nécessaires ?
3.1.2 Comprendre les blocs-notes
3.1.3 Configuration correcte des conteneurs dans un pod
3.2 Création d'un pod avec un descripteur YAML ou JSON
3.2.1 Examen du descripteur YAML d'un pod existant
3.2.2 Écriture d'une définition YAML simple définissant un pod
3.2.3 Création d'un pod avec la commande kubectl create
3.2.4 Consultation des journaux d'application
3.2.5 Envoi d'une requête à un pod
3.3 Configuration des pods à l'aide d'étiquettes
3.3.1 Introduction à l'étiquetage
3.3.2 Étiquetage lors de la création d'un pod
3.3.3 Modification des étiquettes de coussinets existantes
3.4 Lister un sous-ensemble de pods à l'aide de sélecteurs d'étiquettes
3.4.1 Lister les pods à l'aide de sélecteurs d'étiquettes
3.4.2 Utilisation de plusieurs conditions dans les sélecteurs d'étiquettes
3.5 Restriction de la planification des pods à l'aide d'étiquettes et de sélecteurs
3.5.1 Utilisation d'étiquettes pour classer les nœuds de travail
3.5.2 Planification des pods sur des nœuds spécifiques
3.5.3 Planification sur un nœud spécifique
3.6 Blocs d'annotation
3.6.1 Interrogation des annotations d'un objet
3.6.2 Ajout et modification d'annotations
3.7 Regroupement des ressources à l'aide d'espaces de noms
3.7.1 La nécessité des espaces de noms
3.7.2 Exploration d'autres espaces de noms et pods
3.7.3 Création d'un espace de noms
3.7.4 Gestion des objets dans d'autres espaces de noms
3.7.5 Comprendre l'isolation fournie par les espaces de noms
3.8 Arrêt et retrait des plaquettes
3.8.1 Suppression d'un pod par son nom
3.8.2 Suppression d'un pod à l'aide d'un sélecteur d'étiquette
3.8.3 Suppression des pods dont les espaces de noms ont été supprimés
3.8.4 Supprimer tous les pods d'un espace de noms tout en conservant l'espace de noms
3.8.5 Supprimer (presque) toutes les ressources d'un espace de noms
3.9 Résumé


Chapitre 4.
Réplication et autres contrôleurs : déploiement de pods géré

4.1 Maintenir la stabilité du coussin
4.1.1 Présentation de la sonde de vivacité
4.1.2 Création de sondes de disponibilité basées sur HTTP
4.1.3 Vérification du fonctionnement de la sonde de vivacité
4.1.4 Définition des propriétés supplémentaires de la sonde de vivacité
4.1.5 Création de sondes de vivacité efficaces
4.2 Introduction au contrôleur de réplication
4.2.1 Fonctionnement du contrôleur de réplication
4.2.2 Création d'un contrôleur de réplication
4.2.3 Vérification du fonctionnement du contrôleur de réplication
4.2.4 Déplacement de pods dans et hors du périmètre d'un contrôleur de réplication
4.2.5 Modification du modèle de bloc-notes
4.2.6 Mise à l'échelle horizontale des coussinets
4.2.7 Suppression d'un contrôleur de réplication
4.3 Utilisation de ReplicaSets au lieu de ReplicationControllers
4.3.1 Comparaison des ReplicaSets et des ReplicationControllers
4.3.2 Définition d'un ensemble de répliques
4.3.3 Création et inspection d'un ensemble de répliques
4.3.4 Utilisation de sélecteurs d'étiquettes plus expressifs pour les ensembles de répliques
4.3.5 Nettoyage de ReplicaSet
4.4 Utilisation de DaemonSet pour exécuter exactement un pod sur chaque nœud
4.4.1 Exécution de pods sur tous les nœuds avec DaemonSet
4.4.2 Exécution de pods uniquement sur des nœuds spécifiques à l'aide de DaemonSets
4.5 Exécution d'un pod qui effectue une tâche unique et complète
4.5.1 Introduction aux ressources pour l'emploi
4.5.2 Définition des ressources pour l'emploi
4.5.3 Affichage des tâches qui exécutent les pods
4.5.4 Exécution de plusieurs instances de pod dans une tâche
4.5.5 Limitation du temps nécessaire à un module de tâches pour se terminer
4.6 Planification de l'exécution périodique ou ponctuelle d'une tâche
4.6.1 Création d'une tâche cron
4.6.2 Comprendre le fonctionnement des tâches planifiées
4.7 Résumé


Chapitre 5.
Service : Permet aux clients de découvrir les pods et de communiquer avec eux.

5.1 Présentation du service
5.1.1 Création d'un service
5.1.2 Recherche de services
5.2 Connexion aux services en dehors du cluster
5.2.1 Présentation des points de terminaison de service
5.2.2 Configuration manuelle des points de terminaison de service
5.2.3 Création d'un alias pour un service externe
5.3 Exposition des services aux clients externes
5.3.1 Utilisation du service Nodeport
5.3.2 Exposition des services aux équilibreurs de charge externes
5.3.3 Comprendre les caractéristiques des connexions externes
5.4 Exposition des services en externe en tant que ressources d'entrée
5.4.1 Création d'une ressource Ingress
5.4.2 Accès aux services avec Ingress
5.4.3 Exposition de plusieurs services via une seule entrée
5.4.4 Configuration de l'entrée pour gérer le trafic TLS
5.5 Signalisation indiquant qu'un pod est prêt à accepter des connexions
5.5.1 Introduction aux sondes de disponibilité
5.5.2 Ajout d'une sonde de disponibilité à la nacelle
5.5.3 Fonctions qu'une sonde de disponibilité doit exécuter dans un environnement réel
5.6 Recherche de pods individuels avec services headless
5.6.1 Création d'un service sans interface graphique
5.6.2 Recherche de pods via DNS
5.6.3 Rechercher tous les pods, y compris les pods non préparés
5.7 Dépannage des problèmes de service
5.8 Résumé


Chapitre 6.
Volume : Connexion d’un disque dur à un conteneur

6.1 Introduction au volume
6.1.1 Description du volume de l'exemple
6.1.2 Présentation des types de volumes disponibles
6.2 Partage de données entre conteneurs à l'aide de volumes
6.2.1 Utilisation des volumes emptyDir
6.2.2 Utilisation d'un dépôt Git comme volume
6.3 Accès aux fichiers sur le système de fichiers du nœud de travail
6.3.1 Introduction du volume hostPath
6.3.2 Vérification des pods système à l'aide des volumes HostPath
6.4 Utilisation du stockage persistant
6.4.1 Utilisation des disques persistants GCE comme volumes de pod
6.4.2 Utilisation d'autres types de volumes avec stockage persistant
Technologie de stockage basée sur 6,5 et séparation des modules
6.5.1 Introduction des volumes persistants et des revendications de volumes persistants
6.5.2 Création d'un volume persistant
6.5.3 Demande d'un volume persistant par la création d'une demande de volume persistant
6.5.4 Utilisation de PersistentVolumeClaims dans les pods
6.5.5 Comprendre les avantages de l'utilisation des volumes persistants et des revendications de volumes persistants
6.5.6 Réutilisation des volumes persistants
6.6 Provisionnement dynamique des volumes persistants
6.6.1 Définition des types de stockage disponibles via les ressources StorageClass
6.6.2 Demande d'une classe de stockage dans une PersistentVolumeClaim
6.6.3 Provisionnement dynamique sans spécification de classe de stockage
6.7 Résumé


Chapitre 7.
ConfigMaps et secrets : Paramètres de l’application

7.1 Configuration des applications conteneurisées
7.2 Transmission d'arguments de ligne de commande à un conteneur
7.2.1 Définition des commandes et des arguments dans Docker
7.2.2 Redéfinition des commandes et des arguments dans Kubernetes
7.3 Définition des variables d'environnement dans les conteneurs
7.3.1 Spécification des variables d'environnement dans les définitions de conteneur
7.3.2 Référence à d'autres variables d'environnement à partir de valeurs de variables
7.3.3 Inconvénients des variables d'environnement codées en dur
7.4 Séparation des paramètres avec ConfigMap
7.4.1 Introduction à ConfigMap
7.4.2 Création d'une ConfigMap
7.4.3 Transmission des entrées ConfigMap aux conteneurs en tant que variables d'environnement
7.4.4 Transmission simultanée de tous les éléments d'une ConfigMap en tant que variables d'environnement
7.4.5 Transmission des entrées ConfigMap en tant qu'arguments de ligne de commande
7.4.6 Exposer les entrées ConfigMap sous forme de fichiers à l'aide de volumes ConfigMap
7.4.7 Mise à jour des paramètres de l'application sans redémarrage de celle-ci
7.5 Transmission de données sensibles aux conteneurs à l'aide de secrets
7.5.1 Présentation du secret
7.5.2 Présentation du secret du jeton de base
7.5.3 Créer un secret
7.5.4 Comparaison de ConfigMap et Secret
7.5.5 Utiliser des secrets dans les serviettes hygiéniques
7.5.6 Comprendre les secrets utilisés lors de la récupération d'images
7.6 Résumé


Chapitre 8.
Accéder aux métadonnées du pod et à d'autres ressources depuis votre application

8.1 Transmission de métadonnées via l'API Downward
8.1.1 Comprendre les métadonnées disponibles
8.1.2 Exposition des métadonnées en tant que variables d'environnement
8.1.3 Transmission de métadonnées sous forme de fichier à un volume d'API descendante
8.2 Communication avec le serveur d'API Kubernetes
8.2.1 Exploration de l'API REST de Kubernetes
8.2.2 Communication avec le serveur API au sein d'un pod
8.2.3 Simplification de la communication avec le serveur API grâce aux conteneurs Ambassador
8.2.4 Communication avec le serveur API à l'aide de la bibliothèque cliente
8.3 Résumé


Chapitre 9.
Déploiement : Mises à jour déclaratives de l'application

9.1 Mise à jour des applications exécutées sur des pods
9.1.1 Supprimez l'ancien pod et remplacez-le par un nouveau pod.
9.1.2 Démarrage d'un nouveau pod et suppression de l'ancien pod
9.2 Exécution de mises à jour progressives automatiques avec le contrôleur de réplication
9.2.1 Exécution d'une version initiale de l'application
9.2.2 Mises à jour progressives avec kubectl
9.2.3 Pourquoi kubectl rolling-update n'est plus utilisé
9.3 Utilisation des déploiements pour mettre à jour de manière déclarative les applications
9.3.1 Création d'un déploiement
Mise à jour du déploiement 9.3.2
9.3.3 Annulation d'un déploiement
9.3.4 Contrôle de la vitesse de déploiement
9.3.5 Suspension du processus de déploiement
9.3.6 Prévention du déploiement de versions incorrectes
9.4 Résumé


Chapitre 10.
StatefulSets : Déploiement d’applications à état répliquées

10.1 Réplication des pods avec état
10.1.1 Exécution de plusieurs réplicas avec stockage séparé
10.1.2 Fournir une identité stable à chaque pod
10.2 Comprendre les StatefulSets
10.2.1 Comparaison des StatefulSets et des ReplicaSets
10.2.2 Fournir une identité réseau stable
10.2.3 Fournir un stockage dédié et fiable pour chaque instance avec état
10.2.4 Comprendre les garanties StatefulSet
10.3 Utilisation des StatefulSets
10.3.1 Création d'images d'application et de conteneur
10.3.2 Déploiement d'applications avec StatefulSets
10.3.3 Jouer avec des pads
10.4 Découverte des pairs dans les StatefulSets
10.4.1 Découverte des pairs via DNS
Mise à jour de StatefulSet 10.4.2
10.4.3 Utilisation des datastores en cluster
10.5 Comprendre comment les StatefulSets gèrent les défaillances de nœuds
10.5.1 Simulation de la déconnexion réseau d'un nœud
10.5.2 Suppression manuelle des pods
10.6 Résumé


Partie 3.
Kubernetes en détail

Chapitre 11.
Comprendre le fonctionnement interne de Kubernetes

11.1 Comprendre l'architecture
11.1.1 Caractéristiques distribuées des composants Kubernetes
11.1.2 Comment Kubernetes utilise etcd
11.1.3 Fonctions du serveur API
11.1.4 Comprendre comment les serveurs API notifient les clients des modifications de ressources
11.1.5 Comprendre le planificateur
11.1.6 Présentation des contrôleurs exécutés dans le Gestionnaire de contrôleurs
11.1.7 Fonctionnement de Kubelet
11.1.8 Rôle du proxy de service Kubernetes
11.1.9 Présentation des modules complémentaires Kubernetes
11.1.10 Synthèse
11.2 Comment les contrôleurs collaborent
11.2.1 Compréhension des composants associés
11.2.2 Chaîne d'événements
11.2.3 Observation des événements de cluster
11.3 Comprendre les pods en cours d'exécution
11.4 Mise en réseau entre les pods
11.4.1 À quoi devrait ressembler le réseau ?
11.4.2 En savoir plus sur le fonctionnement des réseaux
11.4.3 Introduction des interfaces réseau pour conteneurs
11.5 Méthode de mise en œuvre du service
11.5.1 Introduction de kube-proxy
11.5.2 Comment kube-proxy utilise iptables
11.6 Exécution d'un cluster à haute disponibilité
11.6.1 Amélioration de la disponibilité des applications
11.6.2 Amélioration de la disponibilité des composants du plan de contrôle Kubernetes
11.7 Résumé


Chapitre 12.
Sécurité du serveur d'API Kubernetes

12.1 Comprendre l'authentification
12.1.1 Utilisateurs et groupes
12.1.2 Introduction aux comptes de service
12.1.3 Création d'un compte de service
12.1.4 Attribution d'un compte de service à un pod
12.2 Sécurisation des clusters avec le contrôle d'accès basé sur les rôles
12.2.1 Présentation du plugin d'autorisation RBAC
12.2.2 Introduction aux ressources RBAC
12.2.3 Utilisation des rouleaux et des reliures à rouleaux
12.2.4 Utilisation des rôles de cluster et des liaisons de rôles de cluster
12.2.5 Comprendre les rôles de cluster par défaut et les liaisons de rôles de cluster
12.2.6 Accorder l'autorisation judicieusement
12.3 Résumé


Chapitre 13.
Nœuds de cluster et sécurité du réseau

13.1 Utilisation de l'espace de noms du nœud hôte dans un pod
13.1.1 Utilisation de l'espace de noms réseau d'un nœud dans un pod
13.1.2 Liaison à un port hôte sans utiliser l'espace de noms réseau de l'hôte
13.1.3 Utilisation des PID de nœud et des espaces de noms IPC
13.2 Configuration du contexte de sécurité du conteneur
13.2.1 Exécution d'un conteneur en tant qu'utilisateur spécifique
13.2.2 Empêcher les conteneurs de s'exécuter en tant que root
13.2.3 Exécution du pod en mode privilégié
13.2.4 Ajout de fonctionnalités individuelles du noyau aux conteneurs
13.2.5 Suppression de fonctionnalités d'un conteneur
13.2.6 Empêcher les processus d'écrire sur le système de fichiers du conteneur
13.2.7 Partage de volumes lorsque les conteneurs s'exécutent en tant qu'utilisateurs différents
13.3 Limitation de l'utilisation des fonctionnalités de sécurité du pod
13.3.1 Présentation de la ressource PodSecurityPolicy
13.3.2 Politiques runAsUser, fsGroup et supplementalGroups
13.3.3 Configuration des fonctionnalités autorisées, par défaut et interdites
13.3.4 Limitation des types de volumes que les pods peuvent utiliser
13.3.5 Attribution de différentes stratégies de sécurité de pod à chaque utilisateur et groupe
13.4 Isolation du réseau de pods
13.4.1 Utilisation de l'isolation réseau dans les espaces de noms
13.4.2 Autoriser uniquement certains pods clients d'un espace de noms à se connecter aux pods serveur
13.4.3 Isolation réseau entre les espaces de noms Kubernetes
13.4.4 Isolation à l'aide de la notation CIDR
13.4.5 Restriction du trafic sortant des pods
13.5 Résumé


Chapitre 14.
Gestion des ressources informatiques des pods

14.1 Requêtes de ressources provenant des conteneurs de pods
14.1.1 Création d'un pod avec une demande de ressource
14.1.2 Comment les demandes de ressources affectent la planification
14.1.3 Comment les requêtes CPU affectent le partage du temps CPU
14.1.4 Définition et demande de ressources personnalisées
14.2 Limitation des ressources disponibles pour les conteneurs
14.2.1 Définir une limite stricte à la quantité de ressources disponibles pour un conteneur
14.2.2 Dépassement de la limite de ressources
14.2.3 Comment les applications conteneurisées consultent les limites
14.3 Comprendre les classes QoS des pods
14.3.1 Définition des classes QoS pour les pods
14.3.2 Comprendre quels processus sont arrêtés lorsque la mémoire est faible
14.4 Définition des requêtes et limites par défaut pour les pods par espace de noms
14.4.1 Présentation de la ressource LimitRange
14.4.2 Création d'un objet LimitRange
14.4.3 Limites de ressources imposées
14.4.4 Demandes et limites de ressources de base
14.5 Limitation des ressources totales disponibles pour un espace de noms
14.5.1 Présentation de l'objet de quota de ressources
14.5.2 Spécification des quotas pour le stockage persistant
14.5.3 Limitation du nombre d'objets pouvant être créés
14.5.4 Spécification des quotas pour des états de pod ou des classes QoS spécifiques
14.6 Surveillance de l'utilisation des ressources du pod
14.6.1 Collecte et récupération des données réelles d'utilisation des ressources
14.6.2 Stockage et analyse des statistiques périodiques d'utilisation des ressources
14.7 Résumé


Chapitre 15.
Mise à l'échelle automatique des pods et des nœuds du cluster

15.1 Mise à l'échelle automatique du pavé horizontal
15.1.1 Comprendre le processus de mise à l'échelle automatique
15.1.2 Mise à l'échelle basée sur l'utilisation du processeur
15.1.3 Mise à l'échelle basée sur la consommation de mémoire
15.1.4 Mise à l'échelle basée sur d'autres métriques et des métriques personnalisées
15.1.5 Détermination des indicateurs adaptés à la mise à l'échelle automatique
15.1.6 Réduire le nombre de répliques à 0
Mise à l'échelle automatique du pavé vertical 15.2
15.2.1 Configuration automatique des demandes de ressources
15.2.2 Modification des requêtes de ressources pendant l'exécution d'un pod
15.3 Extension horizontale des nœuds de cluster
15.3.1 Présentation de Cluster Autoscaler
15.3.2 Activation de l'autoscaler de cluster
15.3.3 Limitation des interruptions de service lors de la réduction de la taille du cluster
15.4 Résumé


Chapitre 16.
Planification avancée

16.1 Restriction de l'exécution des pods sur des nœuds spécifiques à l'aide de taints et de tolérances
16.1.1 Introduction à la contamination et à la tolérance
16.1.2 Ajout de taints personnalisés aux nœuds
16.1.3 Ajout de tolérance aux gousses
16.1.4 Comprendre l'utilisation de Tate et de la tolérance
16.2 Utilisation de l'affinité de nœud pour diriger les pods vers des nœuds spécifiques
16.2.1 Spécification des règles d'affinité des nœuds durs
16.2.2 Spécification de la priorité des nœuds lors de la planification des pods
16.3 Colocalisation des capsules en utilisant l'affinité et l'anti-affinité des capsules
16.3.1 Déploiement de pods sur le même nœud à l'aide de l'affinité inter-pods
16.3.2 Déploiement de pods sur le même rack, la même zone de disponibilité ou la même région
16.3.3 Exprimer ses préférences en matière de protections hygiéniques au lieu d'exigences obligatoires
16.3.4 Planification des pods éloignés les uns des autres à l'aide de l'anti-affinité des pods
16.4 Résumé


Chapitre 17.
Meilleures pratiques pour le développement d'applications

17.1 Synthèse
17.2 Comprendre le cycle de vie du pod
17.2.1 Arrêt prévu de l'application et relocalisation du pod
17.2.2 Reprogrammation d'un pod arrêté ou partiellement arrêté
17.2.3 Placer les tampons de démarrage dans l'ordre souhaité
17.2.4 Ajout d'un point d'ancrage de cycle de vie
17.2.5 Comprendre l'arrêt du Pad
17.3 Assurer le traitement adéquat de toutes les demandes des clients
17.3.1 Prévention des déconnexions client lors du démarrage d'un pod
17.3.2 Prévention des déconnexions lors de l'arrêt du pod
17.4 Faciliter l'exécution et la gestion des applications sur Kubernetes
17.4.1 Création d'une image conteneur gérable
17.4.2 Étiquetez correctement vos images et utilisez judicieusement imagePullPolicy.
17.4.3 Utilisation d'étiquettes multidimensionnelles au lieu d'étiquettes unidimensionnelles
17.4.4 Description de chaque ressource par des annotations
17.4.5 Fournir des informations sur la raison pour laquelle un processus s'est terminé.
17.4.6 Gestion de la journalisation des applications
17.5 Bonnes pratiques de développement et de test
17.5.1 Exécution d'applications en dehors de Kubernetes pendant le développement
17.5.2 Utilisation de Minikube pendant le développement
17.5.3 Gestion des versions et déploiement automatisé du manifeste de ressources
17.5.4 Présentation de Ksonnet comme alternative aux manifestes YAML/JSON
17.5.5 Intégration continue et livraison continue
17.6 Résumé


Chapitre 18.
Mise à l'échelle de Kubernetes

18.1 Définition des objets d'API personnalisés
18.1.1 Introduction à CustomResourceDefinition
18.1.2 Automatisation des ressources personnalisées avec des contrôleurs personnalisés
18.1.3 Validation des objets personnalisés
18.1.4 Fourniture d'un serveur API personnalisé pour les objets personnalisés
18.2 Extension de Kubernetes avec le catalogue de services Kubernetes
18.2.1 Présentation du catalogue de services
18.2.2 Présentation du serveur d'API du catalogue de services et du gestionnaire de contrôleurs
18.2.3 Présentation de Service Broker et de l'API OpenServiceBroker
18.2.4 Mise en service et utilisation du service
18.2.5 Dissociation et déprovisionnement
18.2.6 Comprendre les avantages du catalogue de services
18.3 Plateforme basée sur Kubernetes
18.3.1 Plateforme de conteneurs Red Hat OpenShift
18.3.2 Flux de travail Deis et Helm
18.4 Résumé


Annexe A.
Utilisation de kubectl dans un environnement multi-cluster

Annexe B.
Configuration d'un cluster multi-nœuds à l'aide de kubeadm

Annexe C.
Utilisation d'un environnement d'exécution de conteneur différent

Annexe D.
Fédération de clusters

Les ressources Kubernetes abordées dans le livre

★ Ce que ce livre aborde ★

■ Structure interne de Kubernetes
■ Déploiement de conteneurs sur un cluster
■ Sécurité du cluster
■ Mises à jour de l'application sans interruption


★ Public cible de ce livre ★

Il s'adresse aux développeurs de logiciels débutants et intermédiaires qui ne connaissent pas Docker ou les systèmes d'orchestration de conteneurs.
Bien qu'il s'adresse principalement aux développeurs d'applications, il offre également une vue d'ensemble de la gestion des applications d'un point de vue opérationnel.
Cela convient à toute personne intéressée par l'exécution et la gestion d'applications conteneurisées dans un environnement multi-serveurs.
Les ingénieurs logiciels débutants et confirmés qui souhaitent apprendre les technologies de conteneurisation et mettre à l'échelle plusieurs conteneurs connexes acquerront l'expertise nécessaire pour développer, conteneuriser et exécuter des applications dans un environnement Kubernetes.
Aucune expérience préalable en matière de technologies de conteneurs ou de Kubernetes n'est requise.
Il explique le sujet en détail, étape par étape, et n'utilise pas de code source d'application difficile à comprendre pour les développeurs non experts.
Toutefois, vous devez posséder au moins des connaissances de base en programmation, en réseaux informatiques, en exécution de commandes Linux de base et une compréhension des protocoles connus tels que HTTP.


★ Structure de ce livre ★

Ce livre divise le chapitre 18 en trois parties.
La première partie présente brièvement Docker et Kubernetes, explique comment installer un cluster Kubernetes et exécute une application simple.
La première partie comporte deux chapitres.
Le chapitre 1 explique ce qu'est Kubernetes, comment il a été créé et comment il contribue à résoudre les défis actuels liés à la gestion des applications à grande échelle.
Le chapitre 2 propose un tutoriel pratique sur la manière de créer une image de conteneur et de l'exécuter sur un cluster Kubernetes.
Il explique également comment exécuter localement un cluster Kubernetes à nœud unique et comment exécuter un cluster à nœuds multiples dans le cloud.

La deuxième partie présente les concepts fondamentaux que vous devez comprendre pour exécuter des applications sur Kubernetes.
Les chapitres de la partie 2 sont les suivants :
Le chapitre 3 présente les Pods, les éléments de base de Kubernetes, et explique comment organiser les Pods et autres objets Kubernetes à l'aide d'étiquettes.
Le chapitre 4 vous montre comment Kubernetes redémarre automatiquement les conteneurs pour assurer le bon fonctionnement de vos applications.
Vous apprendrez également à gérer correctement les pods, à les mettre à l'échelle horizontalement, à les rendre résilients aux pannes des nœuds du cluster et à les exécuter à des moments prédéfinis ou périodiquement.
Le chapitre 5 explique comment exposer les services fournis par les pods aux clients situés à l'intérieur et à l'extérieur du cluster.
Il montre également comment découvrir et accéder aux services, que les pods exécutés dans le cluster résident à l'intérieur ou à l'extérieur de celui-ci.
Le chapitre 6 explique comment plusieurs conteneurs exécutés sur le même pod peuvent partager des fichiers et comment gérer le stockage persistant et le rendre accessible aux pods.
Le chapitre 7 explique comment transmettre des informations importantes, telles que les données de configuration et les informations d'identification, aux applications exécutées dans des pods.
Le chapitre 8 explique comment obtenir des informations sur l'environnement Kubernetes dans lequel votre application s'exécute et comment communiquer avec Kubernetes pour modifier l'état du cluster.
Le chapitre 9 introduit le concept de déploiement et vous guide à travers la méthode appropriée pour exécuter et mettre à jour des applications dans un environnement Kubernetes.
Le chapitre 10 explique comment exécuter des applications avec état qui nécessitent une identité et un état stables.

La partie 3 examine plus en détail le fonctionnement interne d'un cluster Kubernetes, en introduisant des concepts supplémentaires et en s'appuyant sur ce que nous avons appris dans les parties 1 et 2 à un niveau supérieur.
La composition finale est la suivante :
Le chapitre 11 décrit tous les composants qui constituent un cluster Kubernetes et le rôle de chaque composant.
Il explique également comment les pods communiquent sur le réseau et comment un service répartit la charge de plusieurs pods.
Le chapitre 12 explique comment sécuriser le serveur d'API Kubernetes à l'aide de l'authentification et de l'autorisation.
Le chapitre 13 explique comment les pods peuvent accéder aux ressources d'un nœud et comment les administrateurs de cluster peuvent empêcher les pods d'accéder aux ressources.
Le chapitre 14 explique comment limiter les ressources informatiques disponibles pour les applications, configurer les garanties de qualité de service (QoS) pour les applications et surveiller l'utilisation des ressources pour chaque application.
Il vous explique également comment empêcher les utilisateurs d'utiliser trop de ressources.
Le chapitre 15 explique comment configurer Kubernetes pour faire évoluer automatiquement le nombre de réplicas exécutés dans votre application et comment augmenter la taille du cluster pour prendre en charge des applications dépassant le nombre actuel de nœuds du cluster.
Le chapitre 16 explique comment planifier des pods uniquement sur des nœuds spécifiques ou comment empêcher que des pods soient planifiés sur d'autres nœuds.
Nous examinons également comment planifier les sessions des groupes ensemble ou non.
Le chapitre 17 vous montre comment développer des applications adaptées aux clusters Kubernetes.
Il fournit également des conseils sur la manière de configurer votre flux de travail de développement et de test afin de réduire les frictions pendant le développement.
Le chapitre 18 montre comment étendre Kubernetes avec des objets personnalisés et comment d'autres ont construit des plateformes d'applications de niveau entreprise.
Grâce au contenu ci-dessus, vous découvrirez chaque composant de Kubernetes et apprendrez progressivement à utiliser l'outil en ligne de commande kubectl.


★ Note de l'auteur ★

Après avoir travaillé chez Red Hat pendant plusieurs années, j'ai été affecté à l'équipe nouvellement créée Cloud Enablement fin 2014.
La mission consistait à migrer le portefeuille de logiciels intermédiaires de l'entreprise vers la plateforme de conteneurs OpenShift construite sur Kubernetes.
À cette époque, Kubernetes était dans sa version initiale (1.0) et n'avait pas encore été officiellement publié.
Pour définir la bonne orientation du logiciel et tirer parti des fonctionnalités offertes par Kubernetes, nous devions rapidement comprendre toutes les fonctionnalités de Kubernetes.
Lorsque des problèmes survenaient, il était difficile de déterminer si nous avions commis une erreur ou s'il s'agissait d'un bug dans une version préliminaire de Kubernetes.
Depuis, Kubernetes s'est développé rapidement et j'ai acquis une bonne compréhension de son fonctionnement.
J'ai commencé à utiliser Kubernetes alors que le terme lui-même m'était inconnu.
C'est aujourd'hui la méthode qui connaît la croissance la plus rapide et la plus répandue pour exécuter des applications dans le cloud et les centres de données sur site, ce qui en fait un concept familier à presque tous les ingénieurs logiciels.
Environ un mois après avoir commencé à utiliser Kubernetes, j'ai écrit deux articles de blog sur la façon d'exécuter un cluster de serveurs d'applications JBoss WildFly sur OpenShift/Kubernetes.
À l'époque, je n'aurais jamais imaginé que quelqu'un de Manning Publishing me contacterait après avoir lu mon article de blog pour me demander d'écrire un livre sur Kubernetes.
Je n'ai pas refusé l'offre, même si cela impliquait de contacter quelqu'un qui pourrait être en mesure d'écrire un livre.
C'est ainsi que j'en suis venu à écrire ce livre.
Après plus d'un an et demi de rédaction et de recherche assidues, j'y ai finalement mis un terme.
Ce fut une expérience très précieuse.
L'écriture de ce livre m'a appris beaucoup plus sur Kubernetes que je n'aurais jamais pu l'apprendre en tant qu'utilisateur.
À mesure que mes connaissances sur Kubernetes s'étendaient et que Kubernetes évoluait, j'ai dû réviser et affiner ce que j'avais écrit précédemment.
Je suis perfectionniste.
Je ne suis pas satisfait de ce livre.
Néanmoins, je suis ravi que tant de lecteurs du programme d'accès anticipé Manning (MEAP) aient trouvé ce livre être un excellent guide de Kubernetes.
Mon objectif est d'apprendre aux lecteurs à comprendre la technologie elle-même et à utiliser les outils pour développer et déployer des applications sur des clusters Kubernetes de manière efficace et efficiente.
Ce livre ne traite pas réellement de la configuration ou de l'exploitation d'un cluster Kubernetes avec un niveau de disponibilité raisonnable.
Cependant, dans les trois dernières parties, nous avons rédigé un aperçu détaillé de la configuration du cluster et des ressources supplémentaires pour aider les lecteurs à comprendre.
J'espère que vous apprécierez d'apprendre à tirer le meilleur parti de ce système incroyable qu'est Kubernetes.


★ Note du traducteur ★

Depuis son annonce par Google en 2014, Kubernetes est rapidement devenu l'une des technologies les plus populaires.
Dans un environnement informatique où l'agilité commerciale est de plus en plus mise en avant, l'architecture de microservices (MSA) est devenue la norme de facto, et Kubernetes a récemment été sous les projecteurs comme la technologie la plus adaptée à la mise en œuvre d'environnements MSA.
De plus, Kubernetes est introduit et utilisé dans divers domaines, tels que l'informatique de périphérie dans les environnements IoT, le déploiement de flux de travail d'apprentissage automatique (kubeflow) dans la science des données, la virtualisation de l'infrastructure de communication (VNF, Virtual Network Function) dans la 5G, et en outre comme technologie clé pour la prise en charge du cloud hybride ou multicloud.
Témoignant de cet enthousiasme fervent, de nombreux ouvrages ont été publiés et traduits, mais si j'ai entrepris de rééditer ce livre, qui semble un peu dépassé, c'est parce que j'ai d'abord été fasciné par la visualisation pertinente et l'explication métaphorique des concepts proposée par l'auteur, et parce qu'il s'agit d'un ouvrage que l'on peut qualifier de bible du domaine Kubernetes, grâce à sa structure solide qui couvre l'explication détaillée de la structure interne de Kubernetes, et même le multicloud et l'extension de Kubernetes.
Les traducteurs de ce livre sont membres du groupe d'étude « 100-Day Kubernetes Architecture Journey », un groupe d'étude basé sur ce livre au sein du « Kubernetes Korea Group », et ont tout mis en œuvre pour que cette réédition soit aussi facile et agréable à lire que possible pour les lecteurs.
Nous avons essayé de suivre au plus près le glossaire de l'équipe de traduction coréenne de Kubernetes pour la terminologie, vérifié que les exemples pouvaient être exécutés sur la dernière version de Kubernetes et ajouté diverses annotations pour aider les lecteurs à comprendre.
Bien que le texte original soit globalement bien structuré, de nombreuses subtilités étaient difficiles à retranscrire par la traduction lors de l'explication des concepts, et un effort considérable a été déployé pour les rendre en coréen.
En tant que traductrice, je serais extrêmement flattée si je pouvais entendre des commentaires disant que mon travail était fluide et facile à lire.