Limites de ressources dans Kubernetes

Si le nœud dispose de suffisamment de ressources disponibles, il est possible pour un conteneur d’utiliser plus de ressources. Nous pouvons spécifier combien de chaque ressource un Conteneur a besoin. Les ressources courantes à spécifier sont le CPU et la mémoire. Lorsque nous spécifions la demande de ressources pour les Conteneurs dans un Pod, le planificateur décide sur quel nœud placer le Pod. Lorsque nous spécifions une limite de ressources pour un Conteneur, le kubelet s’occupe des limites afin que le conteneur en cours d’exécution ne soit pas autorisé à utiliser plus que cette limite que nous avons définie.

Par exemple, si nous définissons une demande de mémoire de 100 MiB pour un conteneur, alors le conteneur peut essayer d’utiliser plus de RAM. Mais si nous définissons une limite de mémoire de 4GiB pour ce Conteneur, le runtime empêche le conteneur d’utiliser plus que la limite de ressources configurée.

Le CPU et la mémoire sont appelés ressources de calcul.

Chaque Conteneur d’un Pod peut spécifier une ou plusieurs des éléments suivants :

• limites sur le cpu
• limites sur la mémoire
• limites sur hugepages-
• demandes pour le cpu
• demandes pour la mémoire
• demandes pour hugepages-

Pour en savoir plus sur les ressources dans Kubernetes, cliquez ici pour visiter la documentation officielle de Kubernetes.

Dans cet article, nous verrons un exemple de limite de ressources et de demande pour le CPU et la mémoire. Nous utiliserons également le Metric Server. Le Metrics Server est un agrégateur de données d’utilisation des ressources dans le cluster et il n’est pas déployé par défaut dans le cluster. Nous utiliserons ce Metric Server pour voir la consommation de ressources par les pods.

Prérequis

1. Cluster Kubernetes avec au moins 1 nœud de travail.
   Si vous souhaitez apprendre à créer un Cluster Kubernetes, cliquez ici. Ce guide vous aidera à créer un cluster Kubernetes avec 1 Master et 2 Nœuds sur des instances EC2 AWS Ubuntu 18.04.

Que allons-nous faire ?

1. Limites de ressources

Limites de ressources

Avant de procéder et de créer des pods avec des exigences de ressources spécifiées, installons le Metric Server.

Clonez le dépôt Github du Metric Server en utilisant la commande suivante et installez-le.

git clone https://github.com/kodekloudhub/kubernetes-metrics-server.git

cd kubernetes-metrics-server/

Créez le Metric Server en utilisant les fichiers d’objet.

kubectl create -f .

Attendez un moment pour que le Metric Server soit initié. Après un certain temps, vous pouvez exécuter la commande suivante pour surveiller les nœuds du cluster.

kubectl top node

Maintenant, créez un fichier de définition de pod avec le contenu suivant qui contient la demande et la limite de mémoire.

vim my-pod-with-memory.yml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-memory-demo
spec:
  containers:
  - name: my-container-memory-demo
    image: polinux/stress
    resources:
      limits:
        memory: "50Mi"
      requests:
        memory: "20Mi"
    command: ["stress"]
    args: ["--vm", "1", "--vm-bytes", "30M", "--vm-hang", "1"]

Vous pouvez trouver la propriété “resources” dans laquelle nous avons spécifié la limite de mémoire comme 50Mi et la demande de mémoire comme 20Mi.

Vérifiez les pods existants avec l’espace de noms par défaut sur le cluster.

kubectl get pods #Obtenir les pods du namespace par défaut

Créez un pod en utilisant la définition de pod créée à l’étape précédente.

kubectl create -f my-pod-with-memory.yml #Créer un pod

kubectl get pods

Maintenant, si vous obtenez les détails du Pod, vous pouvez voir que le Pod demande 20Mi de mémoire et a une limite de 50Mi de mémoire.

kubectl get pods

kubectl describe pod my-pod-memory-demo #Décrire le pod

L’utilisation du pod peut être vérifiée en utilisant la commande suivante.

kubectl  top pods #Vérifier la consommation de ressources par le pod

Maintenant, créez une définition de pod avec une demande et une limite de CPU.

vim my-pod-with-cpu.yml

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-cpu-demo
spec:
  containers:
  - name: my-container-cpu-demo    image: vish/stress
    resources:
      limits:        cpu: "1"
      requests:
        cpu: "0.5"
    args:
    - -cpus
    - "2"

Dans le fichier ci-dessus, vous pouvez voir que la définition a une propriété “resource” avec une demande de CPU de 0.5 et une limite de 1. Notez également que nous passons 2 CPUs comme notre exigence, ce qui est supérieur à la limite.

Maintenant, créons un pod avec une demande et une limite de CPU en utilisant la commande suivante.

kubectl apply -f my-pod-with-cpu.yml #Créer un pod

kubectl get pods

Obtenez les détails du pod que nous avons créé.

kubectl get pods

kubectl describe pod my-pod-cpu-demo

Vous pouvez voir que le Pod a demandé 0.5 ou 500m CPU avec une limite de 1 CPU.

Pour vérifier l’utilisation du CPU, utilisez la commande suivante.

kubectl top pod #Vérifier la consommation de ressources par le pod

Dans la capture d’écran ci-dessus, vous pouvez voir que même après avoir passé 2 CPUs dans la définition du pod comme argument, il ne peut pas consommer plus que la limite, c’est-à-dire 1 CPU. Ici, le pod “my-pod-cpu-demo” a pu consommer 999m CPU, ce qui équivaut à 1 CPU et il n’a pas pu augmenter sa consommation.

Conclusion

Dans cet article, nous avons vu les étapes pour activer la surveillance dans le cluster en utilisant le Metric Server. Nous avons vu comment un pod peut demander du CPU et de la mémoire et consommer des ressources sans dépasser la limite spécifiée.