Gestión de cuotas de recursos en Kubernetes

Introducción

En este laboratorio, aprenderás cómo utilizar Kubernetes ResourceQuota para establecer límites en el consumo de recursos en un clúster de Kubernetes. ResourceQuota te permite controlar y gestionar la asignación de recursos como CPU y memoria para los namespaces en un clúster de Kubernetes. Comenzarás con ejemplos simples y progresarás gradualmente hacia escenarios más complejos. Cada paso proporcionará ejemplos de código e instrucciones sobre cómo aplicarlos a tu clúster de Kubernetes.

Skills Graph

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

1. Navegar a tu directorio de trabajo:

   Abre la terminal y navega hasta la carpeta de proyecto predeterminada:

   cd /home/labex/project

2. Iniciar Minikube:

   Inicia Minikube para inicializar un clúster de Kubernetes:

   minikube start

   • Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
   • Minikube puede tardar unos minutos en iniciar, dependiendo del rendimiento de tu sistema.

3. Verificar que Minikube esté en ejecución:

   Comprueba el estado del clúster de Minikube:

   minikube status

   • Busca componentes como kubelet y apiserver listados como Running (En ejecución).
   • Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Crear una ResourceQuota

En este paso, crearás una simple ResourceQuota (cuota de recursos) que limita la cantidad de CPU y memoria que se puede utilizar en un namespace (espacio de nombres). Así es como puedes hacerlo:

1. Crea un archivo llamado resourcequota.yaml con el siguiente contenido:

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

Esta ResourceQuota establece los siguientes límites rígidos (hard limits):

• CPU: 1 núcleo
• Memoria: 1 GiB

2. Aplica el archivo resourcequota.yaml a tu clúster de Kubernetes utilizando el comando kubectl apply:

kubectl apply -f resourcequota.yaml

3. Verifica que la ResourceQuota se haya creado correctamente ejecutando el siguiente comando:

kubectl describe resourcequota example-resourcequota

Debes ver los detalles de la ResourceQuota en la salida.

Aplicar una ResourceQuota a un Namespace

En este paso, aplicarás la ResourceQuota (cuota de recursos) creada en Paso: Crear una ResourceQuota a un namespace (espacio de nombres). Así es como puedes hacerlo:

1. Crea un archivo llamado namespace.yaml con el siguiente contenido:

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

Esta definición de namespace crea un namespace llamado example-namespace.

2. Aplica el archivo namespace.yaml a tu clúster de Kubernetes utilizando el comando kubectl apply:

kubectl apply -f namespace.yaml

3. Aplica la ResourceQuota al namespace example-namespace utilizando el comando kubectl apply:

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

4. Verifica que la ResourceQuota se haya aplicado al namespace ejecutando el siguiente comando:

kubectl describe namespace example-namespace

Debes ver los detalles de la ResourceQuota aplicada al namespace en la salida.

Probar la aplicación de la ResourceQuota

En este paso, crearás un pod (contenedor agrupado) que exceda los límites de recursos definidos en la ResourceQuota (cuota de recursos), y verificarás que la ResourceQuota aplique dichos límites. Así es como puedes hacerlo:

1. Crea un archivo llamado pod-exceeding-limits.yaml con el siguiente contenido:

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

Esta definición de pod crea un pod con un contenedor que solicita recursos que exceden los límites establecidos en la ResourceQuota creada en Paso: Crear una ResourceQuota (CPU: 2 núcleos, memoria: 2 GiB).

2. Aplica el archivo pod-exceeding-limits.yaml a tu clúster de Kubernetes utilizando el comando kubectl apply:

kubectl apply -f pod-exceeding-limits.yaml

Puedes ver que la operación de creación del Pod es rechazada. El mensaje de error es el siguiente: 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.

Modificar una ResourceQuota

En este paso, aprenderás cómo modificar una ResourceQuota (cuota de recursos) existente para actualizar los límites de recursos. Así es como puedes hacerlo:

1. Edita el archivo resourcequota.yaml para actualizar los límites de CPU y memoria a valores más altos:

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

Esto actualiza la ResourceQuota para permitir límites más altos de CPU y memoria (2 núcleos y 2 GiB respectivamente).

2. Aplica el archivo resourcequota.yaml actualizado a tu clúster de Kubernetes utilizando el comando kubectl apply:

kubectl apply -f resourcequota.yaml

3. Verifica que la ResourceQuota se haya actualizado ejecutando el siguiente comando:

kubectl describe resourcequotas example-resourcequota

Debes ver los límites de CPU y memoria actualizados en la salida.

Resumen

En este laboratorio, aprendiste cómo utilizar las ResourceQuota (cuotas de recursos) de Kubernetes para establecer límites en el consumo de recursos en un clúster de Kubernetes. Comenzaste creando una simple ResourceQuota, aplicándola a un namespace (espacio de nombres) y probando su aplicación creando un pod (contenedor agrupado) que excediera los límites de recursos. También aprendiste cómo modificar una ResourceQuota existente para actualizar los límites de recursos. Las ResourceQuota son una herramienta poderosa para administrar recursos en un clúster de Kubernetes y garantizar que las aplicaciones no consuman recursos excesivos.