GSP041

Descripción general

El balanceador de cargas de aplicaciones interno es esencial para crear aplicaciones internas sólidas, seguras y fáciles de administrar que potencien las operaciones comerciales. En este lab, aprenderás a distribuir el tráfico de red dentro de tu red de nube privada sin exponer tus máquinas virtuales (VMs) directamente al Internet público, lo que mantiene tus servicios seguros y eficientes.

Compilarás un patrón de arquitectura simplificado, pero muy común:

• Un "nivel web" (sitio web público) que necesita pedir ayuda a otro servicio interno
• Un "nivel de servicio interno" (una calculadora de números primos) que realiza tareas específicas y se distribuye en varias máquinas

Esta configuración garantiza que, incluso si una parte de tu servicio interno se ocupa o deja de funcionar, el sistema general siga funcionando sin problemas, ya que el balanceador de cargas dirige automáticamente las solicitudes a las máquinas en buen estado.

Actividades

• Conocer los componentes que conforman un balanceador de cargas interno
• Crear un grupo de máquinas de backend (calculadora de números primos)
• Configurar un balanceador de cargas interno para dirigir el tráfico interno a las máquinas de backend
• Probar el balanceador de cargas interno desde otra máquina interna
• Configurar un servidor web orientado al público que use el balanceador de cargas interno para obtener resultados del servicio interno de "calculadora de números primos"

Requisitos previos

• Conocimiento básico de Google Cloud Compute Engine: comprender qué es una instancia de máquina virtual (VM)
• Conceptos básicos de redes: qué es una dirección IP
• Línea de comandos básica de Unix/Linux: cómo escribir comandos en una terminal
• Conocimientos básicos sobre las VPC (nubes privadas virtuales): comprender que tus recursos de Google Cloud residen en una red privada

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

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

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar. Se recomienda el navegador Chrome.

Nota: Usa una ventana del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab (recuerda que, una vez que comienzas un lab, no puedes pausarlo).

Nota: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

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

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

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

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

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

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

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

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

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

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

4. Haz clic en Siguiente.

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

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

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

6. Haz clic en Siguiente.

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

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

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

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

Nota: Para acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

Activa Cloud Shell

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

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

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API de Google Cloud.

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

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

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

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

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

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

gcloud config list project

Resultado:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

Configura la región y la zona

1. Configura la región y la zona del proyecto para este lab:

gcloud config set compute/region {{{project_0.default_region | Region}}} gcloud config set compute/zone {{{project_0.default_zone | Zone}}}

2. Crea una variable para la región:

export REGION={{{project_0.default_region | Region}}}

3. Crea una variable para la zona:

export ZONE={{{project_0.default_zone | Zone}}}

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

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

Tarea 1. Crea un entorno virtual

Un entorno virtual mantiene el software de tu proyecto ordenado y garantiza que tu código siempre se ejecute con las versiones específicas de las herramientas que necesita.

Se utilizan entornos virtuales de Python para aislar del sistema la instalación de paquetes.

1. Instala el entorno virtualenv:

sudo apt-get install -y virtualenv

2. Crea el entorno virtual:

python3 -m venv venv

3. Activa el entorno virtual:

source venv/bin/activate

Tarea 2. Crea un grupo de instancias administrado de backend

Con un "grupo de instancias administrado", Google Cloud puede crear y mantener automáticamente copias idénticas de tu servicio. Si falla una copia, Google Cloud la reemplaza, lo que hace que tu servicio sea más confiable.

Crea la secuencia de comandos de inicio

Esta secuencia de comandos es como un conjunto de instrucciones que seguirá cada VM nueva de tu grupo cuando se inicie. Nuestra secuencia de comandos incluirá un pequeño servidor web escrito en Python que puede indicarnos si un número es primo (True) o no (False).

1. Comienza por crear tu secuencia de comandos backend.sh en el directorio principal:

touch ~/backend.sh

2. Haz clic en Abrir editor haciendo clic en el ícono que se encuentra en la parte superior de Cloud Shell. Si se te solicita, haz clic en Abrir en una nueva ventana.

Nota: Si no ves el ícono del editor de código, haz clic en el ícono del menú de navegación para cerrar el panel izquierdo.

Cuando inicias el editor de código, Cloud Shell se mueve a una ventana nueva y se abre el editor de código. Después de unos segundos, aparecerá el espacio de trabajo.

3. Selecciona el archivo backend.sh en el panel izquierdo.

4. Ahora agrega la siguiente secuencia de comandos en el editor en la parte derecha:

sudo chmod -R 777 /usr/local/sbin/ sudo cat << EOF > /usr/local/sbin/serveprimes.py import http.server def is_prime(a): return a!=1 and all(a % i for i in range(2,int(a**0.5)+1)) class myHandler(http.server.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "text/plain") s.end_headers() s.wfile.write(bytes(str(is_prime(int(s.path[1:]))).encode('utf-8'))) http.server.HTTPServer(("",80),myHandler).serve_forever() EOF nohup python3 /usr/local/sbin/serveprimes.py >/dev/null 2>&1 &

5. Haz clic en Archivo > Guardar.

Crea la plantilla de instancias

6. Haz clic en Abrir terminal en la barra de herramientas de Cloud Shell. Ingresa el siguiente comando para crear la plantilla de instancias primecalc:

gcloud compute instance-templates create primecalc \ --metadata-from-file startup-script=backend.sh \ --no-address --tags backend --machine-type=e2-medium

Este es el "plano" de las VMs de backend. Observa que tiene --no-address, lo que significa que estas VMs de backend no tendrán acceso público a Internet por motivos de seguridad.

Abre el firewall

Debes crear una regla de firewall para permitir que el tráfico en el puerto 80 (tráfico HTTP estándar) llegue a las VMs de backend. Esto es fundamental para que el balanceador de cargas de aplicaciones interno y las verificaciones de estado se comuniquen con ellos.

7. Abre el firewall en el puerto 80:

gcloud compute firewall-rules create http --network default --allow=tcp:80 \ --source-ranges {{{project_0.startup_script.selected_cidr | IP}}} --target-tags backend

Haz clic en Revisar mi progreso a continuación para verificar que estás avanzando en este lab.

Crear una plantilla de instancias y abrir el firewall en el puerto 80

Crea el grupo de instancias

8. A continuación, crea el grupo de instancias administrado llamado backend. Comienza con 3 instancias:

gcloud compute instance-groups managed create backend \ --size 3 \ --template primecalc \ --zone $ZONE

9. Cuando termine de ejecutarse, regresa a la pestaña de la consola. Navega a Compute Engine > Instancias de VM. Ahora deberías ver que tu grupo de instancias crea tres VMs de backend.

Los backends ya están listos para entregar tráfico.

Haz clic en Revisar mi progreso a continuación para verificar que estás avanzando en este lab.

Crear el grupo de instancias

Tarea 3. Configura el balanceador de cargas interno

Estás creando esa única entrada VIP privada para tu servicio interno que permite que otras aplicaciones internas accedan a tu "calculadora de números primos" de forma confiable, sin necesidad de saber qué VM de backend específica está activa o disponible. Ahora, configuremos el balanceador de cargas interno y conectémoslo al grupo de instancias que acabas de crear.

Un balanceador de cargas interno consta de tres partes principales:

• Regla de reenvío: Es la dirección IP privada real a la que otros servicios internos enviarán solicitudes. "Reenvía" el tráfico a tu servicio de backend.
• Servicio de backend: Define cómo el balanceador de cargas distribuye el tráfico a tus instancias de VM. También incluye la verificación de estado.
• Verificación de estado: Es una verificación continua que supervisa el "estado" de tus VMs de backend. El balanceador de cargas solo envía tráfico a las máquinas con verificaciones de estado aprobadas, lo que garantiza que tu servicio esté siempre disponible.

En el siguiente diagrama, se muestra cómo se balancean las cargas de las instancias con varias instancias en varios grupos de backend en diferentes zonas.

Crea una verificación de estado

1. Se necesita una verificación de estado para asegurarse de que el balanceador de cargas solo envíe tráfico a instancias en buen estado. Tu servicio de backend es un servidor HTTP, por lo que debes verificar si responde con un "200 OK" en una ruta de URL específica (en este caso, /2 para verificar si 2 es un número primo):

gcloud compute health-checks create http ilb-health --request-path /2

Dado que se proporciona el servicio HTTP, verifica si se propaga una respuesta 200 en una ruta de URL específica (en este caso, /2 para verificar si 2 es un número primo):

Crea un servicio de backend

2. Ahora, crea el servicio de backend llamado prime-service:

gcloud compute backend-services create prime-service \ --load-balancing-scheme internal --region=$REGION \ --protocol tcp --health-checks ilb-health

Este servicio vinculará la verificación de estado al grupo de instancias.

Agrega el grupo de instancias al servicio de backend

3. Conecta tu grupo de instancias de backend al servicio de backend de prime-service. Esto le indica al balanceador de cargas qué máquinas debe administrar:

gcloud compute backend-services add-backend prime-service \ --instance-group backend --instance-group-zone=$ZONE \ --region=$REGION

Crea la regla de reenvío

4. Por último, crea la regla de reenvío llamada prime-lb con una IP estática de :

gcloud compute forwarding-rules create prime-lb \ --load-balancing-scheme internal \ --ports 80 --network default \ --region=$REGION --address {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}} \ --backend-service prime-service

Tu servicio interno de "cálculo de números primos" ahora está completamente configurado y listo para recibir consultas a través de su dirección IP interna.

Haz clic en Revisar mi progreso a continuación para verificar que estás avanzando en este lab.

Configurar el balanceador de cargas interno

Tarea 4. Prueba el balanceador de cargas

Este paso es fundamental para confirmar que tu balanceador de cargas de aplicaciones interno dirija el tráfico correctamente a los servicios de backend. Esto demuestra que otras aplicaciones internas ahora pueden acceder de manera confiable a tu servicio a través de una sola dirección IP estable, lo que garantiza un funcionamiento continuo.

Para probar el balanceador de cargas, debes crear una instancia de VM nueva en la misma red que tu balanceador de cargas de aplicaciones interno. Solo se puede acceder a ella desde tu red de nube privada, no directamente desde Cloud Shell (que se encuentra fuera de esta red específica).

1. Con gcloud en Cloud Shell, crea una instancia de prueba simple:

gcloud compute instances create testinstance \ --machine-type=e2-standard-2 --zone $ZONE

2. Luego, establece una conexión SSH a ella:

gcloud compute ssh testinstance --zone $ZONE

Si se te solicita, escribe Y y presiona Intro dos veces para continuar.

Consulta el balanceador de cargas

3. Desde la instancia de prueba, usa curl para preguntarle a la dirección IP del balanceador de cargas de aplicaciones interno si algunos números son primos:

curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/2 curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/4 curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/5

El resultado mostrará True o False junto a la línea de comandos, de la siguiente manera:

user@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/2 Trueuser@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/4 Falseuser@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/5 Trueuser@testinstance:~$ exit

Deberías ver que el 2 y el 5 se identifican correctamente como números primos, pero el 4 no. Esto confirma que el balanceador de cargas de aplicaciones interno funciona. Recibió las solicitudes y las reenvió correctamente a una de tus VMs de "cálculo de números primos" de backend.

El servicio respondió correctamente: el 2 y el 5 son números primos, pero el 4 no lo es.

4. Sal de la instancia de prueba:

exit

5. Luego, bórrala, ya que no es necesaria:

gcloud compute instances delete testinstance --zone=$ZONE

6. Escribe Y para confirmar la eliminación.

Tarea 5. Crea un servidor web público

Ahora puedes ver cómo una aplicación pública (como un sitio web) puede aprovechar tus servicios internos. Crearás un servidor web orientado al público que usará el servicio interno de "calculadora de números primos" (a través del balanceador de cargas de aplicaciones interno) para mostrar una matriz de números primos.

1. Primero, crea la secuencia de comandos de inicio para este "frontend" público en el directorio principal:

touch ~/frontend.sh

2. Deberías seguir viendo el editor de código abierto. De lo contrario, selecciona Editor de código en la shell para iniciarlo:

Después de unos segundos, aparecerá el espacio de trabajo.

3. Ahora, agrega esta secuencia de comandos en el editor de la derecha:

sudo chmod -R 777 /usr/local/sbin/ sudo cat << EOF > /usr/local/sbin/getprimes.py import urllib.request from multiprocessing.dummy import Pool as ThreadPool import http.server PREFIX="http://{{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/" #HTTP Load Balancer def get_url(number): return urllib.request.urlopen(PREFIX+str(number)).read().decode('utf-8') class myHandler(http.server.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "text/html") s.end_headers() i = int(s.path[1:]) if (len(s.path)>1) else 1 s.wfile.write("<html><body><table>".encode('utf-8')) pool = ThreadPool(10) results = pool.map(get_url,range(i,i+100)) for x in range(0,100): if not (x % 10): s.wfile.write("<tr>".encode('utf-8')) if results[x]=="True": s.wfile.write("<td bgcolor='#00ff00'>".encode('utf-8')) else: s.wfile.write("<td bgcolor='#ff0000'>".encode('utf-8')) s.wfile.write(str(x+i).encode('utf-8')+"</td> ".encode('utf-8')) if not ((x+1) % 10): s.wfile.write("</tr>".encode('utf-8')) s.wfile.write("</table></body></html>".encode('utf-8')) http.server.HTTPServer(("",80),myHandler).serve_forever() EOF nohup python3 /usr/local/sbin/getprimes.py >/dev/null 2>&1 &

4. Haz clic en Archivo > Guardar.

Crea la instancia de frontend

5. En Cloud Shell, crea una instancia llamada frontend que ejecutará este servidor web:

gcloud compute instances create frontend --zone=$ZONE \ --metadata-from-file startup-script=frontend.sh \ --tags frontend --machine-type=e2-standard-2

Abre el firewall para el frontend

6. Este es un servidor público, por lo que debes abrir su firewall para permitir el tráfico desde cualquier lugar de Internet (0.0.0.0/0) en el puerto 80:

gcloud compute firewall-rules create http2 --network default --allow=tcp:80 \ --source-ranges 0.0.0.0/0 --target-tags frontend

7. En el menú de navegación, haz clic en Compute Engine > Instancias de VM. Actualiza el navegador si no ves la instancia de frontend.

8. Abre la IP externa del frontend en tu navegador:

Deberías ver una matriz como esta, que muestra todos los números primos hasta el 100 en verde:

9. Intenta agregar un número a la ruta, como http://tu-ip/10000, para ver todos los números primos a partir de ese número.

Nota: El ejemplo de secuencia de comandos de inicio no calcula números primos de manera eficaz. Tampoco tiene algoritmos de detección o corrección de errores. Si agregas números grandes a la ruta de acceso, el servicio agotará el tiempo de espera.

Haz clic en Revisar mi progreso a continuación para verificar que estás avanzando en este lab.

Crear un servidor web público

¡Felicitaciones!

Compilaste correctamente un servicio interno confiable con el balanceador de cargas de aplicaciones interno de Google Cloud y demostraste cómo una aplicación pública puede aprovecharlo de forma segura.

Próximos pasos y más información

• Obtén más información sobre los balanceadores de cargas de aplicaciones internos.
• Obtén más información sobre las subredes
• Publica preguntas y encuentra respuestas en Stackoverflow con las etiquetas google-compute-engine o google-cloud-platform.

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.

Fecha de la última actualización del manual: 18 de julio de 2025

Fecha de la prueba más reciente del lab: 18 de julio de 2025

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