GSP188

Descripción general

Google Kubernetes Engine proporciona un entorno administrado para implementar, administrar y escalar tus aplicaciones alojadas en contenedores con la infraestructura de Google. El entorno que proporciona Kubernetes Engine consta de varias máquinas (específicamente, instancias de Compute Engine) que se agrupan para formar un clúster.

Kubernetes proporciona los mecanismos a través de los cuales interactúas con tu clúster. Los comandos y recursos de Kubernetes se usan para implementar y administrar aplicaciones, realizar tareas administrativas, establecer políticas y supervisar el estado de las cargas de trabajo implementadas.

En este lab, implementarás la aplicación Quiz en Kubernetes Engine. Para ello, aprovecharás los recursos de Google Cloud, incluidos Cloud Build y Artifact Registry, y los de Kubernetes, como Deployments, Pods y Services.

Qué aprenderás

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

• Crear Dockerfiles para empaquetar el código del frontend y el backend de la aplicación Quiz para implementarla
• Aprovechar Cloud Build para producir imágenes de Docker
• Aprovisionar un clúster de Kubernetes Engine para alojar la aplicación Quiz
• Usar Deployments de Kubernetes para aprovisionar Pods replicados en Kubernetes Engine
• Aprovechar un Service de Kubernetes para aprovisionar un balanceador de cargas para el frontend de Quiz

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, 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 del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos 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: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

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

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes 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: Ordena 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 Cloud para este lab podría generar cargos adicionales.

7. Haz 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 acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

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.

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API 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 {{{project_0.project_id | "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.

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

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

Inicia el editor de Cloud Shell

En Cloud Shell, haz clic en Abrir editor para iniciar el editor de código.

Nota: El editor de código se inicia en una nueva pestaña del navegador, junto con Cloud Shell.

Prepara la aplicación Quiz

En esta sección, accederás a Cloud Shell, clonarás el repositorio de Git que contiene la aplicación Quiz, configurarás las variables de entorno y ejecutarás la aplicación.

Clona el código fuente en Cloud Shell

1. Haz clic en Abrir terminal y clona el repositorio 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/developingapps/v1.2/python/kubernetesengine ~/kubernetesengine

Configura la aplicación Quiz

1. Cambia al directorio que contiene los archivos de muestra de este lab:

cd ~/kubernetesengine/start

2. Para reemplazar la región predeterminada por la asignada por el lab, ejecuta los siguientes comandos:

export APP_REGION={{{project_0.startup_script.app_region | APP_REGION}}} export REGION={{{project_0.default_region | REGION}}} sed -i -e 's/us-central1/'"$REGION"'/g' -e 's/us-central/'"$APP_REGION"'/g' -e 's/python3/'"python3.12"'/g' prepare_environment.sh

3. Configura la aplicación Quiz:

. prepare_environment.sh

Este archivo de secuencia de comandos realiza lo siguiente:

• Crea una aplicación de Google App Engine.
• Exporta las variables de entorno GCLOUD_PROJECT y GCLOUD_BUCKET.
• Actualiza pip y ejecuta pip install -r requirements.txt.
• Crea entidades en Google Cloud Datastore.
• Crea un tema de Google Cloud Pub/Sub.
• Crea una instancia, una base de datos y una tabla de Cloud Spanner.
• Imprime el ID del proyecto.

La aplicación Quiz se configurará cuando veas el siguiente mensaje:

Resultado de ejemplo

Creating Cloud Pub/Sub topic Created topic [projects/qwiklabs-gcp-92b7e5716e0cbf7e/topics/feedback]. Created subscription [projects/qwiklabs-gcp-92b7e5716e0cbf7e/subscriptions/worker-subscription]. Creating Cloud Spanner Instance, Database, and Table Creating instance...done. Creating database...done. Project ID: qwiklabs-gcp-92b7e5716e0cbf7e

Haz clic en Revisar mi progreso para verificar el objetivo. Configurar la aplicación Quiz

Revisa el código

En esta sección, examinarás los archivos de la aplicación.

Para ver y editar archivos, puedes usar los editores de shell instalados en Cloud Shell, como nano o vim, o el Editor de Cloud Shell. En este lab, se usa el Editor de Cloud Shell.

Examina el código

• Navega a training-data-analyst/courses/developingapps/v1.2/python/kubernetesengine/start.

La estructura de carpetas de la aplicación Quiz refleja el modo en que se implementará en Kubernetes Engine.

La aplicación web está en una carpeta llamada frontend.

El código de la aplicación del trabajador que se suscribe a Cloud Pub/Sub y procesa los mensajes se encuentra en una carpeta llamada backend.

Hay archivos de configuración de Docker (un Dockerfile en las carpetas frontend y backend) y archivos .yaml de Kubernetes Engine para backend-deployment y para frontend-deployment.

Crea un clúster de Kubernetes Engine y conéctate a él

En esta sección, usarás la consola de Google Cloud para crear un clúster de Kubernetes Engine y, luego, conectarte a él.

Crea un clúster de Kubernetes Engine

1. En la consola, haz clic en el menú de navegación () > Kubernetes Engine > Clústeres.

2. Haz clic en Crear.

3. Haz clic en Configurar en Standard: Tú administras el clúster. Luego, ingresa los valores proporcionados en los siguientes campos y deja todos los demás con sus valores predeterminados:

Propiedad	Valor
Nombre	quiz-cluster
Zonal
Grupo default > Seguridad > Permisos de acceso	Selecciona Permitir el acceso total a todas las APIs de Cloud

4. Haz clic en Crear. El clúster tardará unos minutos en aprovisionarse.

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

Conéctate al clúster

En esta sección, conectarás la aplicación Quiz al clúster de Kubernetes.

1. Cuando el clúster esté listo, haz clic en el ícono Acciones y selecciona Conectar.

2. En Conéctate al clúster, haz clic en Ejecutar en Cloud Shell para propagar un comando similar al siguiente en Cloud Shell:

gcloud container clusters get-credentials quiz-cluster --zone {{{project_0.default_zone|ZONE}}} --project {{{project_0.project_id|Project ID}}}

Presiona Intro para ejecutar el comando en Cloud Shell.

3. Ejecuta el siguiente comando para mostrar los Pods del clúster:

kubectl get pods

La respuesta debería ser No resources found in default namespace porque no el clúster no tiene Pods. Esto confirma que configuraste la seguridad para permitir que la herramienta de línea de comandos kubectl realice operaciones en el clúster.

Crea un repositorio de Docker en Artifact Registry

Artifact Registry permite administrar imágenes de contenedor y paquetes de lenguajes. Cada tipo de artefacto requiere especificaciones diferentes. Por ejemplo, las solicitudes de dependencias de Maven son diferentes de las de Node.

Para admitir las diferentes especificaciones de APIs, Artifact Registry necesita saber qué formato quieres que tengan las respuestas de la API. Para ello, crearás un repositorio y pasarás la marca --repository-format, que indica el tipo de repositorio deseado.

1. Desde Cloud Shell, ejecuta el siguiente comando para crear un repositorio de imágenes de Docker:

gcloud artifacts repositories create container-dev-repo --repository-format=docker \ --location={{{project_0.default_region | REGION}}} \ --description="Docker repository for Container Dev Workshop"

Haz clic en Autorizar si aparece el mensaje de autorización de Cloud Shell.

2. En la consola de Cloud, ve a Artifact Registry > Repositorios y observa tu repositorio de Docker recién creado con el nombre container-dev-repo. Si haces clic en él, verás que está vacío por el momento.

Haz clic en Revisar mi progreso para verificar el objetivo.

Crear un repositorio de Docker

Crea imágenes de Docker con Cloud Build

En esta sección, crearás un Dockerfile para el frontend y el backend de la aplicación y, luego, usarás Cloud Build para crear imágenes y almacenarlas en Artifact Registry.

Crea el documento Dockerfile para el código del frontend y el backend

1. En el Editor de Cloud Shell, abre frontend/Dockerfile.
2. Ahora, agrega un bloque de código que hace lo siguiente:

• Ingresa el comando de Dockerfile para inicializar la creación de una imagen de Docker personalizada con la imagen de App Engine para Python de Google como punto de partida.
• Escribe comandos de Dockerfile para activar un entorno virtual.
• Escribe el comando de Dockerfile para ejecutar pip install como parte del proceso de creación.
• Escribe el comando de Dockerfile para agregar el contenido de la carpeta actual en la ruta /app dentro del contenedor.
• Completa el Dockerfile ingresando la sentencia gunicorn…, que se ejecuta junto con el contenedor. Gunicorn (Green Unicorn) es un servidor HTTP compatible con la especificación de interfaz de puerta de enlace del servidor web (WSGI) de Python.

Copia y pega en el Dockerfile lo que se muestra a continuación:

FROM gcr.io/google_appengine/python RUN virtualenv -p python3.7 /env ENV VIRTUAL_ENV /env ENV PATH /env/bin:$PATH ADD requirements.txt /app/requirements.txt RUN pip install -r /app/requirements.txt ADD . /app CMD gunicorn -b 0.0.0.0:$PORT quiz:app

3. Abre el archivo backend/Dockerfile y, luego, copia y pega el siguiente código:

FROM gcr.io/google_appengine/python RUN virtualenv -p python3.7 /env ENV VIRTUAL_ENV /env ENV PATH /env/bin:$PATH ADD requirements.txt /app/requirements.txt RUN pip install -r /app/requirements.txt ADD . /app CMD python -m quiz.console.worker

Crea imágenes de Docker con Cloud Build

1. En Cloud Shell, asegúrate de que te encuentres en la carpeta start:

cd ~/kubernetesengine/start

2. Para crear la imagen de Docker del frontend, ejecuta el siguiente comando:

gcloud builds submit -t {{{project_0.default_region | REGION}}}-docker.pkg.dev/{{{project_0.project_id|Project ID}}}/container-dev-repo/quiz-frontend:v1 ./frontend/

Aquí, la imagen de Docker se crea y se almacena en Artifact Registry, lo que tarda unos minutos.

Pasa por alto cualquier mensaje sobre incompatibilidades que veas en los mensajes del resultado.

3. Ahora, ejecuta el siguiente comando para crear la imagen de Docker del backend:

gcloud builds submit -t {{{project_0.default_region | REGION}}}-docker.pkg.dev/{{{project_0.project_id|Project ID}}}/container-dev-repo/quiz-backend:v1 ./backend/

Cuando la imagen de Docker del backend esté lista, verás estos últimos mensajes:

DONE --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID: 97a3648f-5229-49ef-9c93-a33dbdb421f3 CREATE_TIME: 2024-12-16T13:29:57+00:00 DURATION: 2M10S SOURCE: gs://qwiklabs-gcp-03-2cae39dd1d7c_cloudbuild/source/1734355794.276254-1b5d85622afb4360910a164f9f29734d.tgz IMAGES: us-east1-docker.pkg.dev/qwiklabs-gcp-03-2cae39dd1d7c/container-dev-repo/quiz-backend:v1 STATUS: SUCCESS

4. En el menú de navegación de la consola, haz clic en Artifact Registry y, luego, selecciona container-dev-repo. Deberías ver dos Pods: quiz-frontend y quiz-backend.

5. Haz clic en quiz-frontend.

Nota: Deberías ver el nombre y las etiquetas (más recientes) de la imagen.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear imágenes de Docker con Cloud Build

Crea recursos Deployment y Service de Kubernetes

En esta sección, modificarás los archivos de plantilla yaml que contienen la especificación para los recursos Deployment y Service de Kubernetes. Luego, crearás los recursos en el clúster de Kubernetes Engine.

Crea un archivo de Deployment de Kubernetes

1. En el Editor de Cloud Shell, abre el archivo frontend-deployment.yaml.

Nota: Ya se creó el esqueleto del archivo. Debes reemplazar los marcadores de posición por valores específicos de tu proyecto.

2. Reemplaza los marcadores de posición en el archivo frontend-deployment.yaml por los siguientes valores:

Nombre del marcador de posición	Valor
[GCLOUD_PROJECT]	ID del proyecto (Para consultarlo, ingresa echo $GCLOUD_PROJECT en Cloud Shell)
[GCLOUD_BUCKET]	Nombre del bucket de medios de Cloud Storage para tu proyecto (Para consultarlo, ingresa echo $GCLOUD_BUCKET en Cloud Shell)
[FRONTEND_IMAGE_IDENTIFIER]	Imagen del frontend identificada con el formato [REGION]-docker.pkg.dev/[Project_ID]/container-dev-repo/quiz-frontend:v1

Nota: La Deployment de quiz-frontend aprovisiona tres réplicas de la imagen de Docker del frontend en Pods de Kubernetes, distribuidas en los tres nodos del clúster de Kubernetes Engine.

3. Guarda el archivo.
4. Reemplaza los marcadores de posición en el archivo backend-deployment.yaml por los siguientes valores:

Nombre del marcador de posición	Valor
[GCLOUD_PROJECT]	ID del proyecto
[GCLOUD_BUCKET]	ID del bucket de medios de Cloud Storage para tu proyecto
[BACKEND_IMAGE_IDENTIFIER]	Imagen del backend identificada con el formato [REGION]-docker.pkg.dev/[Project_ID]/container-dev-repo/quiz-backend:v1

Nota: El Deployment de quiz-backend aprovisiona dos réplicas de la imagen de Docker del backend en Pods de Kubernetes, distribuidas en dos de los tres nodos del clúster de Kubernetes Engine.

5. Guarda el archivo.
6. Revisa el contenido del archivo frontend-service.yaml.

Nota: El servicio expone la implementación de frontend a través de un balanceador de cargas, El balanceador envía solicitudes de clientes a las tres réplicas del Pod de frontend.

Ejecuta los archivos de Deployment y Service

1. En Cloud Shell, aprovisiona el Deployment del frontend de Quiz:

kubectl create -f ./frontend-deployment.yaml

2. Aprovisiona el Deployment del backend de Quiz:

kubectl create -f ./backend-deployment.yaml

3. Aprovisiona el Service del frontend de Quiz:

kubectl create -f ./frontend-service.yaml Nota: Cada comando aprovisiona recursos en Kubernetes Engine. El proceso tarda unos cuantos minutos en completarse.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear recursos Deployment y Service de Kubernetes

Prueba la aplicación Quiz

En esta sección, revisarás los recursos de Pods y Service que implementaste, y navegarás a la aplicación Quiz.

Revisa los recursos implementados

1. En el menú de navegación de la consola, haz clic en Kubernetes Engine.
2. Haz clic en Cargas de trabajo en el menú de la izquierda.

Nota: Deberías ver dos contenedores: quiz-frontend y quiz-backend. Tal vez veas que el estado es Correcto o en proceso de creación.

Si el estado de uno o ambos contenedores es Does not have minimum availability, actualiza la ventana.

3. Haz clic en quiz-frontend. En la sección Pods administrados, hay tres Pods quiz-frontend.

4. En la sección Servicios expuestos, cerca de la parte inferior, busca la sección Extremos, copia la dirección IP y pégala en el campo URL de una nueva pestaña o ventana del navegador:

5. Se abrirá la aplicación Quiz, lo que significa que la implementaste con éxito. Puedes finalizar el lab aquí o usar el resto del tiempo para crear algunos cuestionarios.

Nota: Si ves una ventana emergente con el mensaje Tu conexión con este sitio no es segura, haz clic en Continuar al sitio.

¡Felicitaciones!

Aquí finaliza el lab de autoaprendizaje Desarrollo de apps: Implementa la aplicación en Kubernetes Engine (Python). Aprovechaste los recursos de Google Cloud y Kubernetes para implementar una aplicación Quiz.

Próximos pasos y más información

Obtén más información sobre Kubernetes Engine.

Actualización más reciente del manual: 24 de septiembre de 2025

Prueba más reciente del lab: 24 de septiembre de 2025

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