Descripción general

En este lab, configurará una aplicación en Google Kubernetes Engine (GKE) y usará un objeto HorizontalPodAutoscaler para realizar un ajuste de escala automático de la aplicación web. Luego, trabajará con varios grupos de nodos de diferentes tipos y aplicará taints y tolerancias para controlar la programación de Pods respecto del grupo de nodos subyacente.

Objetivos

En este lab, aprenderá a realizar las siguientes tareas:

• Configurar el ajuste de escala automático y HorizontalPodAutoscaler
• Agregar un grupo de nodos y configurar los taints en los nodos para la antiafinidad de los Pods
• Configurar una excepción para el taint de nodo agregando una tolerancia al manifiesto de un Pod

Configuración del lab

Accede a Qwiklabs

En cada lab, recibirá un proyecto de Google Cloud y un conjunto de recursos nuevos por tiempo limitado y sin costo adicional.

1. Accede a Qwiklabs desde una ventana de incógnito.

2. Ten en cuenta el tiempo de acceso del lab (por ejemplo, 1:15:00) y asegúrate de finalizarlo en el plazo asignado.
   No existe una función de pausa. Si lo necesita, puede reiniciar el lab, pero deberá hacerlo desde el comienzo.

3. Cuando esté listo, haga clic en Comenzar lab.

4. Anote las credenciales del lab (el nombre de usuario y la contraseña). Las usarás para acceder a la consola de Google Cloud.

5. Haga clic en Abrir Google Console.

6. Haga clic en Usar otra cuenta, copie las credenciales para este lab y péguelas en el mensaje emergente que aparece.
   Si usa otras credenciales, se generarán errores o incurrirá en cargos.

7. Acepta las condiciones y omite la página de recursos de recuperación.

Después de completar los pasos iniciales de acceso, aparecerá el panel del proyecto.

Activa Google Cloud Shell

Google Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud.

Google Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. En la consola de Cloud, en la barra de herramientas superior derecha, haz clic en el botón Abrir Cloud Shell.

   

2. Haz clic en Continuar.

El aprovisionamiento y la conexión al entorno demorarán unos minutos. Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. Por ejemplo:

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con el completado de línea de comando.

• Puedes solicitar el nombre de la cuenta activa con este comando:

gcloud auth list

Resultado:

Credentialed accounts: - @.com (active)

Resultado de ejemplo:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Puedes solicitar el ID del proyecto con este comando:

gcloud config list project

Resultado:

[core] project =

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: La documentación completa de gcloud está disponible en la guía de descripción general de gcloud CLI .

Tarea 1: Conéctese al clúster de GKE del lab y, luego, implemente una carga de trabajo de muestra

En esta tarea, se conectará al clúster de GKE del lab y creará un manifiesto de implementación para un conjunto de Pods dentro del clúster.

Conéctate al clúster de GKE del lab

1. En Cloud Shell, escribe el siguiente comando para establecer la variable de entorno para la zona y el nombre del clúster:

export my_zone={{{project_0.default_zone|ZONE}}} export my_cluster=standard-cluster-1

2. Configura el completado de línea de comando para la herramienta de línea de comandos de kubectl:

source <(kubectl completion bash)

3. Configura el acceso al clúster para kubectl:

gcloud container clusters get-credentials $my_cluster --zone $my_zone

Implemente una aplicación web de muestra en su clúster de GKE

Implementará una aplicación de muestra en su clúster mediante el archivo de implementación web.yaml que se creó para usted:

apiVersion: apps/v1 kind: Deployment metadata: name: web spec: replicas: 1 selector: matchLabels: run: web template: metadata: labels: run: web spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # Debe especificar las solicitudes de ajuste de escala automático # de la CPU según su uso de CPU requests: cpu: "250m"

Con este manifiesto, se crea una implementación utilizando una imagen de contenedor de la aplicación web de muestra que escucha en un servidor HTTP en el puerto 8080.

1. En Cloud Shell, ingresa el siguiente comando para clonar el repositorio en el entorno de Cloud Shell del lab:

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crea un vínculo simbólico como un acceso directo al directorio de trabajo:

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Cambia al directorio que contenga los archivos de muestra de este lab:

cd ~/ak8s/Autoscaling/

4. Para crear una implementación a partir de este archivo, ejecute el siguiente comando:

kubectl create -f web.yaml --save-config

5. Crea un recurso de servicio del tipo NodePort en el puerto 8080 para la implementación web:

kubectl expose deployment web --target-port=8080 --type=NodePort

6. Verifique que se haya creado el servicio y que se haya asignado un puerto de nodo:

kubectl get service web

Es posible que tu dirección IP y número de puerto sean diferentes del resultado de ejemplo.

Resultado:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE web NodePort 10.11.246.185 8080:32056/TCP 12s

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar una aplicación web de muestra en un clúster de GKE

Tarea 2: Configure el ajuste de escala automático en el clúster

En esta tarea, configurará el clúster para que realice un ajuste de escala automático de la aplicación de muestra que implementó anteriormente.

Configura el ajuste de escala automático

1. Obtén la lista de implementaciones para determinar si tu aplicación web de muestra aún se está ejecutando:

kubectl get deployment

El resultado debería verse como el ejemplo.

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE web 1/1 1 1 5m48s

Si no se muestra la implementación web de su aplicación, regrese a la tarea 1 y vuelva a implementarla en el clúster.

2. Para configurar el ajuste de escala automático en su aplicación de muestra (y establecer la cantidad máxima de réplicas en cuatro y la mínima en una, con un objetivo de uso de CPU del 1%), ejecute el siguiente comando:

kubectl autoscale deployment web --max 4 --min 1 --cpu-percent 1

Cuando usas kubectl autoscale, debes especificar una cantidad máxima y mínima de réplicas para tu aplicación, así como un objetivo de uso de CPU.

3. Obtén la lista de implementaciones para verificar que aún haya una sola implementación de la aplicación web:

kubectl get deployment

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE web 1/1 1 1 8m21s

Inspeccione el objeto HorizontalPodAutoscaler

El comando kubectl autoscale que utilizó en la tarea anterior crea un objeto HorizontalPodAutoscaler que se orienta a un recurso especificado (denominado objetivo de escalamiento) y lo escala según sea necesario.

El escalador automático ajusta periódicamente la cantidad de réplicas del objetivo de escalamiento para que se ajuste al uso de CPU promedio que usted especifica cuando crea dicho escalador.

1. Para obtener la lista de los recursos de HorizontalPodAutoscaler, ejecute el siguiente comando:

kubectl get hpa

El resultado debería verse como el ejemplo.

Resultado:

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 0%/1% 1 4 1 1m

2. Para inspeccionar la configuración de HorizontalPodAutoscaler en formato de tabla, ejecute el siguiente comando:

kubectl describe horizontalpodautoscaler web

El resultado debería verse como el ejemplo.

Resultado:

Name: web Namespace: default Labels: Annotations: CreationTimestamp: Tue, 08 Sep 2020... Reference: Deployment/web Metrics: ( current / target ) resource cpu on pods (as a percentage of request): 0% (0) / 1% Min replicas: 1 Max replicas: 4 Deployment pods: 1 current / 1 desired Conditions: Type Status Reason Message ---- ------ ------ ------- AbleToScale True ScaleDownStabilized recent recommendations [...] ScalingActive True ValidMetricFound the HPA was able to [...] ScalingLimited False DesiredWithinRange the desired count [...] Events:

3. Para ver la configuración de HorizontalPodAutoscaler en formato YAML, ejecuta el siguiente comando:

kubectl get horizontalpodautoscaler web -o yaml

El resultado debería verse como el ejemplo.

Resultado:

apiVersion: autoscaling/v1 kind: HorizontalPodAutoscaler metadata: annotations: autoscaling.alpha.kubernetes.io/conditions: [...] autoscaling.alpha.kubernetes.io/current-metrics: [...] creationTimestamp: 2018-11-14T02:59:28Z name: web namespace: default resourceVersion: "14588" selfLink: /apis/autoscaling/v1/namespaces/[...] spec: maxReplicas: 4 minReplicas: 1 scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: web targetCPUUtilizationPercentage: 1 status: currentCPUUtilizationPercentage: 0 currentReplicas: 1 desiredReplicas: 1

Pruebe la configuración del ajuste de escala automático

Deberá crear una carga pesada en la aplicación web para forzarla a escalar horizontalmente. Cree un archivo de configuración en el que se defina una implementación de cuatro contenedores que ejecuten un bucle infinito de consultas HTTP en el servidor web de la aplicación de muestra.

A fin de crear la carga en su aplicación web, implemente la aplicación loadgen utilizando el archivo loadgen.yaml proporcionado.

apiVersion: apps/v1 kind: Deployment metadata: name: loadgen spec: replicas: 4 selector: matchLabels: app: loadgen template: metadata: labels: app: loadgen spec: containers: - name: loadgen image: k8s.gcr.io/busybox args: - /bin/sh - -c - while true; do wget -q -O- http://web:8080; done

1. Ejecute el siguiente comando para implementar este contenedor:

kubectl apply -f loadgen.yaml

Una vez implementado este manifiesto, el Pod web debería comenzar a escalar.

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar la aplicación loadgen

2. Obtén la lista de implementaciones para verificar que el generador de cargas se esté ejecutando:

kubectl get deployment

El resultado debería verse como el ejemplo.

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 4/4 4 4 26s web 1/1 1 1 14m

3. Inspecciona HorizontalPodAutoscaler:

kubectl get hpa

Cuando el Pod de loadgen comience a generar tráfico, comenzará a aumentar el uso de CPU para la implementación web. En el resultado de ejemplo, los objetivos ahora tienen un uso de CPU del 35%, en comparación con el umbral del 1%.

Resultado:

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 35%/1% 1 4 1 8m

4. Espera unos minutos y vuelve a inspeccionar HorizontalPodAutoscaler:

kubectl get hpa

El escalador automático incrementó la implementación web a cuatro réplicas.

Resultado:

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 88%/1% 1 4 4 9m

5. Para detener la carga en la aplicación web, escala la implementación de loadgen a cero réplicas:

kubectl scale deployment loadgen --replicas 0

6. Obtén la lista de implementaciones para verificar que la escala de loadgen se haya reducido verticalmente:

kubectl get deployment

La implementación de loadgen debería tener cero réplicas.

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 0/0 0 0 3m40s web 2/4 4 2 18m Nota: Debes esperar entre 2 y 3 minutos antes de volver a generar la lista de implementaciones.

7. Obtén la lista de implementaciones para verificar que la aplicación web haya reducido su escala verticalmente al valor mínimo de 1 réplica que configuraste cuando implementaste el escalador automático:

kubectl get deployment

Ahora, deberías tener una sola implementación de la aplicación web.

Resultado:

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 0/0 0 0 12m web 1/1 1 1 14m

Tarea 3. Administre los grupos de nodos

En esta tarea, creará un nuevo grupo de nodos utilizando instancias interrumpibles. Luego, limitará la implementación web para que se ejecute únicamente en los nodos interrumpibles.

Agregue un grupo de nodos

1. Para implementar un nuevo grupo de nodos con tres instancias de VM interrumpibles, ejecute el siguiente comando:

gcloud container node-pools create "temp-pool-1" \ --cluster=$my_cluster --zone=$my_zone \ --num-nodes "2" --node-labels=temp=true --preemptible

Si recibes un error que te indica que no hay instancias interrumpibles disponibles, puedes quitar la opción --preemptible para continuar con el lab.

2. Obtén la lista de nodos para verificar que los nodos nuevos estén listos:

kubectl get nodes

Ahora, debería tener 4 nodos.

Tus nombres serán distintos a los del resultado de ejemplo.

Resultado:

NAME STATUS ROLES AGE VERSION gke-standard-cluster-1-default-pool...xc Ready 33m v1.19.10-gke.1600 gke-standard-cluster-1-default-pool...q8 Ready 33m v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...vj Ready 32s v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...xj Ready 37s v1.19.10-gke.1600

Todos los nodos que agregaste tienen la etiqueta temp=true porque la estableciste cuando creaste el grupo de nodos. Con esta etiqueta, resulta más fácil localizar y configurar estos nodos.

3. Para obtener una lista de los nodos con la etiqueta temp=true, ejecute el siguiente comando:

kubectl get nodes -l temp=true

Debería ver solamente los dos nodos que agregó.

Tus nombres serán distintos a los del resultado de ejemplo.

Resultado:

NAME STATUS ROLES AGE VERSION gke-standard-cluster-1-temp-pool-1-...vj Ready 3m26s v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...xj Ready 3m31s v1.19.10-gke.1600

Controla la programación con taints y tolerancias

Para impedir que el programador ejecute un Pod en los nodos temporales, agregue un taint a cada uno de los nodos del grupo temporal. Los taints se implementan como un par clave-valor con un efecto (como NoExecute) que determina si los Pods pueden ejecutarse en un determinado nodo. Solamente los nodos configurados para tolerar el par clave-valor del taint están programados para ejecutarse en estos nodos.

1. Para agregar un taint a cada uno de los nodos recién creados, ejecuta el siguiente comando:

Puedes usar la etiqueta temp=true para aplicar este cambio en todos los nodos nuevos de forma simultánea:

kubectl taint node -l temp=true nodetype=preemptible:NoExecute

Para permitir que los Pods de la aplicación se ejecuten en estos nodos con taints, debes agregar una clave de tolerancias a la configuración de la implementación.

2. Para editar el archivo web.yaml, ejecuta el siguiente comando:

nano web.yaml

3. Agrega la siguiente clave en la sección spec de la plantilla:

tolerations: - key: "nodetype" operator: Equal value: "preemptible"

La sección spec del archivo debería ser similar al siguiente ejemplo:

... spec: tolerations: - key: "nodetype" operator: Equal value: "preemptible" containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

4. Para que la implementación web utilice el nuevo grupo de nodos, agrega una clave nodeSelector en la sección spec de la plantilla, al mismo nivel que la clave de tolerancias que acaba de agregar:

nodeSelector: temp: "true" Nota: GKE agrega una etiqueta personalizada a cada nodo, denominada cloud.google.com/gke-nodepool, que contiene el nombre del grupo al cual pertenece el nodo. También puede usarse esta clave como parte de un nodeSelector para garantizar que los Pods solo se implementen en los nodos adecuados.

Ahora, la implementación completa de web.yaml debería ser similar a lo siguiente:

apiVersion: apps/v1 kind: Deployment metadata: name: web spec: replicas: 1 selector: matchLabels: run: web template: metadata: labels: run: web spec: tolerations: - key: "nodetype" operator: Equal value: "preemptible" nodeSelector: temp: "true" containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

5. Presiona CTRL + X y, luego, la tecla Y seguida de Intro para guardar el archivo y salir del editor nano.

6. Ejecuta el siguiente comando para aplicar este cambio:

kubectl apply -f web.yaml

Si tiene problemas para editar correctamente este archivo, puede utilizar, en su lugar, el archivo de ejemplo ya preparado llamado web-tolerations.yaml.

Haz clic en Revisar mi progreso para verificar el objetivo. Administrar los grupos de nodos

7. Obtén la lista de Pods:

kubectl get pods

Puede que tus nombres sean distintos a los del resultado de ejemplo.

Resultado:

NAME READY STATUS RESTARTS AGE web-7cb566bccd-pkfst 1/1 Running 0 1m

6. Para confirmar el cambio, inspecciona los Pods web en ejecución a través del siguiente comando:

kubectl describe pods -l run=web

Casi al final del resultado (truncado), debería aparecer una sección Tolerations con nodetype=preemptible en la lista.

Resultado:

Node-Selectors: temp=true Tolerations: node.kubernetes.io/not-ready:NoExecute op=Exists for 300s node.kubernetes.io/unreachable:NoExecute op=Exists for 300s nodetype=preemptible Events:

El resultado confirma que los Pods tolerarán el valor de los taints en los nuevos nodos interrumpibles y que, por lo tanto, pueden programarse para ejecutarse en esos nodos.

7. Para forzar nuevamente el escalamiento horizontal de la aplicación web, escala la implementación de loadgen para que vuelva a tener cuatro réplicas:

kubectl scale deployment loadgen --replicas 4

Podrías escalar solo la aplicación web de forma directa, pero, si utilizas la app loadgen, podrás ver cómo los distintos parámetros de configuración de los taints, las tolerancias y nodeSelector que se aplican a las aplicaciones web y loadgen afectan a los nodos en los que se programan.

8. Obtén la lista de Pods con el formato de resultado amplio para mostrar los nodos que ejecutan los Pods:

kubectl get pods -o wide

Esto muestra que la app loadgen se está ejecutando solo en los nodos default-pool, mientras que la aplicación web se está ejecutando solo en los nodos interrumpibles en temp-pool-1.

La configuración de los taints impide que los Pods se ejecuten en los nodos interrumpibles, de modo que la aplicación loadgen solo se ejecuta en el grupo predeterminado. La configuración de tolerancias permite que la aplicación web se ejecute en los nodos interrumpibles, y nodeSelector fuerza la ejecución de los pods de la aplicación web en esos nodos.

NAME READY STATUS [...] NODE Loadgen-x0 1/1 Running [...] gke-xx-default-pool-y0 loadgen-x1 1/1 Running [...] gke-xx-default-pool-y2 loadgen-x3 1/1 Running [...] gke-xx-default-pool-y3 loadgen-x4 1/1 Running [...] gke-xx-default-pool-y4 web-x1 1/1 Running [...] gke-xx-temp-pool-1-z1 web-x2 1/1 Running [...] gke-xx-temp-pool-1-z2 web-x3 1/1 Running [...] gke-xx-temp-pool-1-z3 web-x4 1/1 Running [...] gke-xx-temp-pool-1-z4

Finalice su lab

Cuando haya completado el lab, haga clic en Finalizar lab. Google Cloud Skills Boost quitará los recursos que usó y limpiará la cuenta.

Tendrá la oportunidad de calificar su experiencia en el lab. Seleccione la cantidad de estrellas que corresponda, ingrese un comentario y haga clic en Enviar.

La cantidad de estrellas indica lo siguiente:

• 1 estrella = Muy insatisfecho
• 2 estrellas = Insatisfecho
• 3 estrellas = Neutral
• 4 estrellas = Satisfecho
• 5 estrellas = Muy satisfecho

Puede cerrar el cuadro de diálogo si no desea proporcionar comentarios.

Para enviar comentarios, sugerencias o correcciones, use la pestaña Asistencia.

Copyright 2020 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.