GSP662

Descripción general

Existen muchas formas de implementar sitios web en Google Cloud. Cada solución ofrece diferentes funciones, capacidades y niveles de control. Compute Engine ofrece un amplio nivel de control sobre la infraestructura utilizada para ejecutar un sitio web, pero también requiere un poco más de administración operativa que otras soluciones como Google Kubernetes Engine (GKE) o App Engine, entre otras. Compute Engine permite tener un control más detallado sobre distintos aspectos de la infraestructura, como las máquinas virtuales y los balanceadores de cargas.

En este lab, explorarás cómo implementar una aplicación de ejemplo, el sitio web de comercio electrónico “Fancy Store”, y comprobarás que es muy sencillo implementar y escalar un sitio web con Compute Engine.

Qué aprenderás

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, deberías tener 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 derecha, se encuentra el panel Configuración del lab y acceso, que tiene los siguientes elementos:

   • El botón Abrir la consola de Google Cloud
   • Las credenciales temporales (nombre de usuario y contraseña) que debes usar para este lab
   • Otra información para completar el lab (si es necesaria)

   Ten en cuenta que el cronómetro del lab se encuentra cerca de la parte superior de la página y muestra el tiempo restante.

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 los 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 Usa 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 Configuración del lab y acceso.

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 Configuración del lab y acceso.

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 ni autenticación de dos factores, ya que esta cuenta es 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.

Configura tu región y zona

Algunos recursos de Compute Engine se encuentran en regiones y zonas. Una región es una ubicación geográfica específica donde puedes ejecutar tus recursos. Cada región tiene una o más zonas.

Ejecuta los siguientes comandos de gcloud en Cloud Shell para establecer la región y la zona predeterminadas de tu lab:

gcloud config set compute/zone "{{{project_0.default_zone|ZONE}}}" export ZONE=$(gcloud config get compute/zone) gcloud config set compute/region "{{{project_0.default_region|REGION}}}" export REGION=$(gcloud config get compute/region)

Tarea 1: Habilita la API de Compute Engine

• Para habilitar la API de Compute Engine, ejecuta el siguiente comando:

gcloud services enable compute.googleapis.com

Tarea 2: Crea un bucket de Cloud Storage

Usará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:

gcloud storage buckets create gs://fancy-store-{{{project_0.project_id | Project ID}}}

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

Tarea 3: Clona un repositorio de código fuente

En este lab, se usa el sitio web de comercio electrónico existente de Fancy Store que se basa en el repositorio monolith-to-microservices como modelo para tu sitio web.

En esta tarea, 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 con lo siguiente:

./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

Deberías recibir el siguiente resultado.

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 ver el frontend. Sin embargo, las funciones Productos y Pedidos no funcionan en este momento, ya que los servicios correspondientes 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: Crea las instancias de Compute Engine

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

En las siguientes secciones, realizarás las acciones detalladas a continuación:

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 terminal de Cloud Shell, ejecuta el siguiente comando para crear un archivo llamado startup-script.sh:

touch ~/monolith-to-microservices/startup-script.sh

2. En la barra de herramientas de Cloud Shell, haz clic en Abrir editor para abrir el editor de código.

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

4. Agrega el siguiente código al archivo startup-script.sh. Más adelante, editarás una parte del código después de agregarlo:

#!/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 apt-get install -y nodejs npm # Get the application source code from the Google Cloud Storage bucket. mkdir /fancy-store gcloud storage 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 /fancy-store # 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. Reemplaza [DEVSHELL_PROJECT_ID] por tu ID de proyecto ({{{project_0.project_id | Project ID}}}).
6. Haz clic en Archivo > Guardar o presiona CTRL+S para guardar el archivo startup-script.sh, pero no lo cierres todavía.

7. Haz clic en Save o presiona Ctrl + S para guardar el archivo startup-script.sh, pero no lo cierres aún.

8. Consulta la parte inferior derecha del editor de código de Cloud Shell y asegúrate de que la opción “End of Line Sequence” esté configurada como “LF” y no “CRLF”.



• Si está configurada como CRLF, haz clic en CRLF y selecciona LF en el menú desplegable.
• Si ya se configuró como LF, déjala como está.

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

gcloud storage cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | Project ID}}}

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

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

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 app como un daemon).
• Clona el código fuente de la app desde el bucket de Cloud Storage y, luego, instala las 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.

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 escribir código de forma que se extraigan variables de entorno de algún otro lugar. Sin embargo, 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 se almacenan 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 gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | 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 permitirles 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-standard-2 configurada y 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 \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=backend \ --image-family={{{project_0.startup_script.debian_image_id_short | Debian image name}}} \ --image-project=debian-cloud \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh

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 recuperar 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: backend ZONE: {{{project_0.default_zone | zone}}} MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.142.0.2 EXTERNAL_IP: 35.237.245.193 STATUS: 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.

En el siguiente paso, editarás el archivo .env para que apunte 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 recientemente.

5. En el archivo .env, reemplaza localhost por [BACKEND_ADDRESS]:
REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

6. Guarda el archivo.

7. En Cloud Shell, ejecuta el siguiente comando 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
8. Luego, ejecuta el siguiente comando para copiar el código de la aplicación en el bucket de Cloud Storage:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Implementa la instancia de frontend

Una vez que hayas configurado el código, podrás implementar 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 \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=frontend \ --image-family={{{project_0.startup_script.debian_image_id_short | Debian image name}}} \ --image-project=debian-cloud \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | 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

1. Ejecuta los siguientes comandos para crear reglas de firewall que permitan que el frontend acceda al puerto 8080 y que el backend acceda a los puertos 8081 y 8082. Estos comandos de firewall utilizan las etiquetas que asignaste cuando creaste las instancias para la aplicación:
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: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.3 EXTERNAL_IP: 34.172.241.242 STATUS: RUNNING

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

3. Espera 3 minutos, abre una nueva pestaña del navegador y ve a http://[FRONTEND_ADDRESS]:8080 para acceder al sitio web. [FRONTEND_ADDRESS] es la EXTERNAL_IP del frontend que determinaste anteriormente.

4. 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 apps, ya que conservan las instancias disponibles de manera proactiva, es decir, en estado RUNNING. 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 permiten definir el tipo de máquina, la imagen del disco de arranque o la imagen de contenedor, la red y otras propiedades de la instancia que usarás cuando crees 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 lo siguiente para detener ambas instancias:
gcloud compute instances stop frontend --zone={{{project_0.default_zone | zone}}} gcloud compute instances stop backend --zone={{{project_0.default_zone | zone}}}
2. Luego, crea la plantilla de instancias desde cada una de las instancias de origen con los siguientes comandos:
gcloud compute instance-templates create fancy-fe \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=backend
3. Ejecuta lo siguiente para confirmar que se hayan creado las plantillas de instancias:
gcloud compute instance-templates list

Resultado de ejemplo:

NAME: fancy-be MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:21.933-07:00 NAME: fancy-fe MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:15.442-07:00
4. Una vez creadas las plantillas de instancias, ejecuta lo siguiente para borrar la VM de backend y ahorrar espacio de recursos:
gcloud compute instances delete backend --zone={{{project_0.default_zone | zone}}}
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 grupos de instancias administrados

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 \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --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. Ejecuta lo siguiente para asegurarte de que, en tu aplicación, 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 products:
gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --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; esto 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 utilizan 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. Ejecuta lo siguiente para crear una regla de firewall que permita que los sondeos de verificación de estado se conecten con los microservicios en los puertos 8080 y 8081:
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. Aplica las verificaciones de estado a sus servicios respectivos con los siguientes comandos:
gcloud compute instance-groups managed update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-be-hc \ --initial-delay 300 Nota: Pueden pasar hasta 15 minutos antes de que la reparación automática comience a supervisar las instancias en el grupo.
4. Continúa con el lab para darle tiempo a la reparación automática de supervisar las instancias del grupo. Simularás una falla para probar la reparación automática al final del lab.

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

Tarea 6: Crea balanceadores de cargas

Para complementar tus grupos de instancias administrados, usa balanceadores de cargas HTTP(S) para entregar tráfico a los microservicios de frontend y backend, y usa asignaciones para enviar tráfico a los servicios de backend adecuados en función de 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 en la Descripción general de Cloud Load Balancing.

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 se estructura de la siguiente manera:

• Una regla de reenvío dirige las solicitudes entrantes a un proxy HTTP de destino.
• El proxy HTTP de destino compara cada solicitud con un mapa de URLs para determinar el servicio de backend apropiado para la solicitud.
• 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 por medio de una verificación de estado HTTP. Si se configura el servicio de backend para usar una verificación de estado HTTPS o HTTP/2, la solicitud se encripta de camino a la instancia de backend.
• 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.
1. Ejecuta lo siguiente para crear verificaciones de estado que se usarán para determinar qué instancias pueden entregar tráfico para cada servicio:
gcloud compute health-checks create http fancy-fe-frontend-hc \ --request-path=/ \ --port=8080 gcloud compute health-checks create http fancy-be-orders-hc \ --request-path=/api/orders \ --port=8081 gcloud compute health-checks create http fancy-be-products-hc \ --request-path=/api/products \ --port=8082 Nota: Estas verificaciones de estado son para el balanceador de cargas y solo se encargan de dirigir el tráfico desde él (no hacen que los grupos de instancias administrados vuelvan a crear instancias).
2. Ejecuta lo siguiente para crear servicios de backend hacia los que se pueda dirigir el tráfico de carga balanceada. Los servicios de backend utilizan las verificaciones de estado y los puertos con nombre que creaste:
gcloud compute backend-services create fancy-fe-frontend \ --health-checks=fancy-fe-frontend-hc \ --port-name=frontend \ --global gcloud compute backend-services create fancy-be-orders \ --health-checks=fancy-be-orders-hc \ --port-name=orders \ --global gcloud compute backend-services create fancy-be-products \ --health-checks=fancy-be-products-hc \ --port-name=products \ --global
3. Ejecuta lo siguiente para agregar los servicios de backend del balanceador de cargas:
gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global
4. Ejecuta el siguiente comando para crear un mapa de URLs que defina cuáles se dirigen hacia cada uno de los servicios de backend:
gcloud compute url-maps create fancy-map \ --default-service fancy-fe-frontend
5. Ejecuta el siguiente comando para crear un comparador de rutas de acceso que permita 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"
6. Para crear el proxy que se vincula al mapa de URLs, ejecuta el siguiente comando:
gcloud compute target-http-proxies create fancy-proxy \ --url-map fancy-map
7. Ejecuta el siguiente comando para crear 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, ejecuta el siguiente comando para cambiar 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 con el siguiente comando:
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. 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
6. Ejecuta lo siguiente para copiar el código de la aplicación en tu bucket:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage 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, ejecuta el siguiente comando para solicitar un reinicio progresivo:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --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 tres minutos después de emitir el comando rolling-action replace para dar tiempo a que se procesen las instancias y, luego, comprueba el estado del grupo de instancias administrado. 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
2. Espera hasta que los dos servicios figuren como HEALTHY.

Resultado de ejemplo:

backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/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/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth Nota: Si alguna de las instancias experimenta un problema 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.
3. 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 la URL http://[LB_IP], en la que [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: Escala 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.

Cambia automáticamente el tamaño 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 \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --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 del balanceador de cargas supera el 60% o las quita cuando está por debajo de ese porcentaje.

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 los parámetros de la plantilla. En esta tarea, realizarás un cambio simple para usar y desplegar un tipo de máquina más grande.

Completa los siguientes pasos para realizar las siguientes acciones:

• Actualiza la instancia de frontend que actúa como base de la plantilla de instancias. Durante la actualización, coloca un archivo en la versión actualizada de la imagen de la plantilla de instancias. Luego, actualiza la plantilla, lanza la nueva y confirma que dicho archivo esté en las instancias del grupo de instancias administrado.

• Para modificar el tipo de máquina de tu plantilla de instancias, cambia del tipo de máquina e2-standard-2 al e2-small.

1. Ejecuta el siguiente comando para modificar el tipo de máquina de la instancia de frontend:
gcloud compute instances set-machine-type frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type e2-small
2. Ejecuta el siguiente comando para crear la nueva plantilla de instancia:
gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone={{{project_0.default_zone | zone}}}
3. Lanza la plantilla de instancias actualizada en el grupo de instancias administrado con el siguiente comando:
gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --version template=fancy-fe-new
4. Espera 3 minutos y ejecuta el siguiente comando para supervisar el estado de la actualización:
watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}}

Este proceso tarda varios minutos.

Antes de continuar, asegúrate de tener 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)

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

6. Presiona Ctrl + C para salir del proceso watch.

7. Ejecuta el siguiente comando para ver si la máquina virtual está usando el nuevo tipo de máquina (e2-small), en el que [VM_NAME] es la instancia recién creada:

gcloud compute instances describe [VM_NAME] --zone={{{project_0.default_zone | zone}}} | grep machineType

Resultado esperado de ejemplo:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/e2-small

Realiza cambios en el sitio web

Situación: El equipo de Marketing te pidió que cambies la página principal de tu sitio. Cree que debería representar mejor la identidad de la empresa y el producto que vendes.

En esta sección, agregarás texto a la página principal para satisfacer 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 parecerse al siguiente resultado.

Resultado:

/* 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 ( <Box sx={{ flexGrow: 1 }}> <Paper elevation={3} sx={{ width: "800px", margin: "0 auto", padding: (theme) => theme.spacing(3, 2), }} > <Typography variant="h5">Welcome to the Fancy Store!</Typography> <br /> <Typography variant="body1"> Take a look at our wide variety of products. </Typography> </Paper> </Box> ); }

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, ejecuta lo siguiente para volver a enviar este código al bucket:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Envía los cambios usando reemplazos progresivos

1. Ahora ejecuta lo siguiente para forzar el reemplazo de todas las instancias y realizar la actualización:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --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 la etapa de producción, se puede dejar un búfer en funcionamiento para permitir que el sitio web se siga entregando mientras se actualiza.

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

2. Espera tres minutos después de emitir el comando rolling-action replace para dar tiempo a que se procesen las instancias y, luego, comprueba el estado del grupo de instancias administrado. 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
3. 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/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/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/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth

4. Cuando los servicios aparezcan en la lista con el estado HEALTHY, presiona Ctrl + C para salir del comando watch.

5. Dirígete al sitio web a través de la URL http://[LB_IP], en la que [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, decides acceder a una instancia y detener los servicios.

1. Para encontrar el nombre de una instancia, ejecuta el siguiente comando:
gcloud compute instance-groups list-instances fancy-fe-mig --zone={{{project_0.default_zone | zone}}}
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] --zone={{{project_0.default_zone | zone}}}

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

4. En la instancia, ejecuta lo siguiente para usar supervisorctl y detener la aplicación:

sudo supervisorctl stop nodeapp; sudo killall node
5. Ejecuta el siguiente comando para salir 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 varios minutos en completarse.

Busca el siguiente resultado de ejemplo:

Resultado:

NAME: repair-1755080598062-63c3c8b99843b-eed8dabc-f1833ea3 TYPE: compute.instances.repair.recreateInstance TARGET: us-east4-c/instances/fancy-fe-tn40 HTTP_STATUS: 200 STATUS: DONE TIMESTAMP: 2025-08-13T03:23:18.062-07:00

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

7. También puedes ir al menú de navegación > Compute Engine > Instancias de VM para realizar la supervisión a través de la consola.

¡Felicitaciones!

Implementaste, escalaste y actualizaste de manera exitosa tu sitio web en Compute Engine. Ahora tienes experiencia en Compute Engine, grupos de instancias administrados, balanceadores de cargas y verificaciones de estado.

Próximos pasos y más información

• Lee sobre la reparación automática y las verificaciones de estado en grupos de instancias administrados.
• Mira este caso de éxito en video sobre cómo alojar aplicaciones web escalables en Google Cloud.

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: 19 de junio de 2026

Prueba más reciente del lab: 19 de junio de 2026

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.