Dimensionnement des charges

La mise à l'échelle de la charge de travail dans Kubernetes est essentielle pour maintenir les performances des applications et l'efficacité des ressources dans les environnements dynamiques. La mise à l'échelle permet de garantir que les applications peuvent gérer différentes charges de travail sans dégrader les performances. Kubernetes permet d'augmenter ou de diminuer automatiquement les ressources en fonction de mesures en temps réel, ce qui permet aux entreprises de réagir rapidement aux changements de trafic. Cette élasticité améliore non seulement l'expérience utilisateur, mais optimise également l'utilisation des ressources, contribuant ainsi à minimiser les coûts associés à des ressources sous-utilisées ou surapprovisionnées.

En outre, une mise à l'échelle efficace de la charge de travail favorise une haute disponibilité, garantissant ainsi la réactivité des applications même pendant les périodes de pointe. La mise à l'échelle de la charge de travail dans Kubernetes permet aux entreprises de mieux utiliser les ressources du cloud en ajustant dynamiquement les capacités pour répondre aux besoins actuels.

Cette section décrit les types suivants de dimensionnement de la charge de travail :

• Autoscaler à nacelle horizontale

• Autoscaleur proportionnel en cluster

• Autoscaler piloté par les événements basé sur Kubernetes

Horizontal Pod Autoscaler

L'Horizontal Pod Autoscaler (HPA) est une fonctionnalité de Kubernetes qui ajuste automatiquement le nombre de répliques de pods dans un déploiement, un contrôleur de réplication ou un ensemble dynamique, en fonction de l'utilisation observée du processeur ou d'autres mesures sélectionnées. Le HPA garantit que les applications peuvent gérer les fluctuations du trafic et des niveaux de charge de travail sans intervention manuelle. Le HPA offre un moyen de préserver des performances optimales tout en utilisant efficacement les ressources disponibles.

Dans les contextes où la demande des utilisateurs peut fluctuer considérablement au fil du temps, les applications Web, les microservices et APIs le HPA sont particulièrement utiles.

L'Autoscaler Horizontal Pod fournit les principales fonctionnalités suivantes :

• Dimensionnement automatique : HPA augmente ou diminue automatiquement le nombre de répliques de pods en réponse à des indicateurs en temps réel, garantissant ainsi que les applications peuvent évoluer pour répondre à la demande des utilisateurs.

• Décisions basées sur des métriques : par défaut, le HPA évolue en fonction de l'utilisation du processeur. Cependant, il peut également utiliser des métriques personnalisées, telles que l'utilisation de la mémoire ou des métriques spécifiques à l'application, ce qui permet d'élaborer des stratégies de dimensionnement plus personnalisées.

• Paramètres configurables : vous pouvez choisir le nombre minimum et maximum de répliques ainsi que les pourcentages d'utilisation souhaités, ce qui vous donne le pouvoir de décider de l'intensité de la mise à l'échelle.

• Intégration à Kubernetes : pour surveiller et modifier les ressources, HPA travaille en tandem avec d'autres éléments de l'écosystème Kubernetes, notamment le serveur de métriques, l'API Kubernetes et les adaptateurs de métriques personnalisés.

• Meilleure utilisation des ressources : le HPA contribue à garantir une utilisation efficace des ressources, à réduire les coûts et à améliorer les performances, en modifiant dynamiquement le nombre de pods.

Autoscaleur proportionnel en cluster

Le Cluster Proportional Autoscaler (CPA) est un composant Kubernetes conçu pour ajuster automatiquement le nombre de répliques de pods dans un cluster en fonction du nombre de nœuds disponibles. Contrairement aux autoscalers traditionnels qui évoluent en fonction des indicateurs d'utilisation des ressources (tels que le processeur et la mémoire), le CPA adapte les charges de travail proportionnellement à la taille du cluster lui-même.

Cette approche est particulièrement utile pour les applications qui doivent maintenir un certain niveau de redondance ou de disponibilité par rapport à la taille du cluster, telles que CoreDNS et d'autres services d'infrastructure. Les principaux cas d'utilisation du CPA sont les suivants :

• Surprovisionnement

• Élargir les services de plateforme de base

• Augmentez les charges de travail car le CPA ne nécessite pas de serveur de métriques ni d'adaptateur Prometheus

En automatisant le processus de dimensionnement, le CPA aide les entreprises à maintenir une répartition équilibrée de la charge de travail, à accroître l'efficacité des ressources et à s'assurer que les applications sont correctement provisionnées pour répondre à la demande des utilisateurs.

L'autoscaler proportionnel en cluster fournit les principales fonctionnalités suivantes :

• Dimensionnement basé sur les nœuds : le CPA adapte les répliques en fonction du nombre de nœuds de cluster pouvant être planifiés, ce qui permet aux applications de s'étendre ou de se contracter proportionnellement à la taille du cluster.

• Ajustement proportionnel : pour garantir que l'application peut évoluer en fonction de l'évolution de la taille du cluster, l'autoscaler établit une relation proportionnée entre le nombre de nœuds et le nombre de répliques. Cette relation est utilisée pour calculer le nombre de répliques souhaité pour une charge de travail.

• Intégration avec les composants Kubernetes : le CPA fonctionne avec des composants Kubernetes standard tels que le Horizontal Pod Autoscaler (HPA), mais se concentre spécifiquement sur le nombre de nœuds plutôt que sur les indicateurs d'utilisation des ressources. Cette intégration permet une stratégie de mise à l'échelle plus complète.

• Clients d'API Golang — Pour surveiller le nombre de nœuds et leurs cœurs disponibles, le CPA utilise des clients d'API Golang qui s'exécutent dans des pods et communiquent avec le serveur d'API Kubernetes.

• Paramètres configurables : à l'aide de aConfigMap, les utilisateurs peuvent définir des seuils et des paramètres de dimensionnement que le CPA utilise pour modifier son comportement et s'assurer qu'il suit le plan de dimensionnement prévu.

Autoscaler piloté par les événements basé sur Kubernetes

L'Event Driven Autoscaler (KEDA) basé sur Kubernetes est un projet open source qui permet aux charges de travail Kubernetes d'évoluer en fonction du nombre d'événements à traiter. KEDA améliore l'évolutivité des applications en leur permettant de répondre de manière dynamique aux différentes charges de travail, en particulier celles qui sont dictées par des événements.

En automatisant le processus de dimensionnement en fonction des événements, KEDA aide les entreprises à optimiser l'utilisation des ressources, à améliorer les performances des applications et à réduire les coûts associés au surprovisionnement. Cette approche est particulièrement utile pour les applications soumises à des modèles de trafic variés, tels que les microservices, les fonctions sans serveur et les systèmes de traitement des données en temps réel.

KEDA fournit les fonctionnalités clés suivantes :

• Dimensionnement piloté par les événements — KEDA vous permet de définir des règles de dimensionnement basées sur des sources d'événements externes, telles que les files d'attente de messages, les requêtes HTTP ou les métriques personnalisées. Cette fonctionnalité permet de s'assurer que les applications évoluent en fonction de la demande en temps réel.

• Composant léger — KEDA est un composant léger à usage unique qui ne nécessite pas beaucoup de configuration ou de surcharge pour être facilement intégré dans les clusters Kubernetes existants.

• Intégration à Kubernetes — KEDA étend les capacités des composants natifs de Kubernetes, tels que le Horizontal Pod Autoscaler (HPA). KEDA ajoute des fonctionnalités de mise à l'échelle pilotées par les événements à ces composants, en les améliorant plutôt qu'en les remplaçant.

• Support de plusieurs sources d'événements — KEDA est compatible avec un large éventail de sources d'événements, y compris les plateformes de messagerie populaires telles que RabbitMQ, Apache Kafka, etc. Grâce à cette adaptabilité, vous pouvez personnaliser la mise à l'échelle en fonction de votre architecture unique axée sur les événements.

• Scalers personnalisés : à l'aide de scalers personnalisés, vous pouvez désigner des métriques spécifiques que KEDA peut utiliser pour lancer des actions de dimensionnement en réponse à une logique ou à des exigences commerciales spécifiques.

• Configuration déclarative — Conformément aux principes de Kubernetes, vous pouvez utiliser KEDA pour décrire le comportement de dimensionnement de manière déclarative en utilisant les ressources personnalisées de Kubernetes pour définir comment le dimensionnement doit se produire.