Kubernetes est un logiciel open source qui automatise le déploiement, la gestion et la mise à l’échelle des applications conteneurisées. Il orchestre les clusters de machines virtuelles, planifie les conteneurs et assure la réparation automatique, l’équilibrage de charge et la portabilité entre les environnements.
Kubernetes est un logiciel open source utilisé par DevOps pour déployer, gérer et faire évoluer les conteneurs sur un cluster. Docker—est une autre technologie—open source qui est le format de fichier conteneur par défaut couramment utilisé conjointement avec Kubernetes.
Les conteneurs regroupent une application avec ses dépendances et sa configuration afin qu'elle puisse s'exécuter de manière cohérente dans différents environnements. À mesure qu’une application évolue, vous pouvez exécuter de nombreux conteneurs sur de nombreux serveurs—et la coordination de tout cela manuellement devient compliquée. Kubernetes résout cette complexité avec une API open source et un système de contrôle qui décide de ce qui doit s’exécuter où et la maintient en cours d’exécution.
Kubernetes orchestre les clusters de machines virtuelles et planifie l'exécution des conteneurs en fonction des ressources de calcul disponibles et des besoins en ressources de chaque conteneur.
Kubernetes gère la découverte des services et l'équilibrage de charge afin que le trafic puisse être acheminé vers les bons pods, même si les pods changent au fil du temps.
Kubernetes met à l’échelle les charges de travail en fonction de l’utilisation du calcul et de l’état souhaité que vous définissez.
Kubernetes vérifie l’intégrité des ressources et peut redémarrer ou répliquer des conteneurs en cas de problèmes. Il redémarre ou remplace les conteneurs défaillants et conserve le trafic jusqu’à ce que les charges de travail soient prêtes.
Kubernetes prend en charge les modèles de déploiement pour l’exécution d’applications, y compris les déploiements automatisés et les restaurations en fonction de l’état souhaité que vous décrivez.
Kubernetes fournit la gestion des secrets et de la configuration pour les informations sensibles telles que les mots de passe ou les jetons.
Kubernetes peut monter les systèmes de stockage que vous choisissez (par exemple, le stockage local ou les options de nuage public), en fonction du modèle d’orchestration de stockage Kubernetes’ .
Kubernetes repose sur les ressources d’objets—API que vous déclarez et gérez. Voici quelques-uns des éléments suivants :
Pod : l'unité de base qui gère un ou plusieurs conteneurs.
Service : un moyen stable d'exposer une application et d'acheminer le trafic vers des pods changeants.
Déploiement : un moyen de décrire l'état d'une application souhaitée et de la mettre à jour au fil du temps (souvent lié aux déploiements et aux restaurations).
Nœud : machine du cluster sur laquelle s'exécutent les pods.
Plan de contrôle : composants qui gèrent l’état du cluster et les décisions de planification.
Vous déclarez l'état souhaité pour votre application (ce qui doit s'exécuter, combien de copies, les besoins en ressources).
Le plan de contrôle enregistre et agit sur cette requête via l’API Kubernetes et le magasin de stockage.
Le planificateur place les pods sur les nœuds disposant de ressources suffisantes.
Les composants de nœud exécutent la charge de travail.
Les contrôleurs se rapprochent en permanence afin que l’état réel corresponde à la mise à l’échelle de l’état—souhaité, au remplacement et à la mise à jour des charges de travail en fonction des besoins.
Un cluster Kubernetes est généralement décrit en deux parties : un plan de contrôle qui gère le cluster et des nœuds de travail qui exécutent vos charges de travail.
Ces composants gèrent l’état global du cluster :
kube-apiserver : expose l'API HTTP de Kubernetes (la porte d'entrée pour les requêtes).
etcd : un système de stockage clé-valeur cohérent et hautement disponible pour les données de cluster.
kube-scheduler : trouve les pods qui nécessitent un placement et les assigne à un nœud.
kube-controller-manager : exécute des contrôleurs qui rapprochent l’état réel de l’état souhaité.
cloud-controller-manager : (facultatif) : connecte Kubernetes à la logique de contrôle spécifique au fournisseur de nuage.
Chaque nœud de travail exécute un logiciel qui gère les pods et les règles de mise en réseau :
kubelet : garantit que les pods s'exécutent sur le nœud, y compris leurs conteneurs.
kube-proxy (facultatif) : Maintient les règles réseau pour prendre en charge les services.
environnement d'exécution de conteneurs : Exécute les conteneurs sur le nœud.
Kubernetes ne planifie pas les conteneurs individuels directement dans l'abstrait. Il regroupe un ou plusieurs conteneurs dans un Pod, qui devient l'unité opérationnelle de base. Les pods s'adaptent ensuite à la hausse ou à la baisse pour atteindre l'état souhaité que vous avez défini.
Dans la pratique, cela signifie :
Vous décrivez l’application que vous souhaitez exécuter.
Kubernetes planifie les pods sur des machines disposant de ressources de calcul disponibles.
Les contrôleurs permettent au cluster de passer à l’état demandé.
Les pods peuvent aller et venir, c'est pourquoi Kubernetes fournit des primitives (des éléments de base que vous combinez pour décrire et exécuter des applications sur un cluster) qui offrent des moyens stables d'atteindre les charges de travail.
Chaque pod obtient sa propre adresse IP à l’échelle du cluster, et les pods peuvent communiquer entre les nœuds sans traduction d’adresses réseau (NAT) dans le modèle réseau Kubernetes.
L’API de service fournit une adresse IP stable ou un nom d’hôte pour un ensemble de pods principaux, même lorsque les pods individuels changent au fil du temps.
Kubernetes gère les objets de segment de point de terminaison pour suivre les pods qui sauvegardent actuellement un service.
Pour exposer des services à des clients en dehors du cluster, Kubernetes prend en charge l’API de passerelle (et l’entrée comme son prédécesseur).
Certains environnements peuvent exposer un service en externe à l’aide du type de service LoadBalancer.
Les clusters Kubernetes incluent souvent des modules complémentaires qui étendent les fonctionnalités au-delà des composants principaux. Exemples :
DNS pour la résolution de noms à l’échelle du cluster.
Interface utilisateur Web (tableau de bord) pour la gestion du cluster.
Surveillance des ressources des conteneurs pour la collecte de métriques.
Journalisation au niveau du cluster pour centraliser la collecte des journaux.
Kubernetes exécute des applications conteneurisées sur un cluster de machines et les conserve dans l’état que vous décrivez. Pour ce faire, il place le travail sur les machines appropriées, route le trafic vers les bons emplacements et surveille les défaillances et les modifications.
La plupart des charges de travail Kubernetes démarrent avec un « état souhaité » déclaré (ce qui doit être exécuté, combien de copies et comment elles doivent être exposées). Kubernetes repose sur la configuration déclarative et l’automatisation.
Kubernetes planifie les conteneurs sur les machines du cluster en fonction des ressources de calcul disponibles et de ce dont chaque conteneur a besoin. Les conteneurs s’exécutent à l’intérieur de Pods, qui est l’unité que Kubernetes place sur une machine.
Les contrôleurs surveillent le cluster et travaillent pour rapprocher l’état actuel de l’état souhaité, en utilisant le serveur d’API pour apporter des modifications.
La planification est l’endroit “où cette exécution doit-elle s’exécuter ?” décision.
Kubernetes regroupe les conteneurs en pods, puis les place sur les ordinateurs.
Le kube-scheduler recherche les pods qui ne sont pas encore attribués et sélectionne un nœud pour eux.
Sur chaque nœud, kubelet s'assure que les Pods sont en cours d'exécution (y compris leurs conteneurs).
Les conteneurs et les pods peuvent être créés, déplacés ou remplacés, de sorte que les applications ont besoin de méthodes stables pour se trouver.
Kubernetes gère la découverte de service et utilise l’équilibrage de charge afin que le trafic puisse être routé même lorsque les pods changent au fil du temps.
L’API service fournit une adresse IP stable ou un nom d’hôte pour un service soutenu par un ou plusieurs pods, et Kubernetes suit les pods de stockage via des objets EndpointSlice.
Lorsque les pods derrière un service changent, le routage du service s’adapte afin que le trafic continue d’atteindre les back-ends actuels.
Kubernetes peut mettre à l’échelle les charges de travail vers l’état que vous définissez, y compris la mise à l’échelle en fonction de l’utilisation du calcul.
Les idées courantes de mise à l’échelle sont les suivantes :
Plus de répliques (plus de modules) pour répondre à la requête accrue.
Moins de répliques lorsque la requête diminue.
Suivi des ressources afin que les décisions de placement reflètent les besoins en CPU et en mémoire.
Cela revient au “modèle d’état” souhaité : vous spécifiez la cible et les contrôleurs continuent à travailler dessus.
Kubernetes inclut des comportements de réparation automatique qui visent à maintenir l’intégrité et la disponibilité de la charge de travail. Ces fonctionnalités sont les suivantes :
Redémarrage des conteneurs ayant échoué (redémarrages au niveau du conteneur).
Remplacement des pods défaillants pour conserver le nombre de répliques demandé (remplacement de réplique).
Reprogrammation des charges de travail lorsque des nœuds deviennent indisponibles.
Suppression des pods défaillants des points de terminaison de service afin que le trafic soit dirigé uniquement vers les pods sains (équilibrage de charge pour les services).
La réparation automatique vérifie l’intégrité du conteneur et redémarre ou les réplique en cas de problèmes.
Les indicateurs de performance clés (indicateurs de performance clés ou métriques) sont utilisés pour comprendre l’intégrité du cluster et le comportement de la charge de travail.
Les composants système Kubernetes émettent des métriques (format Prometheus) utiles pour les tableaux de bord et les alertes.
Les métriques sont généralement disponibles sur le point de terminaison HTTP /metrics d'un composant, y compris des composants tels que kube-apiserver, kube-scheduler, kubelet, kube-proxy et kube-controller-manager.
Signaux d’intégrité du cluster (métriques au niveau des composants et modèles d’erreur)
Stabilité de la charge de travail (par exemple, redémarrages ou remplacements fréquents)
Pression sur la capacité (allocation des ressources par rapport à la requête, liée aux décisions de mise à l'échelle)
La surveillance offre aux équipes une vue plus complète des ressources de cluster, de l’API Kubernetes, des conteneurs et des journaux, ce qui raccourcit la boucle de commentaires entre les problèmes et les correctifs.
Kubernetes est souvent sélectionné lorsque les équipes ont besoin d’un moyen cohérent d’exécuter de nombreux conteneurs sur de nombreux ordinateurs, tout en conservant le routage, la mise à l’échelle et la récupération du trafic gérés par la plateforme.
Kubernetes peut mettre à l’échelle les charges de travail, ce qui signifie les augmenter ou les réduire à mesure que la requête change, vers un état cible et peut être mis à l’échelle en fonction de l’utilisation du calcul.
Applications Web à trafic variable (campagnes, pics saisonniers) : ajustez les réplicas en fonction des changements de charge.
Traitement par lots ou événementiel : ajoutez de la capacité pour les rafales, puis réduisez-la.
Microservices : faites évoluer des services spécifiques sans faire évoluer l'ensemble de l'application.
Kubernetes prend en charge l’empaquetage automatique des compartiments, qui place des conteneurs sur des nœuds en fonction du processeur et de la mémoire, afin d’optimiser l’utilisation des ressources disponibles. Il assure également le suivi de l'allocation des ressources lors de la gestion des charges de travail.
Clusters partagés pour plusieurs équipes : réduisez le gaspillage de capacité en plaçant les charges de travail là où les ressources sont disponibles.
Clusters de charges de travail mixtes (services plus tâches) : gardez les nœuds occupés sans placement manuel.
Kubernetes peut exposer des charges de travail à l’aide d’un DNS ou d’une adresse IP, et il peut distribuer le trafic réseau pour maintenir la stabilité des déploiements. Il gère également la découverte des services et intègre l’équilibrage de charge à mesure que les charges de travail changent.
Communication par microservices : Les services se retrouvent grâce à des noms stables tandis que les Pods changent.
API internes derrière un point de terminaison stable : acheminez le trafic uniquement vers les backends actuels.
Kubernetes est conçu pour remplacer les conteneurs défaillants, replanifier les charges de travail lorsque les nœuds deviennent indisponibles et conserver l’état souhaité. Par exemple, les redémarrages de conteneurs, le remplacement de réplica et la suppression de pods défectueux des points de terminaison de service afin que le trafic ne soit dirigé que vers des pods sains.
Services permanents : redémarrez ou remplacez les instances défaillantes sans intervention manuelle.
Clusters avec une désabonnement fréquent des nœuds : replanifiez les charges de travail lorsqu'un nœud tombe en panne.
Services derrière un service : arrêtez d'acheminer le trafic vers des pods défectueux.
Kubernetes prend en charge les déploiements automatisés et les restaurations. Vous décrivez l’état souhaité et Kubernetes déplace l’état réel vers celui-ci à une vitesse contrôlée.
Mises à jour fréquentes de l'application : effectuez les modifications progressivement, puis revenez si nécessaire.
Teams proposant plusieurs services : veillez à ce que les mécanismes de publication soient cohérents dans toutes les applications.
Les applications conteneurisées sont distinctes de l'infrastructure, et Kubernetes permet de les déplacer des machines locales vers la production dans des environnements sur site, serverless, nuage hybride et multicloud tout en préservant la cohérence entre les environnements.
Parité développement/test/production : conservez le même modèle de packaging et de planification dans tous les environnements.
Déploiements hybrides : exécutez des parties d'un système sur site et des parties dans le nuage avec la même approche d'orchestration.
Kubernetes fournit un moyen commun d'exécuter des charges de travail conteneurisées avec une configuration déclarative et une automatisation du machine learning, soutenu par un ensemble vaste et croissant d'outils et de support communautaire.
À mesure que les équipes créent des systèmes constitués de nombreux services, de charges de travail de courte durée et de mises à jour fréquentes, Kubernetes reste une base pratique, car il se concentre sur les opérations reproductibles :
Opérations cohérentes entre les environnements (conteneurs empaquetés avec des dépendances, s’exécutent de la même façon dans les environnements).
Écosystème large et actif avec des services, un support et des outils largement disponibles.
Extensibilité par le biais de modules complémentaires, de plug-ins et d’un programme de conformité intégrés à la communauté qui garantit la cohérence des API de base entre les versions.
Si vous créez ou exécutez des charges de travail, Service Azure Kubernetes (AKS) vous aide à déployer et à gérer des applications conteneurisées, Azure gérant le plan de contrôle.
Obtenez l'application mobile Azure 
