Descripción general

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

Kubernetes proporciona los mecanismos a través de los cuales interactúa 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, como Cloud Build y Container Registry, y los recursos de Kubernetes, como Deployments, Pods y Services.

Objetivos

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

• Crear Dockerfiles para empaquetar el código frontend y backend de la aplicación Quiz para su implementación
• Aprovechar Cloud Build para producir imágenes de Docker
• Aprovisionar un clúster de Kubernetes Engine para alojar la aplicación Quiz
• Utilizar las implementaciones de Kubernetes para aprovisionar pods replicados en Kubernetes Engine
• Aprovechar un servicio de Kubernetes para aprovisionar un balanceador de cargas para el frontend de Quiz

Configuración y requisitos

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.

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. Prepara la aplicación Quiz

En esta sección, 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. Ingresa el siguiente comando en Cloud Shell para clonar el repositorio del lab:

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

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

ln -s ~/training-data-analyst/courses/developingapps/v1.3/java/kubernetesengine ~/kubernetesengine

Configura la aplicación Quiz

1. Cambia al directorio que contiene los archivos de trabajo:

cd ~/kubernetesengine/start

2. Configura la aplicación del frontend de Quiz:

. prepare_environment.sh Nota: 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.
• Ejecuta mvn clean install.
• 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.

Revisa el código

A continuación, revisa y actualiza el código de la aplicación Quiz en un editor de código. Puedes usar el editor de código de Cloud Shell o los editores de shell que están instalados en Cloud Shell, como nano o vim. Este lab usa el editor de código de Cloud Shell.

1. Inicia el editor de código de Cloud Shell. En Cloud Shell, haz clic en Abrir editor (el ícono es parecido a un lápiz) para iniciar el editor de código.

Nota: El editor de código reemplaza a la terminal. Puedes volver a la terminal haciendo clic en Abrir terminal.

2. Examina el código y la estructura de las carpetas. En el editor de código de Cloud Shell, navega a training-data-analyst/courses/developingapps/v1.3/java/kubernetesengine/start.

Nota: En la carpeta “kubernetesengine”, observa la carpeta “end”. La carpeta “end” contiene los mismos archivos que la carpeta “start”, pero cada archivo de la carpeta “end” contiene el código completo necesario para realizar este lab.

La estructura de las carpetas de la aplicación Quiz ahora refleja el modo en que se implementa en Kubernetes Engine:

• La carpeta frontend contiene el resultado empaquetado para la aplicación web.
• La carpeta backend contiene el resultado empaquetado para la aplicación de la consola.
• Dockerfile en las carpetas frontend y backend contiene archivos de configuración para Docker. Actualmente vacía.
• *.yaml contiene archivos de configuración para Kubernetes Engine.

3. En Cloud Shell, vuelve a la terminal y, luego, usa el siguiente comando para copiar el jar resultante de la aplicación de frontend en la carpeta frontend:

   cp ./target/quiz-frontend-0.0.1.jar ./frontend/

4. Configura la aplicación del backend de Quiz:

   mvn package -f pom-backend.xml

5. Copia el jar resultante correspondiente a la aplicación del backend en la carpeta backend:

   cp ./target/quiz-backend-0.0.1.jar ./backend/

Tarea 2. Crea un clúster de Kubernetes Engine

En esta sección, crearás un clúster de Google Kubernetes Engine para alojar la aplicación Quiz.

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

2. Luego, haz clic en Crear.

3. Selecciona Configurar para GKE Standard.

4. Para configurar el clúster, utiliza los valores especificados de las propiedades que aparecen en la siguiente tabla; deja las propiedades que no están en la lista con los valores predeterminados:

   En Aspectos básicos del clúster:

   Propiedad	Valor
   Nombre	quiz-cluster
   Zona	us-central1-b

5. Expande default-pool.

6. En Seguridad, selecciona Permitir el acceso total a todas las APIs de Cloud.

7. Haz clic en Crear. El aprovisionamiento del clúster puede demorar algunos minutos.

Conéctate al clúster

1. Cuando el clúster esté listo, haz clic en los 3 puntos verticales y selecciona Conectar.

   

2. En Conéctate al clúster, copia el primer comando en el portapapeles.

3. Haz clic en Aceptar para cerrar la ventana Conéctate al clúster.

El comando tiene este formato: gcloud container clusters get-credentials quiz-cluster --zone us-central1-b --project <Project-ID>.

4. Pega el comando en Cloud Shell y presiona Intro.

   O solo haz clic en Ejecutar en Cloud Shell y, luego, presiona Intro.

5. Obtén una lista de los Pods del clúster:

   kubectl get pods

La respuesta debe indicar que no hay Pods en el clúster.

Esto confirma que configuraste la seguridad de modo que la herramienta de línea de comandos kubectl realice operaciones para el clúster.

Tarea 3. 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 Container Registry.

Crea un Dockerfile para el frontend

1. Haz clic en Abrir editor para ir al editor de código de Cloud Shell y, luego, abre frontend/Dockerfile.

2. Copia y pega el siguiente contenido en frontend/Dockerfile:

FROM gcr.io/google_appengine/jetty9 VOLUME /tmp ADD ./quiz-frontend-0.0.1.jar /app.jar CMD java -jar /app.jar

3. Guarda el archivo.

¿Qué hace esta secuencia de comandos?

Esta secuencia de comandos es una serie de comandos de Dockerfile.

• El primer comando, FROM gcr.io/google_appengine/jetty9, inicializa la creación de una imagen de Docker personalizada con la imagen Jetty 9 de Google App Engine, gcr.io/google_appengine/jetty9, como punto de partida.

• El segundo comando, VOLUME /tmp, crea un volumen en el sistema de archivos del contenedor con la ruta /tmp.

• El tercer comando, ADD./quiz-frontend-0.0.1.jar /app.jar, agrega el archivo jar, uiz-frontend-0.0.1.jar, correspondiente al frontend generado por el proceso de empaquetado de Maven, como parte del proceso de compilación.

• El cuarto y último comando, CMD java -jar /app.jar, se ejecuta conjuntamente con el contenedor.

Crea un Dockerfile para el backend

El Dockerfile para el backend se crea de la misma manera que para el frontend, salvo que el archivo jar se agrega al backend.

1. En el editor de código de Cloud Shell, abre backend/Dockerfile.

2. Copia y pega el siguiente contenido en backend/Dockerfile:

FROM gcr.io/google_appengine/jetty9 VOLUME /tmp ADD ./quiz-backend-0.0.1.jar /app.jar CMD java -jar /app.jar

3. Guarda el archivo.

Tarea 4. Crea imágenes de Docker con Cloud Build

1. En Cloud Shell, haz clic en Abrir terminal y escribe el siguiente comando para compilar la imagen de Docker del frontend:

   gcloud builds submit -t gcr.io/$DEVSHELL_PROJECT_ID/quiz-frontend ./frontend/

   Los archivos se almacenan en etapa intermedia en Cloud Storage y se compila una imagen de Docker que se almacena en Container Registry. Esto tardará unos segundos.

2. Compila la imagen de Docker para el backend:

   gcloud builds submit -t gcr.io/$DEVSHELL_PROJECT_ID/quiz-backend ./backend/

3. En la consola, haz clic en el menú de navegación > Container Registry. Deberían aparecer dos carpetas: quiz-frontend y quiz-backend.

4. Haz clic en quiz-frontend. Debería aparecer el nombre de la imagen (un hash), etiquetas (las más recientes) y otros detalles.

Tarea 5. Crea recursos de Deployment y Service de Kubernetes

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

Crea un archivo de implementación de Kubernetes

1. En el editor de código, abre el archivo frontend-deployment.yaml. Ya se creó el esqueleto del archivo. Debes reemplazar los marcadores de posición con valores específicos de tu proyecto.

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

   Nombre del marcador de posición	Valor
   [GCLOUD_PROJECT]	El ID del proyecto de GCP (ingresa echo $GCLOUD_PROJECT en Cloud Shell para mostrar el ID del proyecto)
   [GCLOUD_BUCKET]	ID del bucket de Cloud Storage para el bucket de medios de tu proyecto. El ID de bucket es [GCP_Project_ID]-media.
   [FRONTEND_IMAGE_IDENTIFIER]	La imagen para el frontend identificada con el formato gcr.io/[GCP_Project_ID]/quiz-frontend.

   Solo reemplaza los valores que están entre [].

   El archivo YAML resultante debería ser similar al siguiente:

   apiVersion: apps/v1beta1 kind: Deployment metadata: name: quiz-frontend labels: app: quiz-app spec: replicas: 3 template: metadata: labels: app: quiz-app tier: frontend spec: containers: - name: quiz-frontend image: gcr.io/qwiklabs-gcp-04-3ad1f39f2114/quiz-frontend imagePullPolicy: Always ports: - name: http-server containerPort: 8080 env: - name: GCLOUD_PROJECT value: qwiklabs-gcp-04-3ad1f39f2114 - name: GCLOUD_BUCKET value: qwiklabs-gcp-04-3ad1f39f2114-media

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

3. Guarda el archivo.

4. Abre el archivo backend-deployment.yaml y 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 de GCP (o usa echo $GCLOUD_PROJECT)
   [GCLOUD_BUCKET]	ID del bucket de Cloud Storage para el bucket de medios de tu proyecto. Este es el mismo que usaste en frontend-deployment.yaml (el ID de bucket es [GCP_Project_ID]-media).
   [BACKEND_IMAGE_IDENTIFIER]	La imagen para el backend identificada con la forma gcr.io/[GCP_Project_ID]/quiz-backend

   La implementación del backend de Quiz aprovisiona una réplica de la imagen de Docker para el backend en pods de Kubernetes, que se coloca en uno 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 del frontend a través de un balanceador de cargas que 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 la implementación del frontend de Quiz:

   kubectl create -f ./frontend-deployment.yaml

2. Aprovisiona la implementación del backend de Quiz:

   kubectl create -f ./backend-deployment.yaml

3. Aprovisiona el Service del frontend de Quiz:

   kubectl create -f ./frontend-service.yaml

Cada comando aprovisiona recursos en Kubernetes Engine. Este proceso tardará unos minutos en completarse.

Tarea 6. Prueba la aplicación Quiz

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

Revisa los recursos implementados

1. En la consola, haz clic en el menú de navegación > Kubernetes Engine > Cargas de trabajo. Deberían aparecer dos elementos: quiz-frontend y quiz-backend.

   Tal vez veas que el estado del pod es OK o en proceso de creación.

2. Haz clic en quiz-frontend para ver una descripción general de quiz-frontend.

3. Desplázate hacia abajo para ver la sección Pods administrados.

   Es posible que veas que se está creando el balanceador de cargas quiz-frontend o que está listo. Espera hasta que el Service se muestre con OK antes de continuar. Deberías ver un extremo de la dirección IP cuando el servicio esté listo.

4. En Servicios expuestos, en Extremos, selecciona la dirección IP y ábrela en una pestaña del navegador nueva.

5. Realiza una prueba para verificar que la aplicación funcione como corresponda.

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.