Kubernetes

Un article de Wikipédia, l'encyclopédie libre.
Kubernetes
Description de l'image Kubernetes_logo.svg.
Description de l'image Kubernetes.png.
Informations
Développé par Google et Cloud Native Computing FoundationVoir et modifier les données sur Wikidata
Dernière version 1.30.0 ()[1]Voir et modifier les données sur Wikidata
Dépôt github.com/kubernetes/kubernetesVoir et modifier les données sur Wikidata
Écrit en GoVoir et modifier les données sur Wikidata
Système d'exploitation Linux, Microsoft Windows et macOSVoir et modifier les données sur Wikidata
Type Certification
Orchestrateur de conteneurs (d)Voir et modifier les données sur Wikidata
Licence Licence Apache version 2.0Voir et modifier les données sur Wikidata
Documentation kubernetes.io/docsVoir et modifier les données sur Wikidata
Site web kubernetes.ioVoir et modifier les données sur Wikidata

modifier - modifier le code - voir Wikidata (aide) Consultez la documentation du modèle

Kubernetes (communément appelé « K8s[2] ») est un système open source qui vise à fournir une « plate-forme permettant d'automatiser le déploiement, la montée en charge et la mise en œuvre de conteneurs d'application sur des grappes de serveurs[3] ». Il fonctionne avec toute une série de technologies de conteneurisation, et est souvent utilisé avec Docker. Il a été conçu à l'origine par Google, puis offert à la Cloud Native Computing Foundation.

Usages[modifier | modifier le code]

Les utilisations de l'outil peuvent se répartir ainsi[4] :

Déploiements de conteneurs : automatisation de cette étape, en simplifiant les paramétrages.

Équilibrage de charge : répartition du trafic réseau entre les conteneurs pour équilibrer la charge.

Gestion de l’état : facilitation de la gestion des applications, en assurant que les données restent accessibles même en cas de redémarrage des conteneurs.

Auto-réparation : surveillance temps réel de l’état des applications, avec redémarrage automatique des conteneurs en échec, lancement ou arrêt des services en fonction des politiques définies.

Découverte de services et mise en réseau : attribution des adresses IP aux conteneurs, attribution de noms DNS uniques pour un groupe de conteneurs ....

Monitoring : donne aux administrateurs les informations sur le fonctionnement des conteneurs.

Kubernetes est surtout utile pour la gestion d'un nombre significatif de conteneurs.

Historique[modifier | modifier le code]

Kubernetes (de κυβερνήτης : grec pour « timonier » ou « pilote ») créé par Joe Beda, Brendan Burns et Craig McLuckie[5], rapidement rejoints par d'autres ingénieurs de Google comme Brian Grant et Tim Hockin, est annoncé pour la première fois par Google à la mi-2014[6]. Son développement et son architecture ont été fortement influencés par le système Borg (en) de Google[7],[8]. D'ailleurs, la plupart des contributeurs principaux sont issus du projet Borg. Le nom original de Kubernetes en interne fut Project Seven, en référence au personnage de Star Trek qui est un Borg devenu amical[9] et qui se nomme Seven of Nine. Les sept rayons de la barre du logo de Kubernetes sont un clin d'œil au nom original.

Kubernetes version 1.0 est sorti le [10]. Avec la sortie de la première version de Kubernetes, Google fit un partenariat avec la Fondation Linux pour créer la Cloud Native Computing Foundation (CNCF)[11] et offrit Kubernetes comme technologie de départ.

Kubernetes est également utilisé par RedHat pour son produit OpenShift[12],[13], par CoreOS dans son produit Tectonic, et par Rancher Labs pour sa plateforme de gestion de conteneurs Rancher[14].

Conception[modifier | modifier le code]

Kubernetes définit un jeu d'outils ("primitives") qui, ensemble, fournissent des mécanismes pour déployer, maintenir et mettre à l’échelle des applications. Ces éléments qui composent Kubernetes sont conçus pour être combinés et extensibles et donc permettre de supporter une grande variété de charge de travail. Cette extensibilité est fournie en grande partie par l'API de Kubernetes, qui est utilisée par les composants internes aussi bien que par les extensions et les conteneurs tournant sur Kubernetes[15].

Pods[modifier | modifier le code]

Schéma simplifié de la façon dont Kubernetes utilise la mise en réseau des pods et les services pour résoudre les dépendances réseau.

L’unité de base de l'ordonnancement dans Kubernetes est appelée « pod ». C'est une vue abstraite de composants conteneurisés. Un pod consiste en un ou plusieurs conteneurs qui ont la garantie d'être co-localisés sur une machine hôte et peuvent en partager les ressources[15]. Chaque pod dans Kubernetes possède une adresse IP unique (à l'intérieur du cluster), qui permet aux applications d'utiliser les ports de la machine sans risque de conflit[16]. Un pod peut définir un volume, comme un répertoire sur un disque local ou sur le réseau, et l'exposer aux conteneurs de ce pod[17]. Les pods peuvent être gérés manuellement au travers de l'API de Kubernetes. Leur gestion peut également être déléguée à un contrôleur[15].

Les pods sont rattachés au nœud[Quoi ?] qui les déploie jusqu’à leur expiration ou leur suppression. Si le nœud est défaillant, de nouveaux pods possédant les mêmes propriétés que les précédents seront déployés sur d’autres nœuds disponibles[18].

Labels et selectors[modifier | modifier le code]

Kubernetes permet à des clients (utilisateurs et composants internes) d'attacher des paires clés-valeurs appelées « labels » à n'importe quel objet d'API dans le système, par exemple les pods et les nodes. Par correspondance, les « label selectors » sont des interrogations faites sur les labels en lien avec des objets[15].

Labels et selectors constituent le premier mécanisme de groupement dans Kubernetes, et sont utilisés pour déterminer les composants sur lesquels appliquer une opération[19].

Par exemple, si les Pods d'une application ont des labels pour un système tier ("frontend", "backend", par exemple) et une release_track ("preproduction", "production", par exemple), alors une opération sur tous les nodes "backend" et "preproduction" peuvent utiliser un label selector comme suit[20] :

tier=backend AND release_track=preproduction

Contrôleurs[modifier | modifier le code]

Un contrôleur est une boucle d'arbitrage qui pilote l'état courant d'un cluster vers son état désiré[21]. Il effectue cette action en gérant un ensemble de pods. Un des types de contrôleur est appelé "contrôleur de réplication”, il gère la réplication et la mise à l'échelle en lançant un nombre spécifique de copies d'un pod sur un cluster. Il gère également la création de pods de remplacement si le nœud sous-jacent est en défaut[21]. Deux des contrôleurs qui font partie du cœur de système de Kubernetes sont : le “DaemonSet Controller” pour lancer un seul pod sur chaque machine (ou un sous-ensemble de machine), ainsi que le “Job Controller” pour lancer des pods qui ont une fin déterminée (par exemple des scripts)[22]. L'ensemble des pods qu'un contrôleur gère est déterminé par des labels selectors qui font partie de la définition du contrôleur[20].

Services[modifier | modifier le code]

Un service Kubernetes est un groupe de pods travaillant ensemble, par exemple, une couche dans une application multi-couches. L'ensemble des pods qui constituent un service sont définis par un label selector[15]. Kubernetes fournit un service de découverte et de routage en assignant une adresse IP et un nom de domaine à un service, et équilibre la charge du trafic en utilisant le round-robin des connexions réseaux de cette adresse sur l'ensemble des pods correspondant au sélecteur (même lorsqu'en cas de défaut, les pods changent de machines)[16]. Par défaut, un service est exposé à l'intérieur d'un cluster (ex: les pods de backend peuvent être groupés dans un service, avec les requêtes des pods de frontend load balancées vers les backend), mais un service peut également être exposé à l'extérieur d'un cluster (par exemple pour que les clients puissent joindre les pods de frontend)[23].

Architecture[modifier | modifier le code]

Diagramme d'architecture de Kubernetes

Kubernetes suit l'architecture maître/esclave. Les composants de Kubernetes peuvent être divisés entre ceux qui gèrent un nœud individuel et ceux qui font partie du plan de contrôle[15],[24].

Plan de contrôle Kubernetes[modifier | modifier le code]

Le maître Kubernetes est l'unité de contrôle principale qui gère la charge de travail et dirige les communications dans le système. Le plan de contrôle de Kubernetes consiste en plusieurs composants, chacun ayant son propre processus, qui peuvent s'exécuter sur un seul nœud maître ou sur plusieurs maîtres permettant de créer des clusters haute disponibilité[24]. Les différents composants du plan de contrôle de Kubernetes sont décrits ci-dessous.

etcd[modifier | modifier le code]

etcd[25] est une unité de stockage distribuée persistante et légère de données clé-valeur développée par CoreOS, qui permet de stocker de manière fiable les données de configuration du cluster, représentant l'état du cluster à n'importe quel instant. D'autres composants scrutent les changements dans ce stockage pour aller eux-mêmes vers l'état désiré[24].

serveur d'API[modifier | modifier le code]

Le serveur d'API est un élément clé et sert l'API Kubernetes grâce à JSON via HTTP. Il fournit l'interface interne et externe de Kubernetes[15],[26]. Le serveur d'API gère et valide des requêtes REST et met à jour l'état des objets de l'API dans etcd, permettant ainsi aux clients de configurer la charge de travail et les containers sur les nœuds de travail.

L'ordonnanceur[modifier | modifier le code]

L'ordonnanceur est un composant additionnel permettant de sélectionner quel node devrait faire tourner un pod non ordonnancé en se basant sur la disponibilité des ressources. L'ordonnanceur gère l'utilisation des ressources sur chaque node afin de s'assurer que la charge de travail n'est pas en excès par rapport aux ressources disponibles. Pour accomplir cet objectif, l'ordonnanceur doit connaître les ressources disponibles et celles actuellement assignées sur les serveurs.

Controller manager[modifier | modifier le code]

Le gestionnaire de contrôle (controller manager) est le processus dans lequel s'exécutent les contrôleurs principaux de Kubernetes tels que DaemonSet Controller et le Replication Controller. Les contrôleurs communiquent avec le serveur d'API pour créer, mettre à jour et effacer les ressources qu'ils gèrent (pods, service endpoints, etc.)[26].

Node Kubernetes[modifier | modifier le code]

Le Node aussi appelé nœud, Worker ou Minion est une machine unique (ou une machine virtuelle) où des conteneurs (charges de travail) sont déployés. Chaque node du cluster doit exécuter le programme de conteneurisation (par exemple Docker), ainsi que les composants mentionnés ci-dessous, pour communiquer avec le maître afin de configurer la partie réseau de ces conteneurs.

Kubelet[modifier | modifier le code]

Kubelet est responsable de l'état d'exécution de chaque nœud (c'est-à-dire, d'assurer que tous les conteneurs sur un nœud sont en bonne santé). Il prend en charge le démarrage, l'arrêt, et la maintenance des conteneurs d'applications (organisés en pods) dirigé par le plan de contrôle[15],[27].

Kubelet surveille l'état d'un pod et s'il n'est pas dans l'état voulu, le pod sera redéployé sur le même node. Le statut du node est relayé à intervalle de quelques secondes via messages d’état vers le maître. Dès que le maître détecte un défaut sur un node, le Replication Controller voit ce changement d'état et lance les pods sur d'autres hôtes en bonne santé[réf. nécessaire].

Kube-proxy[modifier | modifier le code]

Le kube-proxy est l’implémentation d'un proxy réseau et d'un répartiteur de charge, il gère le service d'abstraction ainsi que d'autres opérations réseaux[15]. Il est responsable d'effectuer le routage du trafic vers le conteneur approprié en se basant sur l'adresse IP et le numéro de port de la requête entrante.

cAdvisor[modifier | modifier le code]

cAdvisor est un agent qui surveille et récupère les données de consommation des ressources et des performances comme le processeur, la mémoire, ainsi que l'utilisation disque et réseau des conteneurs de chaque node.

Références[modifier | modifier le code]

  1. ↑ « Release 1.30.0 », (consulté le )
  2. ↑ K8s est une abréviation obtenue en remplaçant les 8 lettres "ubernete" par "8"
  3. ↑ (en) « What is Kubernetes? », sur kubernetes.io (consulté le )
  4. ↑ Comprendre Kubernetes, sur GoodTech.info
  5. ↑ (en-US) « Google Made Its Secret Blueprint Public to Boost Its Cloud » (consulté le )
  6. ↑ (en) « Google Open Sources Its Secret Weapon in Cloud Computing », sur Wired (consulté le )
  7. ↑ (en) Abhishek Verma, Luis Pedrosa, Madhukar R. Korupolu, David Oppenheimer, Eric Tune et John Wilkes, « Large-scale cluster management at Google with Borg », Proceedings of the European Conference on Computer Systems (EuroSys),‎ april 21–24, 2015 (lire en ligne)
  8. ↑ (en) « Borg, Omega, and Kubernetes - ACM Queue », sur queue.acm.org (consulté le )
  9. ↑ (en) Sean Michael Kerner, « Early Stage Startup Heptio Aims to Make Kubernetes Friendly », eWeek,‎ (lire en ligne, consulté le )
  10. ↑ (en) « As Kubernetes Hits 1.0, Google Donates Technology To Newly Formed Cloud Native Computing Foundation », sur TechCrunch (consulté le )
  11. ↑ (en) « Cloud Native Computing Foundation »
  12. ↑ (en) « OpenShift v3 Platform Combines Docker, Kubernetes », sur blog.openshift.com (consulté le )
  13. ↑ (en) « Why Red Hat Chose Kubernetes for OpenShift », sur blog.openshift.com (consulté le )
  14. ↑ (en) « Launch a Kubernetes Cloud Cluster with Rancher », sur rancher.com (consulté le )
  15. ↑ a b c d e f g h et i (en) « An Introduction to Kubernetes », sur DigitalOcean (consulté le )
  16. ↑ a et b (en) Jon Langemak, « Kubernetes 101 – Networking », Das Blinken Lichten, (consulté le )
  17. ↑ (en) James Strachan, « Kubernetes for Developers », Medium (publishing platform), (consulté le )
  18. ↑ « Transformez votre Architecture applicative avec Kubernetes », sur Nexworld, (consulté le ).
  19. ↑ (en) Ramit Surana, « Containerizing Docker on Kubernetes », LinkedIn,‎ (lire en ligne, consulté le )
  20. ↑ a et b (en) « Intro: Docker and Kubernetes training - Day 2 », Red Hat, (consulté le )
  21. ↑ a et b (en) « Overview of a Replication Controller », Documentation, CoreOS (consulté le )
  22. ↑ (en) Jake Sanders, « Kubernetes: Exciting Experimental Features »(Archive.org • Wikiwix • Archive.is • Google • Que faire ?), Livewyer, (consulté le )
  23. ↑ (en) Jon Langemak, « Kubernetes 101 – External Access Into The Cluster », Das Blinken Lichten, (consulté le )
  24. ↑ a b et c (en) « Kubernetes Infrastructure », sur OpenShift Community Documentation, OpenShift (consulté le )
  25. ↑ « Etcd-io/etcd », sur GitHub (consulté le ).
  26. ↑ a et b (en) Kamal Marhubi, « Kubernetes from the ground up: API server », kamalmarhubi.com, (consulté le )
  27. ↑ (en) Kamal Marhubi, « What [..] is a Kubelet? », kamalmarhubi.com, (consulté le )
(en) Cet article est partiellement ou en totalité issu de l’article de Wikipédia en anglais intitulé « Kubernetes » (voir la liste des auteurs).

Liens externes[modifier | modifier le code]

v · m
Hyperviseur
Isolateur
Noyau en espace utilisateur
Machine virtuelle et/ou émulateur
Autre
Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Kubernetes&oldid=214035231 ».