Gestion des quotas de ressources Kubernetes

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser Kubernetes ResourceQuota pour définir des limites de consommation de ressources dans un cluster Kubernetes. ResourceQuota vous permet de contrôler et de gérer l'allocation de ressources telles que le CPU et la mémoire pour les espaces de noms (namespaces) dans un cluster Kubernetes. Vous commencerez par des exemples simples et progresserez progressivement vers des scénarios plus complexes. Chaque étape fournira des exemples de code et des instructions sur la façon de les appliquer à votre cluster Kubernetes.

Skills Graph

Démarrer le cluster Minikube

Avant de créer des ressources, vous avez besoin d'un cluster Kubernetes en cours d'exécution. Minikube est un environnement Kubernetes léger qui s'exécute sur votre machine locale.

1. Accédez à votre répertoire de travail:

   Ouvrez le terminal et accédez au dossier de projet par défaut :

   cd /home/labex/project

2. Démarrez Minikube:

   Démarrez Minikube pour initialiser un cluster Kubernetes :

   minikube start

   • Cette commande configure un cluster Kubernetes mono - noeud sur votre machine locale.
   • Minikube peut prendre quelques minutes à démarrer en fonction des performances de votre système.

3. Vérifiez que Minikube est en cours d'exécution:

   Vérifiez l'état du cluster Minikube :

   minikube status

   • Recherchez des composants tels que kubelet et apiserver listés comme Running (en cours d'exécution).
   • Si le cluster n'est pas en cours d'exécution, relancez la commande minikube start.

Si vous rencontrez des problèmes lors du démarrage de Minikube, utilisez minikube delete pour réinitialiser l'environnement si nécessaire.

Création d'un ResourceQuota

Dans cette étape, vous allez créer un simple ResourceQuota (quota de ressources) qui limite la quantité de CPU et de mémoire utilisable dans un espace de noms (namespace). Voici comment procéder :

1. Créez un fichier nommé resourcequota.yaml avec le contenu suivant :

apiVersion: v1
kind: ResourceQuota
metadata:
  name: example-resourcequota
spec:
  hard:
    cpu: "1"
    memory: "1Gi"

Ce ResourceQuota définit les limites strictes suivantes :

• CPU : 1 cœur
• Mémoire : 1 Gio

2. Appliquez le fichier resourcequota.yaml à votre cluster Kubernetes en utilisant la commande kubectl apply :

kubectl apply -f resourcequota.yaml

3. Vérifiez que le ResourceQuota a été créé avec succès en exécutant la commande suivante :

kubectl describe resourcequota example-resourcequota

Vous devriez voir les détails du ResourceQuota dans la sortie.

Application d'un ResourceQuota à un espace de noms (namespace)

Dans cette étape, vous allez appliquer le ResourceQuota (quota de ressources) créé dans Étape : Création d'un ResourceQuota à un espace de noms (namespace). Voici comment procéder :

1. Créez un fichier nommé namespace.yaml avec le contenu suivant :

apiVersion: v1
kind: Namespace
metadata:
  name: example-namespace

Cette définition d'espace de noms crée un espace de noms nommé example-namespace.

2. Appliquez le fichier namespace.yaml à votre cluster Kubernetes en utilisant la commande kubectl apply :

kubectl apply -f namespace.yaml

3. Appliquez le ResourceQuota à l'espace de noms example-namespace en utilisant la commande kubectl apply :

kubectl apply -f resourcequota.yaml -n example-namespace

4. Vérifiez que le ResourceQuota a été appliqué à l'espace de noms en exécutant la commande suivante :

kubectl describe namespace example-namespace

Vous devriez voir les détails du ResourceQuota appliqué à l'espace de noms dans la sortie.

Test de l'application du ResourceQuota

Dans cette étape, vous allez créer un pod (groupe de conteneurs) qui dépasse les limites de ressources définies dans le ResourceQuota (quota de ressources), et vérifier que le ResourceQuota applique ces limites. Voici comment procéder :

1. Créez un fichier nommé pod-exceeding-limits.yaml avec le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: example-pod-exceeding-limits
spec:
  containers:
    - name: nginx
      image: nginx
      resources:
        limits:
          cpu: "2"
          memory: "2Gi"

Cette définition de pod crée un pod avec un conteneur qui demande des ressources qui dépassent les limites définies dans le ResourceQuota créé dans Étape : Création d'un ResourceQuota (CPU : 2 cœurs, mémoire : 2 Gio).

2. Appliquez le fichier pod-exceeding-limits.yaml à votre cluster Kubernetes en utilisant la commande kubectl apply :

kubectl apply -f pod-exceeding-limits.yaml

Vous pouvez constater que l'opération de création du pod est rejetée. Le message d'erreur est le suivant : Error from server (Forbidden): error when creating "pod-exceeding-limits.yaml": pods "example-pod-exceeding-limits" is forbidden: exceeded quota: example-resourcequota, requested: cpu=2,memory=2Gi, used: cpu=0,memory=0, limited: cpu=1,memory=1Gi.

Modification d'un ResourceQuota

Dans cette étape, vous allez apprendre à modifier un ResourceQuota (quota de ressources) existant pour mettre à jour les limites de ressources. Voici comment procéder :

1. Modifiez le fichier resourcequota.yaml pour augmenter les limites de CPU et de mémoire :

apiVersion: v1
kind: ResourceQuota
metadata:
  name: example-resourcequota
spec:
  hard:
    cpu: "2"
    memory: "2Gi"

Cela met à jour le ResourceQuota pour autoriser des limites plus élevées de CPU et de mémoire (2 cœurs et 2 Gio respectivement).

2. Appliquez le fichier resourcequota.yaml mis à jour à votre cluster Kubernetes en utilisant la commande kubectl apply :

kubectl apply -f resourcequota.yaml

3. Vérifiez que le ResourceQuota a été mis à jour en exécutant la commande suivante :

kubectl describe resourcequotas example-resourcequota

Vous devriez voir les limites de CPU et de mémoire mises à jour dans la sortie.

Résumé

Dans ce laboratoire, vous avez appris à utiliser le ResourceQuota (quota de ressources) de Kubernetes pour définir des limites de consommation de ressources dans un cluster Kubernetes. Vous avez commencé par créer un simple ResourceQuota, l'avez appliqué à un espace de noms (namespace) et testé son application en créant un pod (groupe de conteneurs) qui dépasse les limites de ressources. Vous avez également appris à modifier un ResourceQuota existant pour mettre à jour les limites de ressources. Le ResourceQuota est un outil puissant pour gérer les ressources dans un cluster Kubernetes et garantir que les applications ne consomment pas de ressources excessives.