Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Kubernetes Patterns, 2e édition

Kubernetes Patterns, 2e édition

Titre original: Kubernetes Patterns
Créez des applications cloud natives que Kubernetes peut réellement exploiter, faire évoluer et remettre en état.
par Bilgin Ibryam 2019 266 pages
4.31
216 évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Considérez Kubernetes comme un environnement d’exécution distribué, pas comme un parking à conteneurs

La plateforme apporte de nouvelles briques de base. Kubernetes ne se contente pas de démarrer des conteneurs. Il fournit des primitives distribuées pour le déploiement, la découverte, la planification et la gestion du cycle de vie. Une image de conteneur regroupe une unité de fonctionnalité; un Pod rassemble les conteneurs qui doivent partager le placement et le cycle de vie; un Service offre aux clients un moyen stable d’atteindre des Pods qui, eux, changent. Ces abstractions sont comparables à des constructions de programmation familières, mais elles opèrent à l’échelle de plusieurs machines plutôt qu’au sein d’un seul processus.

Un bon logiciel reste essentiel. Kubernetes peut automatiser et faire évoluer une application, mais il ne peut pas corriger des frontières métier confuses, du code de mauvaise qualité ou des conteneurs inadaptés. L’ouvrage se concentre sur les modèles d’orchestration, tout en soulignant qu’une conception claire et des services bien définis sont indispensables pour en tirer parti.

Analyse

Le changement de perspective utile consiste à voir Kubernetes non plus comme un outil en ligne de commande, mais comme un contrat d’exécution. Cette approche rapproche la conception de la plateforme de celle d’un système d’exploitation : les applications bénéficient des services de leur environnement, mais doivent en respecter les interfaces. L’avertissement sur les déchets distribués est plus qu’une boutade. L’automatisation amplifie aussi bien les bonnes structures que les mauvaises. L’orchestration ne remplace toutefois pas la modélisation du domaine ; un système réparti en de nombreux Pods peut rester un système mal conçu.

Déclarez des budgets de ressources pour que l’ordonnanceur puisse placer intelligemment les charges de travail

Les demandes guident le placement. Le profil de ressources d’un conteneur indique ce dont il a besoin et jusqu’où il peut croître. Kubernetes tient compte des demandes en CPU et en mémoire pour déterminer si un nœud a de la capacité disponible; les limites plafonnent la consommation. En cas de contraintes, le CPU peut être limité, tandis qu’une consommation excessive de mémoire peut entraîner l’arrêt du conteneur. Par exemple, un conteneur peut demander 100 milli-cœurs et 100 Mio de mémoire, avec des limites de 200 milli-cœurs et 200 Mio.

Les profils influent sur la survie. L’ouvrage distingue les Pods Best-Effort, sans demandes ni limites, les Pods Burstable, dont les demandes et les limites diffèrent, et les Pods Guaranteed, pour lesquels elles sont identiques. Les quotas de namespace et les LimitRanges peuvent restreindre la consommation globale et empêcher les réglages extrêmes. Tester les charges de travail réelles fournit aux équipes un point de départ pour planifier la capacité.

Analyse

Les déclarations de ressources sont à la fois des prévisions et une négociation avec l’ordonnanceur. Cela ressemble à la planification des capacités dans l’industrie : impossible d’allouer correctement une chaîne de production si l’on ignore les besoins de chaque produit. Mais les estimations peuvent devenir obsolètes à mesure que le trafic et les logiciels évoluent. Des demandes trop élevées gaspillent la capacité ; des demandes trop faibles peuvent conduire à un placement et à des performances trompeurs. Ces déclarations sont plus utiles lorsqu’elles sont considérées comme des hypothèses mesurées à réexaminer, plutôt que comme des vérités permanentes copiées d’un environnement à l’autre.

Choisissez les stratégies de mise en production en fonction des risques de compatibilité, pas par habitude

Un Déploiement décrit la transition souhaitée. Les Deployments Kubernetes gèrent des groupes de Pods et automatisent leur remplacement, le suivi des déploiements et les retours arrière. Une stratégie RollingUpdate remplace progressivement les instances, avec des paramètres qui déterminent combien de Pods supplémentaires ou indisponibles sont autorisés. Les vérifications de disponibilité sont importantes: une instance ne devrait ni recevoir de trafic ni être considérée comme un remplacement réussi avant de pouvoir répondre aux requêtes.

Les risques différents appellent des mises en production différentes. La stratégie Recreate arrête l’ancienne version avant de démarrer la nouvelle, acceptant une interruption de service pour éviter la coexistence des versions. La stratégie blue-green maintient les déploiements ancien et nouveau disponibles, puis fait basculer le Service vers le nouvel ensemble, au prix d’une duplication temporaire de la capacité. Le déploiement canari introduit un petit échantillon de la nouvelle version avant d’en étendre l’utilisation. Ces stratégies déterminent la façon dont les utilisateurs découvrent une nouvelle version, et pas seulement le remplacement des Pods.

Analyse

La stratégie de mise en production est un choix face à l’incertitude. Une mise à jour progressive économise de la capacité, tandis que la stratégie blue-green en consomme pour faciliter le retour arrière et le basculement du trafic. Les déploiements canaris exposent progressivement les utilisateurs à la nouvelle version, mais un petit échantillon n’est informatif que s’il représente des utilisateurs et des charges de travail significatifs. La question opérationnelle n’est pas de savoir quelle stratégie est la plus moderne, mais quel mode de défaillance le service peut tolérer : interruption, coexistence de versions, infrastructure supplémentaire ou données imparfaites.

Fournissez à Kubernetes des signaux de santé fiables et un comportement d’arrêt progressif

L’état du processus ne suffit pas à déterminer la santé de l’application. Un processus peut toujours exister alors que l’application est bloquée ou incapable de répondre. Une sonde de vivacité vérifie si Kubernetes doit redémarrer un conteneur. Une sonde de disponibilité répond à une autre question: le conteneur doit-il recevoir du trafic à cet instant? Elle peut empêcher qu’une instance en cours de démarrage ou surchargée soit ajoutée aux points de terminaison du Service, sans pour autant la redémarrer.

L’arrêt fait partie de l’interface. Quand Kubernetes arrête un conteneur, il envoie SIGTERM et accorde normalement 30 secondes avant d’envoyer SIGKILL. Les applications devraient mettre ce délai à profit pour terminer les requêtes en cours, libérer les connexions et effectuer le nettoyage. Les hooks de cycle de vie tels que postStart et preStop permettent d’ajouter des actions, mais leur calendrier et leurs garanties d’exécution sont limités; il ne faut donc pas en dépendre seuls pour les comportements critiques.

Analyse

Ces sondes font de l’application une participante à ses propres opérations. En théorie du contrôle, un système ne peut pas être régulé efficacement si son état n’est pas observable ; les sondes fournissent un signal restreint et exploitable plutôt qu’une explication complète. Cette simplicité comporte aussi un risque. Une sonde qui vérifie seulement qu’un port répond peut déclarer sain un service dégradé, tandis qu’une sonde trop sensible peut provoquer des redémarrages inutiles. Les signaux de santé devraient représenter des défaillances auxquelles l’action corrective choisie peut réellement remédier.

Choisissez le contrôleur adapté à la durée de vie et au caractère unique du travail

Les différents travaux exigent des garanties différentes. Un ReplicaSet maintient disponible le nombre souhaité de Pods à longue durée de vie. Un Job exécute un travail fini jusqu’à sa réussite, avec des paramètres pour le nombre de tâches à terminer et de travailleurs parallèles. Un CronJob ajoute un calendrier à ce travail. Un DaemonSet place un Pod sur chaque nœud ou sur les nœuds sélectionnés, souvent pour des tâches d’infrastructure comme la collecte de journaux ou de métriques.

Une seule instance active exige des précautions. Une réplique unique de ReplicaSet permet généralement le rétablissement, mais ne garantit pas que deux instances ne se chevaucheront jamais lors d’une partition réseau ou d’un remplacement. Un comportement strictement singleton peut nécessiter une élection de leader au niveau de l’application ou les garanties d’un StatefulSet. Un PodDisruptionBudget peut limiter les évictions volontaires lors de la maintenance, mais ne prévient pas les défaillances qui échappent au contrôle.

Analyse

Le contrôleur exprime la signification du travail. Un Job considère l’achèvement comme une réussite ; un ReplicaSet considère la présence continue comme une réussite ; un DaemonSet associe la présence aux nœuds. Le choix d’une mauvaise abstraction modifie discrètement le comportement en cas de défaillance. Cela revient à choisir des propriétés transactionnelles dans une base de données : la garantie souhaitée doit être explicite. En particulier, disponibilité et unicité peuvent entrer en conflit ; une charge de travail singleton ne devrait donc pas supposer qu’un nombre de répliques égal à un signifie qu’il n’y aura jamais plus d’une exécution simultanée.

Acheminez le trafic par des Services stables, jamais par les adresses éphémères des Pods

Les Pods sont remplaçables; leurs adresses ne sont pas garanties. Kubernetes attribue dynamiquement aux Pods des identités réseau, susceptibles de changer en cas de replanification ou de mise à l’échelle. Un Service fournit un point de terminaison nommé et stable, et sélectionne les Pods disponibles comme backends. À l’intérieur du cluster, les clients peuvent généralement découvrir le Service par DNS. Les variables d’environnement peuvent également exposer les informations du Service, mais uniquement aux Pods créés après son existence.

L’accès externe comporte plusieurs niveaux. NodePort ouvre un port sur les nœuds du cluster; LoadBalancer peut connecter un Service à l’équilibreur de charge externe d’un fournisseur de cloud. Ingress achemine le trafic au niveau applicatif, généralement HTTP, par des points d’entrée externes partagés et peut diriger différents chemins ou noms d’hôte vers différents Services. Un Service peut également représenter des points de terminaison configurés manuellement à l’extérieur du cluster.

Analyse

L’abstraction Service sépare la promesse faite aux clients des mécanismes qui la tiennent. C’est un puissant moyen de découplage : les implémentations peuvent changer tandis que les consommateurs continuent d’utiliser le même nom. Elle rend aussi visible la frontière des responsabilités. ClusterIP gère l’accès interne, tandis que le routage externe dépend de l’infrastructure et du comportement des contrôleurs. Les équipes devraient tester le chemin réseau réel, car un objet Kubernetes stable ne garantit pas à lui seul que les pare-feu, les équilibreurs de charge et les protocoles applicatifs sont correctement configurés.

Donnez aux répliques avec état une identité, un stockage et une appartenance ordonnée

Les charges de travail avec état ne sont pas des copies interchangeables. Un StatefulSet attribue à chaque Pod un nom et un ordinal prévisibles, peut créer un PersistentVolumeClaim distinct pour chaque instance et coordonne par défaut le démarrage et l’arrêt dans un ordre précis. Un Service headless associé publie les identités DNS directes de Pods particuliers, au lieu de répartir chaque requête entre eux. Ces fonctionnalités permettent aux applications en cluster de trouver leurs pairs et de se reconnecter à leur propre stockage.

La persistance exige des opérations réfléchies. Une réduction d’échelle supprime les Pods, mais laisse délibérément leurs demandes de volume en place, ce qui réduit le risque qu’une réduction accidentelle supprime les données. Les StatefulSets visent à empêcher les identités en double, mais la suppression forcée d’un Pod ou le fait de déclarer mort un nœud toujours actif peut contourner cette protection. La plateforme fournit des garanties utiles, pas un plan complet de reprise après sinistre pour une base de données.

Analyse

L’idée essentielle est que l’état ne se limite pas au contenu du disque. Il comprend aussi l’identité, l’emplacement réseau et l’ordre d’appartenance, autant d’éléments qui peuvent compter pour une base de données distribuée ou un service de coordination. Les StatefulSets rendent ces dimensions explicites au lieu de prétendre que chaque réplique est jetable. Toutefois, les garanties de l’infrastructure ne tiennent pas compte des règles propres à une application en matière de réplication, de quorum ou de sauvegarde. Un volume stable peut conserver aussi fidèlement des données corrompues que des données saines ; les procédures opérationnelles restent donc indispensables.

Externalisez la configuration, puis choisissez le mécanisme de transmission le plus léger qui reste sûr

Gardez les paramètres propres à chaque environnement hors de l’image de l’application. Les variables d’environnement conviennent bien aux valeurs simples et peu nombreuses. Les ConfigMaps stockent la configuration ordinaire, tandis que les Secrets sont destinés aux valeurs sensibles; l’un comme l’autre peuvent fournir des variables d’environnement ou des fichiers montés. Les fichiers ConfigMap montés peuvent être actualisés pendant l’exécution d’un Pod, mais l’application doit détecter les changements et recharger la configuration. Les variables d’environnement, elles, ne changent pas après le démarrage du processus.

La complexité doit se justifier. Les grands ensembles de configuration peuvent mieux convenir à une image de configuration versionnée, copiée dans un volume partagé, ou à des modèles rendus par un conteneur d’initialisation à partir d’un petit ensemble de valeurs propres à l’environnement. Ces approches réduisent les duplications, mais ajoutent des images et des étapes opérationnelles. Les valeurs des Secrets sont encodées en Base64, ce qui ne constitue pas en soi un chiffrement; les contrôles d’accès et la protection du stockage restent importants.

Analyse

La configuration est une forme de politique exécutable : elle modifie le comportement d’un service sans modifier son code. La séparer de l’image de l’application favorise la réutilisation, mais chaque couche de configuration supplémentaire crée un nouveau risque de divergence ou d’exposition accidentelle. La démarche progressive de l’ouvrage est utile : commencer par de simples variables, utiliser les ressources de la plateforme lorsque les valeurs doivent être gérées indépendamment, et réserver les modèles ou les images de configuration aux cas véritablement volumineux ou complexes.

Composez les conteneurs selon leurs rôles, plutôt que d’y regrouper commodément tout un monolithe

Un Pod peut combiner des processus distincts sans confondre leurs fonctions. Un conteneur d’initialisation s’exécute jusqu’à son terme avant le démarrage des conteneurs applicatifs; il convient donc aux tâches de préparation, comme la création de fichiers partagés. Un conteneur auxiliaire (sidecar) s’exécute aux côtés du conteneur principal pour lui apporter une fonctionnalité complémentaire. Par exemple, un conteneur peut servir des fichiers Web tandis qu’un autre les synchronise à partir d’un dépôt.

Les assistants spécialisés ont des fonctions distinctes. Un adaptateur traduit la sortie d’une application dans un format standard, par exemple en convertissant des métriques personnalisées pour un système de supervision. Un ambassadeur relaie l’accès aux services externes, en masquant à l’application les détails de découverte ou de connexion. Ces modèles préservent des images et des cycles de publication distincts, même si chaque conteneur supplémentaire consomme des ressources et doit aussi être supervisé.

Analyse

La composition des conteneurs est une forme pratique de modularité. Elle permet aux équipes d’ajouter des fonctionnalités transversales sans reconstruire l’application elle-même, comme l’utilisation de composants dans un système plutôt que l’intégration de chaque fonction dans un artefact unique. Cet avantage n’est réel que si les frontières restent simples. Un conteneur auxiliaire ajoute un processus, une dépendance et un mode de défaillance supplémentaires. Si le comportement d’un sidecar est indissociable de celui de l’application principale, le séparer peut créer de la complexité opérationnelle sans apporter de réutilisation significative.

Utilisez la réconciliation pour enseigner à Kubernetes les règles opérationnelles de votre application

Les contrôleurs comparent continuellement la réalité à une cible déclarée. Leur boucle fondamentale consiste à observer les changements de ressources, à analyser l’écart entre l’état actuel et l’état souhaité, puis à agir au moyen de l’API Kubernetes. Les contrôleurs intégrés s’appuient sur cette approche pour maintenir les Deployments et d’autres ressources; les contrôleurs personnalisés peuvent ajouter des comportements autour des objets Kubernetes standard.

Les Opérateurs ajoutent des ressources propres à un domaine. Un Opérateur est un contrôleur qui utilise des CustomResourceDefinitions pour représenter des concepts propres à une application ou à un système particulier. Une ressource peut décrire une installation de supervision ou un observateur de configuration, tandis que son Opérateur prend en charge les opérations correspondantes. Les ressources personnalisées peuvent être validées et intégrées aux outils Kubernetes, mais l’enregistrement de leurs définitions nécessite généralement des permissions élevées sur le cluster. Toutes les applications n’ont pas besoin d’un Opérateur; des contrôleurs ordinaires ou des services autonomes peuvent être plus simples.

Analyse

La réconciliation remplace une séquence fragile de commandes par une relation persistante entre l’intention et l’état observé. Cela ressemble à une régulation par rétroaction : le système corrige continuellement les écarts au lieu de supposer qu’une procédure exécutée une fois a réussi pour toujours. Ce modèle est puissant, mais les contrôleurs asynchrones peuvent être difficiles à déboguer, et ceux qui sont mal conçus peuvent répéter des changements néfastes. Une bonne extension dispose de permissions limitées, rend clairement compte de son état et vise un état cible que l’on peut atteindre sans risque à plusieurs reprises.

Faites évoluer les Pods et les nœuds, et distinguez les recommandations des changements automatiques

La mise à l’échelle horizontale modifie le nombre de répliques. Un autoscaler horizontal de Pods (HorizontalPodAutoscaler) peut ajuster les Pods d’un Deployment en fonction de métriques telles que l’utilisation du CPU, à condition que des demandes de ressources et une source de métriques soient disponibles. La métrique choisie doit réagir de façon pertinente à l’ajout de répliques. Par exemple, l’utilisation de la mémoire peut ne pas diminuer lorsque l’on ajoute des instances identiques. Des délais et des règles de stabilisation aident à éviter les oscillations rapides.

La mise à l’échelle verticale et celle du cluster répondent à des contraintes différentes. Un autoscaler vertical de Pods recommande ou modifie les demandes de ressources, mais l’application des changements peut nécessiter le redémarrage des Pods. Un autoscaler de cluster ajoute des nœuds pour les charges de travail impossibles à planifier et peut supprimer les nœuds suffisamment sous-utilisés lorsque les Pods peuvent être déplacés sans risque. Ces mécanismes sont complémentaires, mais des autoscalers mal coordonnés peuvent réagir de manière excessive ou se disputer les mêmes ressources.

Analyse

L’élasticité ne se règle pas au moyen d’un seul bouton. Elle s’organise en niveaux : ajuster l’application, dimensionner chaque Pod, modifier le nombre de Pods, puis agrandir ou réduire le cluster. L’ordre compte, car l’ajout de répliques ne corrigera pas un code inefficace, et l’ajout de nœuds peut masquer de mauvaises estimations des ressources. Les autoscalers agissent aussi à partir de mesures différées, et non d’une vérité instantanée. Leur utilité dépend du choix de signaux pertinents et du temps laissé à la nouvelle capacité pour devenir disponible.

Ne construisez des images dans le cluster que si l’intégration l’emporte sur le risque de sécurité accru

La création d’images peut utiliser la même plateforme de planification que le déploiement. La construction dans un cluster Kubernetes peut réduire le besoin d’une infrastructure distincte et relier les résultats de la construction aux déploiements ultérieurs. Le système de construction d’OpenShift prend en charge Source-to-Image, qui combine le code source avec une image de construction propre à un langage, ainsi que d’autres méthodes de construction. Les déclencheurs de changement d’image peuvent relier une image reconstruite à une autre construction ou à un déploiement.

L’isolation des constructions reste importante. Les constructions Docker traditionnelles dépendent d’un démon privilégié, ce qui soulève des préoccupations de sécurité lorsque des instructions de construction s’exécutent dans le cluster. Des outils sans démon, tels que Kaniko, Buildah et img, proposent d’autres moyens de créer des images sans recourir à ce modèle. L’ouvrage présente également Knative Build comme un moyen d’exprimer des étapes de construction sous forme de tâches gérées par Kubernetes, tout en signalant que son implémentation évoluait au moment de la publication.

Analyse

Le pipeline de construction est lui-même une charge de travail avec des besoins en ressources, en sécurité et en planification ; l’exécuter sur la même plateforme peut donc simplifier les opérations. Cette commodité ne devrait pas brouiller la frontière de confiance entre du code source non fiable et l’infrastructure de production. Les tâches de construction exécutent des instructions fournies par les projets, ce qui fait du contrôle des privilèges et de l’isolation des questions essentielles de conception. La construction dans le cluster est particulièrement intéressante lorsque l’intégration événementielle et le partage de capacité justifient la responsabilité supplémentaire de sécuriser l’environnement de construction.

Analyse

Kubernetes Patterns, 2e édition est un langage de modèles techniques, pas un manuel d’installation. Ses 24 modèles vont des contrats fondamentaux — comme la déclaration des ressources et l’exposition de l’état de santé — au comportement des charges de travail et à la composition des Pods, puis à la configuration, aux contrôleurs, à la mise à l’échelle et à la création d’images. L’idée directrice est que Kubernetes constitue un environnement d’exécution distribué, doté d’un vocabulaire permettant d’exprimer des intentions opérationnelles. Les modèles rendent ce vocabulaire réutilisable: un Job désigne un travail fini, un Service un accès stable à des points de terminaison changeants, et un StatefulSet des instances dont l’identité et le stockage comptent.

La contribution majeure de l’ouvrage tient à son insistance sur le fait que l’automatisation exige la coopération de l’application. Un Deployment ne peut pas rendre une mise en production sûre si l’état de disponibilité est mal signalé; un ordonnanceur ne peut pas bien placer les charges de travail sans demandes de ressources; un contrôleur ne peut pas gérer un domaine qu’il ne peut pas observer. Cette approche relie la conception logicielle aux opérations au moyen d’interfaces explicites. Elle explique aussi pourquoi les primitives Kubernetes ne sont pas des recettes interchangeables. Chacune encode une promesse différente en matière de remplacement, de persistance, de disponibilité ou de calendrier.

La principale limite de ce cadre est que le nom des modèles peut donner l’impression que des enjeux complexes de production sont plus circonscrits qu’ils ne le sont. Un StatefulSet fournit une identité stable et une association au stockage, pas une réplication correcte des bases de données. Une sonde fournit un signal, pas un diagnostic complet. Un contrôleur réconcilie des ressources, mais son comportement asynchrone peut être difficile à comprendre. L’ouvrage reconnaît nombre de ces compromis; les lecteurs devraient considérer chaque modèle comme un contrat de départ à éprouver face à leur charge de travail, et non comme une garantie indépendante de la configuration.

Le modèle mental durable est celui des responsabilités en couches. Le code applicatif garantit la justesse métier; les conteneurs regroupent les fonctionnalités; les Pods définissent des groupes d’exécution étroitement couplés; les contrôleurs maintiennent l’état souhaité; et l’infrastructure du cluster fournit la capacité et le routage. Les meilleurs systèmes cloud natifs émergent lorsque chaque couche a un rôle clair, expose les signaux dont la couche suivante a besoin et ne revendique pas des garanties qu’elle ne peut réellement fournir.

Résumé en 30 secondes
L’orchestration fonctionne mieux lorsque les applications déclarent leurs besoins en ressources, indiquent si elles peuvent traiter du trafic et s’arrêtent gracieusement. La découverte de services stables dissocie les clients des instances remplaçables, tandis que des identités et un stockage persistants prennent en charge les charges de travail à état. Les contrôleurs comparent les conditions réelles aux résultats souhaités et agissent pour combler les écarts. La mise à l’échelle dépend de métriques pertinentes, et le placement automatisé ne peut compenser ni une mauvaise conception d’application ni l’absence de plans de récupération des données.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.31 sur 5
Moyenne de 216 évaluations de Goodreads et Amazon.

Kubernetes Patterns reçoit principalement des critiques positives : les lecteurs apprécient son contenu captivant, sa structure claire et ses exemples pratiques. Nombre d’entre eux le trouvent utile pour comprendre les concepts et les bonnes pratiques de Kubernetes. Certains apprécient la manière dont le livre explique les modèles, tandis que d’autres estiment que certains « modèles » ne sont que des fonctionnalités élémentaires de Kubernetes. L’ouvrage est recommandé aux développeurs et aux administrateurs système qui souhaitent approfondir leurs connaissances de Kubernetes, même s’il est peut-être moins utile aux praticiens expérimentés. Dans l’ensemble, il est considéré comme une ressource précieuse pour créer des applications cloud natives.

Votre note :
4.59
325 évaluations
Envie de lire le livre complet ?

Glossaire

Besoins prévisibles

Besoins déclarés à l’exécution

Un modèle fondamental dans lequel les conteneurs indiquent explicitement leurs besoins en ressources et leurs dépendances à l’exécution. Les demandes et les limites de ressources aident Kubernetes à planifier les charges de travail et à gérer la contention, tandis que des dépendances telles que le stockage, les ports, les ConfigMaps et les Secrets influent sur la possibilité de démarrer un Pod ou sur l’endroit où il peut s’exécuter.

Déploiement

Mise à jour contrôlée des Pods

Une ressource Kubernetes qui gère un nombre souhaité de Pods interchangeables et consigne la manière dont ils doivent être mis à jour. Ses stratégies de déploiement peuvent remplacer les Pods progressivement ou arrêter l’ancien ensemble avant de démarrer le nouveau. Les déploiements fournissent également l’état du déploiement et des capacités de retour arrière.

Sondes de vivacité

Vérifications de santé déclenchant un redémarrage

Vérifications effectuées par Kubernetes pour décider si un conteneur doit être redémarré. Une sonde peut utiliser une requête HTTP, une connexion TCP ou une commande. Elle vise à détecter les défaillances qu’un redémarrage peut corriger, par exemple un processus bloqué qui continue de fonctionner.

Sondes de disponibilité

Vérifications de l’aptitude à recevoir du trafic

Vérifications qui indiquent si un conteneur est actuellement prêt à traiter des requêtes. Lorsqu’une sonde de disponibilité échoue, Kubernetes retire le Pod des points de terminaison utilisés par les Services, sans nécessairement redémarrer le conteneur. Cela peut protéger le trafic pendant le démarrage ou une surcharge temporaire.

StatefulSet

Gestionnaire de charges de travail préservant l’identité

Une ressource Kubernetes destinée à gérer des Pods qui nécessitent des identités stables, des associations à un stockage persistant ou une création et une terminaison ordonnées. Elle attribue des noms et des numéros d’ordre prévisibles, peut créer une demande de stockage distincte pour chaque Pod et fonctionne avec un Service directeur pour fournir des identités réseau stables.

API descendante (Downward API)

Injection des métadonnées du Pod

Un mécanisme Kubernetes qui rend certaines informations sur un Pod ou un conteneur accessibles à l’intérieur d’un conteneur, au moyen de variables d’environnement ou de fichiers montés. Les données peuvent inclure le nom du Pod, son espace de noms, son adresse IP, ses étiquettes, ses annotations et ses demandes ou limites de ressources. Les applications peuvent ainsi accéder aux métadonnées sans interroger directement l’API Kubernetes.

Conteneur d’initialisation

Conteneur exécutant une tâche de démarrage

Un conteneur d’un Pod qui s’exécute avant les conteneurs de l’application. Les conteneurs d’initialisation s’exécutent séquentiellement, et chacun doit se terminer correctement avant le démarrage du suivant. Ils conviennent aux tâches préparatoires, comme récupérer des fichiers ou vérifier des prérequis, et peuvent partager des volumes du Pod avec les conteneurs de l’application.

Conteneur auxiliaire (sidecar)

Conteneur auxiliaire exécuté en parallèle

Un conteneur placé dans le même Pod qu’un conteneur d’application principal afin d’étendre ou de prendre en charge son comportement. Les conteneurs partagent le placement et le cycle de vie du Pod et peuvent communiquer par des volumes partagés ou via le réseau localhost. Parmi les rôles courants figurent la synchronisation, la surveillance et la prise en charge réseau.

Contrôleur

Réconciliateur de l’état souhaité

Un processus qui s’exécute en continu, observe les ressources Kubernetes, compare leur état actuel à un état souhaité et prend des mesures pour réduire l’écart. Les contrôleurs intégrés gèrent des ressources telles que les déploiements. Les contrôleurs personnalisés peuvent ajouter des comportements en surveillant les ressources Kubernetes standard par l’intermédiaire de l’API.

Opérateur

Contrôleur tenant compte de l’application

Un contrôleur qui utilise des CustomResourceDefinitions pour représenter des concepts propres à une application et en automatiser le fonctionnement. Un opérateur combine sa connaissance de Kubernetes et celle du système qu’il gère. Ses ressources personnalisées peuvent décrire les configurations souhaitées, tandis que l’opérateur effectue les opérations correspondantes sur le cycle de vie.

Autoscaler horizontal de Pods (HorizontalPodAutoscaler)

Ajusteur du nombre de réplicas fondé sur des métriques

Une ressource Kubernetes qui ajuste le nombre de Pods appartenant à une charge de travail évolutive en fonction de métriques observées et de cibles configurées. Elle peut utiliser des métriques de ressources telles que le CPU et, avec des intégrations adaptées, des métriques personnalisées ou externes. Son efficacité dépend de métriques qui réagissent de manière significative aux variations du nombre de réplicas.

FAQ

De quoi parle Kubernetes Patterns, 2e édition ?

  • Les applications cloud natives au cœur du sujet : Kubernetes Patterns, 2e édition, de Bilgin Ibryam et Roland Huß, est un guide de conception d’applications cloud natives avec Kubernetes. Il met l’accent sur des applications évolutives, résilientes et faciles à gérer.
  • Des éléments de conception réutilisables : le livre présente des éléments réutilisables pour concevoir des applications et propose des solutions pratiques aux difficultés courantes du déploiement sur Kubernetes.
  • Des cas d’usage réels : il s’appuie sur des expériences concrètes pour illustrer l’application efficace des modèles, ce qui le rend utile aux utilisateurs de Kubernetes, débutants comme expérimentés.

Pourquoi lire Kubernetes Patterns, 2e édition ?

  • Développer ses compétences en Kubernetes : l’ouvrage est idéal pour les développeurs qui souhaitent approfondir leur compréhension de Kubernetes et améliorer leurs compétences en conception d’applications grâce aux bonnes pratiques et aux modèles éprouvés.
  • Apprendre auprès d’experts : écrit par des praticiens expérimentés, il rassemble les enseignements tirés de divers projets et offre aux lecteurs de solides connaissances en conception d’applications cloud natives.
  • Des conseils pratiques : les modèles sont applicables et adaptés aux situations réelles ; ils constituent un guide pratique du développement cloud natif.

Quels sont les principaux enseignements de Kubernetes Patterns, 2e édition ?

  • Comprendre les concepts de Kubernetes : le livre couvre des notions essentielles comme les Pods, les Services et les déploiements, et fournit des bases solides pour créer des applications robustes.
  • Des modèles de conception pour les applications : il présente des modèles comme les Besoins prévisibles et les sondes de santé, essentiels à la création d’applications évolutives et faciles à maintenir.
  • Des sujets avancés : il aborde des modèles avancés comme les opérateurs et les contrôleurs, indispensables pour étendre les fonctionnalités de Kubernetes et gérer des applications complexes.

Quels sont les modèles fondamentaux abordés dans Kubernetes Patterns, 2e édition ?

  • Besoins prévisibles : ce modèle souligne l’importance de déclarer les besoins en ressources des conteneurs afin d’aider Kubernetes à prendre des décisions de planification éclairées.
  • Déploiement déclaratif : il porte sur des stratégies de déploiement comme les mises à jour progressives et les déploiements bleu-vert, qui permettent de gérer les mises à jour d’applications avec un minimum d’interruption.
  • Sondes de santé : le livre aborde la mise en œuvre des sondes de vivacité et de disponibilité afin de surveiller la santé des applications et de veiller à ce que seules les instances en bon état reçoivent du trafic.

Comment Kubernetes Patterns, 2e édition définit-il un Job et sa fonction ?

  • Définition d’un Job de traitement par lots : un Job gère l’exécution de Pods jusqu’à ce qu’un nombre spécifié d’entre eux se termine correctement. Il est conçu pour les tâches finies qui doivent s’achever de manière fiable.
  • Fiabilité et évolutivité : il veille à ce que les tâches s’exécutent jusqu’à leur terme en redémarrant automatiquement les Pods au besoin. Il convient au traitement des données et aux tâches par lots.
  • Exécution parallèle : les Jobs peuvent exécuter plusieurs Pods en parallèle, ce qui permet de traiter efficacement des tâches divisées en unités plus petites et indépendantes.

Quelle est l’importance du modèle DaemonSet dans Kubernetes Patterns, 2e édition ?

  • Des Pods axés sur l’infrastructure : il déploie des Pods sur chaque nœud ou sur certains sous-ensembles de nœuds, afin de fournir des services d’infrastructure essentiels comme la journalisation ou la surveillance.
  • Gestion automatique : il gère automatiquement le cycle de vie des Pods, ce qui simplifie la gestion des services d’infrastructure dans un cluster Kubernetes.
  • Opérations propres aux nœuds : il est utile aux applications qui doivent effectuer des opérations propres à un nœud, comme accéder au stockage local ou surveiller l’état du nœud.

Comment Kubernetes Patterns, 2e édition explique-t-il le modèle de service singleton ?

  • Une seule instance active : ce modèle garantit qu’une seule instance d’un service est active, ce qui est essentiel pour des tâches comme les tâches planifiées ou le traitement de messages.
  • Haute disponibilité : il maintient une seule instance active tout en mettant l’accent sur la haute disponibilité au moyen de contrôleurs comme les StatefulSets ou les ReplicaSets.
  • Découverte de services : il utilise des Services sans tête pour fournir des identités réseau stables et garantir un accès cohérent au service singleton.

Quels sont les modèles avancés présentés dans Kubernetes Patterns, 2e édition ?

  • Opérateurs : ils étendent les fonctionnalités de Kubernetes en gérant des applications complexes à l’aide de contrôleurs personnalisés et en automatisant leur déploiement et leur mise à l’échelle.
  • Mise à l’échelle élastique : le livre aborde les stratégies de mise à l’échelle horizontale et verticale, et des fonctionnalités comme l’autoscaling horizontal des Pods pour ajuster dynamiquement les ressources.
  • Création d’images : ce modèle porte sur la création d’images de conteneurs au sein du cluster Kubernetes, ce qui améliore l’efficacité et réduit la complexité.

Qu’est-ce que l’API descendante dans Kubernetes Patterns, 2e édition ?

  • Injection de métadonnées : elle permet à Kubernetes d’injecter les métadonnées du Pod dans les applications sous forme de variables d’environnement ou de fichiers, favorisant ainsi leur capacité à connaître leur propre contexte.
  • Données dynamiques et statiques : elle fournit des données dynamiques comme l’adresse IP du Pod et des données statiques comme les limites de ressources, essentielles à la journalisation et à la surveillance.
  • Des applications indépendantes de Kubernetes : elle permet aux applications de rester indépendantes de Kubernetes, ce qui favorise leur portabilité et leur réutilisabilité.

Comment fonctionne le modèle du conteneur d’initialisation dans Kubernetes Patterns, 2e édition ?

  • Séparation des responsabilités : il permet de séparer les tâches d’initialisation des conteneurs principaux de l’application et de gérer indépendamment des tâches comme la configuration des permissions.
  • Exécution séquentielle : les conteneurs d’initialisation s’exécutent en séquence et chacun doit se terminer avant le démarrage du suivant, ce qui garantit que l’application principale est prête à démarrer.
  • Partage des ressources : ils partagent l’espace de noms réseau et les volumes de stockage avec les conteneurs de l’application, ce qui simplifie la préparation de l’environnement.

Qu’est-ce que le modèle du conteneur auxiliaire dans Kubernetes Patterns, 2e édition ?

  • Extension des fonctionnalités : il consiste à ajouter un conteneur secondaire à un Pod pour améliorer ou étendre les fonctionnalités du conteneur principal.
  • Cas d’usage courants : il sert à la journalisation, à la surveillance ou au proxy de requêtes, permettant à l’application principale de se concentrer sur ses fonctions essentielles.
  • Collaboration entre conteneurs : il facilite le partage de ressources et la communication au sein d’un même Pod, pour des applications efficaces.

Comment fonctionne l’autoscaling horizontal des Pods dans Kubernetes Patterns, 2e édition ?

  • Mise à l’échelle dynamique : il ajuste automatiquement le nombre de réplicas de Pods en fonction de l’utilisation du CPU ou d’autres métriques, afin que les applications puissent gérer des charges variables.
  • Exigences de configuration : il nécessite des demandes de ressources définies et un serveur de métriques opérationnel pour prendre des décisions de mise à l’échelle éclairées.
  • Surveillance continue : il surveille les métriques indiquées et ajuste le nombre de réplicas, afin de maintenir une utilisation des ressources et des performances optimales.

À propos de l'auteur

Bilgin Ibryam est un auteur reconnu et un expert des technologies cloud natives, en particulier de Kubernetes. Il possède une vaste expérience de la mise en œuvre de plateformes cloud natives pour des entreprises, ce qui se reflète dans ses écrits. Le travail d’Ibryam est salué pour sa clarté et sa capacité à simplifier des concepts complexes. Il a coécrit « Kubernetes Patterns » dans le but de créer un ouvrage comparable au livre Design Patterns du Gang of Four, mais consacré à l’orchestration de conteneurs. Son expertise et son approche pratique ont fait de lui une voix respectée au sein de la communauté Kubernetes, où il aide les développeurs et les ingénieurs à mieux comprendre et mettre en œuvre des solutions cloud natives.

Télécharger le PDF

Pour garder le résumé de Kubernetes Patterns, 2e édition pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Kubernetes Patterns, 2e édition sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...