Comment faire évoluer les conteneurs Docker sur les serveurs à l'aide de Kubernetes - CloudSavvy IT
Agence web » Actualités du digital » Comment faire évoluer les conteneurs Docker sur les serveurs à l’aide de Kubernetes –

Comment faire évoluer les conteneurs Docker sur les serveurs à l’aide de Kubernetes –

Docker est une plate-forme de conteneurisation orientée développeur qui vous permet de conditionner des applications en tant que 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 en l’état présente des défis en production, car son CLI n’est équipé 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 un parc de machines physiques, améliorant ainsi la redondance et la résilience de votre service. Voici comment vous pouvez démarrer votre propre cluster pour faire évoluer vos conteneurs « Docker ».

Principes de base 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 chargé de coordonner (« orchestrer ») les 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.
  • Avion de contrôle – Le plan de contrôle est le composant logiciel du nœud maître. Il intègre plusieurs services, notamment un serveur API, un magasin de configuration et un planificateur de conteneurs.
  • Nœud – Un nœud est une machine qui héberge vos conteneurs. Chaque nœud de calcul exécute un composant Kubernetes appelé Kubelet. Celui-ci reste en contact avec le plan de contrôle, reçoit 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 Pod vous permet d’interagir avec plusieurs conteneurs en cours d’exécution dans l’ensemble.
  • Ensemble de répliques – Les ensembles de réplicas sont responsables de la mise à l’échelle des pods pour garantir qu’un nombre spécifié de réplicas sont disponibles. Si vous demandez trois réplicas d’un pod, le jeu de réplicas 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éplicas. 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 par la plupart des principaux fournisseurs de cloud. Ceux-ci offrent 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 un microk8s join commander. 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éfinition d’un déploiement à l’échelle horizontale

Une application qui s’exécute sur plusieurs serveurs est décrite comme « à l’échelle horizontale ». 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 mise en réseau publiques via un service. Les déploiements par défaut sur une seule instance de pod, mais peuvent être configurés avec plusieurs réplicas.

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 du 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 des ressources suffisantes.

Vous pouvez mettre à jour le nombre de répliques à tout moment. Changer la replicas dans votre manifeste et réappliquez-le à votre cluster. Le planificateur Kubernetes prendra des mesures pour provisionner de nouveaux pods ou mettre fin aux anciens selon les besoins. Si vous mettez à l’échelle 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éplicas vous permet d’utiliser les ressources existantes au sein de votre cluster. À terme, vous pourriez é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 des clusters qui peut créer et détruire Nœuds , modifiant ainsi le nombre de pods pouvant être programmés.

La mise en place de l’auto-scaling est relativement complexe. 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 d’instances de conteneurs sur plusieurs serveurs. Enregistrez vos machines en tant que nœuds ou utilisez un cluster cloud géré, puis créez des déploiements qui ont le replicas jeu de champs. Vous pouvez faire évoluer votre charge de travail en mettant à jour le nombre de réplicas demandé.

Lorsque des changements importants de la demande sont anticipés, utilisez la mise à l’échelle automatique pour augmenter la capacité de manière dynamique. 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épliques.

Lorsque vous faites évoluer 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 sur 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é.