Crear un servicio con balanceo de carga

En este tutorial se muestra cómo puedes crear, como productor de servicios, un servicio sencillo que utilice un balanceador de carga de red interno de transferencia. De forma predeterminada, un balanceador de carga de red de paso a través interno solo está disponible en la red de VPC que lo aloja.

Este tutorial está dirigido a arquitectos de nube, arquitectos de redes, administradores de redes y administradores de TI.

Objetivos

• Configurar la red de los recursos del productor de servicios
• Crear recursos de VM para el backend del balanceador de carga
• Configurar los componentes del balanceador de carga
• Probar el acceso al balanceador de carga

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

• Cloud Load Balancing
• Compute Engine

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos pueden disfrutar de una prueba sin coste económico. Google Cloud

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

1. Crea o selecciona un proyecto para los recursos del productor de servicios. En los tutoriales posteriores, se hará referencia a este proyecto como PRODUCER_PROJECT.

1. In the Google Cloud console, go to the project selector page.

   Go to project selector

2. Select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

2. Enable the Compute Engine API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

3. Make sure that you have the following role or roles on the project: Compute Engine > Compute Network Admin, Compute Engine > Compute Security Admin, Compute Engine > Compute Instance Admin

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Ir a IAM
   2. Selecciona el proyecto.
   3. Haz clic en Conceder acceso.

   4. En el campo Nuevos principales, introduce tu identificador de usuario. Normalmente, se trata de la dirección de correo de una cuenta de Google.

   5. Haz clic en Selecciona un rol y busca el rol.
   6. Para conceder más roles, haz clic en Añadir otro rol y añade cada rol adicional.
   7. Haz clic en Guardar.

Configurar redes

En las siguientes secciones se explica cómo crear una red, una subred y reglas de firewall para el servicio.

Configurar una red y una subred

Para crear la red de servicio y la subred del balanceador de carga, sigue los pasos que se indican en las siguientes secciones.

Consola

1. En la Google Cloud consola, ve a la página Redes de VPC.

   Ir a redes de VPC

2. Haz clic en Crear red VPC.

3. En Nombre, escribe service-network.

4. En Modo de creación de subred, selecciona Personalizado.

5. En la sección Nueva subred, introduce la siguiente información.

   1. En Nombre, escribe service-subnet.
   2. En Región, selecciona la región que quieras usar.
   3. En Tipo de pila de IP, selecciona IPv4 (pila única).
   4. En Intervalo de IPv4, introduce 10.10.10.0/24.
   5. Haz clic en Listo.

6. Haz clic en Crear.

gcloud

1. Crea una red de VPC en modo personalizado:

   gcloud compute networks create service-network --subnet-mode=custom
   

2. En la red service-network, crea una subred.

   gcloud compute networks subnets create service-subnet \
       --network=service-network \
       --range=10.10.10.0/24 \
       --region=REGION
   

   Sustituye REGION por la región que quieras usar.

Configurar reglas de cortafuegos

Crea reglas de cortafuegos para permitir el siguiente tráfico:

• fw-allow-subnet: permite que el tráfico de 10.10.10.0/24 llegue a otros recursos de 10.10.10.0/24.
• fw-allow-ssh: permite que el tráfico SSH de 0.0.0.0/0 llegue a las VMs que tengan la etiqueta de red allow-ssh.

• fw-allow-healthcheck: permite que el tráfico de los sistemas de comprobación de estado llegue a las VMs que tienen la etiqueta de red allow-healthcheck. Google Cloud

Consola

1. En la Google Cloud consola, ve a la página Políticas de cortafuegos.

   Ir a Políticas de cortafuegos

2. Para permitir el tráfico de subredes, haz clic en Crear regla de cortafuegos y usa los siguientes ajustes:

   • En Nombre, escribe fw-allow-subnet.
   • En Red, selecciona service-network.
   • En Prioridad, introduce 1000.
   • En Dirección del tráfico, selecciona Entrada.
   • En Acción tras coincidencia, selecciona Permitir.
   • En Destinos, selecciona Todas las instancias de la red.
   • En Filtro de origen, selecciona Intervalos de IPv4.
   • En Intervalos IPv4 de origen, introduce 10.10.10.0/24.
   • En Protocolos y puertos, selecciona Permitir todo.

3. Haz clic en Crear.

4. Para permitir las conexiones SSH entrantes, haz clic en Crear regla de cortafuegos y usa los siguientes ajustes:

   • En Nombre, escribe fw-allow-ssh.
   • En Red, selecciona service-network.
   • En Prioridad, introduce 1000.
   • En Dirección del tráfico, selecciona Entrada.
   • En Acción tras coincidencia, selecciona Permitir.
   • En Destinos, seleccione Etiquetas de destino especificadas.
   • En Etiquetas de destino, escriba allow-ssh.
   • En Filtro de origen, selecciona Intervalos de IPv4.
   • En Intervalos IPv4 de origen, introduce 0.0.0.0/0.
   • En Protocolos y puertos, selecciona Protocolos y puertos especificados y marca la casilla TCP. En Puertos, introduce 22.

5. Haz clic en Crear.

6. Para permitir las comprobaciones del estado, haz clic en Crear regla de cortafuegos y usa los siguientes ajustes: Google Cloud

   • En Nombre, escribe fw-allow-healthcheck.
   • En Red, selecciona service-network.
   • En Prioridad, introduce 1000.
   • En Dirección del tráfico, selecciona Entrada.
   • En Acción tras coincidencia, selecciona Permitir.
   • En Destinos, seleccione Etiquetas de destino especificadas.
   • En Etiquetas de destino, escriba allow-healthcheck.
   • En Filtro de origen, selecciona Intervalos de IPv4.
   • En Intervalos de IPv4 de origen, introduce 130.211.0.0/22 y 35.191.0.0/16.
   • En Protocolos y puertos, selecciona Permitir todo.

7. Haz clic en Crear.

gcloud

1. Crea la regla de cortafuegos fw-allow-subnet para permitir la comunicación desde dentro de la subred:

   gcloud compute firewall-rules create fw-allow-subnet \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.10.10.0/24 \
       --rules=tcp,udp,icmp
   

1. Crea la regla de cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs con la etiqueta de red allow-ssh.

   gcloud compute firewall-rules create fw-allow-ssh \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=0.0.0.0/0 \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

1. Crea la regla fw-allow-healthcheck para permitir Google Cloud las comprobaciones del estado.

   gcloud compute firewall-rules create fw-allow-healthcheck \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-healthcheck \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --rules=tcp,udp,icmp
   

Crear recursos de VM para el backend del balanceador de carga

Crea las VMs y el grupo de instancias que se van a usar con el balanceador de carga.

Crear VMs de backend

El servicio que vas a crear se ejecuta en dos máquinas virtuales para aumentar la disponibilidad: vm-1 y vm-2. Las VMs están en la misma zona, pero en un entorno de producción, recomendamos usar varias zonas.

Además de crear las VMs, al seguir estos pasos se consigue lo siguiente:

• Configura las VMs para que usen las etiquetas de red que has configurado como destinos en las reglas de cortafuegos y una etiqueta de red adicional (allow-nat) que se usará más adelante.

• Instala, configura e inicia el servicio Apache.

Consola

1. En la consola de Google Cloud , ve a la página Instancias de VM.

   Ir a instancias de VM

2. Haz clic en Crear instancia.

3. En Nombre, escribe vm-1.

4. En Región y Zona, selecciona una región y una zona de esa región.

5. En el menú de navegación, ve a SO y almacenamiento.

6. En el panel Sistema operativo y almacenamiento, asegúrate de que Debian GNU/Linux 12 (bookworm) esté seleccionado para el disco de arranque. Si necesitas seleccionar otra imagen, haz clic en Cambiar.

7. En el menú de navegación, vaya a Redes.

8. En el caso de las etiquetas de red, introduce allow-ssh, allow-healthcheck y allow-nat.

9. En Interfaces de red, selecciona lo siguiente:

   • En Red, selecciona service-network.
   • En Subred, selecciona service-subnet.
   • En Tipo de pila de IP, selecciona IPv4 (pila única).
   • En Dirección IPv4 interna principal, selecciona Efímera (automática).
   • En Dirección IPv4 externa, selecciona Efímera.

10. En el menú de navegación, ve a Avanzado.

11. En la sección Automatización, en el campo Secuencia de comandos de inicio, introduce la siguiente secuencia de comandos.

    
    #! /bin/bash
    if [ -f /etc/startup_script_completed ]; then
    exit 0
    fi
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    file_ports="/etc/apache2/ports.conf"
    file_http_site="/etc/apache2/sites-available/000-default.conf"
    file_https_site="/etc/apache2/sites-available/default-ssl.conf"
    http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
    http_vh_prts="*:80 *:8008 *:8080 *:8088"
    https_listen_prts="Listen 443\nListen 8443"
    https_vh_prts="*:443 *:8443"
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    prt_conf="$(cat "$file_ports")"
    prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
    prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
    echo "$prt_conf" | tee "$file_ports"
    http_site_conf="$(cat "$file_http_site")"
    http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
    echo "$http_site_conf_2" | tee "$file_http_site"
    https_site_conf="$(cat "$file_https_site")"
    https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
    echo "$https_site_conf_2" | tee "$file_https_site"
    systemctl restart apache2
    touch /etc/startup_script_completed
    

12. Haz clic en Crear.

13. Repite estos pasos para crear otra VM llamada vm-2 en la misma región y zona que vm-1.

gcloud

1. Crea dos VMs ejecutando los siguientes comandos:

   gcloud compute instances create vm-1 \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-healthcheck,allow-nat \
       --subnet=service-subnet \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   vm_hostname="$(curl -H "Metadata-Flavor:Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/name)"
   echo "Page served from: $vm_hostname" | \
   tee /var/www/html/index.html
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

   gcloud compute instances create vm-2 \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-healthcheck,allow-nati \
       --subnet=service-subnet \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   vm_hostname="$(curl -H "Metadata-Flavor:Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/name)"
   echo "Page served from: $vm_hostname" | \
   tee /var/www/html/index.html
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

   Sustituye ZONE por la zona que quieras usar.

Crear un grupo de instancias

Para usar las VMs en un backend de balanceador de carga, debes añadirlas a un grupo de instancias.

Consola

1. En la consola, ve a la página Grupos de instancias. Google Cloud

   Ir a Grupos de instancias

2. Haz clic en Crear grupo de instancias.

3. En el panel de navegación, haga clic en Nuevo grupo de instancias sin gestionar.

4. En Nombre, escribe ig-1.

5. En la sección Ubicación, selecciona la misma región y zona que tus VMs.

6. En Red, selecciona service-network.

7. En Subred, selecciona service-subnet.

8. En la sección Instancias de VM, añade vm-1 y vm-2 al grupo de instancias.

9. Haz clic en Crear.

gcloud

1. Crea un grupo de instancias sin gestionar:

   gcloud compute instance-groups unmanaged create ig-1 \
       --zone=ZONE
   

   Sustituye ZONE por la zona que contiene las VMs.

2. Añade las VMs al grupo de instancias:

   gcloud compute instance-groups unmanaged add-instances ig-1 \
       --zone=ZONE \
       --instances=vm-1,vm-2
   

Configurar componentes del balanceador de carga

Configura todos los componentes del balanceador de carga de red interno de pases, empezando por la comprobación del estado y el servicio de backend, y, a continuación, los componentes de frontend:

• Comprobación del estado. Utilizas una comprobación del estado de HTTP que comprueba el código de estado HTTP 200 OK.

• Servicio de backend. Como tienes que enviar tráfico HTTP a través del balanceador de carga interno, debes usar TCP, no UDP.

• Regla de reenvío. Crea una sola regla de reenvío interna, service-rule.

• Dirección IP interna. Cuando crea la regla de reenvío, especifica una dirección IP interna, 10.10.10.99.

Consola

Iniciar la configuración

1. En la Google Cloud consola, ve a la página Balanceo de carga.

   Ir a Balanceo de carga

2. Haga clic en Crear balanceador de carga.
3. En Tipo de balanceador de carga, selecciona Balanceador de carga de red (TCP/UDP/SSL) y haz clic en Siguiente.
4. En Proxy o pasarela, selecciona Balanceador de carga de pasarela y haz clic en Siguiente.
5. En Público o interno, selecciona Interno y haz clic en Siguiente.
6. Haz clic en Configurar.

Configuración básica

En la página Crear balanceador de carga de red de paso a través interno, introduce la siguiente información:

• En Nombre del balanceador de carga, introduce service-lb.
• En Región, selecciona la misma región que tus VMs.
• En Red, selecciona service-network.

Configurar los backends

1. Haz clic en Configuración de backend.
2. En la lista Comprobación del estado, haz clic en Crear comprobación del estado e introduce la siguiente información:
   • En Nombre:, introduce hc-http-80.
   • En Protocolo, selecciona HTTP.
   • En Puerto, introduce 80.
   • En Protocolo de proxy, selecciona NONE.
   • En Ruta de la solicitud, introduzca /.
3. Haz clic en Crear.
4. En la sección New Backend (Nuevo backend) de Backends (Backends), selecciona IPv4 (single-stack) (IPv4 [pila única]).
5. En Grupo de instancias, selecciona el grupo de instancias ig-1 y haz clic en Hecho.
6. Comprueba que haya una marca de verificación azul junto a Configuración de backend antes de continuar.

Configurar el frontend

1. Haz clic en Configuración de frontend.
2. En la sección IP de frontend y puerto nuevos, haga lo siguiente:
   1. En Nombre, escribe service-rule.
   2. En Subred, selecciona service-subnet.
   3. En la sección Propósito de la IP interna, en la lista Dirección IP, selecciona Crear dirección IP e introduce la siguiente información:
      • En Nombre, escribe service-rule-ip.
      • En Versión de IP, selecciona IPv4.
      • En Dirección IP estática, selecciona Quiero seleccionarlos yo.
      • En Dirección IP personalizada, introduce 10.10.10.99.
   4. Haz clic en Reservar.
   5. En Puertos, selecciona Único y, en Números de puerto, introduce 80.
   6. Haz clic en Listo.
   7. Comprueba que haya una marca de verificación azul junto a Configuración del frontend antes de continuar.

Revisar la configuración

1. Haz clic en Revisar y finalizar.
2. Revisa los ajustes de configuración de tu balanceador de carga.
3. Haz clic en Crear.

gcloud

1. Crea una comprobación del estado de HTTP regional para probar la conectividad HTTP a las VMs en el puerto 80.

   gcloud compute health-checks create http hc-http-80 \
       --region=REGION \
       --port=80
   

   Sustituye REGION por la misma región que las VMs de backend.

2. Crea el servicio de backend para el tráfico HTTP:

   gcloud compute backend-services create service-lb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=REGION \
       --health-checks=hc-http-80 \
       --health-checks-region=REGION
   

   Sustituye REGION por la misma región que las VMs de backend.

3. Añade el grupo de instancias al servicio de backend:

   gcloud compute backend-services add-backend service-lb \
       --region=REGION \
       --instance-group=ig-1 \
       --instance-group-zone=ZONE
   

   Haz los cambios siguientes:

   • REGION: la misma región que las VMs de backend.
   • ZONE: la misma zona que las VMs de backend.

4. Crea una regla de reenvío para el servicio de backend:

   gcloud compute forwarding-rules create service-rule \
       --region=REGION \
       --load-balancing-scheme=internal \
       --network=service-network \
       --subnet=service-subnet \
       --address=10.10.10.99 \
       --ip-protocol=TCP \
       --ports=80 \
       --backend-service=service-lb \
       --backend-service-region=REGION
   

   Sustituye REGION por la misma región que las VMs de backend.

Probar el acceso al balanceador de carga

Para comprobar que el balanceador de carga funciona, crea una VM de prueba y envíale una solicitud.

Crear una VM de cliente para hacer pruebas

Crea una VM de cliente en la misma región que las VMs de backend (servidor).

Consola

1. En la consola de Google Cloud , ve a la página Instancias de VM.

   Ir a instancias de VM

2. Haz clic en Crear instancia.

3. En Nombre, escribe producer-test.

4. En Región, selecciona la misma región que las VMs de backend.

5. En Zona, selecciona una zona de esa región.

6. Haga clic en Redes y configure los siguientes campos:

   1. En Etiquetas de red, introduce allow-ssh.
   2. En Interfaces de red, selecciona lo siguiente:
      • En Red, selecciona service-network.
      • En Subred, selecciona service-subnet.

7. Haz clic en Crear.

gcloud

gcloud compute instances create producer-test \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=service-subnet

Sustituye ZONE por una zona que esté en la misma región que las VMs de backend.

Probar la conectividad

Esta prueba se pone en contacto con el balanceador de carga desde una máquina virtual cliente. El comportamiento esperado es que el tráfico se distribuya entre las VMs backend del balanceador de carga.

1. Conéctate a la instancia de VM cliente.

   gcloud compute ssh producer-test --zone=ZONE
   

   Sustituye ZONE por la zona de la VM del cliente.
2. Envía una solicitud web al balanceador de carga mediante curl para ponerte en contacto con su dirección IP. Repite la solicitud para ver que las respuestas proceden de diferentes VMs backend. El nombre de la VM que genera la respuesta se muestra en el texto de la respuesta HTML debido al contenido de /var/www/html/index.html en cada VM backend. Por ejemplo, las respuestas esperadas son como Page served from: vm-1 y Page served from: vm-2.

   curl -s http://10.10.10.99
   

Siguientes pasos

• Hacer que el servicio sea accesible desde otras redes de VPC