Comment utiliser les quotas de ressources Kubernetes

Les quotas de ressources évitent les conflits de ressources et les « accaparements de terres » en contrôlant la quantité de processeur ou de mémoire qu'une application peut consommer.

« Contrôle » est le mot qui vient à l'esprit lorsque quelqu'un mentionne qu'il doit gérer les ressources de calcul de Kubernetes, en particulier le processeur et la mémoire. Ces conversations ont généralement lieu après que la plate-forme Kubernetes a été déployée pendant un certain temps et que les développeurs utilisent largement le cluster. Et la plupart du temps, le sujet revient après l'apparition d'un problème.

Les problèmes de ressources sont courants lorsque la mise en œuvre de Kubernetes est déployée sans tenir compte de la croissance future du cluster. Les problèmes peuvent également être liés au niveau d'expérience de l'équipe qui déploie et gère le cluster Kubernetes.

Sans contrôles, une application ou un développeur malveillant peut perturber l'activité. Cela se produit par inadvertance lorsque plusieurs développeurs partagent un cluster avec un nombre fixe de nœuds. Ces contraintes en matière de ressources peuvent déclencher des désaccords, des accusations et un « accaparement des terres » des ressources disponibles parmi les développeurs. C'est une très mauvaise situation pour les administrateurs de cluster et les développeurs.

Il existe plusieurs façons de gérer la manière dont les applications utilisent les ressources informatiques dans l'environnement Kubernetes. La plupart du temps, les quotas de ressources et les plages limites suffisent. Notez que dans Kubernetes, la gestion du stockage adopte une approche inhabituelle en utilisant un plugin Persistent Volume dans lequel les propriétés permettant de répondre et de contrôler les différentes exigences de stockage sont définies.

Les quotas de ressources Kubernetes sont un moyen de contrôler la façon dont les ressources informatiques sont utilisées. Cet article vous montrera comment utiliser cette fonctionnalité pour gérer le comportement des développeurs et contrôler la consommation des ressources des applications.

Que sont les quotas de ressources ?

En bref, les quotas de ressources fournissent des contraintes qui limitent la consommation de ressources par espace de noms. Ils ne peuvent être appliqués qu'au niveau de l'espace de noms, ce qui signifie qu'ils peuvent être appliqués aux ressources informatiques et limiter le nombre d'objets à l'intérieur de l'espace de noms.

Un quota de ressources Kubernetes est défini par un objet ResourceQuota. Lorsqu'il est appliqué à un espace de noms, il peut limiter les ressources informatiques telles que le processeur et la mémoire, ainsi que la création des objets suivants :

Gousses
Prestations de service
Secrets
Réclamations de volume persistantes (PVC)
Cartes de configuration

Kubernetes prend en charge deux types de quotas de CPU et de mémoire pour gérer les ressources de calcul. Celles-ci sont contrôlées via des limites et des requêtes, comme l'explique la documentation LimitRange.

En bref, une requête définit les ressources CPU ou mémoire garanties pour les conteneurs, tandis qu'une limite est le seuil de mémoire ou de CPU qu'un conteneur peut utiliser, en fonction de ce qui est disponible en fonction de sur l'utilisation d'autres conteneurs.

Cette image illustre la différence entre les demandes et les limites dans les quotas de ressources Kubernetes.

^{(Michael Calizo, CC BY-SA 4.0)}

L'exercice suivant montre comment utiliser les quotas de ressources pour créer des contraintes qui limitent une application à certaines ressources en fonction d'un seuil défini. Cela montre également l'utilité de mettre en œuvre des quotas de ressources pour contrôler votre mise en œuvre de Kubernetes.

Conditions préalables

Avant de commencer, assurez-vous que Kubernetes est déployé sur votre machine locale. Voici ma configuration :

Minikube v1.14.2
Système d'exploitation Fedora 33
accès Internet

Si vous avez besoin d'aide pour déployer Minikube sur votre ordinateur portable Linux, vous pouvez suivre les étapes décrites dans Premiers pas avec Minikube de Bryant Son. Ou, si vous utilisez Windows ou macOS, vous pouvez suivre ces étapes.

Configurer un quota de ressources

Cet exemple crée un quota de CPU, mais le processus est similaire pour un quota de mémoire ou une combinaison des deux.

Dans un scénario de production réel, les ressources CPU se situent généralement en tête des ressources informatiques que vous devez gérer pour éviter les conflits de ressources. Cela est vrai chaque fois que plusieurs applications s'exécutent sur votre serveur (calcul).

Commencez par créer un nouvel espace de noms dans lequel vous appliquerez votre quota de CPU :

$ kubectl create namespace quota-test
namespace/quota-test created

Créez un fichier nommé cpu-quota.yaml et placez-y le quota suivant (créé pour cette démo) :

apiVersion: v1
kind: ResourceQuota
metadata:
  name: test-cpu-quota
spec:
  hard:
    requests.cpu: "100m"  
    limits.cpu: "200m"

Appliquez le quota à votre cluster Kubernetes avec :

$ kubectl apply -f cpu-qouta.yaml 
resourcequota/test-cpu-quota created

Vérifiez que le quota a été appliqué avec la commande kubectlscribe :

$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name:         test-cpu-quota
Namespace:    quota-test
Resource      Used  Hard
--------      ----  ----
limits.cpu    0     200m
requests.cpu  0     100m

Notez la colonne Ressources utilisées ; cette valeur changera à mesure que vous déploierez des pods.

Maintenant que vous avez défini votre quota, testez-le. Pour cet exemple, déployez trois pods différents dans le même espace de noms pour voir si vous pouvez contrôler l'utilisation des ressources en fonction des limites que vous avez définies. Les trois modules sont :

PodA : Ce pod, le premier à être instancié, utilisera 50 % du CPU disponible.
PodB : ce pod utilisera les 50 % restants du processeur disponible ; ce sera le deuxième pod instancié.
PodC : Le quota défini doit empêcher le déploiement de ce troisième pod.

Maintenant que vous connaissez le scénario, déployez les pods.

Déployer les pods

PodA :

$ kubectl create -n quota-test -f- <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: poda
spec:
  containers:
  - name: quota-test
    image: busybox
    imagePullPolicy: IfNotPresent
    command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
    resources:
      requests:
        cpu: "50m"
      limits:
        cpu: "100m"
  restartPolicy: Never
EOF

Vérifiez l'utilisation du processeur en décrivant à nouveau le quota et en notant les limites et les requêtes de la valeur CPU utilisé :

$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name:         test-cpu-quota
Namespace:    quota-test
Resource      Used  Hard
--------      ----  ----
limits.cpu    100m  200m
requests.cpu  50m   100m

PodB :

$ kubectl create -n quota-test -f- <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: podb
spec:
  containers:
  - name: quota-test
    image: busybox
    imagePullPolicy: IfNotPresent
    command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
    resources:
      requests:
        cpu: "50m"
      limits:
        cpu: "100m"
  restartPolicy: Never
EOF

Vérifiez à nouveau l'utilisation des ressources du processeur. Comme prévu, le PodB peut être planifié car le quota le permet :

$ kubectl describe resourcequota/test-cpu-quota --namespace quota-test
Name:         test-cpu-quota
Namespace:    quota-test
Resource      Used  Hard
--------      ----  ----
limits.cpu    200m  200m
requests.cpu  100m  100m

PodC :

Maintenant, essayez d'instancier le troisième pod, même si vous savez que le PodA et le Pod B ont maximisé le seuil de quota de CPU que vous avez défini :

$ kubectl create -n quota-test -f- <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: podc
spec:
  containers:
  - name: quota-test
    image: busybox
    imagePullPolicy: IfNotPresent
    command: ['sh', '-c', 'echo Pod is Running ; sleep 5000']
    resources:
      requests:
        cpu: "5m"
      limits:
        cpu: "10m"
  restartPolicy: Never
EOF

Comme prévu, le troisième pod ne s'instanciera pas car le quota défini empêche la création des pods :

Error from server (Forbidden): error when creating "STDIN": pods "podc" is forbidden: exceeded quota: test-cpu-quota, requested: limits.cpu=10m,requests.cpu=5m, used: limits.cpu=200m,requests.cpu=100m, limited: limits.cpu=200m,requests.cpu=100m

Comme le montre cet exemple, des quotas de ressources correctement définis constituent un outil puissant qu'un administrateur Kubernetes peut utiliser pour gérer le comportement des développeurs.

Nettoyer

Supprimez l'espace de noms que vous avez créé (dans ce cas, quota-test) :

$ kubectl delete -n quota-test

Planifier vos quotas

Il existe de nombreuses façons de contrôler la manière dont les utilisateurs peuvent déployer des applications afin d'éviter « l'accaparement des terres » dans un cluster Kubernetes. Une bonne implémentation des quotas, des plages de limites et d'autres fonctionnalités natives contribue à la stabilité d'un cluster.

La mise en œuvre de quotas de ressources sur les ressources informatiques est une décision de conception importante à laquelle vous devez réfléchir attentivement, en particulier lors du déploiement de Kubernetes pour exécuter des applications d'entreprise critiques.

Lors de la définition des quotas, il est important d'inclure les développeurs dans votre planification. Grâce à leur connaissance des applications, ils constituent vos meilleures ressources pour estimer ce qui est requis.