Optimización del Rendimiento: Autoscaling Vertical en Kubernetes

Optimización del Rendimiento: Autoscaling Vertical en Kubernetes

Kubernetes ha introducido como su versión alfa en su lanzamiento de Kubernetes 1.27 la capacidad de Autoscaling Vertical de Pods para proporcionar la opción de que la carga de trabajo de Kubernetes pueda escalar utilizando el enfoque «vertical» al agregar más recursos a un pod existente. Esto aumenta las capacidades de escalado automático de sus cargas de trabajo de Kubernetes que tiene a su disposición, como KEDA o Autoscaling Horizontal de Pods.

Escalado Vertical vs Escalado Horizontal

El escalado vertical y horizontal son dos enfoques utilizados para aumentar el rendimiento y la capacidad de los sistemas informáticos, particularmente en sistemas distribuidos y computación en la nube. El escalado vertical, también conocido como escalado hacia arriba o escalado verticalmente, implica agregar más recursos, como potencia de procesamiento, memoria o almacenamiento, a una sola instancia o servidor. Esto significa actualizar los componentes de cómputo existentes o migrar a una infraestructura más potente. El escalado vertical a menudo es sencillo de implementar y requiere cambios mínimos en la arquitectura del software. Se utiliza comúnmente cuando las demandas del sistema pueden ser satisfechas por una sola infraestructura más potente.

Por otro lado, el escalado horizontal, también llamado escalado hacia afuera o escalado horizontalmente, implica agregar más instancias o servidores para distribuir la carga de trabajo. En lugar de actualizar una sola instancia, se emplean múltiples instancias, cada una manejando una parte de la carga de trabajo. El escalado horizontal ofrece la ventaja de aumentar la redundancia y la tolerancia a fallos, ya que múltiples instancias pueden compartir la carga. Además, proporciona la capacidad de manejar cargas de trabajo más grandes simplemente agregando más máquinas al clúster. Sin embargo, el escalado horizontal a menudo requiere arquitecturas de software más complejas, como balanceo de carga y sistemas de archivos distribuidos, para distribuir y gestionar eficientemente la carga de trabajo entre las máquinas.

En resumen, el escalado vertical implica mejorar las capacidades de un solo objeto, mientras que el escalado horizontal implica distribuir la carga de trabajo entre múltiples instancias. El escalado vertical es más fácil de implementar, pero puede tener limitaciones en términos de los recursos máximos disponibles en una sola máquina. El escalado horizontal proporciona mejor escalabilidad y tolerancia a fallos, pero requiere una infraestructura de software más compleja. La elección entre el escalado vertical y horizontal depende de factores como los requisitos específicos del sistema, la carga de trabajo esperada y los recursos disponibles.

¿Por qué el Autoscaling Vertical de Kubernetes?

Este es un tema interesante porque hemos estado viviendo en un mundo donde el estado era que siempre era mejor escalar hacia afuera (usando el Escalado Horizontal) en lugar de escalar hacia arriba (usando el Escalado Vertical) y especialmente este era uno de los mantras que escuchabas en desarrollos nativos de la nube. Y eso no ha cambiado porque el escalado horizontal proporciona muchos más beneficios que el escalado vertical y está bien cubierto con las capacidades de Autoscaling o proyectos paralelos como KEDA. Entonces, en ese caso, ¿por qué Kubernetes está incluyendo esta característica y por qué estamos usando este sitio para discutirlo?

Porque con la transformación de Kubernetes para ser la alternativa de facto para cualquier implementación que realices hoy en día, las características y capacidades de las cargas de trabajo que necesitas manejar se han ampliado y por eso necesitas usar diferentes técnicas para proporcionar la mejor experiencia a cada uno de los tipos de cargas de trabajo.

¿Cómo el Autoscaling Vertical de Kubernetes?

Aquí encontrarás toda la documentación sobre esta nueva característica que, como se comentó, todavía está en la etapa «alfa», por lo que es algo para probar en modo experimental en lugar de usarlo a nivel de producción Documentación de HPA

El Escalado Vertical funciona de manera que podrás cambiar los recursos asignados al pod, CPU y memoria sin necesidad de reiniciar el pod y cambiar la declaración del manifiesto, y ese es un claro beneficio de este enfoque. Como sabes, hasta ahora si quieres cambiar los recursos aplicados a una carga de trabajo necesitas actualizar el documento del manifiesto y reiniciar el pod para aplicar los nuevos cambios.

Para definir esto necesitas especificar el resizePolicy agregando una nueva sección al manifiesto del pod como puedes ver aquí:

apiVersion: v1
kind: Pod
metadata:
  name: qos-demo-5
  namespace: qos-example
spec:
  containers:
  - name: qos-demo-ctr-5
    image: nginx
    resizePolicy:
    - resourceName: cpu
      restartPolicy: NotRequired
    - resourceName: memory
      restartPolicy: RestartContainer
    resources:
      limits:
        memory: "200Mi"
        cpu: "700m"
      requests:
        memory: "200Mi"
        cpu: "700m"

Por ejemplo, en este caso definimos para los diferentes nombres de recursos la política que queremos aplicar, si vamos a cambiar la CPU asignada no requerirá un reinicio, pero en caso de que estemos cambiando la memoria, requeriría un reinicio.

Eso implica que si deseas cambiar la CPU asignada, puedes parchear directamente el manifiesto como puedes ver en el fragmento a continuación y eso proporciona una actualización de los recursos asignados:

 kubectl -n qos-example patch pod qos-demo-5 --patch '{"spec":{"containers":[{"name":"qos-demo-ctr-5", "resources":{"requests":{"cpu":"800m"}, "limits":{"cpu":"800m"}}}]}}'

¿Cuándo usar el Escalado Vertical son los escenarios objetivo?

Dependerá de muchos escenarios diferentes del caso de uso, pero también de la pila tecnológica que está utilizando tu carga de trabajo para saber cuáles de estas capacidades pueden aplicarse. Como algo normal, el cambio de CPU será fácil de adaptar a cualquier tecnología, pero el de memoria sería más difícil dependiendo de la tecnología utilizada, ya que en la mayoría de las tecnologías la memoria asignada se define en el momento del inicio.

Esto ayudará a actualizar componentes que han cambiado sus requisitos como un escenario promedio o cuando estás probando nuevas cargas de trabajo con carga en vivo y no quieres interrumpir el procesamiento actual de la aplicación o simplemente cargas de trabajo que no admiten el escalado horizontal porque están diseñadas en modo de réplica única.

 Conclusión

En conclusión, Kubernetes ha introducido el Autoscaling Vertical de Pods, permitiendo el autoscaling vertical de cargas de trabajo de Kubernetes al agregar recursos a pods existentes. El autoscaling vertical de Kubernetes permite cambios de recursos sin reiniciar pods, proporcionando flexibilidad en la gestión de asignaciones de CPU y memoria.

El autoscaling vertical de Kubernetes ofrece una opción valiosa para adaptarse a las necesidades cambiantes de las cargas de trabajo. Complementa el escalado horizontal al proporcionar flexibilidad sin la necesidad de arquitecturas de software complejas. Al combinar enfoques de escalado vertical y horizontal, los usuarios de Kubernetes pueden optimizar sus implementaciones en función de las características específicas de la carga de trabajo y los recursos disponibles.

📚 Want to dive deeper into Kubernetes? This article is part of our comprehensive Kubernetes Architecture Patterns guide, where you’ll find all fundamental and advanced concepts explained step by step.

Kubernetes Autoscaling 1.26: ¿Un cambio de juego para los usuarios de KEDA?

Kubernetes Autoscaling 1.26: ¿Un cambio de juego para los usuarios de KEDA?

Introducción

El autoescalado de Kubernetes ha sufrido un cambio dramático. Desde el lanzamiento de Kubernetes 1.26, todos los componentes deben migrar sus objetos HorizontalPodAutoscaler de la versión v1 a la nueva versión v2 que ha estado disponible desde Kubernetes 1.23.

HorizontalPodAutoscaler es un componente crucial en cualquier carga de trabajo desplegada en un clúster de Kubernetes, ya que la escalabilidad de esta solución es uno de los grandes beneficios y características clave de este tipo de entorno.

Un poco de Historia

Kubernetes ha introducido una solución para la capacidad de autoescalado desde la versión Kubernetes 1.3 hace mucho tiempo, en 2016. Y la solución se basaba en un bucle de control que se ejecuta en un intervalo específico que puedes configurar con los parámetros de la propiedad --horizontal-pod-autoscaler-sync-period que pertenecen al kube-controller-manager.

Entonces, una vez durante este período, obtendrá las métricas y evaluará a través de la condición definida en el componente HorizontalPodAutoscaler. Inicialmente, se basaba en los recursos de cómputo utilizados por el pod, memoria principal y CPU.

Kubernetes Autoscaling 1.26: ¿Un cambio de juego para los usuarios de KEDA?

Esto proporcionó una excelente característica, pero con el paso del tiempo y la adopción del entorno de Kubernetes, se ha mostrado un poco limitado para manejar todos los escenarios que deberíamos tener, y aquí es donde otros proyectos impresionantes que hemos discutido aquí, como KEDA entran en escena para proporcionar un conjunto de características mucho más flexible.

Capacidades de Autoescalado de Kubernetes Introducidas v2

Con el lanzamiento de la v2 de los objetos de la API de Autoescalado, hemos incluido una gama de capacidades para mejorar la flexibilidad y las opciones disponibles ahora. Las más relevantes son las siguientes:

  • Escalado en métricas personalizadas: Con el nuevo lanzamiento, puedes configurar un objeto HorizontalPodAutoscaler para escalar usando métricas personalizadas. Cuando hablamos de métricas personalizadas, hablamos de cualquier métrica generada desde Kubernetes. Puedes ver una guía detallada sobre el uso de métricas personalizadas en la documentación oficial
  • Escalado en múltiples métricas: Con el nuevo lanzamiento, también tienes la opción de escalar basado en más de una métrica. Así que ahora el HorizontalPodAutoscaler evaluará cada condición de regla de escalado, propondrá un nuevo valor de escala para cada una de ellas, y tomará el valor máximo como el final.
  • Soporte para la API de Métricas: Con el nuevo lanzamiento, el controlador de los componentes de HoriztalPodAutoscaler recupera métricas de una serie de APIs registradas, como metrics.k8s.io, custom.metrics.k8s.io, external.metrics.k8s.io. Para más información sobre las diferentes métricas disponibles, puedes echar un vistazo a la propuesta de diseño
  • Comportamiento de Escalado Configurable: Con el nuevo lanzamiento, tienes un nuevo campo, behavior, que permite configurar cómo se comportará el componente en términos de actividad de escalado hacia arriba o hacia abajo. Así, puedes definir diferentes políticas para el escalado hacia arriba y otras para el escalado hacia abajo, limitar el número máximo de réplicas que se pueden agregar o eliminar en un período específico, para manejar los problemas con los picos de algunos componentes como las cargas de trabajo de Java, entre otros. También, puedes definir una ventana de estabilización para evitar el estrés cuando la métrica aún está fluctuando.

Kubernetes Autoscaling v2 vs KEDA

Hemos visto todos los nuevos beneficios que proporciona Autoscaling v2, así que estoy seguro de que la mayoría de ustedes se están haciendo la misma pregunta: ¿Está Kubernetes Autoscaling v2 matando a KEDA?

Desde las últimas versiones de KEDA, KEDA ya incluye los nuevos objetos bajo el grupo autoscaling/v2 como parte de su desarrollo, ya que KEDA se basa en los objetos nativos de Kubernetes, y simplifica parte del proceso que necesitas hacer cuando quieres usar métricas personalizadas o externas, ya que tienen escaladores disponibles para prácticamente todo lo que podrías necesitar ahora o incluso en el futuro.

Pero, incluso con eso, todavía hay características que KEDA proporciona que no están cubiertas aquí, como las capacidades de escalado “desde cero” y “a cero” que son muy relevantes para tipos específicos de cargas de trabajo y para obtener un uso muy optimizado de los recursos. Aún así, es seguro decir que con las nuevas características incluidas en el lanzamiento de autoscaling/v2, la brecha ahora es más pequeña. Dependiendo de tus necesidades, puedes optar por las capacidades listas para usar sin incluir un nuevo componente en tu arquitectura.

📚 Want to dive deeper into Kubernetes? This article is part of our comprehensive Kubernetes Architecture Patterns guide, where you’ll find all fundamental and advanced concepts explained step by step.

Opciones mejoradas de AutoScaling para aplicaciones impulsadas por eventos

Opciones mejoradas de AutoScaling para aplicaciones impulsadas por eventos

KEDA proporciona un entorno rico para escalar su aplicación aparte del enfoque tradicional de HPA usando CPU y Memoria

El escalado automático es una de las grandes ventajas de los entornos nativos de la nube y nos ayuda a proporcionar un uso optimizado de las operaciones. Kubernetes ofrece muchas opciones para hacerlo, siendo una de ellas el enfoque del Escalador Automático de Pods Horizontal (HPA). HPA es la forma en que Kubernetes detecta si es necesario escalar alguno de los pods, y se basa en métricas como el uso de CPU o memoria. https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/ A veces esas métricas no son suficientes para decidir si el número de réplicas que tenemos disponibles es suficiente. Otras métricas pueden proporcionar una mejor perspectiva, como el número de solicitudes o el número de eventos pendientes.

Escalado Automático Basado en Eventos de Kubernetes (KEDA)

Aquí es donde KEDA viene a ayudar. KEDA significa Escalado Automático Basado en Eventos de Kubernetes y proporciona un enfoque más flexible para escalar nuestros pods dentro de un clúster de Kubernetes. Se basa en escaladores que pueden implementar diferentes fuentes para medir el número de solicitudes o eventos que recibimos de diferentes sistemas de mensajería como Apache Kafka, AWS Kinesis, Azure EventHub y otros sistemas como InfluxDB o Prometheus. KEDA funciona como se muestra en la imagen a continuación:
Opciones mejoradas de AutoScaling para aplicaciones impulsadas por eventos
Tenemos nuestro ScaledObject que vincula nuestra fuente de eventos externa (es decir, Apache Kafka, Prometheus ..) con el Despliegue de Kubernetes que nos gustaría escalar y registrar eso en el clúster de Kubernetes. KEDA monitoreará la fuente externa y, basado en las métricas recopiladas, comunicará al Escalador Automático de Pods Horizontal para escalar la carga de trabajo según lo definido.

Probando el Enfoque con un Caso de Uso

Entonces, ahora que sabemos cómo funciona, haremos algunas pruebas para verlo en vivo. Vamos a mostrar cómo podemos escalar rápidamente una de nuestras aplicaciones usando esta tecnología. Y para hacer eso, lo primero que necesitamos hacer es definir nuestro escenario. En nuestro caso, el escenario será una aplicación nativa de la nube simple desarrollada usando una aplicación Flogo que expone un servicio REST. El primer paso que necesitamos hacer es desplegar KEDA en nuestro clúster de Kubernetes, y hay varias opciones para hacerlo: gráficos Helm, Operación o archivos YAML. En este caso, vamos a usar el enfoque de gráficos Helm. Entonces, vamos a escribir los siguientes comandos para agregar el repositorio helm y actualizar los gráficos disponibles, y luego desplegar KEDA como parte de nuestra configuración de clúster:
helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda
Después de ejecutar este comando, KEDA se despliega en nuestro clúster K8S, y al escribir el siguiente comando kubectl get all proporcionará una situación similar a esta:
pod/keda-operator-66db4bc7bb-nttpz 2/2 Running 1 10m
pod/keda-operator-metrics-apiserver-5945c57f94-dhxth 2/2 Running 1 10m
Ahora, vamos a desplegar nuestra aplicación. Como ya se comentó, para hacerlo vamos a usar nuestra Aplicación Flogo, y el flujo será tan simple como este:
Opciones mejoradas de AutoScaling para aplicaciones impulsadas por eventos
Aplicación Flogo escuchando las solicitudes
  • La aplicación expone un servicio REST usando /hello como el recurso.
  • Las solicitudes recibidas se imprimen en la salida estándar y se devuelve un mensaje al solicitante
Una vez que tenemos nuestra aplicación desplegada en nuestra aplicación de Kubernetes, necesitamos crear un ScaledObject que sea responsable de gestionar la escalabilidad de ese componente:
Opciones mejoradas de AutoScaling para aplicaciones impulsadas por eventos
Configuración de ScaleObject para la aplicación
Usamos Prometheus como un disparador, y debido a eso, necesitamos configurar dónde está alojado nuestro servidor Prometheus y qué consulta nos gustaría hacer para gestionar la escalabilidad de nuestro componente. En nuestro ejemplo, usaremos el flogo_flow_execution_count que es la métrica que cuenta el número de solicitudes que son recibidas por este componente, y cuando esto tiene una tasa superior a 100, lanzará una nueva réplica. Después de golpear el servicio con una Prueba de Carga, podemos ver que tan pronto como el servicio alcanza el umbral, lanza una nueva réplica para comenzar a manejar solicitudes como se esperaba.
Opciones mejoradas de AutoScaling para aplicaciones impulsadas por eventos
Escalado automático realizado usando métricas de Prometheus.
Todo el código y los recursos están alojados en el repositorio de GitHub que se muestra a continuación: https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/

Resumen

Este post ha mostrado que tenemos opciones ilimitadas para decidir las opciones de escalabilidad para nuestras cargas de trabajo. Podemos usar las métricas estándar como CPU y memoria, pero si necesitamos ir más allá, podemos usar diferentes fuentes externas de información para activar ese escalado automático.

📚 Want to dive deeper into Kubernetes? This article is part of our comprehensive Kubernetes Architecture Patterns guide, where you’ll find all fundamental and advanced concepts explained step by step.

Escalado automático de Kubernetes: Aprende a escalar tus implementaciones de Kubernetes de manera dinámica

Escalado automático de Kubernetes: Aprende a escalar tus implementaciones de Kubernetes de manera dinámica

Descubre las diferentes opciones para escalar tu plataforma según la carga de tráfico que recibas

Cuando hablamos de Kubernetes, siempre estamos hablando de las opciones de flexibilidad que proporciona. Normalmente, uno de los temas que surgen en la discusión son las opciones de elasticidad que vienen con la plataforma, especialmente cuando se trabaja con un proveedor de nube pública. Pero, ¿cómo podemos implementarlo realmente?

Antes de comenzar a mostrar cómo escalar nuestra plataforma Kubernetes, necesitamos hacer un breve repaso de las opciones que están disponibles para nosotros:

  • Cluster Autoscaler: Cuando la carga de toda la infraestructura alcanza su pico, podemos mejorarla creando nuevos nodos de trabajo para alojar más instancias de servicio.
  • Horizontal Pod Autoscaling: Cuando la carga para un pod específico o conjunto de pods alcanza su pico, desplegamos una nueva instancia para asegurar que podemos tener la disponibilidad global que necesitamos.

Veamos cómo podemos implementar esto usando uno de los servicios gestionados de Kubernetes más populares, los Servicios de Kubernetes Elásticos (EKS) de Amazon.


Configuración

Lo primero que vamos a hacer es crear un clúster con un solo nodo de trabajo para demostrar fácilmente el comportamiento de escalabilidad. Y para hacerlo, vamos a usar la herramienta de línea de comandos eksctl para gestionar fácilmente un clúster EKS.

Para poder crear el clúster, lo haremos con el siguiente comando:

eksctl create cluster --name=eks-scalability --nodes=1 --region=eu-west-2 --node-type=m5.large --version 1.17 --managed --asg-access

Después de unos minutos, tendremos nuestro propio clúster de Kubernetes con un solo nodo para desplegar aplicaciones sobre él.

Ahora vamos a crear una aplicación de muestra para generar carga. Vamos a usar TIBCO BusinessWorks Application Container Edition para generar una aplicación simple. Será una API REST que ejecutará un bucle de 100,000 iteraciones actuando como un contador y devolverá un resultado.

Aplicación de muestra de BusinessWorks para mostrar las opciones de escalabilidad
Aplicación de muestra de BusinessWorks para mostrar las opciones de escalabilidad

Y utilizaremos los recursos disponibles en este repositorio de GitHub:

Construiremos la imagen del contenedor y la subiremos a un registro de contenedores. En mi caso, voy a usar mi instancia de Amazon ECR para hacerlo, y usaré los siguientes comandos:

docker build -t testeks:1.0 .
docker tag testeks:1.0 938784100097.dkr.ecr.eu-west-2.amazonaws.com/testeks:1.0
docker push 938784100097.dkr.ecr.eu-west-2.amazonaws.com/testeks:1.0

Y una vez que la imagen esté subida al registro, desplegaremos la aplicación sobre el clúster de Kubernetes usando este comando:

kubectl apply -f .testeks.yaml

Después de eso, tendremos nuestra aplicación desplegada allí, como puedes ver en la imagen a continuación:

Imagen desplegada en el clúster de Kubernetes
Imagen desplegada en el clúster de Kubernetes

Entonces, ahora podemos probar la aplicación. Para hacerlo, haré que el puerto 8080 esté disponible usando un comando de reenvío de puerto como este:

kubectl port-forward pod/testeks-v1-869948fbb-j5jh7 8080:8080

Con eso, puedo ver y probar la aplicación de muestra usando el navegador, como se muestra a continuación:

Probador de Swagger UI para la aplicación de muestra de Kubernetes
Probador de Swagger UI para la aplicación de muestra de Kubernetes

Escalado automático de pods horizontales

Ahora, necesitamos comenzar a definir las reglas de escalado automático, y comenzaremos con la regla de Escalado Automático de Pods Horizontales (HPA). Necesitaremos elegir el recurso que nos gustaría usar para escalar nuestro pod. En esta prueba, usaré la utilización de CPU para hacerlo, y usaré el siguiente comando:

kubectl autoscale deployment testeks-v1 --min=1 --max=5 --cpu-percent=80

Ese comando escalará el conjunto de réplicas testeks de una (1) instancia a cinco (5) instancias cuando el porcentaje de utilización de CPU sea superior al 80%.

Si ahora verificamos el estado de los componentes, obtendremos algo similar a la imagen a continuación:

Definición de regla HPA para la aplicación usando la utilización de CPU como la métrica clave
Definición de regla HPA para la aplicación usando la utilización de CPU como la métrica clave

Si verificamos la columna TARGETS, veremos este valor: <unknown>/80%. Eso significa que el 80% es el objetivo para activar las nuevas instancias y el uso actual es <unknown>.

No tenemos nada desplegado en el clúster para obtener las métricas de cada uno de los pods. Para resolver eso, necesitamos desplegar el Servidor de Métricas. Para hacerlo, seguiremos la documentación de Amazon AWS:

Entonces, ejecutando el siguiente comando, tendremos el Servidor de Métricas instalado.

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.3.7/components.yaml

Y después de hacer eso, si verificamos nuevamente, podemos ver que el uso actual ha reemplazado el <unknown>:

Utilización actual de recursos después de instalar el servidor de métricas en el clúster de Kubernetes
Utilización actual de recursos después de instalar el Servidor de Métricas en el clúster de Kubernetes

Si eso funciona, voy a comenzar a enviar solicitudes usando una Prueba de Carga dentro del clúster. Usaré la aplicación de muestra definida a continuación:

Para desplegar, usaremos un archivo YAML con el siguiente contenido:

https://gist.github.com/BetterProgramming/53181f3aa7bee7b7e3adda7c4ed8ca40#file-deploy-yaml

Y lo desplegaremos usando el siguiente comando:

kubectl apply -f tester.yaml

Después de hacer eso, veremos que la utilización actual está aumentando. Después de unos segundos, comenzará a girar nuevas instancias hasta que alcance el número máximo de pods definido en la regla HPA.

Aumento de pods cuando la carga excede el objetivo definido en pasos anteriores.
Aumento de pods cuando la carga excede el objetivo definido en pasos anteriores.

Luego, tan pronto como la carga también disminuya, el número de instancias será eliminado.

Los pods se eliminan tan pronto como la carga disminuye.
Los pods se eliminan tan pronto como la carga disminuye.

Escalado automático de clústeres

Ahora, necesitamos ver cómo podemos implementar el Escalador Automático de Clústeres usando EKS. Usaremos la información que proporciona Amazon:

https://github.com/alexandrev/testeks

El primer paso es desplegar el escalado automático del clúster, y lo haremos usando el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/autoscaler/master/cluster-autoscaler/cloudprovider/aws/examples/cluster-autoscaler-autodiscover.yaml

Luego ejecutaremos este comando:

kubectl -n kube-system annotate deployment.apps/cluster-autoscaler cluster-autoscaler.kubernetes.io/safe-to-evict=”false”

Y editaremos el despliegue para proporcionar el nombre actual del clúster que estamos gestionando. Para hacer eso, ejecutaremos el siguiente comando:

kubectl -n kube-system edit deployment.apps/cluster-autoscaler

Cuando tu editor de texto predeterminado se abra con el contenido del texto, necesitas hacer los siguientes cambios:

  • Establece el nombre de tu clúster en el marcador de posición disponible.
  • Agrega estas propiedades adicionales:
- --balance-similar-node-groups
- --skip-nodes-with-system-pods=false
Ediciones de despliegue necesarias para configurar el Escalador Automático de Clústeres
Ediciones de despliegue necesarias para configurar el Escalador Automático de Clústeres

Ahora necesitamos ejecutar el siguiente comando:

kubectl -n kube-system set image deployment.apps/cluster-autoscaler cluster-autoscaler=eu.gcr.io/k8s-artifacts-prod/autoscaling/cluster-autoscaler:v1.17.4

Lo único que queda es definir la política de AutoScaling. Para hacerlo, usaremos el portal de Servicios de AWS:

  • Ingresa a la página de servicio EC en la región en la que hemos desplegado el clúster.
  • Selecciona las opciones de Grupo de Auto Scaling.
  • Selecciona el Grupo de Auto Scaling que se ha creado como parte del proceso de creación del clúster EKS.
  • Ve a la pestaña de Escalado Automático y haz clic en el botón Agregar Política disponible.
Opción de política de escalado automático en la consola de servicio EC2
Opción de política de escalado automático en la consola de servicio EC2

Luego deberíamos definir la política. Usaremos la utilización promedio de CPU como la métrica y estableceremos el valor objetivo en 50%:

Diálogo de creación de política de escalado automático
Diálogo de creación de política de escalado automático

Para validar el comportamiento, generaremos carga usando el probador como lo hicimos en la prueba anterior y validaremos la carga del nodo usando el siguiente comando:

kubectl top nodes
Salida de muestra de kubectl top nodes
Salida de muestra de kubectl top nodes

Ahora desplegamos el probador nuevamente. Como ya lo tenemos desplegado en este clúster, necesitamos eliminarlo primero para desplegarlo nuevamente:

kubectl delete -f .tester.yaml
kubectl apply -f .tester.yaml

Tan pronto como comience la carga, se crearán nuevos nodos, como se muestra en la imagen a continuación:

Salida de muestra de kubectl top nodes
kubectl top nodes mostrando cómo los nodos han sido escalados hacia arriba

Después de que la carga termine, volvemos a la situación anterior:

kubectl top nodes mostrando cómo los nodos han sido escalados hacia abajo
kubectl top nodes mostrando cómo los nodos han sido escalados hacia abajo

Resumen

En este artículo, hemos mostrado cómo podemos escalar un clúster de Kubernetes de manera dinámica tanto a nivel de nodo de trabajo usando la capacidad de Escalador Automático de Clústeres como a nivel de pod usando el Escalador Automático de Pods Horizontales. Eso nos da todas las opciones necesarias para crear un entorno verdaderamente elástico y flexible capaz de adaptarse a las necesidades de cada momento con el enfoque más eficiente.

📚 Want to dive deeper into Kubernetes? This article is part of our comprehensive Kubernetes Architecture Patterns guide, where you’ll find all fundamental and advanced concepts explained step by step.