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, por ejemplo.

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

Qué aprenderás

En este lab, aprenderás a hacer lo siguiente:

• 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, ajuste de escala 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 son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

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

Para completar este lab, necesitarás lo siguiente:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4. Haz clic en Siguiente.

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

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

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

6. Haz clic en Siguiente.

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

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

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

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

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

Activa Cloud Shell

Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

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

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

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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

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

gcloud auth list

3. Haz clic en Autorizar.

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

Resultado:

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

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

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

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

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 la consola de Cloud 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:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID Nota: El uso de la variable de entorno $DEVSHELL_PROJECT_ID en Cloud Shell sirve para garantizar que los nombres de los objetos sean únicos. Dado que todos los IDs de proyectos deben ser únicos en Google Cloud, el hecho de agregar el ID del proyecto debería asegurar que los demás nombres también sean únicos.

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

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

Clona el código fuente para 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. Clona el código fuente y, luego, navega 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 finalizar.

3. Cuando se complete, 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 ver el 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. Crea instancias de Compute Engine

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

En los siguientes pasos, debes hacer lo siguiente:

1. Crea una secuencia de comandos de inicio para configurar las instancias.
2. Clona el código fuente y súbelo a Cloud Storage.
3. Implementa una instancia de Compute Engine para alojar los microservicios de backend.
4. Reconfigura el código de frontend para utilizar la instancia de microservicios de backend.
5. Implementa una instancia de Compute Engine para alojar el microservicio de frontend.
6. Configura la red para permitir la comunicación.

Crea la secuencia de comandos de inicio

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

1. En Cloud Shell, ejecuta el siguiente comando para crear un archivo llamado startup-script.sh:

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

2. En la cinta de Cloud Shell, haz clic en Open 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. Una vez que lo hayas agregado, editarás una parte del código:

#!/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. Busca el texto [DEVSHELL_PROJECT_ID] en el archivo y reemplázalo por el ID de tu proyecto:

Ahora, la línea de código de startup-script.sh debería ser similar a la siguiente:

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

6. Guarda el archivo startup-script.sh, pero no lo cierres aún.

7. Observa 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 en “LF” y no en “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á.

8. Cierra el archivo startup-script.sh.

9. 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-$DEVSHELL_PROJECT_ID

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 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 podrán 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 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 los 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 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.

1. Copia el código clonado en el 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 implementarás será la de backend, que alojará 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 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 \ --zone=$ZONE \ --machine-type=e2-standard-2 \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_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 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: 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 previamente.

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

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. A continuación, copia el código de la aplicación en el bucket de Cloud Storage:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

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 \ --zone=$ZONE \ --machine-type=e2-standard-2 \ --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

1. Crea 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:

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 algunos 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 de frontend que se determinó 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 crearán grupos de instancias administrados, que utilizarán 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 tus 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, ajuste de escala 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, detén ambas instancias:

gcloud compute instances stop frontend --zone=$ZONE gcloud compute instances stop backend --zone=$ZONE

2. Luego, crea la plantilla de instancias desde cada una de las instancias de origen:

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

3. Confirma 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, borra la VM backend para ahorrar espacio de recursos:

gcloud compute instances delete backend --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 un grupo de instancias administrado

1. A continuación, crea dos grupos de instancias administrados, uno para el frontend y otro para el backend:

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

Esos grupos de instancias administrados usarán 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, el microservicio frontend se ejecuta en el puerto 8080. Por su parte, el microservicio backend lo hace en el puerto 8081 para orders y en el puerto 8082 para products:

gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone=$ZONE \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --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; eso indica que el servicio está disponible en todas las instancias del grupo. A esta información la usa el servicio de balanceo de cargas HTTP que será configurado más adelante.

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. Crea 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:

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:

gcloud compute instance-groups managed update fancy-fe-mig \ --zone=$ZONE \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone=$ZONE \ --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 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: Descripción general del balanceo de cargas.

Crea un 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.

1. Crea verificaciones de estado que se utilizarán 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 se encargan de dirigir el tráfico desde él (no hacen que los grupos de instancias administrados vuelvan a crear instancias).

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

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

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone=$ZONE \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone=$ZONE \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone=$ZONE \ --instance-group fancy-be-mig \ --global

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

5. 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"

6. Crea el proxy que se vincula al mapa de URL:

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

7. 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 de 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-$DEVSHELL_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 \ --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 3 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 2 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 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. 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 una configuración estática, más allá de la carga. A continuación, crearás una política de ajuste de escala 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 ajuste de escala automático, ejecuta los siguientes comandos:

gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --zone=$ZONE \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --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 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ás un cambio simple para usar y desplegar un tipo de máquina más grande.

Completa los siguientes pasos para poder hacer lo siguiente:

• Actualiza la instancia 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, implementa 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=$ZONE \ --machine-type e2-small

2. Crea la nueva plantilla de instancias:

gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone=$ZONE

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

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --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=$ZONE

El proceso 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)

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), donde [VM_NAME] es la instancia recién creada:

gcloud compute instances describe [VM_NAME] --zone=$ZONE | grep machineType

Resultado esperado (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: 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 su empresa y lo que vende.

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 ( <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, 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-$DEVSHELL_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 \ --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 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 3 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 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.

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 --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=$ZONE

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 tardará unos minutos en completarse.

Busca el siguiente resultado de ejemplo:

NAME TYPE TARGET HTTP_STATUS STATUS TIMESTAMP repair-1568314034627-5925f90ee238d-fe645bf0-7becce15 compute.instances.repair.recreateInstance us-central1-a/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 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 con Compute Engine, grupos de instancias administrados, balanceadores de cargas y verificaciones de estado.

Próximos pasos y más información

• Reparación automática y 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: 26 de abril de 2024

Prueba más reciente del lab: 15 de diciembre de 2023

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.