GSP182

Descripción general

En este lab, aprenderás a utilizar Kubernetes Engine para implementar un framework de prueba de carga distribuida. El framework usa varios contenedores con el objetivo de crear tráfico de prueba de carga para una API simple basada en REST. A pesar de que esta solución pone a prueba una aplicación web simple, se puede usar el mismo patrón si se quieren crear situaciones de prueba de carga más complejas, como aplicaciones de Internet de las cosas (IoT) o de videojuegos. Esta solución analiza la arquitectura general de un framework de prueba de carga basado en contenedores.

Sistema a prueba

Para este lab, el sistema que se somete a prueba es una pequeña aplicación web implementada en Google App Engine. La aplicación expone extremos de estilo REST básicos para capturar solicitudes POST de HTTP entrantes (los datos entrantes no se conservan).

Ejemplos de cargas de trabajo

La aplicación que implementarás se basa en el componente de servicio de backend que se encuentra en muchas implementaciones de Internet de las cosas (IoT). Los dispositivos primero se registran en el servicio y, luego, comienzan a enviar métricas o lecturas de sensores, a la vez que se vuelven a registrar regularmente en el servicio.

La interacción del componente de servicio de backend común se ve de la siguiente manera:

Para modelar esta interacción, usarás Locust, una herramienta de prueba de carga distribuida y basada en Python que es capaz de distribuir solicitudes a través de varias rutas de destino. Por ejemplo, puede distribuir solicitudes a las rutas de destino /login y /metrics.

La carga de trabajo se basa en la interacción descrita anteriormente y se modela como un conjunto de tareas en Locust. Para aproximarse a los clientes del mundo real, cada tarea de Locust está ponderada. Por ejemplo, el registro se realiza una vez por cada mil solicitudes totales de clientes.

Procesamiento basado en contenedores

• La imagen del contenedor de Locust es una imagen de Docker que contiene el software de Locust.

• Un clúster de contenedor consta de al menos una instancia principal del clúster y varias máquinas trabajadoras, llamadas nodos. Estas máquinas de instancia principal y de nodo ejecutan el sistema de organización de clústeres de Kubernetes. Para obtener más información sobre los clústeres, consulta la Documentación de Kubernetes Engine.

• Un pod es un contenedor o varios implementados juntos en un host, y es la unidad de procesamiento más pequeña que se puede definir, implementar y administrar. Algunos Pods contienen un solo contenedor. Por ejemplo, en este lab, cada uno de los contenedores de Locust se ejecuta en su propio Pod.

• Un controlador de implementación proporciona actualizaciones declarativas de los Pods y ReplicaSets. En este lab, hay dos implementaciones: una para locust-master y otra para locust-worker.

Objetos Service

Un Pod en particular puede desaparecer por varias razones, entre las que se incluye la falla en un nodo o la interrupción intencional del nodo para realizar actualizaciones o mantenimiento. Esto significa que la dirección IP de un Pod no proporciona una interfaz confiable para ese Pod. Un enfoque más confiable usaría una representación abstracta de esa interfaz que nunca cambia, incluso si el Pod subyacente desaparece y se reemplaza por un Pod nuevo con una dirección IP diferente. Un Service de Kubernetes Engine proporciona este tipo de interfaz abstracta por medio de la definición de un conjunto lógico de Pods y una política para acceder a ellos.

En este lab, hay varios objetos Service que representan Pods o conjuntos de Pods. Por ejemplo, hay un Service para el Pod del servidor DNS, otro Service para el Pod principal de Locust y un Service que representa los 10 Pods trabajadores de Locust.

En el siguiente diagrama, se muestran los contenidos del nodo principal y de los nodos trabajadores:

Aprendizajes esperados

• Crea un sistema a prueba, es decir, una pequeña aplicación web implementada en Google App Engine.
• Usa Kubernetes Engine para implementar un marco de trabajo de prueba de carga distribuida.
• Crea un tráfico de prueba de carga para una API simple basada en REST.

Requisitos previos

• Se recomienda estar familiarizado con los servicios de Google Cloud de Kubernetes Engine y App Engine
• Conocimientos de editores de texto estándares de Linux, como Vim, Emacs o Nano

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón Abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia Cuenta de Google podría generar cargos adicionales.

7. Haga clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para ver un menú con una lista de productos y servicios de Google Cloud, haz clic en el menú de navegación que se encuentra en la parte superior izquierda.

Activa Cloud Shell

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. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. El resultado contiene una línea que declara el PROJECT_ID para esta sesión:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

2. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

3. Haz clic en Autorizar.

4. Ahora, el resultado debería verse de la siguiente manera:

Resultado:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: Para obtener toda la documentación de gcloud, consulta la guía con la descripción general de gcloud CLI en Google Cloud.

Tarea 1. Configura el proyecto y la zona

• Define las variables de entorno de ID del proyecto, región y zona que deseas usar para el lab.

PROJECT=$(gcloud config get-value project) REGION={{{ project_0.default_region | "REGION" }}} ZONE={{{ project_0.default_zone | "ZONE" }}} CLUSTER=gke-load-test TARGET=${PROJECT}.appspot.com gcloud config set compute/region $REGION gcloud config set compute/zone $ZONE

Tarea 2. Obtén el código de muestra y crea una imagen de Docker para la aplicación

1. Obtén el código fuente del repositorio ejecutando lo siguiente:

gsutil -m cp -r gs://spls/gsp182/distributed-load-testing-using-kubernetes .

2. Ingresa al directorio:

cd distributed-load-testing-using-kubernetes/

3. Crea una imagen de Docker y almacénala en Container Registry:

gcloud builds submit --tag gcr.io/$PROJECT/locust-tasks:latest docker-image/.

Resultado de ejemplo:

ID CREATE_TIME DURATION SOURCE IMAGES STATUS 47f1b8f7-0b81-492c-aa3f-19b2b32e515d xxxxxxx 51S gs://project_id_cloudbuild/source/1554261539.12-a7945015d56748e796c55f17b448e368.tgz gcr.io/project_id/locust-tasks (+1 more) SUCCESS

Haz clic en Revisar mi progreso para verificar el objetivo. Obtener el código de muestra y crear una imagen de Docker para la aplicación

Tarea 3. Implementa la aplicación web

La carpeta sample-webapp contiene una aplicación de Python de Google App Engine simple como “sistema a prueba”.

• Para implementar la aplicación en tu proyecto, usa el comando gcloud app deploy:

gcloud app deploy sample-webapp/app.yaml

Después de ejecutar el comando, se te solicitará lo siguiente.

Please choose the region where you want your App Engine application located:

De la lista de regiones, puedes elegir , ya que seleccionamos como la región para este proyecto. Por ejemplo, para elegir us-central, ingresa "10" como la entrada para el mensaje.

Please enter your numeric choice: 10 Nota: Necesitarás la URL de la aplicación web de muestra implementada cuando implementes locust-master y locust-worker que ya están almacenados en la variable TARGET.

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

Tarea 4. Implementa el clúster de Kubernetes

• Crea el clúster de Google Kubernetes Engine con el comando de gcloud que se muestra a continuación:

gcloud container clusters create $CLUSTER \ --zone $ZONE \ --num-nodes=5

Resultado de ejemplo:

NAME: gke-load-test LOCATION: {{{ project_0.default_zone | "ZONE" }}} MASTER_VERSION: 1.11.7-gke.12 MASTER_IP: 34.66.156.246 MACHINE_TYPE: n1-standard-1 NODE_VERSION: 1.11.7-gke.12 NUM_NODES: 5 STATUS: RUNNING

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar el clúster de Kubernetes

Tarea 5. Carga la instancia principal de prueba

El primer componente de la implementación es la instancia principal de Locust, que constituye el punto de entrada para ejecutar las tareas de prueba de carga descritas anteriormente. La instancia principal de Locust se implementa con una única réplica porque solo necesitamos una instancia principal.

La configuración de la implementación de la instancia principal especifica varios elementos, incluidos los puertos que el contenedor debe exponer (8089 para la interfaz web, 5557 y 5558 para comunicarse con los trabajadores). Esta información se usa más adelante para configurar las instancias de trabajador de Locust.

El siguiente fragmento contiene la configuración de los puertos:

ports: - name: loc-master-web containerPort: 8089 protocol: TCP - name: loc-master-p1 containerPort: 5557 protocol: TCP - name: loc-master-p2 containerPort: 5558 protocol: TCP

Tarea 6. Implementa locust-master

1. Reemplaza [TARGET_HOST] y [PROJECT_ID] en locust-master-controller.yaml y locust-worker-controller.yaml con el extremo y el ID del proyecto implementados, respectivamente.

sed -i -e "s/\[TARGET_HOST\]/$TARGET/g" kubernetes-config/locust-master-controller.yaml sed -i -e "s/\[TARGET_HOST\]/$TARGET/g" kubernetes-config/locust-worker-controller.yaml sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kubernetes-config/locust-master-controller.yaml sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kubernetes-config/locust-worker-controller.yaml

2. Implementa la instancia principal de Locust:

kubectl apply -f kubernetes-config/locust-master-controller.yaml

3. Para confirmar que se haya creado el Pod locust-master, ejecuta el siguiente comando:

kubectl get pods -l app=locust-master

4. A continuación, implementa locust-master-service:

kubectl apply -f kubernetes-config/locust-master-service.yaml

En este paso, se expondrán el Pod con un nombre de DNS interno (locust-master) y los puertos 8089, 5557 y 5558. Como parte de este paso, la directiva type: LoadBalancer en locust-master-service.yaml le indicará a Google Kubernetes Engine que cree una regla de reenvío de Compute Engine desde una dirección IP disponible públicamente al Pod locust-master.

5. Para ver la regla de reenvío que acabas de crear, ejecuta lo siguiente:

kubectl get svc locust-master

Resultado de ejemplo:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE locust-master LoadBalancer 10.59.244.88 35.222.161.198 8089:30865/TCP,5557:30707/TCP,5558:31327/TCP 1m

Haz clic en Revisar mi progreso para verificar el objetivo. Cargar la instancia principal de prueba

Tarea 7. Carga las instancias de trabajador de prueba

El siguiente componente de la implementación incluye las instancias de trabajador de Locust, que ejecutan las tareas de prueba de carga descritas anteriormente. Las instancias de trabajador de Locust se implementan mediante una única implementación que crea varios Pods. Los Pods se extienden a través del clúster de Kubernetes. Cada Pod usa variables de entorno para controlar información importante de la configuración, como el nombre de host del sistema a prueba y el nombre de host de la instancia principal de Locust.

Después de que se implementen las instancias de trabajador de Locust, puedes volver a la interfaz web de la instancia principal de Locust y comprobar que la cantidad de instancias secundarias se corresponda con la cantidad de trabajadores implementados.

El siguiente fragmento contiene la configuración de implementación del nombre, las etiquetas y la cantidad de réplicas:

apiVersion: "apps/v1" kind: "Deployment" metadata: name: locust-worker labels: name: locust-worker spec: replicas: 5 selector: matchLabels: app: locust-worker template: metadata: labels: app: locust-worker spec: ...

Implementa locust-worker

1. Ahora implementa locust-worker-controller:

kubectl apply -f kubernetes-config/locust-worker-controller.yaml

2. locust-worker-controller está configurado para implementar 5 Pods de locust-worker. Para confirmar que se hayan implementado, ejecuta lo siguiente:

kubectl get pods -l app=locust-worker

Aumentar la cantidad de usuarios simulados requerirá de un aumento en la cantidad de Pods trabajadores de Locust. Para aumentar la cantidad de Pods implementados, Kubernetes ofrece la capacidad de cambiar el tamaño de las implementaciones sin volver a implementarlas.

3. El siguiente comando escala el grupo de Pods trabajadores de Locust a 20:

kubectl scale deployment/locust-worker --replicas=20

4. Para confirmar que los Pods se hayan iniciado y estén listos, obtén la lista de Pods de locust-worker:

kubectl get pods -l app=locust-worker

En el siguiente diagrama, se muestra la relación entre la instancia principal y las instancias de trabajador de Locust:

Haz clic en Revisar mi progreso para verificar el objetivo. Cargar las instancias de trabajador de prueba

Tarea 8. Ejecuta pruebas

1. Para ejecutar las pruebas de Locust, obtén la dirección IP externa con el siguiente comando:

EXTERNAL_IP=$(kubectl get svc locust-master -o yaml | grep ip: | awk -F": " '{print $NF}') echo http://$EXTERNAL_IP:8089

2. Haz clic en el vínculo y navega a la interfaz web de la instancia principal de Locust.

La interfaz web de la instancia principal de Locust te permite ejecutar las tareas de prueba de carga en el sistema a prueba.

3. Para comenzar, especifica la cantidad total de usuarios que se debe simular y la velocidad a la que debe generarse cada uno.

4. A continuación, haz clic en Start swarming para iniciar la simulación. Por ejemplo, puedes especificar la cantidad de usuarios en 300 y la velocidad en 10.

5. Haz clic en Start swarming.

A medida que pasa el tiempo y se generan usuarios, se agregan estadísticas para métricas de simulación, como la cantidad de solicitudes y solicitudes por segundo.

6. Si quieres detener la simulación, haz clic en Detener y la prueba terminará. Los resultados completos se pueden descargar en una hoja de cálculo.

¡Felicitaciones!

Usaste Kubernetes Engine para implementar un framework de prueba de carga distribuida.

Finaliza la Quest

Este lab de autoaprendizaje forma parte de la Quest Google Cloud Solutions I: Scaling Your Infrastructure. Una Quest es una serie de labs relacionados que forman una ruta de aprendizaje. Si completas esta Quest, obtendrás una insignia como reconocimiento por tu logro. Puedes hacer públicas tus insignias y agregar vínculos a ellas en tu currículum en línea o en tus cuentas de redes sociales. Inscríbete en cualquier Quest que contenga este lab y obtén un crédito inmediato de finalización. Consulta el catálogo de Google Cloud Skills Boost para ver todas las Quests disponibles.

Realiza tu próximo lab

Continúa tu Quest con el siguiente lab o consulta estos labs de Google Cloud Skills Boost:

• Entrega continua con Jenkins en Kubernetes Engine
• Cómo implementar Memcached en Kubernetes Engine

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 12 de octubre de 2023

Prueba más reciente del lab: 12 de octubre de 2023

Copyright 2024 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.