Docker est une plate-forme de conteneurisation orientée développeur qui vous permet de conditionner des applications sous forme de conteneurs autonomes. Ils s'exécuteront partout où un environnement d'exécution de conteneur compatible est disponible.
La popularité de Docker l'a rendu presque synonyme de conteneurs, mais ce n'est pas la technologie parfaite pour tous les cas d'utilisation. L'utilisation de Docker tel quel présente des défis en production, car sa CLI n'est équipée que pour gérer des conteneurs individuels.
Kubernetes est une plate-forme d'orchestration qui gère des piles de conteneurs et les fait évoluer sur plusieurs serveurs. Vous pouvez déployer sur une flotte de machines physiques, améliorant ainsi la redondance et la résilience de votre service. Voici comment démarrer votre propre cluster pour faire évoluer vos conteneurs "Docker".
Bases de Kubernetes
Reconnaître certains termes clés de Kubernetes vous aidera à comprendre les différences par rapport à Docker. Le dictionnaire Kubernetes décrit des dizaines de ressources que vous pouvez ajouter à votre cluster. Seuls les composants qui contrôlent la planification des conteneurs sont pertinents pour cet article.
À un niveau élevé, une installation Kubernetes est un cluster de « nœuds ». Les nœuds sont des machines physiques indépendantes qui hébergent vos charges de travail. Un seul nœud « maître » est responsable de la coordination (« orchestration ») des opérations du cluster en « planifiant » de nouveaux conteneurs vers le nœud de travail le plus approprié.
Voici quelques termes critiques :
- Maître – Le nœud maître exploite le cluster. Il s'agit de la machine sur laquelle vous installez Kubernetes. Il exécute le plan de contrôle et délègue l'hébergement des applications conteneurisées aux nœuds de travail.
- Plan de contrôle – Le plan de contrôle est le composant logiciel du nœud maître. Il intègre plusieurs services, dont un serveur d'API, un magasin de configuration et un planificateur de conteneurs.
- Nœud – Un nœud est une machine qui héberge vos conteneurs. Chaque travailleur exécute un composant Kubernetes appelé Kubelet. Celui-ci reste en contact avec le plan de contrôle, recevant des instructions de planification sur lesquelles il agit pour provisionner de nouveaux conteneurs.
- Cosse – Un pod est la plus petite unité de calcul d'un cluster Kubernetes, représentant un groupe d'instances de conteneur. L'abstraction de pod vous permet d'interagir avec plusieurs conteneurs en cours d'exécution de manière agrégée.
- Ensemble de répliques – Les ensembles de répliques sont responsables de la mise à l'échelle des pods pour garantir qu'un nombre spécifié de répliques sont disponibles. Si vous demandez trois répliques d'un Pod, le jeu de répliques garantira que la contrainte de disponibilité est respectée. Les pods sont automatiquement remplacés en cas d'échec, ce qui vous permet d'automatiser la réplication des conteneurs sur les serveurs.
La création d'un cluster évolutif nécessite un nœud maître, au moins deux nœuds de travail et un déploiement qui provisionne plusieurs répliques. Kubernetes sera en mesure de planifier vos pods sur tous les nœuds disponibles, vous offrant ainsi une résilience en cas de panne.
Création de votre cluster
Kubernetes est disponible en tant qu'offre gérée auprès de la plupart des principaux fournisseurs de cloud. Ceux-ci fournissent un moyen en un clic de créer votre plan de contrôle et d'ajouter un nombre variable de nœuds de travail.
Vous pouvez exécuter un cluster sur votre propre matériel à l'aide d'une distribution Kubernetes autonome comme MicroK8s. Vous aurez besoin d'au moins deux machines physiques ou virtuelles isolées si vous souhaitez bénéficier d'une prise en charge de la planification redondante.
Installez MicroK8s sur les deux machines. Désignez un nœud comme maître et utilisez le add-node commande pour démarrer le processus d'enregistrement du nœud :
microk8s add-node
Cela émettra une jointure microk8s join commande. Basculez vers votre nœud secondaire et exécutez la commande. Il rejoindra le premier cluster en tant que nouveau travailleur. Les deux machines sont maintenant prêtes à héberger vos charges de travail conteneurisées.
Définir un déploiement à dimensionnement horizontal
Une application qui s'exécute sur plusieurs serveurs est décrite comme « mise à l'échelle horizontalement ». Il se répand dans plusieurs environnements distincts. La mise à l'échelle verticale d'un système implique l'ajout de ressources à un environnement existant.
Le moyen le plus simple de définir une charge de travail Kubernetes consiste à utiliser un déploiement. Ce type de ressource crée des pods à partir d'une image de conteneur et configure des routes de réseau public via un service. Les déploiements se font par défaut sur une seule instance de pod, mais peuvent être configurés avec plusieurs répliques.
Voici un manifeste de déploiement simple :
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80 Appliquez le manifeste à votre cluster à l'aide de Kubectl :
microk8s kubectl apply -f ./manifest.yaml
Kubernetes créera trois pods, chacun hébergeant un serveur Web NGINX créé à partir de nginx:latest image. Le port 80 est exposé en tant que port de conteneur pour permettre le trafic entrant.
Les pods seront automatiquement distribués sur les nœuds de votre cluster. Un nœud sera éligible pour héberger un pod s'il peut fournir suffisamment de ressources.
Vous pouvez mettre à jour le nombre de répliques à tout moment. Modifier les replicas dans votre manifeste et réappliquez-le à votre cluster. Le planificateur Kubernetes prendra des mesures pour provisionner de nouveaux pods ou résilier les anciens si nécessaire. Si vous mettez à l'échelle les replicas jusqu'à 0, vous pouvez mettre votre application hors ligne sans réellement supprimer le déploiement ou ses ressources associées.
Ajout dynamique de nœuds
La mise à jour du nombre de répliques vous permet d'utiliser les ressources existantes au sein de votre cluster. À terme, vous risquez d'épuiser complètement la capacité de vos nœuds combinés, empêchant ainsi la planification de nouveaux pods. Kubernetes offre une fonction de mise à l'échelle automatique du cluster qui peut créer et détruire des nœuds , modifiant ainsi le nombre de pods pouvant être programmés.
La mise en place de l'auto-scaling est relativement compliquée. Le processus exact dépend de l'environnement d'hébergement de votre cluster. Il nécessite une intégration avec un Cluster Autoscaler capable de se connecter à votre hôte pour détecter les changements de demande. La documentation officielle est disponible pour Google Cloud ; des solutions sont également disponibles auprès d'Amazon EKS et de Microsoft AKS.
La mise à l'échelle automatique fonctionne en maintenant une vérification constante des pods qui ne peuvent pas être planifiés en raison d'une capacité de cluster insuffisante. Il évalue également si les pods planifiés avec succès pourraient réellement être colocalisés avec un nombre de nœuds réduit. L'autoscaler utilise ensuite l'API de votre fournisseur de cloud pour ajouter et supprimer des instances de calcul, en ajustant dynamiquement les ressources de votre cluster. Cela peut avoir un impact sur votre facture car la création d'une nouvelle instance est généralement une opération payante.
Résumé
Kubernetes facilite la distribution des instances de conteneur sur plusieurs serveurs. Enregistrez vos machines en tant que nœuds ou utilisez un cluster cloud géré, puis créez des déploiements contenant les replicas ensemble de champs. Vous pouvez faire évoluer votre charge de travail en mettant à jour le nombre de répliques demandées.
Lorsque des changements importants de la demande sont anticipés, utilisez la mise à l'échelle automatique pour augmenter dynamiquement la capacité. Cette fonctionnalité vous permet de créer de nouveaux nœuds à la volée, en ajoutant des ressources supplémentaires afin que vous puissiez continuer à augmenter votre nombre de réplicas.
Lorsque vous mettez à l'échelle des pods, vous devez vous rappeler qu'une certaine forme de distribution du trafic entrant est également requise. Si vous exposez le port 80, Kubernetes doit pouvoir mapper les requêtes vers le port 80 sur tout des nœuds. Cela fonctionne automatiquement avec les déploiements et les services. Kubernetes crée un équilibreur de charge qui surveille en permanence les pods pour déterminer où le trafic peut être dirigé.