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

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 lb-network.

4. En la sección Subredes, haga lo siguiente:

   1. Elige Personalizado en Modo de creación de subred.
   2. 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
   3. Haz clic en Listo.
   4. Haz clic en Añadir subred e introduce la siguiente información:
      • Nombre: europe-subnet
      • Región: europe-west1
      • Tipo de pila de IP: IPv4 (pila única)
      • Intervalo de direcciones IP: 10.3.4.0/24
   5. Haz clic en Listo.

5. Haz clic en Crear.

gcloud

1. Crea la red VPC personalizada:

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

2. En la red lb-network, crea una subred para los backends de la región us-west1:

   gcloud compute networks subnets create lb-subnet \
       --network=lb-network \
       --range=10.1.2.0/24 \
       --region=us-west1
   

3. En la red lb-network, crea otra subred para probar el acceso global en la región europe-west1:

   gcloud compute networks subnets create europe-subnet \
       --network=lb-network \
       --range=10.3.4.0/24 \
       --region=europe-west1
   

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "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
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
  "ipCidrRange": "10.3.4.0/24",
  "privateIpGoogleAccess": false
}

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 e introduce la siguiente información:

   • Nombre: fw-allow-lb-access
   • Red: lb-network
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la 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: Permitir todo

3. Haz clic en Crear.

4. Para permitir las conexiones SSH entrantes, vuelva a hacer clic en Crear regla de cortafuegos e introduzca la siguiente información:

   • Nombre: fw-allow-ssh
   • Red: lb-network
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la coincidencia: permitir
   • Objetivos: 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: selecciona Protocolos y puertos especificados, marca la casilla TCP y, a continuación, introduce 22 en Puertos.

5. Haz clic en Crear.

6. Para permitir las Google Cloud comprobaciones del estado, haz clic en Crear regla de cortafuegos por tercera vez e introduce la siguiente información:

   • Nombre: fw-allow-health-check
   • Red: lb-network
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la coincidencia: permitir
   • Objetivos: 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 todo

7. Haz clic en Crear.

gcloud

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

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

2. Crea la regla de cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs con 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
   

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

   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
   

API

Crea la regla de cortafuegos fw-allow-lb-access 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",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "10.1.2.0/24", "10.3.4.0/24"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Crea la regla de cortafuegos fw-allow-ssh haciendo 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
}

Crea la regla de cortafuegos fw-allow-health-check 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",
 "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
}

Consola

Crear VMs de backend

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

   Ir a instancias de VM

2. Repite los pasos del 3 al 8 para cada VM, usando las siguientes combinaciones de nombre y zona.

   • Nombre: vm-a1, zona: us-west1-a
   • Nombre: vm-a2, zona: us-west1-a
   • Nombre: vm-c1, zona: us-west1-c
   • Nombre: vm-c2, zona: us-west1-c

3. Haz clic en Crear instancia.

4. Asigna el Nombre como se indica en el paso 2.

5. En Región, selecciona us-west1 y elige una Zona como se indica en el paso 2.

6. En la sección Disco de arranque, asegúrate de que la opción Debian GNU/Linux 12 (bookworm) esté seleccionada para el disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

7. Haz clic en Advanced options (Opciones avanzadas).

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

   1. En Etiquetas de red, introduce allow-ssh y allow-health-check.
   2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network
      • Subred: lb-subnet
      • Tipo de pila de IP: IPv4 (pila única)
      • Dirección IPv4 interna principal: efímera (automática)
      • Dirección IPv4 externa: efímera

9. Haz clic en Gestión y, a continuación, en el campo Secuencia de comandos de inicio, introduce la siguiente secuencia de comandos. El contenido de la secuencia de comandos es idéntico en las cuatro máquinas virtuales.

   
   #! /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
   

10. Haz clic en Crear.

Crear grupos de instancias

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

   Ir a Grupos de instancias

2. Repite los pasos siguientes para crear dos grupos de instancias no gestionados, cada uno con dos VMs, usando estas combinaciones.

   • Nombre del grupo de instancias: ig-a, zona: us-west1-a, VMs: vm-a1 y vm-a2
   • Nombre del grupo de instancias: ig-c, zona: us-west1-c, VMs: vm-c1 y vm-c2

3. Haz clic en Crear grupo de instancias.

4. Haga clic en Nuevo grupo de instancias sin gestionar.

5. Asigna el Nombre como se indica en el paso 2.

6. En la sección Ubicación, selecciona us-west1 en Región y, a continuación, elige una Zona como se indica en el paso 2.

7. En Red, selecciona lb-network.

8. En Subred, selecciona lb-subnet.

9. En la sección Instancias de VM, añade las VMs como se indica en el paso 2.

10. Haz clic en Crear.

gcloud

1. Crea las cuatro VMs ejecutando el siguiente comando cuatro veces y usando estas cuatro combinaciones para [VM-NAME] y [ZONE]. El contenido de la secuencia de comandos es idéntico en las cuatro VMs.

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c
   • VM-NAME: vm-c2, ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
         --zone=ZONE \
         --image-family=debian-12 \
         --image-project=debian-cloud \
         --tags=allow-ssh,allow-health-check \
         --subnet=lb-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'
   

2. Crea los dos grupos de instancias sin gestionar en cada zona:

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Añade las VMs a los grupos de instancias correspondientes:

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

API

En las cuatro VMs, usa los siguientes nombres y zonas:

• VM-NAME: vm-a1, ZONE: us-west1-a
• VM-NAME: vm-a2, ZONE: us-west1-a
• VM-NAME: vm-c1, ZONE: us-west1-c
• VM-NAME: vm-c2, ZONE: us-west1-c

Para obtener el DEBIAN_IMAGE_NAME actual, ejecuta el siguiente comando gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crea cuatro VMs de backend haciendo cuatro solicitudes POST al método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "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": [
   {
     "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-NAME",
     "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\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\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\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea dos grupos 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"
}

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

{
 "name": "ig-c",
 "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",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

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

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

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:

• Nombre del balanceador de carga: be-ilb
• Región: us-west1
• Red: lb-network

Configurar los backends

1. Haz clic en Configuración de backend.
2. Para gestionar solo el tráfico IPv4, en la sección Nuevo backend de Backends, selecciona IPv4 (pila única) en Tipo de pila de IP.
3. En Grupo de instancias, selecciona el grupo de instancias ig-c y haz clic en Hecho.
4. Haz clic en Añadir un backend y repite el paso para añadir ig-a.

5. En la lista Comprobación del estado, selecciona Crear comprobación del estado, introduce la siguiente información y haz clic en Guardar.

   • Nombre: hc-http-80
   • Protocolo: HTTP
   • Puerto: 80
   • Protocolo de proxy: NONE
   • Ruta de la solicitud: /

   Ten en cuenta que, cuando usas la Google Cloud consola para crear tu balanceador de carga, la comprobación del estado es global. Si quieres crear una comprobación del estado regional, usa gcloud o la API.

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 fr-ilb.
   2. En Subred, selecciona lb-subnet.
   3. En la sección Propósito de la IP interna, en la lista Dirección IP, selecciona Crear dirección IP, introduce la siguiente información y, a continuación, haz clic en Reservar.
      • Nombre: ip-ilb
      • Versión de IP: IPv4
      • Dirección IP estática: Quiero elegir
      • Dirección IP personalizada: 10.1.2.99
   4. En Puertos, selecciona Varios y, en Números de puerto,introduce 80,8008, 8080 y 8088.
   5. 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. Opcional: Haz clic en Código equivalente para ver la solicitud de la API REST que se usará para crear el balanceador de carga.
4. Haz clic en Crear.

gcloud

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

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

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

   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
   

3. Añade los dos grupos 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
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crea una regla de reenvío para el servicio de backend. Cuando cree la regla de reenvío, especifique 10.1.2.99 para la dirección IP interna de la subred.

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

API

Crea la comprobación del estado haciendo una solicitud POST al método regionHealthChecks.insert.

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",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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"
}

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

4. En Región, selecciona us-west1.

5. En Zona, selecciona us-west1-a.

6. Haz clic en Advanced options (Opciones avanzadas).

7. Haga clic en Redes y configure 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

8. 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 \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --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",
 "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
}

Consola

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

   Ir a redes de VPC

2. Haz clic en add_boxCrear red VPC.

3. En Nombre, escribe lb-network-dual-stack.

4. Si quieres configurar intervalos de direcciones IPv6 internas en subredes de esta red, sigue estos pasos:

   1. En Configuración de direcciones IPv6 privadas, selecciona Configurar un intervalo de direcciones IPv6 internas ULA para esta red de VPC.
   2. En Asignar intervalo de IPv6 interno, selecciona Automáticamente o Manualmente. Si selecciona Manualmente, introduzca un intervalo /48 dentro del intervalo fd20::/20. Si el intervalo está en uso, se te pedirá que proporciones otro.

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

6. En la sección Nueva subred, especifica los siguientes parámetros de configuración de una subred:

   • Nombre: lb-subnet
   • Región: us-west1
   • Tipo de pila de IP: IPv4 e IPv6 (pila dual)
   • Intervalo de IPv4: 10.1.2.0/24.
   • Tipo de acceso IPv6: Interno

7. Haz clic en Listo.

8. Haz clic en Añadir subred e introduce la siguiente información:

   • Nombre: europe-subnet
   • Región: europe-west1
   • Tipo de pila de IP: IPv4 (pila única)
   • Intervalo de direcciones IP: 10.3.4.0/24

9. Haz clic en Listo.

10. Haz clic en Crear.

gcloud

1. 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. Si quieres seleccionar el /48 intervalo de IPv6 asignado, usa la marca --internal-ipv6-range para especificar un intervalo.

   gcloud compute networks create lb-network-dual-stack \
      --subnet-mode=custom \
      --enable-ula-internal-ipv6 \
      --internal-ipv6-range=ULA_IPV6_RANGE \
      --bgp-routing-mode=regional
   

   Sustituye ULA_IPV6_RANGE por un prefijo /48 del intervalo fd20::/20 que usa Google para los intervalos de subredes IPv6 internos. Si no usas la marca --internal-ipv6-range, Google selecciona un prefijo /48 para la red, como fd20:bc7:9a1c::/48.

2. En la red NETWORK, crea una subred para las back-ends en la región us-west1 y otra subred para probar el acceso global en la región europe-west1.

   Para crear las subredes, ejecuta el comando gcloud compute networks subnets create.

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

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

API

Crea una red VPC en modo personalizado.

Para configurar intervalos IPv6 internos en cualquier subred de esta red, asigna el valor true a enableUlaInternalIpv6. Esta opción asigna un intervalo /48 del intervalo fd20::/20 que usa Google para los intervalos de subredes IPv6 internas. Si quieres seleccionar el intervalo de IPv6 /48 que se asigna, usa también el campo internalIpv6Range para especificar un intervalo.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }
 

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.
• ULA_IPV6_RANGE: un prefijo /48 del intervalo fd20::/20 que usa Google para los intervalos de subredes IPv6 internos. Si no proporciona ningún valor para internalIpv6Range, Google selecciona un prefijo /48 para la red.

• DYNAMIC_ROUTING_MODE: global o regional para controlar el comportamiento de anuncio de rutas de los routers de Cloud Router en la red. Para obtener más información, consulta el artículo sobre el modo de enrutamiento dinámico.

  Para obtener más información, consulta el método networks.insert.

Haz dos solicitudes 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-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

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

Consola

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

   Ir a Políticas de cortafuegos

2. Para crear la regla que permita el tráfico de la subred, haz clic en Crear regla de cortafuegos e introduce la siguiente información:

   • Nombre: fw-allow-lb-access
   • Red: lb-network-dual-stack
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la 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 y 10.3.4.0/24
   • Protocolos y puertos: Permitir todo

3. Haz clic en Crear.

4. Para permitir el tráfico de la subred IPv6, haz clic de nuevo en Crear regla de cortafuegos e introduce la siguiente información:

   • Nombre: fw-allow-lb-access-ipv6
   • Red: lb-network-dual-stack
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la 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: Permitir todo

5. Haz clic en Crear.

6. Para permitir las conexiones SSH entrantes, vuelva a hacer clic en Crear regla de cortafuegos e introduzca la siguiente información:

   • Nombre: fw-allow-ssh
   • Red: lb-network-dual-stack
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la coincidencia: permitir
   • Objetivos: 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: selecciona Protocolos y puertos especificados, marca la casilla TCP y, a continuación, introduce 22 en Puertos.

7. Haz clic en Crear.

8. Para permitir las comprobaciones del estado de Google Cloud IPv6, haz clic en Crear regla de cortafuegos de nuevo e introduce la siguiente información:

   • Nombre: fw-allow-health-check-ipv6
   • Red: lb-network-dual-stack
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción en la coincidencia: permitir
   • Objetivos: 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 todo

9. Haz clic en Crear.

10. Para permitir las comprobaciones del estado, haz clic en Crear regla de cortafuegos de nuevo e introduce la siguiente información: Google Cloud

    • Nombre: fw-allow-health-check
    • Red: lb-network-dual-stack
    • Prioridad: 1000
    • Sentido del tráfico: entrada
    • Acción en la coincidencia: permitir
    • Objetivos: 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 todo

11. Haz clic en Crear.

gcloud

1. Crea la regla de cortafuegos fw-allow-lb-access para permitir la comunicación con la subred:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24,10.3.4.0/24 \
       --rules=all
   

2. Crea la regla de cortafuegos fw-allow-lb-access-ipv6 para permitir la comunicación con la subred:

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

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

3. Crea la regla de cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs con 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-dual-stack \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

4. Crea la regla fw-allow-health-check-ipv6 para permitir las comprobaciones del estado deGoogle Cloud IPv6.

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

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

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network-dual-stack \
       --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
   

API

1. Crea la regla de cortafuegos fw-allow-lb-access 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",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "10.1.2.0/24", "10.3.4.0/24"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

2. 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-dual-stack",
    "priority": 1000,
    "sourceRanges": [
      "IPV6_ADDRESS"
    ],
    "allowed": [
      {
         "IPProtocol": "tcp"
       },
       {
         "IPProtocol": "udp"
       },
       {
         "IPProtocol": "icmp"
       }
    ],
    "direction": "INGRESS",
    "logConfig": {
       "enable": false
    },
    "disabled": false
   }
   

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

3. Crea la regla de cortafuegos fw-allow-ssh haciendo 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-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "0.0.0.0/0"
   ],
   "targetTags": [
     "allow-ssh"
   ],
   "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
   ],
   "direction": "INGRESS",
   "logConfig": {
    "enable": false
   },
   "disabled": false
   }
   

4. 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-dual-stack",
   "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
   }
   

5. Crea la regla de cortafuegos fw-allow-health-check 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",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "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
   }
   

Consola

Crear VMs de backend

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

   Ir a instancias de VM

2. Repite los pasos del 3 al 8 para cada VM, usando las siguientes combinaciones de nombre y zona.

   • Nombre: vm-a1, zona: us-west1-a
   • Nombre: vm-a2, zona: us-west1-a
   • Nombre: vm-c1, zona: us-west1-c
   • Nombre: vm-c2, zona: us-west1-c

3. Haz clic en Crear instancia.

4. Asigna el Nombre como se indica en el paso 2.

5. En Región, selecciona us-west1 y elige una Zona como se indica en el paso 2.

6. En la sección Disco de arranque, asegúrate de que la opción Debian GNU/Linux 12 (bookworm) esté seleccionada para el disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

7. Haz clic en Advanced options (Opciones avanzadas).

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

   1. En Etiquetas de red, introduce allow-ssh y allow-health-check-ipv6.
   2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-dual-stack
      • Subred: lb-subnet
      • Tipo de pila de IP: IPv4 e IPv6 (pila dual)
      • Dirección IPv4 interna principal: efímera (automática)
      • Dirección IPv4 externa: efímera

   3. Haz clic en Gestión y, a continuación, en el campo Secuencia de comandos de inicio, introduce la siguiente secuencia de comandos. El contenido de la secuencia de comandos es idéntico en las cuatro máquinas virtuales.

      #! /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
      

9. Haz clic en Crear.

Crear grupos de instancias

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

   Ir a Grupos de instancias

2. Repite los pasos siguientes para crear dos grupos de instancias no gestionados, cada uno con dos VMs, usando estas combinaciones.

   • Nombre del grupo de instancias: ig-a, zona: us-west1-a, VMs: vm-a1 y vm-a2
   • Nombre del grupo de instancias: ig-c, zona: us-west1-c, VMs: vm-c1 y vm-c2

3. Haz clic en Crear grupo de instancias.

4. Haga clic en Nuevo grupo de instancias sin gestionar.

5. Asigna el Nombre como se indica en el paso 2.

6. En la sección Ubicación, selecciona us-west1 en Región y, a continuación, elige una Zona como se indica en el paso 2.

7. En Red, selecciona lb-network-dual-stack.

8. En Subred, selecciona lb-subnet.

9. En la sección Instancias de VM, añade las VMs como se indica en el paso 2.

10. Haz clic en Crear.

gcloud

1. Para crear las cuatro VMs, ejecuta el comando gcloud compute instances create cuatro veces. Usa estas cuatro combinaciones para [VM-NAME] y [ZONE]. El contenido de la secuencia de comandos es idéntico en las cuatro VMs.

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c

   • VM-NAME: vm-c2, ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet \
       --stack-type=IPV4_IPV6 \
       --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'
     

2. Crea los dos grupos de instancias sin gestionar en cada zona:

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Añade las VMs a los grupos de instancias correspondientes:

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

api

En las cuatro VMs, usa los siguientes nombres y zonas:

• VM-NAME: vm-a1, ZONE: us-west1-a
• VM-NAME: vm-a2, ZONE: us-west1-a
• VM-NAME: vm-c1, ZONE: us-west1-c
• VM-NAME: vm-c2, ZONE: us-west1-c

Para obtener el DEBIAN_IMAGE_NAME actual, ejecuta el siguiente comando gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crea cuatro VMs de backend haciendo cuatro solicitudes POST al método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "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-dual-stack",
     "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-NAME",
     "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\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea dos grupos 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-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

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

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "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",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

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

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

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:

• Nombre del balanceador de carga: be-ilb
• Región: us-west1
• Red: lb-network-dual-stack

Configuración de backend

1. Haz clic en Configuración de backend.
2. En la sección Nuevo backend de Backends, selecciona IPv4 e IPv6 (pila dual) en Tipo de pila de IP.
3. En Grupo de instancias, selecciona el grupo de instancias ig-a y haz clic en Hecho.
4. Haz clic en Añadir un backend y repite el paso para añadir ig-c.
5. En la lista Comprobación del estado, selecciona Crear comprobación del estado, introduce la siguiente información y haz clic en Guardar:
   • Nombre: hc-http-80.
   • Ámbito: regional.
   • Protocolo: HTTP.
   • Puerto: 80.
   • Protocolo de proxy: NONE.
   • Ruta de la solicitud: /.
6. Comprueba que aparezca una marca de verificación azul junto a Configuración de backend.

Configuración de frontend

1. Haz clic en Configuración de frontend. En la sección IP de frontend y puerto nuevos, haga lo siguiente:
   1. En Nombre, escribe fr-ilb-ipv6.
   2. Para gestionar el tráfico IPv6, siga estos pasos:
      1. En Versión de IP, selecciona IPv6.
      2. En Subred, selecciona lb-subnet. El intervalo de direcciones IPv6 de la regla de reenvío siempre es efímero.
      3. En Puertos, selecciona Varios y, en el campo Número de puerto, introduce 80,8008,8080,8088.
      4. Haz clic en Listo.
   3. Para gestionar el tráfico IPv4, siga estos pasos:
      1. Haz clic en Añadir IP y puerto de frontend.
      2. En Nombre, escribe fr-ilb.
      3. En Subred, selecciona lb-subnet.
      4. En la sección Propósito de la IP interna, en la lista Dirección IP, selecciona Crear dirección IP, introduce la siguiente información y, a continuación, haz clic en Reservar.
         • Nombre: ip-ilb
         • Versión de IP: IPv4
         • Dirección IP estática: Quiero elegir
         • Dirección IP personalizada: 10.1.2.99
      5. En Puertos, selecciona Varios y, en Números de puerto, introduce 80, 8008, 8080 y 8088.
      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. Revisa todos los ajustes.
2. Si los ajustes son correctos, haz clic en Crear. El balanceador de carga de red de paso a través interno tarda unos minutos en crearse.

gcloud

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

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

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

   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
   

3. Añade los dos grupos 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
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crea dos reglas de reenvío para el servicio de backend. Cuando cree la regla de reenvío de IPv4, especifique 10.1.2.99 como dirección IP interna en la subred de direcciones IPv4.

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

   gcloud compute forwarding-rules create fr-ilb-ipv6 \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --subnet=lb-subnet \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

api

Crea la comprobación del estado haciendo una solicitud POST al método regionHealthChecks.insert.

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",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"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-ipv6",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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",
"networkTier": "PREMIUM"
}

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

4. En Región, selecciona us-west1.

5. En Zona, selecciona us-west1-a.

6. Haz clic en Advanced options (Opciones avanzadas).

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

   1. En Etiquetas de red, introduzca allow-ssh.
   2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-dual-stack
      • Subred: lb-subnet
      • Tipo de pila de IP: IPv4 e IPv6 (pila dual)
      • IP interna principal: efímera (automática)
      • IP externa: efímera
   3. Haz clic en Listo.

8. 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 \
    --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",
 "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-dual-stack",
     "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
}

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 lb-network-ipv6-only.

4. Si quieres configurar intervalos de direcciones IPv6 internas en subredes de esta red, sigue estos pasos:

   1. En Configuración de direcciones IPv6 privadas, selecciona Configurar un intervalo de direcciones IPv6 internas ULA para esta red de VPC.
   2. En Asignar intervalo de IPv6 interno, selecciona Automáticamente o Manualmente. Si selecciona Manualmente, introduzca un intervalo /48 dentro del intervalo fd20::/20. Si el intervalo ya está en uso, se te pedirá que proporciones otro.

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

6. En la sección Nueva subred, especifica los siguientes parámetros de configuración de una subred:

   • Nombre: lb-subnet-ipv6-only
   • Región: us-west1
   • Tipo de pila de IP: IPv6 (pila única)
   • Tipo de acceso IPv6: Interno

7. Haz clic en Listo.

8. Haz clic en Crear.

gcloud

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

   gcloud compute networks create lb-network-ipv6-only \
     --subnet-mode=custom \
     --enable-ula-internal-ipv6 \
     --bgp-routing-mode=regional
   

2. Configura una subred con el valor ipv6-access-type definido como INTERNAL. Esto indica que las VMs de esta subred solo pueden tener direcciones IPv6 internas.Para crear la subred, ejecuta el comando gcloud compute networks subnets create.

   gcloud compute networks subnets create lb-subnet-ipv6-only \
     --network=lb-network-ipv6-only \
     --region=us-west1 \
     --stack-type=IPV6_ONLY \
     --ipv6-access-type=INTERNAL
   

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 subred IPv6, haz clic de nuevo en Crear regla de cortafuegos e introduce la siguiente información:

   • Nombre: fw-allow-lb-access-ipv6-only
   • Red: lb-network-ipv6-only
   • Prioridad: 1000
   • Sentido 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: ::/0
   • Protocolos y puertos: Permitir todo

3. Haz clic en Crear.

4. Para permitir las conexiones SSH entrantes, vuelve a hacer clic en Crear regla de cortafuegos e introduce la siguiente información:

   • Nombre: fw-allow-ssh
   • Red: lb-network-ipv6-only
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción tras coincidencia: Permitir
   • Objetivos: 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: selecciona Protocolos y puertos especificados, marca la casilla TCP y, a continuación, introduce 22 en Puertos.

5. Haz clic en Crear.

6. Para permitir las comprobaciones de estado de Google Cloud IPv6, haz clic de nuevo en Crear regla de cortafuegos e introduce la siguiente información:

   • Nombre: fw-allow-health-check-ipv6-only
   • Red: lb-network-ipv6-only
   • Prioridad: 1000
   • Sentido del tráfico: entrada
   • Acción tras coincidencia: Permitir
   • Objetivos: 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 todo

7. Haz clic en Crear.

gcloud

1. Crea la regla de cortafuegos fw-allow-lb-access-ipv6-only para permitir el tráfico IPv6 a todas las instancias de VM de la red de VPC.

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

2. Crea la regla de cortafuegos fw-allow-ssh para permitir la conectividad SSH a las VMs con 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-ipv6-only \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

3. Crea la regla fw-allow-health-check-ipv6 para permitir las comprobaciones del estado deGoogle Cloud IPv6.

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

Consola

Crear VMs de backend

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

   Ir a instancias de VM

2. Repite estos pasos con cada máquina virtual, usando las siguientes combinaciones de nombre y zona.

   • Nombre: vm-a1, zona: us-west1-a
   • Nombre: vm-a2, zona: us-west1-a
   • Nombre: vm-c1, zona: us-west1-c
   • Nombre: vm-c2, zona: us-west1-c

3. Haz clic en Crear instancia.

4. Asigna el Nombre como se indica en el paso 2.

5. En Región, selecciona us-west1 y elige una Zona como se indica en el paso 2.

6. En la sección Disco de arranque, asegúrate de que la opción Debian GNU/Linux 12 (bookworm) esté seleccionada para el disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

7. Haz clic en Advanced options (Opciones avanzadas).

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

   1. En Etiquetas de red, introduce allow-ssh y allow-health-check-ipv6.
   2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-ipv6-only
      • Subred: lb-subnet-ipv6-only
      • Tipo de pila de IP: IPv6 (pila única)
      • Dirección IPv6 interna principal: efímera (automática)

9. Haz clic en Crear.

La VM backend debe ejecutar un servidor TCP IPv6 que escuche las conexiones entrantes. Instala este servidor en las VMs de backend después de configurar el balanceador de carga. Esto se debe a que la secuencia de comandos del servidor crea un socket que se vincula a la regla de reenvío del balanceador de carga.

Crear grupos de instancias

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

   Ir a Grupos de instancias

2. Repite los pasos siguientes para crear dos grupos de instancias no gestionados, cada uno con dos VMs, usando estas combinaciones.

   • Nombre del grupo de instancias: ig-a, zona: us-west1-a, VMs: vm-a1 y vm-a2
   • Nombre del grupo de instancias: ig-c, zona: us-west1-c, VMs: vm-c1 y vm-c2

3. Haz clic en Crear grupo de instancias.

4. Haga clic en Nuevo grupo de instancias sin gestionar.

5. Asigna el Nombre como se indica en el paso 2.

6. En la sección Ubicación, selecciona us-west1 en Región y, a continuación, elige una Zona como se indica en el paso 2.

7. En Red, selecciona lb-network-ipv6-only.

8. En Subred, selecciona lb-subnet-ipv6-only.

9. En la sección Instancias de VM, añade las VMs como se indica en el paso 2.

10. Haz clic en Crear.

gcloud

1. Para crear las cuatro VMs, ejecuta el comando gcloud compute instances create cuatro veces. Usa estas cuatro combinaciones para [VM-NAME] y [ZONE].

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c
   • VM-NAME: vm-c2, ZONE: us-west1-c

   gcloud beta compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet-ipv6-only \
       --stack-type=IPV6_ONLY
   

   La VM backend debe ejecutar un servidor TCP IPv6 que escuche las conexiones entrantes. Instala este servidor en las VMs de backend después de configurar el balanceador de carga. Esto se debe a que la secuencia de comandos del servidor crea un socket que se vincula a la regla de reenvío del balanceador de carga.

2. Crea los dos grupos de instancias sin gestionar en cada zona:

   gcloud beta compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud beta compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Añade las VMs a los grupos de instancias correspondientes:

   gcloud beta compute instance-groups unmanaged add-instances ig-a \
     --zone=us-west1-a \
     --instances=vm-a1,vm-a2
   gcloud beta compute instance-groups unmanaged add-instances ig-c \
     --zone=us-west1-c \
     --instances=vm-c1,vm-c2
   

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:

• Nombre del balanceador de carga: ilb-ipv6-only
• Región: us-west1
• Red: lb-network-ipv6-only

Configuración de backend

1. Haz clic en Configuración de backend.
2. En la sección Nuevo backend de Backends, selecciona IPv6 (pila única) como tipo de pila de IP.
3. En Grupo de instancias, selecciona el grupo de instancias ig-a y haz clic en Hecho.
4. Haz clic en Añadir un backend y repite el paso para añadir ig-c.
5. En la lista Comprobación del estado, selecciona Crear comprobación del estado, introduce la siguiente información y haz clic en Guardar:
   • Nombre: hc-http-80.
   • Ámbito: regional.
   • Protocolo: HTTP.
   • Puerto: 80.
   • Protocolo de proxy: NONE.
   • Ruta de la solicitud: /.
6. Comprueba que aparezca una marca de verificación azul junto a Configuración de backend.

Configuración de frontend

1. Haz clic en Configuración de frontend. En la sección IP de frontend y puerto nuevos, haga lo siguiente:
   1. En Nombre, escribe fr-ilb-ipv6-only.
   2. Para gestionar el tráfico IPv6, siga estos pasos:
      1. En Versión de IP, selecciona IPv6. El servidor TCP IPv6 que vas a crear en la siguiente sección se vincula a la IP virtual de la regla de reenvío.
      2. En Subred, selecciona lb-subnet-ipv6-only. El intervalo de direcciones IPv6 de la regla de reenvío siempre es efímero.
      3. En Puertos, selecciona Varios y, a continuación, en el campo Número de puerto, introduce 80,8008,8080,8088.
      4. Haz clic en Listo.
   3. Verifica 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. Revisa todos los ajustes.
2. Si los ajustes son correctos, haz clic en Crear. El balanceador de carga de red de paso a través interno tarda unos minutos en crearse.

gcloud

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

   gcloud beta compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. Crea el servicio de backend:

   gcloud beta compute backend-services create ilb-ipv6-only \
       --load-balancing-scheme=INTERNAL \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

3. Añade los dos grupos de instancias al servicio de backend:

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

   gcloud beta compute backend-services add-backend ilb-ipv6-only \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crea la regla de reenvío IPv6 con una dirección IPv6 efímera.

   gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
       --region=us-west1 \
       --load-balancing-scheme=INTERNAL \
       --subnet=lb-subnet-ipv6-only \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=ilb-ipv6-only \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

   El servidor TCP IPv6 que vas a crear en la siguiente sección se vincula a la IP virtual de la regla de reenvío.

Consola

1. En la lista de instancias de VM que has creado anteriormente, haz clic en la que quieras actualizar.

2. Haz clic en Editar.

3. En la sección Metadata (Metadatos), introduce la siguiente secuencia de comandos en el campo Startup script (Secuencia de comandos de inicio).

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

4. Haz clic en Guardar.

5. Reinicia la instancia.

gcloud

1. Crea una secuencia de comandos de inicio.

   nano startup.sh
   

2. Añade la siguiente secuencia de comandos y guarda el archivo.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

3. Añade el archivo de metadatos a la instancia de VM.

   gcloud compute instances add-metadata VM-NAME \
     --metadata-from-file=startup-script=startup.sh
   

4. Reinicia la instancia.

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

4. En Región, selecciona us-west1.

5. En Zona, selecciona us-west1-a.

6. Haz clic en Advanced options (Opciones avanzadas).

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

   1. En Etiquetas de red, introduzca allow-ssh.
   2. En Interfaces de red, selecciona lo siguiente:
      • Red: lb-network-ipv6-only
      • Subred: lb-subnet-ipv6-only
      • Tipo de pila de IP: IPv6 (pila única)
   3. Haz clic en Listo.

8. 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 beta compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV6_ONLY \
    --tags=allow-ssh \
    --subnet=lb-subnet-ipv6-only

Consola

Editar la regla de reenvío del balanceador de carga

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

   Ir a Balanceo de carga

2. En la columna Nombre, haz clic en tu balanceador de carga de red de paso a través interno. El balanceador de carga de ejemplo se llama be-ilb.

3. Haz clic en Configuración de frontend.

4. Haz clic en Editar edit.

5. En Acceso global, selecciona Habilitar.

6. Haz clic en Listo.

7. Haz clic en Actualizar.

En la página Detalles del balanceador de carga, comprueba que en la configuración de frontend se indique Regional (REGION) con acceso global.

gcloud

1. Actualiza la regla de reenvío del balanceador de carga de ejemplo, fr-ilb, para incluir la marca --allow-global-access.

    gcloud compute forwarding-rules update fr-ilb \
        --region=us-west1 \
        --allow-global-access
   

2. Puedes usar el comando forwarding-rules describe para determinar si una regla de reenvío tiene habilitado el acceso global. Por ejemplo:

    gcloud compute forwarding-rules describe fr-ilb \
        --region=us-west1 \
        --format="get(name,region,allowGlobalAccess)"
   

   La palabra True aparece en el resultado, después del nombre y la región de la regla de reenvío, cuando el acceso global está habilitado.

API

Realiza una solicitud PATCH al método forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
"allowGlobalAccess": true
}

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. Asigna el valor vm-client2 a Nombre.

4. Define Región como europe-west1.

5. En Zona, elija europe-west1-b.

6. Haz clic en Advanced options (Opciones avanzadas).

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

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

8. 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 europe-west1-b y usa la misma subred que las VMs de backend.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
"name": "vm-client2",
"tags": {
  "items": [
    "allow-ssh"
  ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/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/europe-west1/subnetworks/europe-subnet",
    "accessConfigs": [
      {
        "type": "ONE_TO_ONE_NAT",
        "name": "external-nat",
        "networkTier": "PREMIUM"
      }
    ]
  }
],
"disks": [
  {
    "type": "PERSISTENT",
    "boot": true,
    "mode": "READ_WRITE",
    "autoDelete": true,
    "deviceName": "vm-client2",
    "initializeParams": {
      "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
      "diskType": "projects/PROJECT_ID/zones/europe-west1-b/diskTypes/pd-standard",
      "diskSizeGb": "10"
    }
  }
],
"scheduling": {
  "preemptible": false
},
"deletionProtection": false
}

Consola

Plantilla de instancia

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

   Ir a plantillas de instancias de VM

2. Haz clic en Crear plantilla de instancia.

3. Asigna el valor template-vm-ilb a Nombre.

4. Elige un tipo de máquina.

5. En la sección Disco de arranque, asegúrate de que la opción Debian GNU/Linux 12 (bookworm) esté seleccionada para el disco de arranque. Si es necesario, haz clic en Cambiar para cambiar la imagen.

6. Haz clic en Advanced options (Opciones avanzadas).

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

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

8. Haga clic en Gestión y, a continuación, en el campo Secuencia de comandos de inicio, introduzca 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
   

9. Haz clic en Crear.

Grupo de instancias gestionado

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. Asigna el valor ig-ilb a Nombre.

4. En Ubicación, elige Multizona y, en Región, selecciona us-west1.

5. Asigna el valor template-vm-ilb a Plantilla de instancia.

6. Opcional: Configura el autoescalado. No puedes autoescalar el grupo de instancias en función del uso del balanceo de carga HTTP porque el grupo de instancias es un backend del balanceador de carga de red interno de transferencia.

7. Define 1 en Número mínimo de instancias y 6 en Número máximo de instancias.

8. Opcional: Configura la reparación automática. Si configura la reparación automática, utilice la misma comprobación del estado que el servicio de backend para el balanceador de carga de red interno de pases. En este ejemplo, utiliza hc-http-80.

9. Haz clic en Crear.

gcloud

1. Crea la plantilla de instancia. También puedes definir otros parámetros, como el tipo de máquina, para que los use la plantilla de imagen.

   gcloud compute instance-templates create template-vm-ilb \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --region=us-west1 \
       --network=lb-network \
       --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'
   

2. Crea un grupo de instancias gestionado regional con la plantilla:

   gcloud compute instance-groups managed create ig-ilb \
       --template=template-vm-ilb \
       --region=us-west1 \
       --size=6
   

3. Añade el grupo de instancias gestionado regional como backend al servicio de backend que ya has creado:

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

4. Desconecta los dos grupos de instancias no gestionados (zonales) del servicio de backend:

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

Consola

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

   Ir a instancias de VM

2. Repite los pasos siguientes para cada VM de backend.

3. Haga clic en el nombre de la VM de backend, por ejemplo, vm-a1.

4. Haz clic en editEditar.

5. En la sección Interfaces de red, haz clic en la red.

6. En la lista IP externa, selecciona Ninguna y haz clic en Hecho.

7. Haz clic en Guardar.

gcloud

1. Para buscar la zona de una instancia (por ejemplo, si usas un grupo de instancias gestionado regional), ejecuta el siguiente comando para cada instancia y determina su zona. Sustituye [SERVER-VM] por el nombre de la VM que quieras buscar.

   gcloud compute instances list --filter="name=[SERVER-VM]"
   

2. Repite el siguiente paso con cada VM de backend. Sustituye [SERVER-VM] por el nombre de la VM y [ZONE] por la zona de la VM.

   gcloud compute instances delete-access-config [SERVER-VM] \
       --zone=[ZONE] \
       --access-config-name=external-nat
   

API

Haz una solicitud POST al método instances.deleteAccessConfig de cada VM de backend. Sustituye vm-a1 por el nombre de la VM y us-west1-a por la zona de la VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Consola

Eliminar una regla de reenvío y crear otra

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

   Ir a Balanceo de carga

2. Haz clic en el balanceador de carga be-ilb y, a continuación, en Editar.

3. Haz clic en Configuración de frontend.

4. Coloca el cursor sobre la regla de reenvío 10.1.2.9 y haz clic en deleteEliminar.

5. Haz clic en Añadir IP y puerto de frontend.

6. En la sección IP de frontend y puerto nuevos, introduce la siguiente información y haz clic en Hecho:

   • Nombre: fr-ilb
   • Subred: lb-subnet
   • IP interna: ip-ilb
   • Puertos: Todos.

7. Comprueba que haya una marca de verificación azul junto a Configuración del frontend antes de continuar.

8. Haz clic en Revisar y finalizar y revisa los ajustes de configuración de tu balanceador de carga.

9. Haz clic en Crear.

gcloud

1. Elimina la regla de reenvío que ya tengas, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. Crea una regla de reenvío de sustitución con el mismo nombre cuya configuración de puerto utilice la palabra clave ALL. Los demás parámetros de la regla de reenvío no cambian.

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

API

Elimina la regla de reenvío haciendo una solicitud DELETE al método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"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",
"networkTier": "PREMIUM"
}

Consola

1. En la Google Cloud consola, ve a la página Reglas de reenvío.

   Ir a Reglas de reenvío

2. En la columna Nombre, haga clic en fr-ilb y, a continuación, en Eliminar.

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

   Ir a Balanceo de carga

4. En la columna Nombre, haga clic en be-ilb.

5. Haz clic en Editar.

6. Haz clic en Configuración de frontend.

7. Haz clic en Añadir IP y puerto de frontend.

8. En la sección IP de frontend y puerto nuevos, haga lo siguiente:

   1. En Nombre, escribe fr-ilb-http.
   2. En Subred, selecciona lb-subnet.
   3. En Propósito de la IP interna, selecciona Compartida.
   4. En la lista Dirección IP, selecciona Crear dirección IP, introduce la siguiente información y haz clic en Reservar:
      • Nombre: internal-10-1-2-99
      • Dirección IP estática: Quiero elegir
      • Dirección IP personalizada: 10.1.2.99
   5. En Puertos, selecciona Varios y, en Números de puerto, introduce 80, 8008, 8080 y 8088.
   6. Haz clic en Listo.

9. Haz clic en Añadir IP y puerto de frontend.

10. En la sección IP de frontend y puerto nuevos, haga lo siguiente:

    1. En Nombre, escribe fr-ilb-https.
    2. En Subred, selecciona lb-subnet.
    3. En Propósito de la IP interna, selecciona Compartida.
    4. En la lista Dirección IP, seleccione internal-10-1-2-99.
    5. En Puertos, selecciona Varios y, en Números de puerto, introduce 443 y 8443.
    6. Haz clic en Listo.

11. Haz clic en Revisar y finalizar y revisa los ajustes de configuración de tu balanceador de carga.

12. Haz clic en Actualizar.

gcloud

1. Elimina la regla de reenvío que ya tengas, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. Crea una dirección IP interna estática (reservada) para 10.1.2.99 y asigna el valor SHARED_LOADBALANCER_VIP a su marca --purpose. La marca --purpose es obligatoria para que dos reglas de reenvío internas puedan usar la misma dirección IP interna.

   gcloud compute addresses create internal-10-1-2-99 \
       --region=us-west1 \
       --subnet=lb-subnet \
       --addresses=10.1.2.99 \
       --purpose=SHARED_LOADBALANCER_VIP
   

   1. Crea dos reglas de reenvío de sustitución con los siguientes parámetros:

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

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

API

Elimina la regla de reenvío haciendo una solicitud DELETE al método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crea una dirección IP interna estática (reservada) para 10.1.2.99 y asigna el valor SHARED_LOADBALANCER_VIP a su propiedad "purpose" (propósito) mediante una solicitud POST al método addresses.insert.

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

{
"name": "internal-10-1-2-99",
"address": "10.1.2.99",
"prefixLength": 32,
"addressType": INTERNAL,
"purpose": SHARED_LOADBALANCER_VIP,
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Crea dos reglas de reenvío haciendo dos solicitudes POST al método forwardingRules.insert.

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

{
"name": "fr-ilb-http",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080",  "8088"
],
"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"
}

{
"name": "fr-ilb-https",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "443", "8443"
],
"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"
}

Consola

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

   Ir a Balanceo de carga

2. Haz clic en be-ilb (el nombre del servicio de backend que has creado para este ejemplo) y, a continuación, en Editar.

3. En la página Editar balanceador de carga de red de paso a través interno, haga clic en Configuración de backend.

4. En la lista Afinidad de sesión, seleccione IP de cliente.

5. Haz clic en Actualizar.

gcloud

Usa el siguiente comando gcloud para actualizar el servicio de backend be-ilb y especificar la afinidad de sesión de la IP del cliente:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

Realiza una solicitud PATCH al método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"sessionAffinity": "CLIENT_IP"
}

gcloud

Usa el siguiente comando gcloud compute backend-services para actualizar la política de seguimiento de conexiones del servicio backend:

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

Sustituye los marcadores de posición por valores válidos:

• BACKEND_SERVICE: el servicio de backend que estás actualizando
• REGION: la región del servicio backend que vas a actualizar
• TRACKING_MODE: el modo de seguimiento de conexiones que se va a usar para los paquetes entrantes. Para ver la lista de valores admitidos, consulta Modo de seguimiento.
• CONNECTION_PERSISTENCE_BEHAVIOR: el comportamiento de persistencia de la conexión cuando los back-ends no están en buen estado. Para ver la lista de valores admitidos, consulta Persistencia de la conexión en back-ends en mal estado.

• IDLE_TIMEOUT_VALUE: número de segundos que debe mantenerse una entrada de la tabla de seguimiento de conexiones después de que el balanceador de carga procese el último paquete que coincida con la entrada.

  Solo puede modificar esta propiedad cuando el seguimiento de la conexión sea inferior a 5 tuplas (es decir, cuando la afinidad de sesión esté configurada como CLIENT_IP o CLIENT_IP_PROTO, y el modo de seguimiento sea PER_SESSION).

  El valor predeterminado es 600 segundos (10 minutos). El valor máximo configurable del tiempo de espera inactivo es de 57.600 segundos (16 horas).

Consola

Añade la segunda subred

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. Haz clic en lb-network.

4. En la sección Subredes, haga lo siguiente:

   1. Haz clic en Añadir subred.
   2. En la sección Nueva subred, introduce la siguiente información:
      • Nombre: second-subnet
      • Región: us-west1
      • Intervalo de direcciones IP: 10.5.6.0/24
   3. Haz clic en Añadir.

Añadir la segunda regla de reenvío

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

   Ir a Balanceo de carga

2. Haz clic en el balanceador de carga be-ilb y, a continuación, en Editar.

3. Haz clic en Configuración de frontend.

4. Haz clic en Añadir IP y puerto de frontend.

5. En la sección IP de frontend y puerto nuevos, define los siguientes campos y haz clic en Hecho:

   • Nombre: fr-ilb-2
   • Versión de IP: IPv4
   • Subred: second-subnet
   • IP interna: ip-ilb
   • Puertos: 80 y 443

6. Comprueba que haya una marca de verificación azul junto a Configuración del frontend antes de continuar.

7. Haz clic en Revisar y finalizar y revisa los ajustes de configuración de tu balanceador de carga.

8. Haz clic en Crear.

gcloud

1. Crea una segunda subred en la red lb-network de la región us-west1:

    gcloud compute networks subnets create second-subnet \
        --network=lb-network \
        --range=10.5.6.0/24 \
        --region=us-west1
   

2. Crea una segunda regla de reenvío para los puertos 80 y 443. Los demás parámetros de esta regla, como la dirección IP y el servicio de backend, son los mismos que los de la regla de reenvío principal, fr-ilb.

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

API

Realiza solicitudes POST al método subnetworks.insert.

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

{
 "name": "second-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.5.6.0/24",
 "privateIpGoogleAccess": false
}

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-2",
"IPAddress": "10.5.6.99",
"IPProtocol": "TCP",
"ports": [
  "80", "443"
],
"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"
}

gcloud

Usa el siguiente comando gcloud para actualizar el servicio de backend be-ilb y especificar la política de subconjuntos:

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

API

Realiza una solicitud PATCH al método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

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

1. En Load balancer name (Nombre del balanceador de carga), introduce un nombre.
2. En Región, selecciona la región de las instancias de VM en las que quieras replicar paquetes.
3. En Red, seleccione la red en la que quiera replicar los paquetes.
4. Haz clic en Configuración de backend.
5. En la sección Nuevo backend, en Grupo de instancias, selecciona el grupo de instancias al que quieras reenviar los paquetes.
6. En la lista Comprobación del estado, selecciona Crear comprobación del estado, introduce la siguiente información y haz clic en Guardar:
   1. En Name (Nombre), introduce un nombre para la comprobación del estado.
   2. En Protocolo, selecciona HTTP.
   3. En Puerto, escribe 80.
7. Haz clic en Configuración de frontend.
8. En la sección IP de frontend y puerto nuevos, haga lo siguiente:
   1. En Name (Nombre), escribe un nombre.
   2. En Subred, selecciona una subred de la misma región que las instancias que quieras replicar.
   3. En Puertos, selecciona Todos.
   4. Haga clic en Configuraciones avanzadas y seleccione la casilla Habilitar este balanceador de carga en la replicación de paquetes.
   5. Haz clic en Listo.
9. Haz clic en Crear.

gcloud

1. Crea una comprobación del estado de HTTP regional para probar la conectividad HTTP con un grupo de instancias en el puerto 80:

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

   Haz los cambios siguientes:

   • HEALTH_CHECK_NAME: el nombre de la comprobación del estado.
   • REGION: la región de las instancias de VM para las que quieres replicar paquetes.

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

   gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --health-checks-region=REGION \
       --health-checks=HEALTH_CHECK_NAME \
       --load-balancing-scheme=internal \
       --protocol=tcp
   

   Haz los cambios siguientes:

   • COLLECTOR_BACKEND_SERVICE: el nombre del servicio de backend.
   • REGION: la región de las instancias de VM en la que quieres replicar paquetes.
   • HEALTH_CHECK_NAME: el nombre de la comprobación del estado.

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

   gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --instance-group=INSTANCE_GROUP \
       --instance-group-zone=ZONE
   

   Haz los cambios siguientes:

   • COLLECTOR_BACKEND_SERVICE: el nombre del servicio de backend.
   • REGION: la región del grupo de instancias.
   • INSTANCE_GROUP: el nombre del grupo de instancias.
   • ZONE: la zona del grupo de instancias.

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

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
       --region=REGION \
       --network=NETWORK \
       --subnet=SUBNET \
       --backend-service=COLLECTOR_BACKEND_SERVICE \
       --load-balancing-scheme=internal \
       --ip-protocol=TCP \
       --ports=all \
       --is-mirroring-collector
   

   Haz los cambios siguientes:

   • FORWARDING_RULE_NAME: el nombre de la regla de reenvío.
   • REGION: la región de la regla de reenvío.
   • NETWORK: la red de la regla de reenvío.
   • SUBNET: una subred de la región de las VMs en la que quieras replicar paquetes.
   • COLLECTOR_BACKEND_SERVICE: el servicio de backend de este balanceador de carga.