GSP1122

Descripción general

Administrar la creación, la implementación y las actualizaciones en curso de las aplicaciones es fundamental para las operaciones en la nube. Las principales dudas se centran en la optimización de los recursos para cumplir con ANS, la implementación de cambios en el código, las actualizaciones de VMs sin interrupciones y la configuración del balanceo de cargas o la red. AWS utiliza las canalizaciones de Code Deploy, los grupos de implementación en instancias EC2 con escalado automático y la configuración de IAM/firewall. Los roles de servicio son fundamentales para la ejecución y la comunicación de las aplicaciones, mientras que las puertas de enlace de NAT, los balanceadores de cargas, las verificaciones de estado y las estrategias de replicación completan la configuración de la infraestructura. La actualización de VMs puede implicar la actualización de la instancia y funciones lambda.

Google Cloud ofrece flexibilidad comparable. Las secuencias de comandos de inicio pueden recuperar actualizaciones de código, lo que facilita realizar actualizaciones progresivas para no tener tiempo de inactividad. Si bien existen soluciones como GKE y App Engine, Compute Engine otorga control detallado de las VMs y los balanceadores de cargas. En este lab, se demuestra la implementación y el ajuste de escala de la aplicación de comercio electrónico "Fancy Store" en Compute Engine, destacando este sólido enfoque para la administración de la aplicación web.

Objetivos

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

• Crear instancias de Compute Engine
• Crear plantillas de instancias a partir de instancias de origen
• Crear grupos de instancias administrados
• Crear y probar verificaciones de estado de grupos de instancias administrados
• Crear balanceadores de cargas HTTP(S)
• Crear verificaciones de estado de balanceadores de cargas
• Usar una red de distribución de contenidos (CDN) para el almacenamiento en caché

Al final del lab, tendrás instancias dentro de los grupos de instancias administrados que proporcionarán reparación automática, balanceo de cargas, escalado automático y actualizaciones progresivas para tu sitio web.

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.

Establece la zona predeterminada

• Establece la zona predeterminada y la configuración del proyecto:

gcloud config set compute/zone {{{ project_0.default_zone | "ZONE" }}}

Obtén más información en la documentación Regiones y zonas.

Nota: Cuando ejecutas gcloud en tu máquina, se mantiene la configuración en las diferentes sesiones. En cambio, en Cloud Shell, es necesario configurar esto en cada nueva sesión o reconexión.

Tarea 1: Habilita la API de Compute Engine y Gemini Code Assist

A continuación, habilita la API de Compute Engine.

• Para ello, ejecuta el siguiente comando:

gcloud services enable compute.googleapis.com

Habilita Gemini Code Assist en el IDE de Cloud Shell

Puedes usar Gemini Code Assist en un entorno de desarrollo integrado (IDE) como Cloud Shell para recibir orientación sobre el código o resolver problemas con tu código. Antes de comenzar a usar Gemini Code Assist, debes habilitarlo.

1. En Cloud Shell, habilita la API de Gemini for Google Cloud con el siguiente comando:

gcloud services enable cloudaicompanion.googleapis.com

2. En la barra de herramientas de Cloud Shell, haz clic en Abrir editor.

Nota: Para abrir el editor de Cloud Shell, haz clic en Abrir editor en la barra de herramientas de Cloud Shell. Para cambiar entre Cloud Shell y el editor de código, haz clic en Abrir editor o Abrir terminal, según sea necesario.

3. En el panel izquierdo, haz clic en el ícono de Configuración y, luego, en la vista Configuración, busca Gemini Code Assist.

4. Busca la opción Geminicodeassist: Habilitar y asegúrate de que esté seleccionada. Luego, cierra la Configuración.

5. Haz clic en Cloud Code - Sin proyecto en la barra de estado, en la parte inferior de la pantalla.

6. Autoriza el complemento según las instrucciones. Si no se selecciona un proyecto automáticamente, haz clic en Seleccionar un proyecto de Google Cloud y elige .

7. Verifica que tu proyecto de Google Cloud () se muestre en el mensaje de la barra de estado de Cloud Code.

Tarea 2: Crea un bucket de Cloud Storage

En esta tarea, configurarás un bucket de Cloud Storage para alojar el código compilado y tus secuencias de comandos de inicio.

• En Cloud Shell, ejecuta el siguiente comando para crear un nuevo bucket de Cloud Storage:

gsutil mb gs://fancy-store-{{{project_0.project_id | BUCKET}}}

Haz clic en Revisar mi progreso para verificar el objetivo. Crear un bucket de Cloud Storage

Tarea 3: Clona el repositorio de código fuente

En esta tarea, usarás el sitio web de comercio electrónico existente Fancy Store que se basa en el repositorio monolith-to-microservices como modelo para tu sitio web.

Clonarás el código fuente para poder enfocarte en los aspectos de la implementación en Compute Engine. Más adelante en este lab, realizarás una pequeña actualización en el código para comprobar lo fácil que es realizar actualizaciones en Compute Engine.

1. Ejecuta los siguientes comandos para clonar el código fuente y, luego, navegar al directorio monolith-to-microservices:

git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices

2. Ejecuta la compilación inicial del código para permitir que se ejecute la aplicación de manera local:

./setup.sh

Esta secuencia de comandos tardará unos minutos en completarse.

3. Cuando lo haga, asegúrate de que Cloud Shell esté ejecutando una versión de Node.js compatible con el siguiente comando:

nvm install --lts

4. A continuación, ejecuta el siguiente comando para probar la aplicación, cambiar al directorio microservices e iniciar el servidor web:

cd microservices npm start

El resultado debería ser similar al siguiente:

Resultado:

Products microservice listening on port 8082! Frontend microservice listening on port 8080! Orders microservice listening on port 8081!

5. Para obtener una vista previa de tu aplicación, haz clic en el ícono de vista previa en la Web y selecciona Vista previa en el puerto 8080.

Se abrirá una ventana nueva en la que podrás ver el frontend de Fancy Store.

Nota: En la opción Vista previa, deberías poder ver el frontend. Sin embargo, las funciones Productos y Pedidos no funcionarán, ya que esos servicios aún no están expuestos.

6. Después de ver el sitio web, cierra esta ventana y presiona CTRL + C en la ventana de terminal para detener el proceso del servidor web.

Tarea 4: Crear las instancias de Compute Engine

Es hora de comenzar a implementar algunas instancias de Compute Engine.

En los pasos que siguen, realizarás varias acciones:

1. Crear una secuencia de comandos de inicio para configurar las instancias.
2. Clonar el código fuente y subirlo a Cloud Storage.
3. Implementar una instancia de Compute Engine para alojar los microservicios de backend.
4. Reconfigurar el código de frontend para utilizar la instancia de microservicios de backend.
5. Implementar una instancia de Compute Engine para alojar el microservicio de frontend.
6. Configurar la red para permitir la comunicación.

Crea la secuencia de comandos de inicio

Se usa una secuencia de comandos de inicio para indicarle a la instancia qué hacer cada vez que se inicia. De esta forma, se configuran automáticamente las instancias.

1. En la barra de herramientas de Cloud Shell, haz clic en Abrir editor (Open Editor) para abrir el editor de código.

2. Navega a la carpeta monolith-to-microservices.

3. Haz clic en Archivo > Nuevo archivo y crea un archivo llamado startup-script.sh.

Luego, aprovecharás las acciones inteligentes potenciadas por IA de Gemini Code Assist para editar el archivo del script de Bash.

4. Pega el siguiente código en el archivo:

#!/bin/bash # Install logging monitor. The monitor will automatically pick up logs sent to # syslog. curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash service google-fluentd restart & # Install dependencies from apt apt-get update apt-get install -yq ca-certificates git build-essential supervisor psmisc # Install nodejs mkdir /opt/nodejs curl https://nodejs.org/dist/v16.14.0/node-v16.14.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1 ln -s /opt/nodejs/bin/node /usr/bin/node ln -s /opt/nodejs/bin/npm /usr/bin/npm # Get the application source code from the Google Cloud Storage bucket. mkdir /fancy-store gsutil -m cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/ # Install app dependencies. cd /fancy-store/ npm install # Create a nodeapp user. The application will run as this user. useradd -m -d /home/nodeapp nodeapp chown -R nodeapp:nodeapp /opt/app # Configure supervisor to run the node app. cat >/etc/supervisor/conf.d/node-app.conf << EOF [program:nodeapp] directory=/fancy-store command=npm start autostart=true autorestart=true user=nodeapp environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production" stdout_logfile=syslog stderr_logfile=syslog EOF supervisorctl reread supervisorctl update

5. Haz clic en Archivo > Guardar para guardar el archivo.

6. En el editor de código de Cloud Shell, asegúrate de que la opción “End of Line Sequence” esté configurada como “LF” y no como “CRLF”. Mira la esquina inferior derecha del editor de código para comprobarlo.

• Si está configurada como CRLF, haz clic en CRLF y selecciona LF en el menú desplegable para cambiarla.

7. Con el archivo de secuencia de comandos de Bash startup-script.sh abierto en el editor de archivos, Gemini Code Assist está disponible, como lo indica el ícono en la esquina superior derecha del editor.

8. Haz clic en el ícono Gemini Code Assist: Smart Actions en la barra de herramientas.

9. Para pedirle a Gemini Code Assist que te ayude a actualizar el archivo startup-script.sh, pega la siguiente instrucción en el campo de texto intercalado de Gemini Code Assist que se abre desde la barra de herramientas.

En el archivo startup-script.sh, reemplaza el marcador de posición [PROJECT_ID] por {{{project_0.project_id | PROJECT_ID}}}.

10. Para indicarle a Gemini Code Assist que modifique el código según corresponda, presiona INTRO.

11. Cuando se te solicite en la vista comparativa (diff) en Gemini, haz clic en Aceptar.

La línea de código de startup-script.sh debería ser similar a la que se ve a continuación:

gs://fancy-store-{{{project_0.project_id | BUCKET}}}/monolith-to-microservices/microservices/* /fancy-store/

Luego, aprovecharás las acciones inteligentes potenciadas por IA de Gemini Code Assist para generar una explicación del propósito de la secuencia de comandos de Bash y su rol en la automatización de la implementación de un microservicio de Node.js.

12. Abre el archivo data.csv en el explorador de archivos. Como antes, Gemini Code Assist está disponible, como lo indica el ícono en la esquina superior derecha del editor.

13. Haz clic en el ícono Gemini Code Assist: Smart Actions y selecciona Explicar esto.

14. Gemini Code Assist abre un panel de chat con la instrucción Explicar esto completada previamente. En el cuadro de texto intercalado del chat de Code Assist, reemplaza la instrucción completada previamente por lo siguiente y haz clic en Enviar:

Eres un desarrollador experto de aplicaciones en Cymbal AI. Proporciona una explicación completa del propósito y la funcionalidad de la secuencia de comandos de bash startup-script.sh. La explicación tiene como objetivo ayudar a un nuevo miembro del equipo y debe abordar los siguientes puntos: * Una descripción general de alto nivel de la función principal de la secuencia de comandos en un flujo de trabajo de implementación automatizada. * Un desglose de los pasos clave, incluida la instalación de dependencias de la aplicación (npm) y la recuperación del código fuente de una ubicación de almacenamiento remoto. * El rol del supervisor en la administración del proceso de aplicación, lo que garantiza que se inicie automáticamente y se reinicie en caso de falla. * Una explicación de cómo la secuencia de comandos configura el entorno de producción, incluida la creación de usuarios (useradd) y las prácticas recomendadas de seguridad. Para las mejoras sugeridas, no hagas cambios en el contenido del archivo.

En el chat de Gemini Code Assist, aparecen explicaciones detalladas del código del archivo de secuencia de comandos de Bash startup-script.sh.

La secuencia de comandos de inicio realiza las siguientes tareas:

• Instala el agente de Logging, que recopila automáticamente registros de syslog.
• Instala Node.js y Supervisor (este último ejecuta la aplicación como un daemon).
• Clona el código fuente de la app desde el bucket de Cloud Storage y, luego, instala dependencias.
• Configura Supervisor para ejecutar la app. Supervisor se asegura de que se reinicie la app, ya sea si se cierra de forma inesperada o si la detiene un administrador o algún otro proceso. También envía las transmisiones stdout y stderr de la app a syslog para que las recopile el agente de Logging.

15. Vuelve a la terminal de Cloud Shell y ejecuta el siguiente comando para copiar el archivo startup-script.sh en tu bucket:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | BUCKET}}}

Ahora podrás acceder al archivo con el siguiente vínculo: https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh.

[BUCKET_NAME] representa el nombre del bucket de Cloud Storage. De manera predeterminada, este archivo solo estará visible para cuentas de servicio y usuarios autorizados, por lo que no será posible acceder a él mediante un navegador web. Las instancias de Compute Engine podrán acceder automáticamente a través de su cuenta de servicio.

Copia el código en el bucket de Cloud Storage

Cuando se inician las instancias, estas extraen el código del bucket de Cloud Storage, por lo que puedes almacenar algunas variables de configuración en el archivo .env del código.

Nota: También puedes codificar de forma que se extraigan variables de entorno de algún otro lugar, pero, a los fines de esta demostración, este es un método simple para realizar la configuración. En la etapa de producción, las variables de entorno generalmente estarán almacenadas fuera del código.

• Ejecuta el siguiente comando para copiar el código clonado en tu bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/ Nota: Los directorios de dependencias node_modules se borran para garantizar que la copia se realice de la forma más rápida y eficiente posible. Se vuelven a crear esos directorios en las instancias cuando se inician.

Haz clic en Revisar mi progreso para verificar el objetivo. Copiar la secuencia de comandos de inicio y el código en el bucket de Cloud Storage

Implementa la instancia de backend

La primera instancia que se implementará es la de backend, que aloja los microservicios de Pedidos y Productos.

Nota: En un entorno de producción, se recomienda separar cada microservicio en su propia instancia y grupo de instancias para permitirle escalar de manera independiente. A los fines de esta demostración, se ubicarán ambos microservicios de backend (Pedidos y Productos) en la misma instancia y grupo de instancias.

• Ejecuta el siguiente comando para crear una instancia e2-medium configurada para usar la secuencia de comandos de inicio. Está etiquetada como una instancia backend para que después puedas aplicarle reglas de firewall específicas:

gcloud compute instances create backend \ --machine-type=e2-medium \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh Nota: Si se te solicita especificar una zona, asegúrate de haber configurado una predeterminada en la sección Configuración de este lab.

Configura una conexión al backend

Antes de implementar el frontend de la aplicación, es necesario actualizar la configuración para que se dirija al backend que acabas de implementar.

1. Para obtener la dirección IP externa del backend, ejecuta el siguiente comando y busca la dirección en la pestaña EXTERNAL_IP de la instancia de backend:

gcloud compute instances list

Resultado de ejemplo:

NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS backend {{{ project_0.default_zone | "ZONE" }}} e2-medium 10.128.0.2 34.68.223.88 RUNNING

2. Copia la IP externa del backend.

3. En el explorador de Cloud Shell, navega a monolith-to-microservices > react-app.

4. En el editor de código, selecciona View > Toggle Hidden Files para ver el archivo .env.

5. Edita el archivo .env para que dirija a la IP externa del backend. [BACKEND_ADDRESS] representa la dirección IP externa de la instancia de backend determinada a partir del comando gcloud ejecutado previamente.

6. En el archivo .env, reemplaza localhost por tu [BACKEND_ADDRESS]:

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

7. Guarda el archivo.

8. Ejecuta los siguientes comandos para volver a compilar react-app, lo que actualizará el código del frontend:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

9. Luego, copia el código de la aplicación en el bucket de Cloud Storage con el siguiente comando:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | BUCKET}}}/

Implementa la instancia de frontend

Una vez que hayas configurado el código, implementa la instancia de frontend.

• Ejecuta el siguiente comando para implementar la instancia de frontend con un comando similar al anterior. Esta instancia está etiquetada como frontend por motivos relacionados con el firewall:

gcloud compute instances create frontend \ --machine-type=e2-medium \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh Nota: El comando de implementación y la secuencia de comandos de inicio se usan con las instancias de frontend y backend para que el proceso sea más sencillo y porque el código está configurado para iniciar todos los microservicios de forma predeterminada. Por este motivo, en esta muestra, se ejecutan todos los microservicios tanto en el frontend como en el backend. En un entorno de producción, solo se ejecutarían los microservicios que necesites en cada componente.

Configura la red

En esta sección, crearás reglas de firewall que permitan que el frontend acceda al puerto 8080, y el backend, a los puertos 8081 y 8082. Estos comandos de firewall utilizan las etiquetas que se asignan al momento de crear las instancias para la aplicación:

1. Ejecuta los siguientes comandos para crear las reglas de firewall:

gcloud compute firewall-rules create fw-fe \ --allow tcp:8080 \ --target-tags=frontend gcloud compute firewall-rules create fw-be \ --allow tcp:8081-8082 \ --target-tags=backend

Ahora el sitio web debería funcionar en su totalidad.

2. Para navegar a la IP externa del frontend, debes conocer la dirección. Ejecuta el siguiente comando y busca la dirección IP externa (EXTERNAL_IP) de la instancia de frontend:

gcloud compute instances list

Resultado de ejemplo:

NAME: backend ZONE: {{{ project_0.default_zone | "ZONE" }}} MACHINE_TYPE: e2-medium PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: {{{ project_0.default_zone | "ZONE" }}} MACHINE_TYPE: e2-medium PREEMPTIBLE: INTERNAL_IP: 10.128.0.3 EXTERNAL_IP: 34.172.241.242 STATUS: RUNNING

Es posible que la instancia tarde algunos minutos en iniciarse y configurarse.

3. Espera 30 segundos y, luego, ejecuta el siguiente comando para supervisar que se esté preparando la aplicación. Reemplaza FRONTEND_ADDRESS por la IP externa de la instancia de frontend:

watch -n 2 curl http://[FRONTEND_ADDRESS]:8080

Una vez que veas un resultado similar al siguiente, el sitio web debería estar listo.

4. Presiona CTRL + C para detener el comando watch.

5. Abre una nueva pestaña del navegador y dirígete a http://[FRONTEND_ADDRESS]:8080 para acceder al sitio web. [FRONTEND_ADDRESS] es la dirección IP externa de frontend determinada anteriormente.

6. Intenta navegar a las páginas Productos y Pedidos, que ya deberían estar en funcionamiento.

Haz clic en Revisar mi progreso para verificar el objetivo. Implementar las instancias y configurar la red

Tarea 5: Crea grupos de instancias administrados

Para permitir el escalamiento de la aplicación, se crean grupos de instancias administrados, que utilizan las instancias de frontend y backend como plantillas de instancias.

Un grupo de instancias administrado (MIG) contiene instancias idénticas que puedes administrar como una única entidad en una única zona. Los grupos de instancias administrados mantienen la alta disponibilidad de tus aplicaciones, ya que conservan tus instancias disponibles de manera proactiva, es decir, en estado RUNNING. En este lab, usarás grupos de instancias administrados para que tus instancias de frontend y backend proporcionen reparación automática, balanceo de cargas, escalado automático y actualizaciones progresivas.

Crea una plantilla de instancias a partir de una instancia de origen

Antes de crear un grupo de instancias administrado, debes crear una plantilla de instancias que será la base del grupo. Las plantillas de instancias te permiten definir el tipo de máquina, la imagen del disco de arranque o del contenedor, la red y otras propiedades de la instancia que usarás al crear nuevas instancias de VM. Puedes usar esas plantillas para crear instancias en un grupo de instancias administrado o incluso instancias individuales.

Para crear la plantilla de instancias, utiliza las instancias que ya creaste anteriormente.

1. Primero, ejecuta los siguientes comandos para detener ambas instancias:

gcloud compute instances stop frontend gcloud compute instances stop backend

2. Luego, ejecuta los siguientes comandos para crear la plantilla de instancias desde cada una de las instancias de origen:

gcloud compute instance-templates create fancy-fe \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance=backend

3. Confirma que se hayan creado las plantillas de instancias con el siguiente comando:

gcloud compute instance-templates list

Resultado de ejemplo:

NAME MACHINE_TYPE PREEMPTIBLE CREATION_TIMESTAMP fancy-be e2-medium 2020-02-03T10:34:12.966-08:00 fancy-fe e2-medium 2020-02-03T10:34:01.082-08:00

4. Una vez creadas las plantillas de instancias, ejecuta lo siguiente para borrar la VM backend y ahorrar espacio de recursos:

gcloud compute instances delete backend

5. Escribe e ingresa y cuando se te solicite.

Normalmente, podrías también borrar la VM de frontend, pero la usarás para actualizar la plantilla de instancias más adelante en el lab.

Crea un grupo de instancias administrado

1. A continuación, ejecuta los siguientes comandos para crear dos grupos de instancias administrados, uno para el frontend y otro para el backend:

gcloud compute instance-groups managed create fancy-fe-mig \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

Esos grupos de instancias administrados usan las plantillas de instancias y están configurados para tener dos instancias en cada grupo para iniciar. Esas instancias reciben automáticamente un nombre según el base-instance-name especificado con caracteres aleatorios agregados.

2. Para tu aplicación, ejecuta lo siguiente para asegurarte de que el microservicio frontend se ejecute en el puerto 8080 y el microservicio backend se ejecute en el puerto 8081 para orders y en el puerto 8082 para productos:

gcloud compute instance-groups set-named-ports fancy-fe-mig \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --named-ports orders:8081,products:8082

Dado que esos son puertos no estándar, debes especificar puertos con nombre para identificarlos. Los puertos con nombre son metadatos de pares clave-valor que muestran el nombre del servicio y el puerto en el que se ejecuta. Los puertos con nombre se pueden asignar a un grupo de instancias; eso indica que el servicio está disponible en todas las instancias del grupo. El servicio de balanceo de cargas HTTP que configurarás más adelante usa esta información.

Configura la reparación automática

Para mejorar la disponibilidad de la aplicación y verificar que responda, configura una política de reparación automática para los grupos de instancias administrados.

Una política de reparación automática depende de una verificación de estado basada en aplicaciones para comprobar que la aplicación responda según lo esperado. Es más preciso controlar que una aplicación responde que simplemente verificar que una instancia está en estado RUNNING (el comportamiento predeterminado).

Nota: Se utilizarán diferentes verificaciones de estado para el balanceo de cargas y la reparación automática. Las verificaciones de estado para el balanceo de cargas pueden y deben ser más agresivas, ya que determinan si una instancia recibe tráfico de usuarios. Las instancias sin respuesta deben detectarse con rapidez para poder redireccionar el tráfico si es necesario.

En cambio, la verificación de estado para la reparación automática hace que Compute Engine reemplace de forma proactiva las instancias que fallan, por lo que esa verificación debe ser más conservadora que una verificación de estado para el balanceo de cargas.

1. Ejecuta lo siguiente para crear una verificación de estado para el frontend y el backend que repare la instancia si pasa a estar en mal estado 3 veces consecutivas:

gcloud compute health-checks create http fancy-fe-hc \ --port 8080 \ --check-interval 30s \ --healthy-threshold 1 \ --timeout 10s \ --unhealthy-threshold 3 gcloud compute health-checks create http fancy-be-hc \ --port 8081 \ --request-path=/api/orders \ --check-interval 30s \ --healthy-threshold 1 \ --timeout 10s \ --unhealthy-threshold 3

2. Crea una regla de firewall para permitir que los sondeos de verificación de estado se conecten con los microservicios en los puertos 8080 y 8081 con lo siguiente:

gcloud compute firewall-rules create allow-health-check \ --allow tcp:8080-8081 \ --source-ranges 130.211.0.0/22,35.191.0.0/16 \ --network default

3. Ejecuta los siguientes comandos para aplicar las verificaciones de estado a sus servicios respectivos:

gcloud compute instance-groups managed update fancy-fe-mig \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --health-check fancy-be-hc \ --initial-delay 300 Nota: Es posible que la reparación automática tarde 15 minutos en comenzar a supervisar las instancias del grupo.

4. Continúa con el lab para darle tiempo a la reparación automática de supervisar las instancias del grupo. Al final del lab, simularás una falla para probar la reparación automática.

Haz clic en Revisar mi progreso para verificar el objetivo. Crear grupos de instancias administrados

Tarea 6: Crea balanceadores de cargas

Para complementar los grupos de instancias administrados, usa un balanceador de cargas HTTP(S) para entregar tráfico a los microservicios de frontend y backend, y utiliza asignaciones para enviar tráfico a los servicios de backend correctos en función de las reglas de rutas de acceso. Esto expone una única IP con balanceo de cargas para todos los servicios.

Puedes obtener más información sobre las opciones de balanceo de cargas en Google Cloud: Descripción general del balanceo de cargas.

Crea el balanceador de cargas HTTP(S)

Google Cloud ofrece diferentes tipos de balanceadores de cargas. Para este lab, utilizarás un balanceador de cargas HTTP(S) para distribuir el tráfico. Un balanceador de cargas HTTP(S) se estructura de la siguiente manera:

1. Una regla de reenvío dirige las solicitudes entrantes a un proxy HTTP de destino.
2. El proxy HTTP de destino compara cada solicitud con un mapa de URL para determinar el servicio de backend apropiado para la solicitud.
3. El servicio de backend dirige cada solicitud a un backend adecuado según la capacidad de entrega, la zona y el estado de la instancia de los backends asociados. El estado de cada instancia de backend se comprueba mediante una verificación de estado HTTP. Si el servicio de backend está configurado para usar una verificación de estado HTTPS o HTTP/2, se encriptará la solicitud de camino a la instancia de backend.
4. Las sesiones entre el balanceador de cargas y la instancia pueden usar los protocolos HTTP, HTTPS o HTTP/2. Si usas los protocolos HTTPS o HTTP/2, cada instancia de los servicios de backend debe tener un certificado SSL.

Nota: A los fines de esta demostración, para evitar la complejidad de los certificados SSL, usaremos el protocolo HTTP en vez del HTTPS. En un entorno de producción, se recomienda usar HTTPS para la encriptación siempre que sea posible.

5. Crea verificaciones de estado para determinar qué instancias pueden entregar tráfico para cada servicio:

gcloud compute http-health-checks create fancy-fe-frontend-hc \ --request-path / \ --port 8080 gcloud compute http-health-checks create fancy-be-orders-hc \ --request-path /api/orders \ --port 8081 gcloud compute http-health-checks create fancy-be-products-hc \ --request-path /api/products \ --port 8082 Nota: Estas verificaciones de estado son para el balanceador de cargas y solo dirigen el tráfico desde él (no hacen que los grupos de instancias administrados vuelvan a crear instancias).

6. Crea servicios de backend hacia los que se pueda dirigir el tráfico de carga balanceada. Los servicios de backend utilizarán las verificaciones de estado y los puertos con nombre que creaste:

gcloud compute backend-services create fancy-fe-frontend \ --http-health-checks fancy-fe-frontend-hc \ --port-name frontend \ --global gcloud compute backend-services create fancy-be-orders \ --http-health-checks fancy-be-orders-hc \ --port-name orders \ --global gcloud compute backend-services create fancy-be-products \ --http-health-checks fancy-be-products-hc \ --port-name products \ --global

7. Agrega los servicios de backend del balanceador de cargas:

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group fancy-fe-mig \ --instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group fancy-be-mig \ --instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group fancy-be-mig \ --instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \ --global

8. Crea un mapa de URL. Este mapa define cuáles son las URLs que se dirigen hacia cada uno de los servicios de backend:

gcloud compute url-maps create fancy-map \ --default-service fancy-fe-frontend

9. Crea un comparador de rutas de acceso para permitir que las rutas /api/orders y /api/products se dirijan hacia sus respectivos servicios:

gcloud compute url-maps add-path-matcher fancy-map \ --default-service fancy-fe-frontend \ --path-matcher-name orders \ --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"

10. Para crear el proxy que se vincula al mapa de URL, ejecuta el siguiente comando:

gcloud compute target-http-proxies create fancy-proxy \ --url-map fancy-map

11. Crea una regla de reenvío global que vincule el proxy a una dirección IP pública y a un puerto:

gcloud compute forwarding-rules create fancy-http-rule \ --global \ --target-http-proxy fancy-proxy \ --ports 80

Haz clic en Revisar mi progreso para verificar el objetivo. Crear balanceadores de cargas HTTP(S)

Actualiza la configuración

Ahora que tienes una nueva dirección IP estática, actualiza el código del frontend para que dirija hacia esta dirección, en lugar de hacia la dirección temporal que utilizaste antes y que llevaba a la instancia de backend.

1. En Cloud Shell, cambia a la carpeta react-app que contiene el archivo .env con la configuración:

cd ~/monolith-to-microservices/react-app/

2. Busca la dirección IP del balanceador de cargas:

gcloud compute forwarding-rules list --global

Resultado de ejemplo:

NAME: fancy-http-rule REGION: IP_ADDRESS: 34.111.203.235 IP_PROTOCOL: TCP TARGET: fancy-proxy

3. Regresa al editor de Cloud Shell y edita el archivo .env otra vez para que dirija hacia la IP pública del balanceador de cargas. [LB_IP] representa la dirección IP externa de la instancia de backend que se determinó anteriormente.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products Nota: Los puertos se quitan de la nueva dirección porque el balanceador de cargas está configurado para encargarse de estos reenvíos por ti.

4. Guarda el archivo.

5. Vuelve a compilar react-app, lo que actualizará el código del frontend:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

6. Copia el código de la aplicación en tu bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Actualiza las instancias de frontend

Ahora que hay un nuevo código y una nueva configuración, es necesario que las instancias de frontend ubicadas en el grupo de instancias administrado extraigan el nuevo código.

• Dado que las instancias extraen el código cuando se inician, puedes ejecutar un comando de reinicio progresivo:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --max-unavailable 100% Nota: En este ejemplo de un reemplazo progresivo, se especifica que todas las máquinas pueden reemplazarse de inmediato a través del parámetro --max-unavailable. Sin este parámetro, el comando mantendría una instancia activa mientras se reinician las demás para garantizar que haya disponibilidad. Para realizar pruebas, se especifica que se reemplacen inmediatamente todas las instancias para obtener mayor velocidad.

Haz clic en Revisar mi progreso para verificar el objetivo. Actualizar las instancias de frontend

Prueba el sitio web

1. Espera unos 30 segundos después de ejecutar el comando rolling-action replace para dar tiempo a que se procesen las instancias y, luego, comprueba el estado del grupo de instancias administrado hasta que las instancias aparezcan en la lista:

watch -n 2 gcloud compute instance-groups list-instances fancy-fe-mig

2. Una vez que aparezcan en la lista, presiona CTRL + C para salir del comando watch.

3. Ejecuta el siguiente comando para confirmar que el servicio figure como HEALTHY:

watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global

4. Espera hasta que los 2 servicios figuren como HEALTHY.

Resultado de ejemplo:

--- backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080 - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth Nota: Si ocurre algún problema en alguna de las instancias y aparece como UNHEALTHY, debería repararse automáticamente. Espera a que esto se lleve a cabo.

Si ninguna instancia figura como HEALTHY después de esperar unos minutos, significa que hay un error en la configuración de las instancias de frontend y que no funciona el acceso por el puerto 8080. Para comprobarlo, explora las instancias directamente en el puerto 8080.

5. Una vez que ambas figuren como HEALTHY en la lista, presiona CTRL + C para salir del comando watch.

Nota: Podrás acceder a la aplicación a través de http://[LB_IP], donde [LB_IP] es la IP_ADDRESS que se especificó para el balanceador de cargas y que se puede encontrar con el siguiente comando: gcloud compute forwarding-rules list --global Comprobarás el funcionamiento de la aplicación más adelante en el lab.

Tarea 7: Escalar los grupos de instancias de Compute Engine

Hasta ahora, creaste dos grupos de instancias administrados con dos instancias cada uno. Esta configuración funciona correctamente, pero no deja de ser estática, más allá de la carga. A continuación, crearás una política de escalado automático en función del uso para escalar automáticamente cada grupo de instancias administrado.

Cambio de tamaño automático según el uso

• Para crear la política de escalado automático, ejecuta los siguientes comandos:

gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60

Esos comandos crean un escalador automático en los grupos de instancias administrados que automáticamente agrega instancias cuando el uso supera el 60% o las quita cuando está por debajo de esa cifra.

Habilita la red de distribución de contenidos

Otra función que puede ser de utilidad con el escalamiento es habilitar el servicio de red de distribución de contenidos para brindarle almacenamiento en caché al frontend.

• Ejecuta el siguiente comando en el servicio de frontend:

gcloud compute backend-services update fancy-fe-frontend \ --enable-cdn --global

Cuando un usuario solicita contenido del balanceador de cargas HTTP(S), la solicitud llega a un servicio Google Front End (GFE) que primero busca una respuesta para la solicitud en la caché de Cloud CDN. Si el GFE encuentra una respuesta almacenada en caché, la envía al usuario. Esto se conoce como acierto de caché.

Si el GFE no encuentra una respuesta almacenada en caché, realiza una solicitud directamente en el backend. Si se puede almacenar en caché la respuesta a ese pedido, el GFE la almacena en la caché de Cloud CDN para que pueda utilizarse en futuras solicitudes.

Haz clic en Revisar mi progreso para verificar el objetivo. Escalar Compute Engine

Tarea 8: Actualiza el sitio web

Actualiza la plantilla de instancias

No se pueden editar las plantillas de instancias que ya existen. Sin embargo, como tus instancias no tienen estado y toda la configuración se realiza a través de la secuencia de comandos de inicio, solo debes modificar la plantilla de instancias si deseas cambiar las configuraciones de la plantilla. Ahora realizará un cambio simple para usar y desplegar un tipo de máquina más grande.

1. Actualiza la instancia frontend que actúa como base de la plantilla de instancias. Durante la actualización, colocarás un archivo en la versión actualizada de la imagen de la plantilla de instancias. Luego, actualizarás la plantilla, implementarás la nueva y confirmarás que dicho archivo esté en las instancias del grupo de instancias administrado.

2. Ahora, modifica el tipo de máquina de tu plantilla de instancias. Para hacerlo, cambia el tipo e2-medium por un tipo personalizado de máquina con 4 CPUs virtuales y 3,840 MiB de RAM.

3. Ejecuta el siguiente comando para modificar el tipo de máquina de la instancia de frontend:

gcloud compute instances set-machine-type frontend --machine-type custom-4-3840

4. Crea la nueva plantilla de instancias:

gcloud compute instance-templates create fancy-fe-new \ --source-instance=frontend \ --source-instance-zone={{{ project_0.default_zone | "ZONE" }}}

5. Lanza la plantilla de instancias actualizada en el grupo de instancias administrado:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --version template=fancy-fe-new

6. Espera 30 segundos y ejecuta lo siguiente para supervisar el estado de la actualización:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig

Esto tardará unos minutos.

Una vez que tengas al menos una instancia en el siguiente estado:

• STATUS: RUNNING
• ACTION: configurada como None
• INSTANCE_TEMPLATE: el nuevo nombre de la plantilla (fancy-fe-new)

7. Copia el nombre de una de las máquinas de la lista para su utilización en el siguiente comando.

8. Presiona CTRL + C para salir del proceso watch.

9. Ejecuta el siguiente comando para ver si la máquina virtual está utilizando el nuevo tipo de máquina (custom-4-3840). [VM_NAME] es la nueva instancia creada:

gcloud compute instances describe [VM_NAME] | grep machineType

Resultado esperado (ejemplo):

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/{{{ project_0.default_zone | "ZONE" }}}/machineTypes/custom-4-3840

Realiza cambios en el sitio web

Situación: Tu equipo de marketing te pidió que cambies la página principal de tu sitio. Cree que debería tener más información sobre tu empresa y lo que vendes.

Tarea: Agrega algunos párrafos en la página principal para complacer al equipo de marketing. Al parecer, uno de los desarrolladores ya realizó los cambios en el archivo llamado index.js.new. Puedes simplemente copiar ese archivo en index.js, y deberían poder verse los cambios. Sigue las instrucciones que se incluyen a continuación para realizar los cambios apropiados.

1. Ejecuta los siguientes comandos para copiar el archivo actualizado en el nombre de archivo correcto:

cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js

2. Muestra el contenido del archivo para verificar los cambios:

cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js

El código resultante debería verse así:

/* Copyright 2019 Google LLC Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ import React from "react"; import { Box, Paper, Typography } from "@mui/material"; export default function Home() { return ( theme.spacing(3, 2), }} > Fancy Fashion & Style Online
Tired of mainstream fashion ideas, popular trends and societal norms? This line of lifestyle products will help you catch up with the Fancy trend and express your personal style. Start shopping Fancy items now! ); }

Ya actualizaste los componentes de React, pero debes compilar la app de React para generar archivos estáticos.

3. Ejecuta el siguiente comando para compilar la app y copiarla en el directorio público de monolith:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build

4. Luego, vuelve a enviar este código al bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Envía los cambios usando reemplazos progresivos

1. Ahora fuerza el reemplazo de todas las instancias para realizar la actualización:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --max-unavailable=100% Nota: En este ejemplo de un reemplazo progresivo, se especifica que todas las máquinas pueden reemplazarse de inmediato a través del parámetro --max-unavailable. Sin ese parámetro, el comando mantendría una instancia activa mientras se reemplazan las demás. Para realizar pruebas, se especifica que se reemplacen inmediatamente todas las instancias para obtener mayor velocidad. En un entorno de producción, se puede dejar un búfer en funcionamiento para permitir que el sitio web continúe activo mientras se actualiza.

Haz clic en Revisar mi progreso para verificar el objetivo. Actualizar el sitio web

2. Espera unos 30 segundos después de ejecutar el comando rolling-action replace para dar tiempo a que se procesen las instancias y, luego, comprueba el estado del grupo de instancias administrado hasta que las instancias aparezcan en la lista:

watch -n 2 gcloud compute instance-groups list-instances fancy-fe-mig

3. Una vez que aparezcan en la lista, presiona CTRL + C para salir del comando watch.

4. Ejecuta el siguiente comando para confirmar que el servicio figure como HEALTHY:

watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global

5. Espera unos minutos hasta que aparezcan ambos servicios y figuren como HEALTHY.

Resultado de ejemplo:

--- backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080 - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth

6. Una vez que aparezcan en la lista, presiona CTRL + C para salir del comando watch.

7. Dirígete al sitio web a través de http://[LB_IP], donde [LB_IP] es la IP_ADDRESS que se especificó para el balanceador de cargas y que se puede encontrar con el siguiente comando:

gcloud compute forwarding-rules list --global

Ahora deberían verse los cambios en el sitio web nuevo.

Simula una falla

Para confirmar que funcione la verificación de estado, accede a una instancia y detén los servicios.

1. Para encontrar el nombre de una instancia, ejecuta el siguiente comando:

gcloud compute instance-groups list-instances fancy-fe-mig

2. Copia el nombre de una instancia y, luego, ejecuta lo siguiente para asegurar la shell en la instancia. INSTANCE_NAME es una de las instancias de la lista:

gcloud compute ssh [INSTANCE_NAME]

3. Escribe “y” para confirmar y presiona Intro dos veces para no usar una contraseña.

4. En la instancia, usa supervisorctl para detener la aplicación:

sudo supervisorctl stop nodeapp; sudo killall node

5. Sal de la instancia:

exit

6. Supervisa las operaciones de reparación:

watch -n 2 gcloud compute operations list \ --filter='operationType~compute.instances.repair.*'

Este proceso tarda unos minutos en completarse.

Busca el siguiente resultado de ejemplo:

Resultado de ejemplo:

NAME TYPE TARGET HTTP_STATUS STATUS TIMESTAMP repair-1568314034627-5925f90ee238d-fe645bf0-7becce15 compute.instances.repair.recreateInstance {{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-1vqq 200 DONE 2019-09-12T11:47:14.627-07:00

El grupo de instancias administrado volvió a crear la instancia para repararla.

7. También puedes supervisar a través de la consola. Ve al menú de navegación > Compute Engine > Instancias de VM.

¡Felicitaciones!

¡Felicitaciones! En este lab, implementaste, escalaste y actualizaste correctamente tu sitio web en Compute Engine, lo que te ayudó a obtener experiencia práctica con Compute Engine, los grupos de instancias administrados, los balanceadores de cargas y las verificaciones de estado. En este lab, se destaca cómo Google Cloud y AWS facilitan las implementaciones de aplicaciones basadas en VMs con balanceadores de cargas orientados a Internet. El enfoque de Google Cloud utiliza las secuencias de comandos de inicio para unificar la implementación de código y la configuración de VMs, optimiza la administración de VMs con el escalado automático, ofrece balanceo de cargas HTTP(S) externo global y habilita actualizaciones de imágenes y aplicaciones sin interrupciones en la secuencia de comandos de inicio y el flujo de trabajo de MIG.

Próximos pasos y más información

• Para obtener más información, consulta Reparación automática y verificaciones de estado en grupos de instancias administrados.

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.

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

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

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