Container Service for Kubernetes:Use load-aware scheduling

Funcionamiento de la programación consciente de la carga

La programación consciente de la carga es un plugin que implementa el programador de Container Service for Kubernetes (ACK) basado en el Scheduling Framework de Kubernetes. La directiva de programación nativa de Kubernetes coloca los pods principalmente según la asignación de recursos. En cambio, el programador de ACK detecta la carga real de recursos de cada nodo: consulta las estadísticas históricas de carga del nodo, estima la carga del pod que se va a programar y luego coloca el pod en un nodo con menor carga. Esto equilibra las cargas entre los nodos y ayuda a prevenir fallos en las aplicaciones o en los nodos causados por la sobrecarga de un solo nodo.

La programación consciente de la carga requiere tanto el componente kube-scheduler como el complemento ack-koordinator. El complemento ack-koordinator recopila y reporta la utilización de recursos del nodo, y el programador de ACK utiliza esos datos para puntuar y clasificar los nodos, de modo que se seleccionen primero los nodos con menor carga. Para obtener detalles sobre el diseño del complemento, consulte ack-koordinator architecture.

En la siguiente figura, Requested es la cantidad de recursos que se han solicitado y Usage es la cantidad de recursos que realmente se utilizan. Solo los recursos que realmente se utilizan cuentan como carga real. Dadas condiciones idénticas en los nodos, el programador de ACK asigna el nuevo pod al Nodo B, que tiene la carga más baja.

La utilización de los nodos cambia dinámicamente con el tiempo y depende del entorno del clúster, el tráfico de la carga de trabajo y el volumen de solicitudes. Para reducir la probabilidad de que el clúster vuelva a desequilibrarse después de programar los pods, el complemento ack-koordinator también proporciona desprogramación. Utilice la programación consciente de la carga junto con use hotspot-aware descheduling to balance node loads para mantener equilibradas las cargas de los nodos a lo largo del tiempo.

Directivas de programación

La programación consciente de la carga ofrece las siguientes directivas. Ambas utilizan la estadística agregada de carga del nodo descrita en la sección anterior.

Requisitos previos

• Tipo de clúster: Solo se admite un clúster ACK administrado Pro. Para consultar el procedimiento, vea Create an ACK Pro cluster.

• Complemento ack-koordinator: Instale el complemento ack-koordinator versión 1.1.1-ack.1 o posterior. Para consultar el procedimiento de instalación, vea ack-koordinator (FKA ack-slo-manager).

• Versión del programador de ACK: El programador de ACK debe cumplir con el requisito de versión correspondiente a la versión de Kubernetes de su clúster, como se indica en la siguiente tabla.

Estas versiones son necesarias para configurar la programación consciente de la carga mediante los parámetros de kube-scheduler. Algunas versiones anteriores del programador solo admiten el protocolo de anotaciones de pod. Para consultar la matriz de compatibilidad completa, vea FAQ.

Facturación

La instalación o el uso del complemento ack-koordinator es gratuito. Sin embargo, pueden generarse costos en los siguientes escenarios:

• Recursos de nodos worker: ack-koordinator es un complemento no administrado que consume recursos de los nodos worker después de la instalación. Las solicitudes de recursos se pueden configurar para cada módulo durante la instalación.

• Métricas personalizadas: De forma predeterminada, ack-koordinator expone métricas de monitoreo para funciones como el perfilado de recursos y la programación detallada en formato Prometheus. Si selecciona Enable Prometheus monitoring metrics for ack-koordinator y utiliza Managed Service for Prometheus, estas métricas se facturan como custom metrics. Los cargos varían según factores como el tamaño del clúster y el número de aplicaciones. Antes de habilitar esta función, consulte Billing of Prometheus instances para conocer el nivel gratuito y los precios de las métricas personalizadas. Para monitorear y gestionar el uso de sus recursos, utilice usage query.

Paso 1: Habilitar la programación consciente de la carga

1. Inicie sesión en la consola de ACK. En el panel de navegación izquierdo, haga clic en Clusters.

2. En la página Clusters, haga clic en el nombre de su clúster. En el panel de navegación izquierdo, haga clic en Components and Add-ons .

3. Busque kube-scheduler y haga clic en Configuration.

4. En el cuadro de diálogo de parámetros de kube-scheduler, configure los parámetros descritos en la siguiente tabla y haga clic en OK.

   La siguiente tabla describe los principales parámetros para la programación consciente de la carga. Para consultar la referencia completa de configuración de parámetros y las versiones del complemento que requiere cada parámetro, vea kube-scheduler y .

   Parámetro	Tipo	Descripción	Valores válidos	Valor predeterminado	Ejemplo
   loadAwareThreshold	Una lista que consiste en el nombre del recurso resourceName y el umbral threshold.	El umbral del tipo de recurso correspondiente, utilizado por la directiva de filtrado de nodos.	resourceName: Se admiten cpu y memory. threshold: [0,100].	Vacío, lo que significa que el filtrado de nodos está deshabilitado.	resourceName: cpu y threshold: 80
   loadAwareResourceWeight	Una lista que consiste en el nombre del recurso resourceName y el peso resourceWeight.	El peso de puntuación del tipo de recurso correspondiente, utilizado por la directiva de puntuación de nodos. Debe seleccionar Specifies whether to enable load-aware node scoring during pod scheduling.	resourceName: Solo se admiten cpu y memory. resourceWeight: Un entero en el rango [1,100].	cpu: 1 y memory: 1	resourceName: cpu y resourceWeight: 1
   loadAwareAggregatedUsageAggragationType	enum	El tipo de agregación de la estadística de carga. avg: El valor promedio. p50: El percentil 50, que es la mediana. p90, p95 y p99: Los percentiles 90, 95 y 99.	avg, p50, p90, p95 y p99	avg	p90

   Importante

   Si el escalado automático de nodos ya está habilitado para los nodos del clúster, un umbral de filtrado consciente de la carga puede desencadenar un escalado horizontal o vertical inesperado. Esto se debe a que el escalado automático de nodos escala horizontalmente según si hay pods pendientes y escala verticalmente según el nivel de asignación del clúster. Para utilizar el escalado automático de nodos junto con el filtrado de nodos consciente de la carga, ajuste la configuración para que coincida con la capacidad y la utilización de su clúster, como se describe en Enable node auto scaling.

5. En el panel de navegación izquierdo, haga clic en Cluster Information. En la página que aparece, haga clic en la pestaña Basic Information y espere hasta que el clúster entre en estado Running, lo que indica que la programación consciente de la carga está habilitada.

Paso 2: Comprobar la programación consciente de la carga

El siguiente ejemplo utiliza un clúster que tiene tres nodos, cada uno con 4 núcleos y 16 GiB de memoria. El ejemplo primero desequilibra las cargas entre los nodos y luego comprueba dónde se programan los nuevos pods.

1. Cree un archivo llamado stress-demo.yaml con el siguiente contenido.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: stress-demo
     namespace: default
     labels:
       app: stress-demo
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: stress-demo
     template:
       metadata:
         name: stress-demo
         labels:
           app: stress-demo
       spec:
         containers:
           - args:
               - '--vm'
               - '2'
               - '--vm-bytes'
               - '1600M'
               - '-c'
               - '2'
               - '--vm-hang'
               - '2'
             command:
               - stress
             image: polinux/stress
             imagePullPolicy: Always
             name: stress
             resources:
               limits:
                 cpu: '2'
                 memory: 4Gi
               requests:
                 cpu: '2'
                 memory: 4Gi
         restartPolicy: Always

2. Ejecute el siguiente comando kubectl para crear el pod. El pod aumenta la carga del nodo que lo aloja.

   kubectl create -f stress-demo.yaml

   deployment.apps/stress-demo created

3. Ejecute el siguiente comando kubectl para comprobar el estado del pod hasta que el pod esté en ejecución.

   kubectl get pod -o wide

   NAME                           READY   STATUS    RESTARTS   AGE   IP           NODE                    NOMINATED NODE   READINESS GATES
   stress-demo-7fdd89cc6b-g****   1/1     Running   0          82s   10.XX.XX.112   cn-beijing.10.XX.XX.112   <none>           <none>

   stress-demo-7fdd89cc6b-g**** se programa en el nodo cn-beijing.10.XX.XX.112. Espere aproximadamente 3 minutos hasta que el pod finalice la inicialización y la carga del nodo haya aumentado.

4. Ejecute el siguiente comando kubectl para comprobar la carga de cada nodo.

   kubectl top node

   NAME                    CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
   cn-beijing.10.XX.XX.110   92m          2%     1158Mi          9%
   cn-beijing.10.XX.XX.111   77m          1%     1162Mi          9%
   cn-beijing.10.XX.XX.112   2105m        53%    3594Mi          28%

   cn-beijing.10.XX.XX.111 tiene la carga más baja y el nodo cn-beijing.10.XX.XX.112 tiene la carga más alta. Las cargas entre los nodos del clúster ahora están desequilibradas.

5. Cree un archivo llamado nginx-with-loadaware.yaml con el siguiente contenido.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nginx-with-loadaware
     namespace: default
     labels:
       app: nginx
   spec:
     replicas: 6
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         name: nginx
         labels:
           app: nginx
       spec:
         containers:
         - name: nginx
           image: nginx
           resources:
             limits:
               cpu: 500m
             requests:
               cpu: 500m

6. Ejecute el siguiente comando kubectl para crear los pods.

   kubectl create -f nginx-with-loadaware.yaml

   deployment/nginx-with-loadawre created

7. Ejecute el siguiente comando kubectl para ver los detalles de programación de los pods.

   kubectl get pods | grep nginx

   nginx-with-loadaware-5646666d56-2****   1/1     Running   0          18s   10.XX.XX.118   cn-beijing.10.XX.XX.110   <none>           <none>
   nginx-with-loadaware-5646666d56-7****   1/1     Running   0          18s   10.XX.XX.115   cn-beijing.10.XX.XX.110   <none>           <none>
   nginx-with-loadaware-5646666d56-k****   1/1     Running   0          18s   10.XX.XX.119   cn-beijing.10.XX.XX.110   <none>           <none>
   nginx-with-loadaware-5646666d56-q****   1/1     Running   0          18s   10.XX.XX.113   cn-beijing.10.XX.XX.111   <none>           <none>
   nginx-with-loadaware-5646666d56-s****   1/1     Running   0          18s   10.XX.XX.120   cn-beijing.10.XX.XX.111   <none>           <none>
   nginx-with-loadaware-5646666d56-z****   1/1     Running   0          18s   10.XX.XX.116   cn-beijing.10.XX.XX.111   <none>           <none>

   La salida esperada muestra que, tras habilitar la programación consciente de la carga, el programador detecta las cargas de los nodos y utiliza la estrategia de programación para programar preferentemente los pods en nodos distintos a cn-beijing.10.XX.XX.112.

Operaciones relacionadas

Preguntas frecuentes