Skip to content

Tema:

Kubernetes Resources Request y Resources Limits

Introducción

En Kubernetes, la gestión eficiente de los recursos de CPU y memoria es esencial para garantizar la estabilidad y el rendimiento de las aplicaciones. Resources Requests y Resources Limits son mecanismos clave que permiten definir cuánto recurso necesita un contenedor para operar y cuánto se le puede permitir consumir. Estas configuraciones ayudan a optimizar el uso de los recursos del clúster, prevenir la sobreutilización y garantizar un entorno equilibrado para las aplicaciones. En esta guía, aprenderás a configurar y aplicar estas restricciones de manera efectiva.

Objetivo

Objetivo General:

  • Proporcionar a los participantes las habilidades necesarias para configurar y gestionar Resources Requests y Resources Limits en Kubernetes, asegurando una asignación eficiente de los recursos del clúster y promoviendo la estabilidad y el rendimiento de las aplicaciones desplegadas.

Laboratorio: Kubernetes Resources Request y Resources Limits

En este laboratorio aprenderás a configurar los parámetros de Resources Requests y Resources Limits para los Pods creados mediante un Deployment en Kubernetes.

  1. Asegurarse de estar en el servidor bastion con el usuario student 
    student@lab-0-bastion:~>
  2. Ingresar como usuario administrador al cluster de Kubernetes con el siguiente comando: 
    export KUBECONFIG=/home/student/rke2_conn/cluster1/cluster1_kubeconfig.yaml
  3. La asignación y el consumo de recursos en el Cluster de Kubernetes, esta relacionado con los Resources Request y Resources Limits, por lo que podemos comenzar esta guía explorando el consumo de recursos de los nodos de conforman el cluster: 
    kubectl top nodes
    Deberías de obtener una salida como la siguiente: 
    NAME                             CPU(cores)   CPU(%)   MEMORY(bytes)   MEMORY(%)   
lab-0-master.c.mx-g05.internal   356m         17%      2762Mi          34%         
lab-0-node1.c.mx-g05.internal    154m         7%       1854Mi          23%         
lab-0-node2.c.mx-g05.internal    82m          4%       1225Mi          15%
  4. Además es posible verificar la asignación y consumo de recursos de los servidores que conforman el cluster con el siguiente comando, asegurarse de cambiar en el comando el número de laboratorio correspondiente: 
    kubectl describe node lab-0-node1.c.mx-g05.internal
    La sección que nos interesa analizar es donde se muestran los Resources Requests y Resources Limits como la siguiente: 
    Namespace                   Name                                                     CPU Requests  CPU Limits  Memory Requests  Memory Limits  Age
  ---------                   ----                                                     ------------  ----------  ---------------  -------------  ---
  calico-system               calico-node-m42k5                                        0 (0%)        0 (0%)      0 (0%)           0 (0%)         5h51m
  calico-system               calico-typha-97dc874c4-n79wd                             0 (0%)        0 (0%)      0 (0%)           0 (0%)         6h
  5. Crea un nuevo namespace para el laboratorio: 
    kubectl create namespace resource-lab-request
  6. Establece el namespace recién creado como predeterminado: 
    kubectl config set-context --current --namespace=resource-lab-request
  7. Crea un archivo YAML llamado deployment-requests.yaml con la siguiente configuración: 
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: deployment-requests
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - name: alpine
        image: alpine
        command: ["sh", "-c", "while true; do :; done"]
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
  8. Aplica el archivo YAML para crear el Deployment: 
    kubectl apply -f deployment-requests.yaml
  9. Verifica que el Deployment y el Pod estén ejecutándose: 
    kubectl get pods -o wide
  10. Instala la herramienta stress-ng en el Pod, debes reemplazar <pod-name> por el nombre correspondiente de tu Pod: 
    kubectl exec -it <pod-name> -- sh
  11. Una vez dentro del Pod, instala el generador de carga: 
    apk add --no-cache stress-ng
  12. Genera carga limitada por los valores configurados en los Requests: 
    stress-ng --cpu 2 --vm 1 --vm-bytes 64M --timeout 30s
    La salida debe ser similar a la siguiente: 
    stress-ng: info:  [17] setting to a 30 secs run per stressor
stress-ng: info:  [17] dispatching hogs: 2 cpu, 1 vm
stress-ng: info:  [17] skipped: 0
stress-ng: info:  [17] passed: 3: cpu (2) vm (1)
stress-ng: info:  [17] failed: 0
stress-ng: info:  [17] metrics untrustworthy: 0
stress-ng: info:  [17] successful run completed in 30.02 secs
    En el ejemplo anterior, el Pod utilizó los recursos que tenia como reservados y mas. También puedes verificar de forma gráfica el consumo de recursos en Rancher Manager.
  13. Observa cómo Kubernetes asigna y reserva los recursos del Pod, debes reemplazar <pod-name> por el nombre correspondiente de tu Pod: 
    kubectl describe pod <pod-name>

Crear un Deployment con Resource Limits

  1. Asegurarse de estar en el servidor bastion con el usuario student 
    student@lab-0-bastion:~>
  2. Ingresar como usuario administrador al cluster de Kubernetes con el siguiente comando: 
    export KUBECONFIG=/home/student/rke2_conn/cluster1/cluster1_kubeconfig.yaml
  3. Crea un nuevo namespace para el laboratorio: 
    kubectl create namespace resource-lab-limits
  4. Establece el namespace recién creado como predeterminado: 
    kubectl config set-context --current --namespace=resource-lab-limits
  5. Crea un archivo YAML llamado deployment-limits.yaml con la siguiente configuración: 
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: deployment-limits
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - name: alpine
        image: alpine
        command: ["sh", "-c", "while true; do :; done"]
        resources:
          limits:
            memory: "128Mi"
            cpu: "500m"
  6. Aplica el archivo YAML para crear el Deployment: 
    kubectl apply -f deployment-limits.yaml
  7. Verifica que el Pod esté ejecutándose: 
    kubectl get pods -o wide
  8. Ingresa al Pod, debes reemplazar <pod-name> por el nombre correspondiente de tu Pod: 
    kubectl exec -it <pod-name> -- sh
  9. Una vez dentro del Pod, instala el generador de carga: 
    apk add --no-cache stress-ng
  10. Genera una carga que exceda los límites configurados: 
    stress-ng --cpu 4 --vm 2 --vm-bytes 200M --timeout 30s
  11. Observa cómo Kubernetes reinicia el Pod y limita el uso de recursos del Pod. También puedes verificar de forma gráfica el consumo de recursos en Rancher Manager y los eventos del Pod.

Limpieza del Entorno

  1. Elimina los Deployments creados: 
    kubectl delete -f deployment-requests.yaml -n resource-lab-request

    kubectl delete -f deployment-limits.yaml -n resource-lab-limits
  2. Eliminar los Namespaces creados: 
    kubectl delete namespace resource-lab-request

    kubectl delete namespace resource-lab-limits
  3. Eliminar los archivos creados 
    rm -f deployment-requests.yaml deployment-limits.yaml

Conclusión

Has aprendido a configurar y probar Resources Requests y Resources Limits en Kubernetes, verificando cómo estas configuraciones afectan el comportamiento de los Pods bajo diferentes niveles de carga. Estos conocimientos son clave para optimizar el uso de los recursos en clústeres Kubernetes productivos.