Esta página se ha traducido con Cloud Translation API.

Configurar un balanceador de carga de red de paso a través interno con backends de grupos de instancias de VM para varios protocolos

En esta página se proporcionan instrucciones para crear balanceadores de carga de red de paso a través internos para balancear la carga del tráfico de varios protocolos.

Para configurar un balanceador de carga para varios protocolos, incluidos TCP y UDP, debes crear una regla de reenvío con el protocolo definido en L3_DEFAULT. Esta regla de reenvío apunta a un servicio de backend con el protocolo UNSPECIFIED.

En este ejemplo, usamos un balanceador de carga de red con paso a través interno para distribuir el tráfico entre una VM de backend en la región us-west1. El balanceador de carga tiene una regla de reenvío con el protocolo L3_DEFAULT para gestionar TCP, UDP, ICMP, ICMPv6, SCTP, ESP, AH y GRE.

Balancea la carga del tráfico IPv4 e IPv6 en función de los protocolos, con servicios de backend para gestionar la distribución de conexiones a un solo grupo de instancias zonal. — Balanceador de carga de red de paso a través interno para varios protocolos (haz clic en la imagen para ampliarla).

Antes de empezar

Instala Google Cloud CLI. Para obtener una descripción general completa de la herramienta, consulta la información general sobre la CLI de gcloud. Puedes encontrar comandos relacionados con el balanceo de carga en las referencias de la API y de gcloud CLI. Si no has ejecutado la CLI de gcloud anteriormente, ejecuta primero el comando gcloud init para autenticarte.
Consulta información sobre Bash.

Permisos

Para obtener los permisos que necesitas para completar esta guía, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el proyecto:

Para crear recursos de balanceador de carga, sigue estos pasos: Administrador de balanceadores de carga de Compute (roles/compute.loadBalancerAdmin)
Para crear instancias y grupos de instancias de Compute Engine, sigue estos pasos: Administrador de instancias de Compute (roles/compute.instanceAdmin.v1)
Para crear componentes de red, siga estos pasos: Administrador de red de Compute (roles/compute.networkAdmin)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Configurar un balanceador de carga para el tráfico L3_DEFAULT

En los pasos de esta sección se describen las siguientes configuraciones:

Un ejemplo que usa una red de VPC en modo personalizado llamada lb-network. Puedes usar una red en modo automático si solo quieres gestionar el tráfico IPv4. Sin embargo, el tráfico IPv6 requiere una subred en modo personalizado.
Una subred de pila única (stack-type configurado como IPv4), que es necesaria para el tráfico IPv4. Cuando creas una subred de pila única en una red de VPC en modo personalizado, eliges un intervalo de subred IPv4 para la subred. En el caso del tráfico IPv6, necesitamos una subred de pila dual (stack-type definido como IPV4_IPV6). Cuando creas una subred de pila dual en una red de VPC en modo personalizado, eliges un tipo de acceso IPv6 para la subred. En este ejemplo, hemos definido el parámetro ipv6-access-type de la subred en INTERNAL. Esto significa que a las nuevas VMs de esta subred se les pueden asignar tanto direcciones IPv4 internas como direcciones IPv6 internas.
Reglas de cortafuegos que permiten las conexiones entrantes a las VMs de backend.
El grupo de instancias de backend y los componentes del balanceador de carga que se usan en este ejemplo se encuentran en esta región y subred:
- Región: us-west1
- Subred: lb-subnet, con el intervalo de direcciones IPv4 principal 10.1.2.0/24. Aunque elijas el intervalo de direcciones IPv4 que se configura en la subred, el intervalo de direcciones IPv6 se asigna automáticamente. Google proporciona un bloque CIDR IPv6 de tamaño fijo (/64).
Una VM de backend de un grupo de instancias gestionado en la zona us-west1-a.
Una VM cliente para probar las conexiones con los back-ends.
Un balanceador de carga de red de paso a través interno con los siguientes componentes:
- Una comprobación del estado del servicio backend.
- Un servicio de backend en la región us-west1 con el protocolo configurado como UNSPECIFIED para gestionar la distribución de conexiones al grupo de instancias de zona.
- Una regla de reenvío con el protocolo L3_DEFAULT y el puerto ALL.

Configurar una red, una región y una subred

Para configurar subredes con intervalos IPv6 internos, habilita un intervalo IPv6 interno ULA de una red de nube privada virtual (VPC). Los intervalos de subredes IPv6 internas se asignan a partir de este intervalo. Para crear la red y la subred de ejemplo, sigue estos pasos:

Consola

Para admitir el tráfico IPv4 e IPv6, sigue estos pasos:

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

Ir a redes de VPC
Haz clic en Crear red VPC.
En Nombre, escribe lb-network.
Si quieres configurar intervalos de direcciones IPv6 internas en subredes de esta red, sigue estos pasos:
1. En Intervalo IPv6 interno ULA de la red VPC, selecciona Habilitado.
2. En Asignar intervalo de IPv6 interno, selecciona Automáticamente o Manualmente.
  Consejo profesional:Si seleccionas Manualmente, introduce un intervalo /48 dentro del intervalo fd20::/20. Si el intervalo está en uso, se te pedirá que proporciones otro.
En Modo de creación de subred, selecciona Personalizado.
En la sección Nueva subred, especifica los siguientes parámetros de configuración de una subred:
1. En Nombre, escribe lb-subnet.
2. En Región, selecciona us-west1.
3. Para crear una subred de doble pila, en Tipo de pila de IP, selecciona IPv4 e IPv6 (doble pila).
4. En Intervalo de IPv4, introduce 10.1.2.0/24.
5. En Tipo de acceso IPv6, selecciona Interno.
Haz clic en Listo.
Haz clic en Crear.

Para admitir el tráfico IPv4, sigue estos pasos:

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

Ir a redes de VPC
Haz clic en Crear red VPC.
En Nombre, escribe lb-network.
En la sección Subredes:
- Elige Personalizado en Modo de creación de subred.
- En la sección Nueva subred, introduce la siguiente información:
  - Nombre: lb-subnet
  - Región: us-west1
  - Tipo de pila de IP: IPv4 (pila única)
  - Intervalo de direcciones IP: 10.1.2.0/24
- Haz clic en Listo.
Haz clic en Crear.

gcloud

Para el tráfico IPv4 e IPv6, usa los siguientes comandos:

Para crear una red VPC de modo personalizado, ejecuta el comando gcloud compute networks create.

Para configurar intervalos IPv6 internos en cualquier subred de esta red, usa la marca --enable-ula-internal-ipv6. Esta opción asigna un prefijo ULA /48 del intervalo fd20::/20 que usa Google Cloud para los intervalos de subredes IPv6 internas.
```
gcloud compute networks create lb-network \
 --subnet-mode=custom \
 --enable-ula-internal-ipv6
```

En lb-network, crea una subred para las back-ends en la región us-west1.

Para crear las subredes, ejecuta el gcloud compute networks subnets createcomando:

gcloud compute networks subnets create lb-subnet \
 --network=lb-network \
 --range=10.1.2.0/24 \
 --region=us-west1 \
 --stack-type=IPV4_IPV6 --ipv6-access-type=INTERNAL

Para solo tráfico IPv4, usa los siguientes comandos:

Para crear la red de VPC personalizada, usa el comando gcloud compute networks create:
```
gcloud compute networks create lb-network --subnet-mode=custom
```
Para crear la subred de las backends en la región us-west1 de la red lb-network, usa el comando gcloud compute networks subnets create.
```
gcloud compute networks subnets create lb-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1
```

API

Para el tráfico IPv4 e IPv6, usa los siguientes comandos:

Crea una red VPC en modo personalizado. Realiza una solicitud POST al método networks.insert.

Para configurar intervalos IPv6 internos en cualquier subred de esta red, asigna el valor enableUlaInternalIpv6 a true. Esta opción asigna un intervalo /48 del intervalo fd20::/20 que usa Google para los intervalos de subredes IPv6 internas.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
  "autoCreateSubnetworks": false,
  "name": "lb-network",
  "mtu": MTU,
  "enableUlaInternalIpv6": true,
}
```
Haz los cambios siguientes:
- PROJECT_ID: el ID del proyecto en el que se crea la red VPC.
- MTU: unidad máxima de transmisión de la red. El MTU puede ser 1460 (valor predeterminado) o 1500. Consulta la información general sobre la unidad máxima de transmisión antes de definir la MTU en 1500.

Realiza una solicitud POST al método subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
{
"ipCidrRange": "10.1.2.0/24",
"network": "lb-network",
"name": "lb-subnet"
"stackType": IPV4_IPV6,
"ipv6AccessType": Internal
}

Para solo el tráfico IPv4, sigue estos pasos:

Realiza una solicitud POST al método networks.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
"name": "lb-network",
"autoCreateSubnetworks": false
}

Haz dos solicitudes POST al método subnetworks.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
"name": "lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"ipCidrRange": "10.1.2.0/24",
"privateIpGoogleAccess": false
}

Configurar reglas de cortafuegos

En este ejemplo se usan las siguientes reglas de cortafuegos:

fw-allow-lb-access: regla de entrada aplicable a todos los destinos de la red VPC que permite el tráfico procedente de orígenes de los intervalos 10.1.2.0/24. Esta regla permite el tráfico entrante de cualquier cliente ubicado en la subred.
fw-allow-lb-access-ipv6: una regla de entrada aplicable a todos los destinos de la red VPC que permite el tráfico de fuentes del intervalo IPv6 configurado en la subred. Esta regla permite el tráfico IPv6 entrante de cualquier cliente ubicado en la subred.
fw-allow-ssh: una regla de entrada aplicable a las instancias que se van a balancear, que permite la conectividad SSH entrante en el puerto TCP 22 desde cualquier dirección. Puede elegir un intervalo de IPs de origen más restrictivo para esta regla. Por ejemplo, puede especificar solo los intervalos de IPs del sistema desde el que inicia sesiones SSH. En este ejemplo se usa la etiqueta de destino allow-ssh para identificar las VMs a las que se debe aplicar.
fw-allow-health-check: una regla de entrada, aplicable a las instancias con balanceo de carga, que permite el tráfico de los sistemas de comprobación del estado ( Google Cloud , 130.211.0.0/22 y 35.191.0.0/16). En este ejemplo, se usa la etiqueta de destino allow-health-check para identificar las instancias a las que se debe aplicar.
fw-allow-health-check-ipv6: una regla de entrada, aplicable a las instancias que se están balanceando, que permite el tráfico de los sistemas de comprobación del estado (2600:2d00:1:b029::/64). En este ejemplo, se usa la etiqueta de destino allow-health-check-ipv6 para identificar las instancias a las que se debe aplicar. Google Cloud

Sin estas reglas de cortafuegos, la regla denegar predeterminada de entrada bloquea el tráfico entrante a las instancias de backend.

Consola

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

Ir a Políticas de cortafuegos
Para permitir que el tráfico IPv4 TCP, UDP e ICMP llegue al grupo de instancias de backend ig-a, haz lo siguiente:
- Haz clic en Crear regla de cortafuegos.
- Nombre: fw-allow-lb-access
- Red: lb-network
- Prioridad: 1000
- Dirección del tráfico: entrada
- Acción tras coincidencia: permitir
- Destinos: todas las instancias de la red
- Filtro de origen: intervalos de IPv4
- Intervalos de IPv4 de origen: 10.1.2.0/24
- Protocolos y puertos: selecciona Protocolos y puertos especificados.
  - Selecciona TCP e introduce ALL.
  - Selecciona UDP.
  - Selecciona Otro e introduce ICMP.
Haz clic en Crear.
Para permitir las conexiones SSH entrantes, sigue estos pasos:
- Haz clic en Crear regla de cortafuegos.
- Nombre: fw-allow-ssh
- Red: lb-network
- Prioridad: 1000
- Dirección del tráfico: entrada
- Acción tras coincidencia: permitir
- Destinos: etiquetas de destino especificadas
- Etiquetas de destino: allow-ssh
- Filtro de origen: intervalos de IPv4
- Intervalos de IPv4 de origen: 0.0.0.0/0
- Protocolos y puertos: elige Protocolos y puertos especificados y, a continuación, escribe tcp:22.
Haz clic en Crear.
Para permitir que el tráfico IPv6 TCP, UDP e ICMP llegue al grupo de instancias de backend ig-a:
- Haz clic en Crear regla de cortafuegos.
- Nombre: fw-allow-lb-access-ipv6
- Red: lb-network
- Prioridad: 1000
- Dirección del tráfico: entrada
- Acción tras coincidencia: permitir
- Destinos: todas las instancias de la red
- Filtro de origen: Intervalos de IPv6
- Intervalos de IPv6 de origen: IPV6_ADDRESS asignados en el lb-subnet
- Protocolos y puertos: selecciona Protocolos y puertos especificados.
  - Selecciona TCP e introduce 0-65535.
  - Selecciona UDP.
  - Selecciona Otro y, en el protocolo ICMPv6, introduce 58.
Haz clic en Crear.
Para permitir las comprobaciones de estado de IPv6, sigue estos pasos: Google Cloud
- Haz clic en Crear regla de cortafuegos.
- Nombre: fw-allow-health-check-ipv6
- Red: lb-network
- Prioridad: 1000
- Dirección del tráfico: entrada
- Acción tras coincidencia: permitir
- Destinos: etiquetas de destino especificadas
- Etiquetas de destino: allow-health-check-ipv6
- Filtro de origen: Intervalos de IPv6
- Intervalos de IPv6 de origen: 2600:2d00:1:b029::/64
- Protocolos y puertos: permitir todos
Haz clic en Crear.
Para permitir las comprobaciones de estado de IPv4, sigue estos pasos: Google Cloud
- Haz clic en Crear regla de cortafuegos.
- Nombre: fw-allow-health-check
- Red: lb-network
- Prioridad: 1000
- Dirección del tráfico: entrada
- Acción tras coincidencia: permitir
- Destinos: etiquetas de destino especificadas
- Etiquetas de destino: allow-health-check
- Filtro de origen: intervalos de IPv4
- Intervalos de IPv4 de origen: 130.211.0.0/22 y 35.191.0.0/16
- Protocolos y puertos: permitir todos
Haz clic en Crear.

gcloud

Para permitir que el tráfico TCP IPv4 llegue al grupo de instancias de backend ig-a, crea la siguiente regla:

gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24 \
    --rules=tcp,udp,icmp

Crea la regla de cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs mediante la etiqueta de red allow-ssh. Si omite source-ranges, Google Cloud interpreta que la regla se aplica a cualquier fuente.
```
gcloud compute firewall-rules create fw-allow-ssh \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22
```

Para permitir que el tráfico IPv6 llegue al grupo de instancias de backend ig-a, crea la siguiente regla:

gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=IPV6_ADDRESS \
    --rules=all

Sustituye IPV6_ADDRESS por la dirección IPv6 asignada en el lb-subnet.

Crea la regla de cortafuegos fw-allow-health-check para permitir las comprobaciones del estado Google Cloud.

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

Crea la regla fw-allow-health-check-ipv6 para permitir Google Cloud comprobaciones del estado de IPv6.

gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --target-tags=allow-health-check-ipv6 \
   --source-ranges=2600:2d00:1:b029::/64 \
   --rules=tcp,udp,icmp

API

Para crear la regla de cortafuegos fw-allow-lb-access, envía una solicitud POST al método firewalls.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-lb-access",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "10.1.2.0/24"
],
"allPorts": true,
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

Crea la regla de cortafuegos fw-allow-lb-access-ipv6 haciendo una solicitud POST al método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
 "name": "fw-allow-lb-access-ipv6",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allPorts": true,
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "58"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

Sustituye IPV6_ADDRESS por la dirección IPv6 asignada en el lb-subnet.

Para crear la regla de cortafuegos fw-allow-ssh, haz una solicitud POST al método firewalls.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-ssh",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "0.0.0.0/0"
],
"targetTags": [
  "allow-ssh"
],
"allowed": [
 {
   "IPProtocol": "tcp",
   "ports": [
     "22"
   ]
 }
],
"direction": "INGRESS",
"logConfig": {
 "enable": false
},
"disabled": false
}

Para crear la regla de cortafuegos fw-allow-health-check, haz una solicitud POST al método firewalls.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-health-check",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "130.211.0.0/22",
  "35.191.0.0/16"
],
"targetTags": [
  "allow-health-check"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  },
  {
    "IPProtocol": "icmp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

Crea la regla de cortafuegos fw-allow-health-check-ipv6 haciendo una solicitud POST al método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-health-check-ipv6",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"priority": 1000,
"sourceRanges": [
  "2600:2d00:1:b029::/64"
],
"targetTags": [
  "allow-health-check-ipv6"
],
"allowed": [
  {
    "IPProtocol": "tcp"
  },
  {
    "IPProtocol": "udp"
  }
],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

Crear VMs de backend y grupos de instancias

En este caso de balanceo de carga, creará un grupo de instancias gestionado zonal de Compute Engine e instalará un servidor web Apache.

Para gestionar el tráfico IPv4 e IPv6, configura las VMs de backend para que sean de doble pila. Define el valor stack-type de la VM como IPV4_IPV6. Las VMs también heredan el ajuste ipv6-access-type (en este ejemplo, INTERNAL) de la subred. Para obtener más información sobre los requisitos de IPv6, consulta el artículo Descripción general del balanceador de carga de red interno de tipo pasarela: reglas de reenvío.

Si quieres usar máquinas virtuales como back-ends, actualízalas para que sean de doble pila con el comando gcloud compute instances network-interfaces update.

Las instancias que participan como VMs de backend de balanceadores de carga de red de paso a través internos deben ejecutar el entorno de invitado de Linux, el entorno de invitado de Windows u otros procesos que proporcionen una funcionalidad equivalente.

Para simplificar las instrucciones, las VMs de backend ejecutan Debian GNU/Linux 12.

Crea el grupo de instancias

Consola

Para admitir el tráfico IPv4 e IPv6, sigue estos pasos:

Crea una plantilla de instancia. En la consola, ve a la página Plantillas de instancia. Google Cloud

Ir a Plantillas de instancia
1. Haz clic en Crear plantilla de instancia.
2. En Nombre, escribe vm-a1.
3. Asegúrate de que el disco de arranque esté configurado con una imagen de Debian, como Debian GNU/Linux 12 (bookworm). En estas instrucciones se usan comandos que solo están disponibles en Debian, como apt-get.
4. Expande la sección Opciones avanzadas.
5. Despliega la sección Gestión y, a continuación, copia la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar del puerto 80.
```
#! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
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
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2
```
6. Despliega la sección Redes y, a continuación, especifica lo siguiente:
  1. En Etiquetas de red, añade allow-ssh y allow-health-check-ipv6.
  2. En Interfaces de red, haz clic en la interfaz predeterminada y configura los siguientes campos:
    - Red: lb-network
    - Subred: lb-subnet
    - Tipo de pila de IP: IPv4 e IPv6 (pila dual)
7. Haz clic en Crear.

Para admitir el tráfico IPv4, sigue estos pasos:

Crea una plantilla de instancia. En la consola, ve a la página Plantillas de instancia. Google Cloud

Ir a Plantillas de instancia
Haz clic en Crear plantilla de instancia.
1. En Nombre, escribe vm-a1.
2. Asegúrate de que el disco de arranque esté configurado con una imagen de Debian, como Debian GNU/Linux 12 (bookworm). En estas instrucciones se usan comandos que solo están disponibles en Debian, como apt-get.
3. Expande la sección Opciones avanzadas.
4. Despliega la sección Gestión y, a continuación, copia la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio. La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar del puerto 80.
```
#! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
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
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2
```
5. Despliega la sección Redes y, a continuación, especifica lo siguiente:
  1. En Etiquetas de red, añade allow-ssh y allow-health-check.
  2. En Interfaces de red, haz clic en la interfaz predeterminada y configura los siguientes campos:
    - Red: lb-network
    - Subred: lb-subnet
    - Tipo de pila de IP: IPv4 (pila única)
6. Haz clic en Crear.
Crea un grupo de instancias gestionado. Ve a la página Grupos de instancias de la consola de Google Cloud Google Cloud.

Ir a Grupos de instancias
1. Haz clic en Crear grupo de instancias.
2. Elige Nuevo grupo de instancias gestionado (sin reconocimiento del estado). Para obtener más información, consulta Grupos de instancias gestionados con o sin reconocimiento del estado.
3. En Nombre, escribe ig-a.
4. En Ubicación, selecciona Una sola zona.
5. En Región, seleccione us-west1.
6. En Zona, selecciona us-west1-a.
7. En Plantilla de instancia, selecciona vm-a1.
8. Especifica el número de instancias que quieres crear en el grupo.
  
  En este ejemplo, especifica las siguientes opciones en Escalado automático:
  - En Modo de autoescalado, selecciona Off:do not autoscale.
  - En Número máximo de instancias, introduce 2.
9. Haz clic en Crear.

gcloud

En las gcloud instrucciones de esta guía se presupone que usas Cloud Shell u otro entorno con bash instalado.

Crea una plantilla de instancia de VM con un servidor HTTP con el comando gcloud compute instance-templates create.

La secuencia de comandos de inicio también configura el servidor Apache para que escuche en el puerto 8080 en lugar del puerto 80.

Para gestionar el tráfico IPv4 e IPv6, usa el siguiente comando.

gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --ipv6-network-tier=PREMIUM \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      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
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

Si solo quieres gestionar el tráfico IPv4, usa el siguiente comando:

gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --tags=allow-ssh \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      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
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

Crea un grupo de instancias gestionado en la zona con el comando gcloud compute instance-groups managed create.

gcloud compute instance-groups managed create ig-a \
    --zone us-west1-a \
    --size 2 \
    --template vm-a1

api

Para gestionar el tráfico IPv4 e IPv6, sigue estos pasos:

Crea una VM haciendo solicitudes POST al método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"tags": {
 "items": [
   "allow-health-check-ipv6",
   "allow-ssh"
 ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
 {
   "stackType": "IPV4_IPV6",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "accessConfigs": [
     {
       "type": "ONE_TO_ONE_NAT",
       "name": "external-nat",
       "networkTier": "PREMIUM"
     }
   ]
 }
],
"disks": [
 {
   "type": "PERSISTENT",
   "boot": true,
   "mode": "READ_WRITE",
   "autoDelete": true,
   "deviceName": "vm-a1",
   "initializeParams": {
     "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
     "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
     "diskSizeGb": "10"
   }
 }
],
"metadata": {
 "items": [
   {
     "key": "startup-script",
     "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

Para gestionar el tráfico IPv4, sigue estos pasos.

Crea una VM haciendo solicitudes POST al método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"tags": {
 "items": [
   "allow-health-check",
   "allow-ssh"
 ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
 {
   "stackType": "IPV4",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "accessConfigs": [
     {
       "type": "ONE_TO_ONE_NAT",
       "name": "external-nat",
       "networkTier": "PREMIUM"
     }
   ]
 }
],
"disks": [
 {
   "type": "PERSISTENT",
   "boot": true,
   "mode": "READ_WRITE",
   "autoDelete": true,
   "deviceName": "vm-a1",
   "initializeParams": {
     "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
     "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
     "diskSizeGb": "10"
   }
 }
],
"metadata": {
 "items": [
   {
     "key": "startup-script",
     "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

Crea un grupo de instancias haciendo una solicitud POST al método instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
"name": "ig-a",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Añade instancias a cada grupo de instancias haciendo una solicitud POST al método instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
"instances": [
{
 "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1"
}
]
}

Crear una VM cliente

En este ejemplo se crea una VM de cliente en la misma región que las VMs de backend (servidor). El cliente se usa para validar la configuración del balanceador de carga y demostrar el comportamiento esperado, tal como se describe en la sección Pruebas.

Para el tráfico IPv4 e IPv6:

Consola

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

Ir a instancias de VM
Haz clic en Crear instancia.
Asigna el valor vm-client-ipv6 a Nombre.
En Zona, elija us-west1-a.
Despliega la sección Opciones avanzadas y haz los siguientes cambios:
- Despliega Redes y añade el allow-ssh a Etiquetas de red.
- En Interfaces de red, haz clic en Editar, haz los siguientes cambios y, a continuación, haz clic en Hecho:
  - Red: lb-network
  - Subred: lb-subnet
  - Tipo de pila de IP: IPv4 e IPv6 (pila dual)
  - IP interna principal: efímera (automática)
  - IP externa: efímera
Haz clic en Crear.

gcloud

La VM cliente puede estar en cualquier zona de la misma región que el balanceador de carga y puede usar cualquier subred de esa región. En este ejemplo, el cliente está en la zona us-west1-a y usa la misma subred que las VMs de backend.

gcloud compute instances create vm-client-ipv6 \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Realiza una solicitud POST al método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client-ipv6",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Para el tráfico IPv4:

Consola

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

Ir a instancias de VM
Haz clic en Crear instancia.
En Nombre, escribe vm-client.
En Zona, escribe us-west1-a.
Expande la sección Opciones avanzadas.
Despliega Redes y, a continuación, configura los siguientes campos:
1. En Etiquetas de red, introduzca allow-ssh.
2. En Interfaces de red, selecciona lo siguiente:
  - Red: lb-network
  - Subred: lb-subnet
Haz clic en Crear.

gcloud

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

Haz una solicitud POST al método instances.insert. Sustituye PROJECT_ID por el ID de tu Google Cloud proyecto.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances
 {
    "name": "vm-client",
    "tags": {
      "items": [
        "allow-ssh"
      ]
  },
    "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
    "canIpForward": false,
    "networkInterfaces": [
      {
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
        "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
        "accessConfigs": [
          {
            "type": "ONE_TO_ONE_NAT",
            "name": "external-nat",
            "networkTier": "PREMIUM"
          }
        ]
      }
    ],
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "autoDelete": true,
        "deviceName": "vm-client",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
          "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
          "diskSizeGb": "10"
        }
      }
    ],
    "scheduling": {
      "preemptible": false
     },
    "deletionProtection": false
  }

Configurar componentes del balanceador de carga

Crea un balanceador de carga para varios protocolos.

gcloud

Crea una comprobación del estado de HTTP para el puerto 80. Esta comprobación del estado se usa para verificar el estado de los backends del grupo de instancias ig-a.
```
gcloud compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80
```

Crea el servicio de backend con el protocolo definido como UNSPECIFIED:

gcloud compute backend-services create be-ilb-l3-default \
    --load-balancing-scheme=internal \
    --protocol=UNSPECIFIED \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

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

gcloud compute backend-services add-backend be-ilb-l3-default \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

Para el tráfico IPv6: crea una regla de reenvío con el protocolo definido en L3_DEFAULT para gestionar todo el tráfico de protocolo IPv6 admitido. Todos los puertos deben configurarse con L3_DEFAULT reglas de reenvío.

gcloud compute forwarding-rules create fr-ilb-ipv6 \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --subnet=lb-subnet \
   --ip-protocol=L3_DEFAULT \
   --ports=ALL \
   --backend-service=be-ilb-l3-default \
   --backend-service-region=us-west1 \
   --ip-version=IPV6

Para el tráfico IPv4: crea una regla de reenvío con el protocolo definido en L3_DEFAULT para gestionar todo el tráfico del protocolo IPv4 admitido. Todos los puertos deben configurarse con L3_DEFAULT reglas de reenvío. Usa 10.1.2.99 como dirección IP interna.

gcloud compute forwarding-rules create fr-ilb-l3-default \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --network=lb-network \
   --subnet=lb-subnet \
   --address=10.1.2.99 \
   --ip-protocol=L3_DEFAULT \
   --ports=ALL \
   --backend-service=be-ilb-l3-default \
   --backend-service-region=us-west1

API

Crea la comprobación del estado haciendo una solicitud POST al método regionHealthChecks.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
 "port": 80
}
}

Crea el servicio backend regional haciendo una solicitud POST al método regionBackendServices.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb-l3-default",
"backends": [
 {
   "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
   "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "UNSPECIFIED",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

Para el tráfico IPv6: crea la regla de reenvío haciendo una solicitud POST al método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-ipv6",
"IPProtocol": "L3_DEFAULT",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

Para el tráfico IPv4: crea la regla de reenvío haciendo una solicitud POST al método forwardingRules.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-l3-default",
"IPAddress": "10.1.2.99",
"IPProtocol": "L3_DEFAULT",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"networkTier": "PREMIUM"
}

Probar el balanceador de carga

Las siguientes pruebas muestran cómo validar la configuración de tu balanceador de carga y conocer su comportamiento esperado.

Probar la conexión desde la VM cliente

Esta prueba se pone en contacto con el balanceador de carga desde una VM de cliente independiente, es decir, no desde una VM de backend del balanceador de carga.

gcloud:IPv6

Conéctate a la instancia de VM cliente.

gcloud compute ssh vm-client-ipv6 --zone=us-west1-a

Describe la regla de reenvío de IPv6 fr-ilb-ipv6. Fíjate en el IPV6_ADDRESS de la descripción.
```
gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1
```
En los clientes con conectividad IPv6, ejecuta el siguiente comando. Sustituye IPV6_ADDRESS por la dirección IPv6 efímera de la regla de reenvío fr-ilb-ipv6.
```
curl -m 10 -s http://IPV6_ADDRESS:80
```
Por ejemplo, si la dirección IPv6 asignada es [fd20:1db0:b882:802:0:46:0:0/96]:80, el comando debería tener este aspecto:
```
curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80
```

gcloud:IPv4

Conéctate a la instancia de VM cliente.

gcloud compute ssh vm-client --zone=us-west1-a

Describe la regla de reenvío de IPv4 fr-ilb.

gcloud compute forwarding-rules describe fr-ilb --region=us-west1

Haz una solicitud web al balanceador de carga usando 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 máquina virtual que genera la respuesta se muestra en el texto de la respuesta HTML en función del contenido de /var/www/html/index.html en cada máquina virtual backend. Las respuestas esperadas tienen este aspecto: Page served from: vm-a1.
```
curl http://10.1.2.99
```
La regla de reenvío está configurada para servir los puertos 80 y 53. Para enviar tráfico a esos puertos, añade dos puntos (:) y el número de puerto después de la dirección IP, de esta forma:
```
curl http://10.1.2.99:80
```

Hacer ping a la dirección IP del balanceador de carga

Esta prueba muestra un comportamiento esperado: puedes hacer ping a la dirección IP del balanceador de carga.

gcloud:IPv6

Conéctate a la instancia de VM cliente.

gcloud compute ssh vm-client-ipv6 --zone=us-west1-a

Intenta hacer ping a la dirección IPv6 del balanceador de carga. Sustituye IPV6_ADDRESS por la dirección IPv6 efímera de la regla de reenvío fr-ilb-ipv6.

Observa que obtienes una respuesta y que el comando ping funciona en este ejemplo.
```
ping6 IPV6_ADDRESS
```
Por ejemplo, si la dirección IPv6 asignada es [2001:db8:1:1:1:1:1:1/96], el comando es el siguiente:
```
ping6 2001:db8:1:1:1:1:1:1
```
El resultado debería ser similar al siguiente:
```
@vm-client: ping IPV6_ADDRESS
PING IPV6_ADDRESS (IPV6_ADDRESS) 56(84) bytes of data.
64 bytes from IPV6_ADDRESS: icmp_seq=1 ttl=64 time=1.58 ms
```

gcloud:IPv4

Conéctate a la instancia de VM cliente.

gcloud compute ssh vm-client --zone=us-west1-a

Intenta hacer ping a la dirección IPv4 del balanceador de carga. Observa que obtienes una respuesta y que el comando ping funciona en este ejemplo.

ping 10.1.2.99

El resultado es el siguiente:

@vm-client: ping 10.1.2.99
PING 10.1.2.99 (10.1.2.99) 56(84) bytes of data.
64 bytes from 10.1.2.99: icmp_seq=1 ttl=64 time=1.58 ms
64 bytes from 10.1.2.99: icmp_seq=2 ttl=64 time=0.242 ms
64 bytes from 10.1.2.99: icmp_seq=3 ttl=64 time=0.295 ms

Opciones de configuración adicionales

En esta sección se amplía el ejemplo de configuración para ofrecer opciones de configuración alternativas y adicionales. Todas las tareas son opcionales. Puedes llevarlas a cabo en el orden que quieras.

Puedes reservar una dirección IP interna estática para tu ejemplo. Esta configuración permite que varias reglas de reenvío internas usen la misma dirección IP con diferentes protocolos y puertos. Los backends del balanceador de carga de ejemplo deben seguir estando en la región us-west1.

En el siguiente diagrama se muestra la arquitectura de este ejemplo.

Balancea la carga del tráfico en función de los protocolos, con servicios de backend para gestionar la distribución de conexiones a un solo grupo de instancias zonales. — Un balanceador de carga de red de paso a través interno para varios protocolos que usa una dirección IP interna estática (haz clic para ampliar).

También puedes usar las siguientes configuraciones de reglas de reenvío:

Reglas de reenvío con varios puertos:
- Protocolo TCP con puertos 80,8080
- Protocolo L3_DEFAULT con puertos ALL
Reglas de reenvío con todos los puertos:
- Protocolo TCP con puertos ALL
- Protocolo L3_DEFAULT con puertos ALL

Reservar una dirección IPv4 interna estática

Reserva una dirección IP interna estática para 10.1.2.99 y define su marca --purpose como SHARED_LOADBALANCER_VIP. La marca --purpose es obligatoria para que muchas reglas de reenvío puedan usar la misma dirección IP interna.

gcloud

Usa el comando gcloud compute addresses create:

gcloud compute addresses create internal-lb-ipv4 \
    --region us-west1 \
    --subnet lb-subnet \
    --purpose SHARED_LOADBALANCER_VIP \
    --addresses 10.1.2.99

API

Llama al método addresses.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

El cuerpo de la solicitud debe incluir el addressType, que debe ser INTERNAL, el name de la dirección y el subnetwork al que pertenece la dirección IP. Debes especificar address como 10.1.2.99.

{
  "addressType": "INTERNAL",
  "name": "internal-lb-ipv4",
  "subnetwork": "regions/us-west1/subnetworks/lb-subnet",
  "purpose": "SHARED_LOADBALANCER_VIP",
  "address": "10.1.2.99"
}

Configurar componentes del balanceador de carga

Configura tres balanceadores de carga con los siguientes componentes:

El primer balanceador de carga tiene una regla de reenvío con el protocolo TCP y el puerto 80. El tráfico TCP que llega a la dirección IP interna en el puerto 80 se gestiona mediante la regla de reenvío TCP.
El segundo balanceador de carga tiene una regla de reenvío con el protocolo UDP y el puerto 53. El tráfico UDP que llega a la dirección IP interna en el puerto 53 se gestiona mediante la regla de reenvío UDP.
El tercer balanceador de carga tiene una regla de reenvío con el protocolo L3_DEFAULT y el puerto ALL. El resto del tráfico que no coincida con las reglas de reenvío TCP o UDP se gestiona mediante la regla de reenvío L3_DEFAULT.
Los tres balanceadores de carga comparten la misma dirección IP interna estática (internal-lb-ipv4) en sus reglas de reenvío.

Crear el primer balanceador de carga

Crea el primer balanceador de carga para el tráfico TCP en el puerto 80.

gcloud

Crea el servicio de backend para el tráfico TCP:

gcloud compute backend-services create be-ilb \
    --load-balancing-scheme=internal \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

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

gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

Crea una regla de reenvío para el servicio de backend. Usa la dirección IP interna estática reservada (internal-lb-ipv4) como dirección IP interna.

gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=TCP \
    --ports=80 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

Crea el servicio backend regional haciendo una solicitud POST al método regionBackendServices.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices { "name": "be-ilb", "backends": [ { "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a", "balancingMode": "CONNECTION" } ], "healthChecks": [ "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80" ], "loadBalancingScheme": "INTERNAL", "protocol": "TCP", "connectionDraining": { "drainingTimeoutSec": 0 } }

Create the forwarding rule by making a POST request to the forwardingRules.insert method:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "TCP",
"ports": [
 "80"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Crear el segundo balanceador de carga

Crea el segundo balanceador de carga para el tráfico UDP en el puerto 53.

gcloud

Crea el servicio de backend con el protocolo definido como UDP:

gcloud compute backend-services create be-ilb-udp \
    --load-balancing-scheme=internal \
    --protocol=UDP \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

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

gcloud compute backend-services add-backend be-ilb-udp \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a

Crea una regla de reenvío para el servicio de backend. Usa la dirección IP interna estática reservada (internal-lb-ipv4) como dirección IP interna.

gcloud compute forwarding-rules create fr-ilb-udp \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=UDP \
    --ports=53 \
    --backend-service=be-ilb-udp \
    --backend-service-region=us-west1

API

Crea el servicio backend regional haciendo una solicitud POST al método regionBackendServices.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
{
"name": "be-ilb-udp",
"backends": [
 {
  "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
  "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "UDP",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

Crea la regla de reenvío haciendo una solicitud POST al método forwardingRules.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-udp",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "UDP",
"ports": [
 "53"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-udp",
"networkTier": "PREMIUM"
}

Crea el tercer balanceador de carga

Crea la regla de reenvío del tercer balanceador de carga para usar la dirección IP interna estática reservada.

gcloud

Crea la regla de reenvío con el protocolo L3_DEFAULT para gestionar el resto del tráfico de protocolos IPv4 admitidos. Usa la dirección IP interna estática reservada (internal-lb-ipv4) como dirección IP interna.

gcloud compute forwarding-rules create fr-ilb-l3-default \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=L3_DEFAULT \
    --ports=ALL \
    --backend-service=be-ilb-l3-default \
    --backend-service-region=us-west1

API

Crea la regla de reenvío haciendo una solicitud POST al método forwardingRules.insert. Sustituye PROJECT_ID por el ID de tuGoogle Cloud proyecto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-l3-default",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "L3_DEFAULT",
"ports": [
  "ALL"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"networkTier": "PREMIUM"
}

Probar el balanceador de carga

Para probar el balanceador de carga, sigue los pasos que se indican en la sección anterior.

Siguientes pasos

Para obtener información sobre conceptos importantes, consulta el artículo Información general sobre el balanceador de carga de red de paso a través interno.
Para saber cómo configurar la conmutación por error, consulta el artículo Configurar la conmutación por error de un balanceador de carga de red pasarela interno.
Para obtener información sobre cómo configurar el registro y la monitorización de los balanceadores de carga de red de paso a través internos, consulta el artículo Registro y monitorización de balanceadores de carga de red de paso a través internos.
Para obtener información sobre cómo solucionar problemas, consulta el artículo Solucionar problemas de balanceadores de carga de red de pases internos.
Limpiar una configuración de balanceo de carga.

Configurar un balanceador de carga de red de paso a través interno con backends de grupos de instancias de VM para varios protocolos Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Permisos

Configurar un balanceador de carga para el tráfico L3_DEFAULT

Configurar una red, una región y una subred

Consola

gcloud

API

Configurar reglas de cortafuegos

Consola

gcloud

API

Crear VMs de backend y grupos de instancias

Crea el grupo de instancias

Consola

gcloud

api

Crear una VM cliente

Consola

gcloud

api

Consola

gcloud

API

Configurar componentes del balanceador de carga

gcloud

API

Probar el balanceador de carga

Probar la conexión desde la VM cliente

gcloud:IPv6

gcloud:IPv4

Hacer ping a la dirección IP del balanceador de carga

gcloud:IPv6

gcloud:IPv4

Opciones de configuración adicionales

Reservar una dirección IPv4 interna estática

gcloud

API

Configurar componentes del balanceador de carga

Crear el primer balanceador de carga

gcloud

API

Crear el segundo balanceador de carga

gcloud

API

Crea el tercer balanceador de carga

gcloud

API

Probar el balanceador de carga

Siguientes pasos

Configurar un balanceador de carga de red de paso a través interno con backends de grupos de instancias de VM para varios protocolos