Prepararse para la configuración del balanceo de cargas de HTTP(S) interno

La configuración del balanceo de cargas HTTP(S) interno tiene dos fases:

  • Realizar tareas de requisitos previos, como garantizar que las cuentas requeridas tengan los permisos correctos y preparar la red de VPC
  • Configurar los recursos del balanceador de cargas

En esta guía, se describe cómo configurar los requisitos previos. Las guías adicionales describen cómo configurar los recursos de balanceo de cargas.

Antes de seguir con esta guía, familiarízate con lo siguiente:

Permisos

Para seguir esta guía, debes poder crear instancias y modificar una red en un proyecto. Debes ser propietario o editor de un proyecto o tener todas las siguientes funciones de IAM de Compute Engine:

Tarea Función requerida
Crear redes, subredes y componentes del balanceador de cargas Administrador de la red
Agregar y quitar reglas de firewall Administrador de seguridad
Crea instancias Administrador de instancias

Descripción general de la configuración

Puedes configurar el balanceo de cargas HTTP(S) interno como se describe en el siguiente flujo de configuración de alto nivel. Los pasos numerados se refieren a los números en el diagrama.

Componentes numerados de balanceo de cargas HTTP(S) interno (haz clic para ampliar)
Componentes numerados de balanceo de cargas HTTP(S) interno (haz clic para ampliar)

Como se muestra en el diagrama, este ejemplo crea un balanceador de cargas HTTP(S) interno en una red de VPC en la región us-west1, con un servicio de backend y dos grupos de backend.

El diagrama muestra lo siguiente:

  1. Una red de VPC con dos subredes:

    1. Una subred se usa para backends (grupos de instancias y NEG) y la regla de reenvío. Su rango de direcciones IP principal es 10.1.2.0/24.

    2. Una subred es una subred de solo proxy en la región us-west1. Debes crear una subred de solo proxy en cada región de una red de VPC en la que uses balanceadores de cargas HTTP(S) internos. La subred de solo proxy de la región se comparte entre todos los balanceadores de cargas HTTP(S) internos de la región. Las direcciones de origen de los paquetes enviados desde el balanceador de cargas HTTP(S) interno a los backends de tu servicio se asignan desde la subred de solo proxy. En este ejemplo, la subred de solo proxy para la región tiene un rango de direcciones IP principal de 10.129.0.0/26. Para obtener más información, consulta Subredes de solo proxy para balanceadores de cargas HTTP(S) internos.

  2. Reglas de firewall que permiten los flujos de tráfico deseados en tu red. Esto incluye agregar una regla que permita el tráfico del puerto TCP 80, 443 y 8000 desde 10.129.0.0/26 (el rango de la subred de solo proxy en este ejemplo) y otra regla para el sondeo de verificación de estado.

  3. Instancias de backend. Este ejemplo muestra las siguientes implementaciones de backend:

    1. VM de Google Compute Engine
    2. Backends de Google Kubernetes Engine (GKE) agregados a los grupos de extremo de red (NEG)
  4. Grupos de instancias y NEG:

    1. Grupos de instancias administrados o no administrados para implementaciones de VM de Compute Engine
    2. NEG para implementaciones de GKE

    En cada zona, puedes tener una combinación de tipos de grupo de backend según los requisitos de tu implementación.

  5. Una verificación de estado regional que informa la preparación de tus backends.

  6. Un servicio de backend regional que supervisa el uso y el estado de los backends.

  7. Un mapa de URL regional que analiza la URL de una solicitud y reenvía las solicitudes a servicios de backend específicos en función del host y la ruta de acceso de la URL de la solicitud.

  8. Un proxy HTTP o HTTPS de destino regional, que recibe una solicitud del usuario y la reenvía al mapa de URL. Para HTTPS, configura un recurso de certificado SSL regional. El proxy de destino desencripta el tráfico SSL mediante el uso del certificado SSL si configuras el balanceo de cargas HTTPS. El proxy de destino puede reenviar tráfico a tus instancias a través de HTTP o HTTPS.

  9. Una regla de reenvío, que tiene la dirección IP interna de tu balanceador de cargas, para reenviar cada solicitud entrante al proxy de destino.

Configura la red y las subredes

Necesitas una red de VPC con dos subredes: una para los backends del balanceador de cargas y la otra para los proxies del balanceador de cargas. Un balanceador de cargas HTTP(S) interno es regional. El tráfico dentro de la red de VPC se enruta al balanceador de cargas si la fuente de tráfico está en una subred en la misma región que el balanceador de cargas.

Este ejemplo usa la siguiente red de VPC, región y subredes:

  • Red: es una red de VPC de modo personalizado llamada lb-network.

  • Subred para backends: una subred llamada backend-subnet en la región us-west1 usa 10.1.2.0/24 para su rango de IP principal.

  • Subred para proxies: una subred llamada proxy-subnet en la región us-west1 usa 10.129.0.0/26 para su rango de IP principal.

Configura la red y la subred para los backends

Console

  1. Ve a la página Redes de VPC en Google Cloud Platform Console.
    Ve a la página Red de VPC
  2. Haz clic en Crear red de VPC.
  3. Ingresa un Nombre de lb-network.
  4. En la sección Subredes, realiza lo siguiente:
    • Configura el Modo de creación de subred como Personalizado.
    • En la sección Subred nueva, ingresa la siguiente información:
      • Nombre: backend-subnet
      • Región: us-west1
      • Rango de direcciones IP: 10.1.2.0/24
      • Haz clic en Listo.
  5. Haz clic en Crear.

gcloud

  1. Crea la red de VPC personalizada con el comando gcloud compute networks create:

    gcloud compute networks create lb-network --subnet-mode=custom
    
  2. Crea una subred en la red lb-network en la región us-west1 con el comando gcloud compute networks subnets create:

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

api

Realiza una solicitud POST al método networks.insert y reemplaza [project-id] con tu ID del proyecto.

POST https://www.googleapis.com/compute/v1/projects/[project-id]/global/networks
{
  "routingConfig": {
    "routingMode": "REGIONAL"
  },
  "name": "lb-network",
  "autoCreateSubnetworks": false
}

Realiza una solicitud POST al método subnetworks.insert y reemplaza [project-id] con tu ID del proyecto.

POST https://www.googleapis.com/compute/v1/projects/[project-id]/regions/us-west1/subnetworks
{
  "name": "backend-subnet",
  "network": "projects/[project-id]/global/networks/lb-network",
  "ipCidrRange": "10.1.2.0/24",
  "region": "projects/[project-id]/regions/us-west1",
}

Configura la subred de solo proxy

La subred de solo proxy es para todos los balanceadores de cargas HTTP(S) internos en la región us-west1.

Console

Si usas GCP Console, puedes esperar y crear la subred de solo proxy en la IU de balanceo de cargas. Consulta Continuación del proceso de configuración.

gcloud

Crea la subred de solo proxy con el comando gcloud compute networks subnets create.

gcloud beta compute networks subnets create proxy-subnet \
  --purpose=INTERNAL_HTTPS_LOAD_BALANCER \
  --role=ACTIVE \
  --region=us-west1 \
  --network=lb-network \
  --range=10.129.0.0/26

api

Crea la subred de solo proxy con el método subnetworks.insert y reemplaza [project-id] con tu ID del proyecto.

POST https://www.googleapis.com/compute/projects/[project-id]/regions/us-west1/subnetworks
{
  "name": "proxy-subnet",
  "ipCidrRange": "10.129.0.0/26",
  "network": "projects/[project-id]/global/networks/lb-network",
  "region": "projects/[project-id]/regions/us-west1",
  "purpose": "INTERNAL_HTTPS_LOAD_BALANCER",
  "role": "ACTIVE"
}

Configura las reglas de firewall

En este ejemplo, se usan las siguientes reglas de firewall:

  • fw-allow-backend-subnet: una regla de entrada, aplicable a todos los objetivos en la red de VPC, que permite el tráfico de TCP, ICMP y UDP de fuentes en el rango 10.1.2.0/24. Esta regla permite el tráfico entrante desde cualquier fuente dentro de backend-subnet a las instancias (VM) en las que se aplica el balanceo de cargas. El ejemplo muestra la regla de firewall aplicada a todas las instancias de la red. Alternativamente, puedes aplicar la regla solo a los backends reales del balanceador de cargas.

  • fw-allow-ssh: una regla de entrada, aplicable a las instancias en las que se realiza el balanceo de cargas, que permite la conectividad SSH entrante en el puerto TCP 22 desde cualquier dirección. Puedes elegir un rango de IP de origen más restrictivo para esta regla; por ejemplo, puedes especificar solo los rangos de IP del sistema desde el que inicias sesiones SSH. En este ejemplo, se usa la etiqueta de destino allow-ssh para identificar las VM a las que se aplica la regla de firewall.

  • fw-allow-health-check: una regla de entrada, aplicable a las instancias en las que se realiza el balanceo de cargas, que permite todo el tráfico de TCP de los sistemas de verificación de estado de GCP (en 130.211.0.0/22 y 35.191.0.0/16). En este ejemplo, se usa la etiqueta de destino load-balanced-backend para identificar las instancias a las que debe aplicarse.

  • fw-allow-proxies: una regla de entrada, aplicable a las instancias en las que se realiza el balanceo de cargas, que permite el tráfico de TCP en los puertos 80, 443 y 8000 desde los proxies administrados del balanceador de cargas HTTP(S) interno. En este ejemplo, se usa la etiqueta de destino load-balanced-backend para identificar las instancias a las que debe aplicarse.

Sin estas reglas de firewall, la regla predeterminada de denegación de entrada bloquea el tráfico entrante a las instancias de backend.

Console

  1. Ve a la página Reglas de firewall en Google Cloud Platform Console.
    Ir a la página Reglas de firewall
  2. Haz clic en Crear regla de firewall y, luego, ingresa la siguiente información para crear la regla a fin de permitir el tráfico de subred:
    • Nombre: fw-allow-backend-subnet
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: todas las instancias de la red
    • Filtro de origen: IP ranges
    • Rangos de IP de origen: 10.1.2.0/24
    • Protocolos y puertos: Selecciona puertos y protocolos especificados, y marca tcp, icmp y udp.
  3. Haz clic en Crear.
  4. Vuelve a hacer clic en Crear regla de firewall para crear la regla que permita conexiones SSH entrantes:
    • Nombre: fw-allow-ssh
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: allow-ssh
    • Filtro de origen: IP ranges
    • Rangos de IP de origen: 0.0.0.0/0
    • Protocolos y puertos: Selecciona Protocolos y puertos especificados, marca tcp y, luego ingresa 22 para el número de puerto.
  5. Haz clic en Crear.
  6. Haz clic en Crear regla de firewall por tercera vez a fin de crear la regla para permitir las verificaciones de estado de GCP:
    • Nombre: fw-allow-health-check
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: load-balanced-backend
    • Filtro de origen: IP ranges
    • Rangos de IP de origen: 130.211.0.0/22 y 35.191.0.0/16
    • Protocolos y puertos: Selecciona Protocolos y puertos especificados y marca tcp (elige un conjunto de puertos si lo prefieres)
  7. Haz clic en Crear.
  8. Haz clic en Crear regla de firewall por cuarta vez para crear la regla para permitir que los servidores proxy del balanceador de cargas conecten los backends:
    • Nombre: fw-allow-proxies
    • Red: lb-network
    • Dirección del tráfico: entrada
    • Acción si hay coincidencia: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de destino: load-balanced-backend
    • Filtro de origen: IP ranges
    • Rangos de IP de origen: 10.129.0.0/26
    • Protocolos y puertos: Selecciona Protocolos y puertos especificados, marca tcp y, luego, ingresa 80, 443, 8000 para los números de puerto.
  9. Haz clic en Crear.

gcloud

  1. Crea la regla de firewall fw-allow-backend-subnet para permitir la comunicación desde la subred con el comando gcloud compute firewall-rules create.

    gcloud compute firewall-rules create fw-allow-backend-subnet \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --source-ranges=10.1.2.0/24 \
        --rules=tcp,udp,icmp
    
  2. Crea la regla de firewall fw-allow-ssh para permitir la conectividad SSH a las VM con la etiqueta de red allow-ssh. Cuando omites source-ranges, GCP interpreta que la regla significa 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 las verificaciones de estado de GCP. Este ejemplo permite todo el tráfico de TCP proveniente de la verificación de estado. Sin embargo, puedes configurar un conjunto más limitado de puertos para satisfacer tus necesidades.

    gcloud compute firewall-rules create fw-allow-health-check \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --source-ranges=130.211.0.0/22,35.191.0.0/16 \
        --target-tags=load-balanced-backend \
        --rules=tcp
    
  4. Crea la regla fw-allow-proxies para permitir que los proxies del balanceador de cargas HTTP(S) interno se conecten a tus backends.

    gcloud compute firewall-rules create fw-allow-proxies \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=10.129.0.0/26 \
      --target-tags=load-balanced-backend \
      --rules=tcp:80,tcp:443,tcp:8000
    

api

Crea la regla de firewall fw-allow-backend-subnet mediante una solicitud POST al método firewalls.insert y reemplaza [project-id] con tu ID del proyecto.

POST https://www.googleapis.com/compute/v1/projects/[project-id]/global/firewalls
{
  "name": "fw-allow-backend-subnet",
  "network": "projects/[project-id]/global/networks/lb-network",
  "sourceRanges": [
    "10.1.2.0/24"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS"
}

Crea la regla de firewall fw-allow-ssh mediante una solicitud POST al método firewalls.insert y reemplaza [project-id] con tu ID del proyecto.

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

Crea la regla de firewall fw-allow-health-check mediante una solicitud POST al método firewalls.insert y reemplaza [project-id] con tu ID del proyecto.

POST https://www.googleapis.com/compute/v1/projects/[project-id]/global/firewalls
{
  "name": "fw-allow-health-check",
  "network": "projects/[project-id]/global/networks/lb-network",
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    }
  ],
  "direction": "INGRESS"
}

Crea la regla de firewall fw-allow-proxies para permitir el tráfico de TCP dentro de la subred de proxy del método firewalls.insert y reemplaza [project-id] con tu ID del proyecto.

POST https://www.googleapis.com/compute/v1/projects/{project}/global/firewalls
{
  "name": "fw-allow-proxies",
  "network": "projects/[project-id]/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/26"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8000"
      ]
    }
  ],
  "direction": "INGRESS"
}

Continuación del proceso de configuración

Para configurar el balanceo de cargas HTTP(S) interno, usa uno de los siguientes procedimientos, según si tus servicios de backend se ejecutan en VM de Compute Engine o pods de GKE:

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...