Les premiers pas avec Kubernetes

Qu'est-ce que Kubernetes peut faire pour vous ?

Avec les services web modernes, les utilisateurs s'attendent à ce que les applications soient disponibles 24 heures sur 24, 7 jours sur 7, tandis que les développeurs prévoient de déployer de nouvelles versions de ces applications plusieurs fois par jour. La conteneurisation aide les progiciels à atteindre ces objectifs, en permettant aux applications d'être publiées et mises à jour de manière simple et rapide, sans interruption.   Kubernetes vous aide à vous assurer que ces applications conteneurisées s'exécutent où et quand vous le souhaitez, ainsi qu’à trouver les ressources et les outils dont les applications ont besoin pour travailler.  

Les modules de base de Kubernetes

Créer un cluster Kubernetes

Un cluster Kubernetes est constitué de deux types de ressources : 

• Le maître qui coordonne le cluster ; 
• Les nœuds qui sont les serveurs qui exécutent des applications. 

Chaque nœud est doté d’un Kubelet, l’agent permettant de gérer le nœud et de communiquer avec le maître Kubernetes. Le nœud doit également disposer d'outils permettant de gérer les opérations de conteneur, telles que Docker ou rkt. Un cluster Kubernetes qui gère le trafic de production doit comporter au moins trois nœuds.  Lorsque vous déployez des applications sur Kubernetes, vous indiquez au maître de démarrer les conteneurs d'applications. Le maître planifie l'exécution des conteneurs sur les nœuds du cluster. Les nœuds communiquent avec le maître, depuis l'API Kubernetes que le maître expose. Les utilisateurs finaux peuvent également utiliser l'API Kubernetes directement pour interagir avec le cluster.  Un cluster Kubernetes peut être déployé sur des machines physiques ou virtuelles. Pour démarrer avec le développement de Kubernetes, vous pouvez utiliser Minikube. Minikube est une implémentation Kubernetes légère qui crée une machine virtuelle sur votre machine locale et déploie un cluster simple, contenant un seul nœud. Minikube est disponible pour les systèmes Linux, macOS et Windows.

Déployer une application

Une fois que vous avez un cluster Kubernetes en cours d'exécution, vous pouvez déployer vos applications conteneurisées par-dessus. Pour ce faire, vous créez une configuration de Déploiement (Deployments) Kubernetes. Le déploiement instruit Kubernetes sur la création et le mise-à-jour des instances de votre application. Une fois que vous avez créé un déploiement, le planificateur de Kubernetes (kube-scheduler) planifie les instanciations d'application sur des nœuds du cluster.  Une fois les instances d’application créées, un contrôleur de déploiement Kubernetes surveille en permanence ces instances. Si le nœud hébergeant une instance tombe en panne ou est supprimé, le contrôleur de déploiement remplace l'instance par une instance située sur un autre nœud du cluster. Ceci fournit un mécanisme d'auto-réparation pour faire face aux pannes ou à la maintenance de la machine. 

Explorez votre application

Lorsque vous avez créé un déploiement, Kubernetes a créé un pod pour héberger votre instance d'application. Un pod est une abstraction de Kubernetes qui représente un groupe d'un ou plusieurs conteneurs d'application (tels que Docker ou rkt), ainsi que certaines ressources partagées pour ces conteneurs. Ces ressources comprennent : 

• Stockage partagé, sous forme de volumes ; 
• Mise en réseau, en tant qu'adresse IP de cluster unique ; 
• Informations sur la manière d'exécuter chaque conteneur, telles que la version de l'image du conteneur ou les ports spécifiques à utiliser.

Exposer votre application publiquement

Un service dans Kubernetes est une abstraction qui définit un ensemble logique de pods et une politique permettant d'y accéder. Les services permettent un couplage lâche entre les pods dépendants. Un service est défini en utilisant YAML (préféré) ou JSON, comme tous les objets Kubernetes. L'ensemble de pods ciblés par un service est généralement déterminé par un LabelSelector.  Bien que chaque pod ait une adresse IP unique, ces IP ne sont pas exposées en dehors du cluster sans service. Les services permettent à vos applications de recevoir du trafic. Ils peuvent être exposés de différentes manières, en spécifiant un type dans ServiceSpec : 

• ClusterIP (valeur par défaut) : expose le service sur une adresse IP interne du cluster. Ce type rend le service accessible, uniquement à partir du cluster. 
• NodePort : expose le service sur le même port de chaque nœud sélectionné dans le cluster en utilisant NAT. Rend un service accessible de l'extérieur du cluster à l'aide de <NodeIP>: <NodePort>. Sur-ensemble de ClusterIP. 
• LoadBalancer : crée un équilibreur de charge externe dans le cloud actuel (si pris en charge) et attribue une adresse IP externe fixe au service. Sur-ensemble de NodePort. 

• ExternalName : expose le service en utilisant un nom arbitraire (spécifié par externalName dans la spécification) en renvoyant un enregistrement CNAME avec le nom. Aucun proxy n'est utilisé. Ce type nécessite la version 1.7 ou supérieure de kube-dns. 

Mettre à l’échelle votre application

Dans les modules précédents, nous avions créé un déploiement, puis l'avions exposé publiquement via un service. Le déploiement n'a créé qu'un seul pod pour l'exécution de notre application. Lorsque le trafic augmente, nous devrons adapter l'application pour répondre à la demande des utilisateurs.  La mise à l'échelle d'un déploiement garantira la création et la planification de nouveaux pods aux nœuds avec les ressources disponibles. La mise à l'échelle augmentera le nombre de pods au nouvel état souhaité. Kubernetes prend également en charge la mise à l'échelle automatique des pods mais cela sort du cadre de cet article ! La mise à l'échelle à zéro est également possible : elle met fin à tous les pods du déploiement spécifié.  L'exécution de plusieurs instances d'une application nécessitera un moyen de répartir le trafic sur toutes les applications. Les services ont un équilibreur de charge intégré qui répartira le trafic réseau sur tous les pods d'un déploiement exposé. Les services surveilleront en permanence les pods en cours d'exécution à l'aide de points d'extrémité, afin de s'assurer que le trafic n'est envoyé qu'aux pods disponibles.  La mise à l'échelle est réalisée en modifiant le nombre de répliquas dans un déploiement.  Une fois que plusieurs instances d'une application sont en cours d'exécution, vous pouvez effectuer des mises à jour continues, sans interruption.  

Mettre à jour votre application

Les utilisateurs s'attendent à ce que les applications soient disponibles à tout moment et les développeurs à en déployer de nouvelles versions, plusieurs fois par jour. Dans Kubernetes, c’est possible grâce à des mises à jour progressives. Ces dernières permettent à la mise à jour des déploiements de se dérouler sans temps d'arrêt, en mettant à jour de manière incrémentielle les instances Pods avec de nouvelles instances. Les nouveaux pods seront planifiés sur des nœuds avec les ressources disponibles.  Dans le module précédent, nous avions dimensionné notre application pour exécuter plusieurs instances. Ceci est une condition nécessaire pour effectuer des mises à jour sans affecter la disponibilité des applications. Par défaut, le nombre maximal de pods pouvant être indisponibles lors de la mise à jour et le nombre maximal de nouveaux pods pouvant être créés est de 1. Les deux options peuvent être configurées avec des nombres ou des pourcentages (de pods). Dans Kubernetes, les mises à jour sont versionnées et toute mise à jour de déploiement peut être rétablie à la version précédente (stable).  Comme pour l'application Scaling, si un déploiement est exposé publiquement, le service équilibrera le trafic uniquement entre les pods disponibles lors de la mise à jour. Un pod disponible est une instance disponible pour les utilisateurs de l'application.  Les mises à jour progressives permettent les actions suivantes : 

• Promouvoir une application d'un environnement à un autre (via les mises à jour d'image de conteneur) ;
• Revenir aux versions précédentes ;
• Intégration continue et livraison continue des applications avec zéro temps d'arrêt. 

Conclusion

Kubernetes est un système open source qui vise à fournir une « plateforme permettant d'automatiser le déploiement, la montée en charge et la mise en œuvre de conteneurs d'application sur des clusters de serveurs ». 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.