Limites des ressources dans les Kuberenetes

Si le nœud dispose d’une quantité suffisante d’une ressource, il est possible pour un conteneur d’utiliser davantage de ressources. Nous pouvons spécifier la quantité de chaque ressource dont 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 d’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 la limite que nous avons définie.

Par exemple, si nous définissons une demande de mémoire de 100 MiB pour un conteneur, 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 un ou plusieurs des éléments suivants :

  • limites sur le cpu
  • limites sur la mémoire
  • limites sur les hugepages-<size>
  • demandes de cpu
  • demandes de mémoire
  • demandes pour hugepages-<size>

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

Dans cet article, nous allons voir un exemple de limite de ressources et de demande de CPU et de mémoire. Nous utiliserons également Metric Server. Le Metric Server est un agrégateur de données sur l’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 tu veux apprendre à créer un cluster Kubernetes, cliqueici. Ce guide t’aidera à créer un cluster Kubernetes avec 1 Maître et 2 Nœuds sur des Instances EC2 AWS Ubuntu 18.04.

Que ferons-nous ?

  1. Limites des ressources

Limites de ressources

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

Clone le dépôt Github de Metric Server à l’aide de la commande suivante et installe-le.

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

Crée Metric Server à l’aide des fichiers d’objets.

kubectl create -f .

install-metric-server

Attends un certain temps pour que Metric Server soit lancé. Après un certain temps, tu peux exécuter la commande suivante pour surveiller les nœuds du cluster.

kubectl top node

verify-node-metrcis

Maintenant, crée un fichier de définition de pod avec le contenu suivant dans celui-ci 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"]

ma-pod-mémoire-démo

Tu peux trouver la propriété « ressources » dans laquelle nous avons spécifié la limite de mémoire comme étant 50Mi et la demande de mémoire comme étant 20Mi.

Vérifie les pods existants sur le cluster.

kubectl get pods #Get pods from the default namespace

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

kubectl create -f my-pod-with-memory.yml #Create a pod
kubectl get pods

Créer un pod avec demande et limite de mémoire

Maintenant, si tu obtiens les détails du pod, tu peux 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 #Describe the pod

décrire-le-pod-et-vérifier-la-mémoire

L’utilisation du pod peut être vérifiée à l’aide de la commande suivante.

kubectl  top pods #Check resource consumption by the pod

Vérifier la consommation de mémoire

Maintenant, crée 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"

my-pod-cpu-demo

Dans le fichier ci-dessus, tu peux voir que la définition a une propriété « ressource » avec une demande de CPU de 0,5 et une limite de 1. Note également que nous passons 2 CPU comme exigence, ce qui est plus que 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 #Create a pod
kubectl get pods

create-a-pod-with-cpu-request-and-limit

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

kubectl get pods
kubectl describe pod my-pod-cpu-demo

décrire-le-pod-et-vérifier-le-cpu

Tu peux voir que le pod a demandé 0,5 ou 500m de CPU avec une limite de 1 CPU.

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

kubectl top pod #Check resource consumption by the pod

check-cpu-consumption

Dans la capture d’écran ci-dessus, tu peux voir que même après avoir passé 2 CPU 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 à l’aide du 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 indiquée.

Vous aimerez aussi...