Kubernetes : à quoi sert cet outil ?

Les conteneurs ont radicalement changé le développement logiciel, mais aussi d’autres domaines informatiques. Grâce à cette nouvelle technologie, les logiciels sont exécutés dans un environnement virtuel conçu spécialement à cet effet. Tout ce dont l’application a besoin est situé dans le conteneur et y reste de façon fiable et sécurisée. Plusieurs instances peuvent se dérouler en parallèle.

Un outil est toutefois nécessaire pour pouvoir gérer facilement de tels conteneurs, car il est rare que l’on travaille avec un seul conteneur. Kubernetes (également connu sous le nom de « K8s ») est un outil de gestion de conteneurs pouvant gérer une grande quantité de conteneurs.

Bien que Kubernetes n’ait que quelques années d’existence, il a déjà bonne réputation. Ceci est probablement dû à son lien avec le géant du numérique Google. L’entreprise a en effet lancé Kubernetes et plusieurs employés de Google ont travaillé sur ce projet open source ; cependant, de nombreux développeurs ne faisant pas partie de Google ont également travaillé sur le logiciel. La première version de Kubernetes a finalement vu le jour en 2015. Cet outil est aujourd’hui compatible avec de nombreuses plateformes Cloud telles qu’Azure ou AWS sur lesquelles il peut être utilisé.

Mais ce n’était pas l’objectif au départ. Kubernetes reposait à l’origine sur les systèmes de Google Borg et Omega permettant de gérer les clusters en interne. À l’époque, personne n’avait encore imaginé d’applications virtuelles sur le Cloud. Il fut ensuite décidé de publier une version open source et de rendre public le développement de Kubernetes.

Kubernetes est codé dans le langage de programmation Go développé par Google et vise aussi bien une utilisation sur le Cloud que sur les ordinateurs locaux ou les centres de calcul On-Premise. Son orientation Cloud se manifeste également dans la suite du développement du projet : sous l’égide de la Cloud Native Computing Foundation, Google continue aujourd’hui de faire progresser ce projet open source avec l’aide de quelques autres entreprises et d’une très vaste communauté.

Kubernetes est un système de gestion de conteneurs. Le but du logiciel n’est donc pas de créer les conteneurs, simplement de les gérer. Pour y parvenir, Kubernetes a recours à l’automatisation des processus. Les développeurs peuvent ainsi procéder plus facilement aux tests, à la maintenance ou à la publication des applications. L’architecture Kubernetes comporte une hiérarchie claire :

• Conteneur : un conteneur contient des applications et des environnements logiciels.
• Pod : dans l’architecture Kubernetes, cette unité regroupe des conteneurs devant travailler ensemble pour une application.
• Node : un ou plusieurs pods s’exécutent sur un node (nœud) pouvant être à la fois une machine virtuelle ou physique.
• Cluster : dans Kubernetes, plusieurs nodes sont réunis en un cluster.

L’architecture Kubernetes est de plus basée sur le principe maître/esclave. Les nodes décrits sont utilisés comme esclaves et constituent donc les parties contrôlées du système. Ils sont soumis à la gestion et au contrôle effectués par le maître Kubernetes.

La répartition des pods sur des nodes fait par exemple partie des tâches d’un maître. Une surveillance permanente permet également au maître d’intervenir dès qu’un node tombe en panne et de le doubler directement pour compenser la défaillance. L’état actuel est toujours comparé à un état cible et adapté en cas de besoin. Les processus de ce type sont effectués automatiquement. Le maître constitue toutefois également le point d’accès pour les administrateurs. Il permet à ces derniers de gérer les conteneurs.

Le maître et les nodes ont une structure spécifique.

L’esclave (également appelé « minion ») est un serveur physique ou virtuel sur lequel un ou plusieurs conteneurs sont actifs. Le node dispose d’un environnement d’exécution pour les conteneurs. Par ailleurs, le Kubelet, une composante permettant la communication avec le maître, est actif. Cette composante procède également au démarrage et à l’arrêt des conteneurs. cAdvisor est un service enregistrant l’utilisation des ressources pour le Kubelet ce qui constitue un point intéressant pour les analyses. On trouve également le Kube-proxy permettant au système de lancer la répartition de charge, mais aussi les connexions réseau via TCP ou d’autres protocoles.

Le maître est également un serveur. Pour assurer le contrôle et la surveillance des nodes, le gestionnaire de contrôle est exécuté sur le maître. Cette composante réunit à son tour plusieurs processus :

• Le Node Controller surveille les nodes et réagit lorsqu’ils sont en panne.
• Le Replication Controller veille à ce que le nombre souhaité de pods soit toujours actif simultanément.
• Le Endpoints Controller prend en charge l’objet Endpoint responsable de la connexion des services et des pods.
• Les Service Account & Token Controller gèrent l’espace de nom et créent des jetons d’accès API.

Une base de données intitulée etcd est exécutée en plus du gestionnaire de contrôle. La configuration du cluster sous la responsabilité du maître est enregistrée dans cette base de données Key Value. La composante Scheduler permet au maître de procéder à l’automatisation de la répartition des pods sur les nodes. La connexion avec le node fonctionne par le biais du serveur API intégré au maître. Celui-ci met une interface REST à disposition et échange les informations avec le cluster via JSON. Il est ainsi possible d’accéder aux différents controllers sur les nodes.

Inutile de se demander s’il vaut mieux choisir Kubernetes ou Docker, car cette question n’a pas lieu d’être. Les deux programmes sont utilisés conjointement. Dans le cas de Kubernetes, la composition et l’exécution du conteneur sont également assurées par Docker (ou une autre plateforme de conteneurs comme rkt). Kubernetes accède à ces conteneurs et assure la gestion ou l’automatisation des processus. Kubernetes n’est pas en mesure d’assurer seul la création des conteneurs.

Kubernetes entre davantage en concurrence avec Docker Swarm, un outil de gestion proposé par le fabricant de Docker. À l’instar de Kubernetes, cet outil travaille également avec des clusters et offre des fonctionnalités similaires.

Dans le développement logiciel, Kubernetes joue aujourd’hui un rôle essentiel, en particulier pour les projets agiles. La gestion des conteneurs facilite le cycle de développement, de test et de déploiement (ainsi que toutes les autres étapes intermédiaires). Kubernetes permet de déplacer facilement des conteneurs d’un niveau à l’autre et ainsi d’automatiser de nombreuses étapes de travail.

L’évolutivité est un facteur essentiel, en particulier en cas de location d’espaces de stockage externes sur le cloud : Kubernetes peut exploiter parfaitement les ressources afin de limiter les coûts. Au lieu de laisser tourner des machines inutilisées, Kubernetes peut libérer ces ressources et les utiliser pour d’autres tâches ou simplement ne pas les utiliser afin d’économiser des coûts. Grâce à l’autoscaling, Kubernetes veille à ne pas consommer plus de ressources que nécessaire. Mais une évolutivité rapide est également essentielle dans l’autre sens : lorsque l’on publie un logiciel pour la première fois, il est parfois difficile d’estimer correctement quelle sera l’affluence. Kubernetes peut rapidement fournir des instances supplémentaires pour que le système ne s’effondre pas en cas de demande extrêmement élevée.

L’avantage de Kubernetes réside également dans le fait qu’il permet d’associer sans difficulté plusieurs plateformes. Il est par exemple possible d’utiliser la solution dans un Cloud hybride. Le système est alors situé en partie sur des serveurs locaux propres et en partie dans un centre de calcul distant, à savoir le Cloud. Cette possibilité augmente à nouveau l’évolutivité : si des ressources supplémentaires sont nécessaires, il est généralement possible de les réserver rapidement et facilement auprès du fournisseur de Cloud.

Enfin, Kubernetes aide également les développeurs à garder une vue d’ensemble. Chaque conteneur est clairement identifié et permet d’obtenir des informations sur le statut de chaque instance. Kubernetes intègre également un contrôle de version. Il est donc possible de suivre les mises à jour a posteriori. En général, la publication des mises à jour est l’un des principaux avantages du système : de nouvelles versions peuvent être déployées de façon à ce qu’il n’y ait aucun temps d’arrêt. Pour ce faire, les pods sont modifiés progressivement plutôt qu’en une seule fois. Ceci s’applique à la version d’essai interne et à la publication de nouvelles versions pour les utilisateurs finaux.

La configuration autonome de nombreux aspects de la gestion par Kubernetes permet d’éviter un grand nombre de pièges pendant le travail. C’est la raison pour laquelle Kubernetes est considéré de manière générale comme un système sûr : les pannes sont peu fréquentes et si un pod ne fonctionne pas comme prévu, le maître Kubernetes en a directement connaissance et peut remplacer le pod défaillant.