Configura el balanceo de cargas de HTTP(S) interno para los pods de GKE

En este documento, se proporcionan instrucciones a fin de configurar el balanceo de cargas de HTTP(S) interno para los servicios que se ejecutan en pods de Google Kubernetes Engine (GKE).

Antes de comenzar

Antes de seguir las instrucciones de esta guía, revisa los documentos siguientes:

Configura el balanceo de cargas de HTTP(S) interno con un servicio basado en GKE

En esta sección, se muestra la configuración requerida para los servicios que se ejecutan en pods de GKE. Las VM cliente se conectan a la dirección IP y al puerto que configuras en la regla de reenvío. Cuando las aplicaciones cliente envían tráfico a esta dirección IP y al puerto, sus solicitudes se reenvían a tus pods de GKE de backend según el mapa de URL del balanceador de cargas de HTTP(S) interno.

El ejemplo en esta página configura de manera explícita una dirección IP interna reservada para la regla de reenvío interno, en lugar de permitir que se asigne una dirección IP interna efímera. Esta es la práctica recomendada para las reglas de reenvío.

Configura backends: clúster de GKE

En esta sección, se crea un clúster de demostración de GKE y una implementación a fin de ejecutar un contenedor simple que ejecute un servidor web simple que entregue el nombre de host del nodo. También se crea un servicio ClusterIP, que crea un NEG de forma automática.

Console

Para crear un clúster con GCP Console, sigue los pasos siguientes:

  1. Dirígete al menú de Google Kubernetes Engine en GCP Console.

    Ir al menú de Google Kubernetes Engine

  2. Haz clic en Crear clúster.

  3. En el campo Nombre, ingresa l7-ilb-cluster.

  4. Para el Tipo de ubicación, selecciona Zonal.

  5. Para la Zona, selecciona us-west1-b.

  6. Elige la Versión principal predeterminada.

  7. Expande la sección Disponibilidad, Herramientas de redes, seguridad y características adicionales.

    1. Asegúrate de que la casilla Habilitar VPC nativa (con un alias de IP) esté marcada.
    2. Para la Red, selecciona lb-network.
    3. Para la Subred del nodo, selecciona backend-subnet.
    4. Asegúrate de que el Balanceo de cargas esté habilitado. Para ello, marca la casilla junto a Enable HTTP load balancing.
  8. Para los campos restantes, mantén los valores predeterminados o modifícalos según tus necesidades.

  9. Haz clic en Crear.

Cuando usas GCP Console para crear el clúster, debes agregar la etiqueta de red generada por el sistema al filtro de firewall de proxy:

  1. Busca la etiqueta de red que GKE agregó a los nodos en el clúster. Se generará la etiqueta a partir del hash del clúster.

    1. Ve a la página Instancias de VM.

      Ir a la página Instancias de VM

    2. En el menú desplegable Columnas, selecciona Etiquetas de red.

    3. Copia la etiqueta de red para los nodos de GKE. Esta debería ser similar a la que se muestra a continuación:

      gke-l7-ilb-cluster-id-node
      
  2. Edita la regla de firewall fw-allow-proxies y agrega la etiqueta.

    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 la regla de firewall fw-allow-proxies y, luego, en Editar.
    3. En el campo Etiquetas de destino, agrega la etiqueta de red que copiaste en el paso anterior.
    4. Haz clic en Guardar.

gcloud

  1. Crea un clúster de GKE con el comando gcloud container clusters create.

    gcloud container clusters create l7-ilb-cluster \
      --zone=us-west1-b \
      --network=lb-network \
      --subnetwork=backend-subnet \
      --enable-ip-alias \
      --tags=allow-ssh,load-balanced-backend
    

api

Crea un clúster de GKE con el método projects.zones.clusters.create y reemplaza [project-id] por el ID de tu proyecto.

POST https://container.googleapis.com/v1beta1/projects/<var>[project-id]</var>/zones/us-west1-b/clusters
{
  "cluster": {
    "name": "l7-ilb-cluster",
    "network": "projects/<var>[project-id]</var>/global/networks/lb-network1",
    "subnetwork": "projects/<var>[project-id]</var>/regions/us-west1/subnetworks/backend-subnet1",
    "initialClusterVersion": "1.11",
    "location": "us-west1-b",
    "nodePools": [{
      "name": "l7-ilb-node-pool",
      "initialNodeCount": 3
    }],
    "nodeConfig":{
       "tags":["allow-ssh","load-balanced-backend"]
    }
    "defaultMaxPodsConstraint": {
      "maxPodsPerNode": "110"
    },
    "ipAllocationPolicy": {
      "useIpAliases": True
    }
  }
}

Obtén credenciales para operar el clúster

Usa el comando gcloud container clusters get-credentials.

gcloud container clusters get-credentials l7-ilb-cluster \
    --zone=us-west1-b

Define una implementación con contenedores de prueba que entreguen su nombre de host

Crea hostname.yaml con la implementación y la especificación de servicio.

cat << EOF > hostname.yaml
apiVersion: v1
kind: Service
metadata:
  name: hostname
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"80":{}}}'
spec:
  ports:
  - port: 80
    name: host1
    protocol: TCP
    targetPort: 8000
  selector:
    run: hostname
  type: ClusterIP

---

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    run: hostname
  name: hostname
spec:
  replicas: 3
  template:
    metadata:
      labels:
        run: hostname
    spec:
      containers:
      - image: gcr.io/kubernetes-e2e-test-images/serve-hostname-amd64:1.1
        name: host1
        command:
        - /bin/sh
        - -c
        - /serve_hostname -http=true -udp=false -port=8000
        ports:
        - protocol: TCP
          containerPort: 8000
EOF

Aplica la configuración

kubectl apply -f hostname.yaml

Verifica la implementación y la configuración de GKE

Asegúrate de que se cree el nombre de host del servicio nuevo y que el pod de aplicación se ejecute.

kubectl get svc

El resultado de ejemplo es el que se muestra a continuación:

NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
hostname     ClusterIP   10.71.9.71           80/TCP    41m
[..skip..]

Ten en cuenta que la dirección IP de tu clúster puede que sea diferente, ya que GKE crea de forma automática el rango de IP del clúster como un rango de IP secundario en la backend-subnet.

Si el comando kubectl get svc falla con problemas de credenciales/OAuth, ejecuta el comando gcloud auth application-default login.

kubectl get pods

El resultado de ejemplo es el que se muestra a continuación:

NAME                        READY     STATUS    RESTARTS   AGE
hostname-6db459dcb9-896kh   1/1       Running   0          33m
hostname-6db459dcb9-k6ddk   1/1       Running   0          50m
hostname-6db459dcb9-x72kb   1/1       Running   0          33m
[..skip..]

Ten en cuenta que los nombres de tus pods son diferentes.

Deberías ver que se creó el nombre de host del servicio nuevo y que se ejecutan los pods para la aplicación de nombre de host.

Obtén el nombre del NEG

  1. Busca el nombre de la NEG mediante el comando gcloud compute network-endpoint-groups list y filtra por la zona del clúster y el nombre de la implementación:

    gcloud compute network-endpoint-groups list \
       --filter="us-west1-b AND hostname" \
       --format="get(name)"
    

Examina la configuración NEG

  1. Examina los detalles y enumera los extremos en el NEG con los comandos gcloud compute network-endpoint-groups list-network-endpoints y gcloud compute network-endpoint-groups describe, y reemplaza neg-name por el nombre del NEG que creaste.

    gcloud compute network-endpoint-groups describe neg-name \
       --zone=us-west1-b
    
    gcloud compute network-endpoint-groups list-network-endpoints neg-name \
       --zone=us-west1-b
    

Configura el balanceador de cargas para GKE

En el ejemplo, se muestran las siguientes tareas de configuración del balanceador de cargas de HTTP(S) interno:

  • Crea una verificación de estado con el protocolo HTTP.
  • Crea un servicio de backend con administración interna y regional.
  • Agrega el NEG como un backend al servicio de backend.
  • Crea un mapa de URL.
    • Asegúrate de hacer referencia a un mapa de URL regional si se define una región para el proxy HTTP(S) de destino. Un mapa de URL regional enruta las solicitudes a un servicio de backend regional en función de las reglas que definas para el host y la ruta de acceso de una URL nueva. Una regla de proxy de destino regional solo en la misma región puede hacer referencia a un mapa de URL regional.
  • Crea un proxy de destino.
  • Crea una regla de reenvío.

Console

Selecciona un tipo de balanceador de cargas

  1. Ve a la página Balanceo de cargas de Google Cloud Platform Console.
    Ir a la página Balanceo de cargas
  2. Haz clic en Crear balanceador de cargas.
  3. En Balanceo de cargas de HTTP(S), haz clic en Iniciar configuración.
  4. Selecciona Solo entre mis VM. Esta configuración implica que el balanceador de cargas es interno.
  5. Haz clic en Continuar.

Prepara el balanceador de cargas

  1. Para el Nombre del balanceador de cargas, ingresa l7-ilb-gke-map.
  2. Asegúrate de que el Protocolo sea HTTP.
  3. Para la Región, selecciona us-west1.
  4. Para la Red de VPC, selecciona lb-network.
  5. Mantén la ventana abierta para continuar.

Reserva una subred de solo proxy

Para el balanceo de cargas de HTTP(S) interno, sigue estos pasos y reserva una subred proxy:

  1. Haz clic en Reservar una subred.
  2. Para el Nombre, ingresa proxy-subnet.
  3. Para la Red, selecciona lb-network.
  4. Para la Región, selecciona us-west1.
  5. Para el Rango de direcciones IP, ingresa 10.129.0.0/26.
  6. Haz clic en Agregar.

Configura el servicio de backend

  1. Haz clic en Configuración de backend.
  2. En el menú Crear o seleccionar servicios de backend, selecciona Crear un servicio de backend.
  3. Establece el Nombre del servicio de backend en l7-ilb-gke-backend-service.
  4. En Tipo de backend, selecciona Grupos de extremos de red.
  5. En la tarjeta de Nuevo backend de la sección Backends, sigue estos pasos:
    1. Configura el Grupo de extremos de red en el NEG que GKE creó. Consulta Obtén el nombre del NEG para saber cómo determinar su nombre.
    2. Ingresa una tasa máxima de 5 RPS por extremo. GCP excederá este máximo si es necesario.
    3. Haz clic en Listo.
  6. En la sección Verificación de estado, elige Crear una verificación de estado con los parámetros siguientes:
    1. Nombre: l7-ilb-gke-basic-check
    2. Protocolo: HTTP
    3. Especificación de puerto: puerto de servicio
    4. Haz clic en Guardar y continuar.
  7. Haz clic en Crear.

Configura el mapa de URL

  1. Haz clic en Reglas de host y ruta. Asegúrate de que l7-ilb-gke-backend-service sea el único servicio de backend para cualquier host y ruta de acceso no coincidentes.

Configura los componentes del frontend

  1. Haz clic en Configuración de frontend y edita la sección IP y puerto de frontend nuevos.
  2. Establece el Nombre en l7-ilb-gke-forwarding-rule.
  3. Establece el Protocolo en HTTP.
  4. Establece la Subred en backend-subred.
  5. Elige Reservar una dirección IP interna estática en el botón emergente de la IP interna.
  6. En el panel que aparece, proporciona los detalles siguientes:
    1. En el campo Nombre, ingresa l7-ilb-gke-ip.
    2. En la sección Dirección IP estática, selecciona Permitirme elegir.
    3. En la sección Dirección IP personalizada, ingresa 10.1.2.199.
    4. Haz clic en Reservar.
  7. Establece el Puerto en 80.
  8. Haz clic en Listo.

Completa la configuración

  1. Haz clic en Crear.

gcloud

  1. Define la verificación de estado de HTTP con el comando gcloud compute health-check create http.

    gcloud beta compute health-checks create http l7-ilb-gke-basic-check \
    --region=us-west1 \
    --use-serving-port
    
  2. Define el servicio de backend con el comando gcloud compute backend-services create.

    gcloud beta compute backend-services create l7-ilb-gke-backend-service \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --protocol=HTTP \
    --health-checks=l7-ilb-gke-basic-check \
    --health-checks-region=us-west1 \
    --region=us-west1
    
  3. Agrega backends de NEG al servicio de backend con el comando gcloud compute backend-services add-backend.

    gcloud beta compute backend-services add-backend l7-ilb-gke-backend-service \
     --network-endpoint-group=neg-name \
     --network-endpoint-group-zone=us-west1-b \
     --region=us-west1 \
     --balancing-mode=RATE \
     --max-rate-per-endpoint=5
    
  4. Crea el mapa de URL con el comando gcloud compute url-maps create.

    gcloud beta compute url-maps create l7-ilb-gke-map \
    --default-service=l7-ilb-gke-backend-service \
    --region=us-west1
    
  5. Crea el proxy de destino con el comando gcloud compute target-http-proxies create.

    gcloud beta compute target-http-proxies create l7-ilb-gke-proxy \
    --url-map=l7-ilb-gke-map \
    --url-map-region=us-west1 \
    --region=us-west1
    
  6. Crea la regla de reenvío con el comando gcloud compute forwarding-rules create.

    Para las redes personalizadas, debes hacer referencia a la subred en la regla de reenvío. Ten en cuenta que esta es la subred de VM, no la subred de proxy.

    gcloud beta compute forwarding-rules create l7-ilb-gke-forwarding-rule \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --network=lb-network \
    --subnet=backend-subnet \
    --address=10.1.2.199 \
    --ports=80 \
    --region=us-west1 \
    --target-http-proxy=l7-ilb-gke-proxy \
    --target-http-proxy-region=us-west1
    

api

Crea la verificación de estado mediante una solicitud POST al método healthChecks.insert y reemplaza [project-id] por el ID de tu proyecto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/global/healthChecks
{
  "name": "l7-ilb-gke-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Crea el servicio de backend regional mediante una solicitud POST al método regionBackendServices.insert y reemplaza [project-id] por el ID de tu proyecto y [neg-name] por el nombre del NEG que creaste.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/regions/us-west1/backendServices
{
  "name": "l7-ilb-gke-backend-service",
  "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/[project-id]/zones/us-west1-b/networkEndpointGroups/[neg-name]",
      "balancingMode": "RATE"
      "maxRatePerEndpoint": 5
    }
  ],
  "healthChecks": [
    "projects/[project-id]/global/healthChecks/l7-ilb-gke-basic-check"
  ],
  "loadBalancingScheme": "INTERNAL_MANAGED"
}

Crea el mapa de URL mediante una solicitud POST al método urlMap.insert y reemplaza [project-id] por el ID de tu proyecto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/global/urlMaps
{
  "name": "l7-ilb-gke-map",
  "defaultService": "projects/[project-id]/regions/us-west1/backendServices/l7-ilb-gke-backend-service"
}

Crea el proxy HTTP de destino mediante una solicitud POST al método targetHttpProxies.insert y reemplaza [project-id] por el ID de tu proyecto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/regions/us-west1/targetHttpProxy
{
  "name": "l7-ilb-gke-proxy",
  "urlMap": "projects/[project-id]/global/urlMaps/l7-ilb-gke-map",
  "region": "us-west1"
}

Crea la regla de reenvío mediante una solicitud POST al método forwardingRules.insert y reemplaza [project-id] por el ID de tu proyecto.

POST https://www.googleapis.com/compute/beta/projects/[project-id]/regions/us-west1/forwardingRules
{
  "name": "l7-ilb-gke-forwarding-rule",
  "IPAddress": "10.1.2.199",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/[project-id]/regions/us-west1/targetHttpProxies/l7-ilb-gke-proxy",
  "loadBalancingScheme": "INTERNAL_MANAGED",
  "subnetwork": "projects/[project-id]/regions/us-west1/subnetworks/backend-subnet",
  "network": "projects/[project-id]/global/networks/lb-network",
  "networkTier": "PREMIUM",
}

Realiza pruebas

Crea una instancia de VM en la zona para probar la conectividad

gcloud compute instances create l7-ilb-client-us-west1-b \
    --image-family=debian-9 \
    --image-project=debian-cloud \
    --zone=us-west1-b \
    --network=lb-network \
    --subnet=backend-subnet \
    --tags=l7-ilb-client

Permite el acceso SSH a la instancia

gcloud compute firewall-rules create allow-ssh-to-l7-ilb-client \
    --network=lb-network \
    --target-tags=l7-ilb-client \
    --allow=tcp:22

Prueba el balanceador de cargas

Accede a la instancia cliente para verificar que los servicios HTTP(S) en los backends sean accesibles mediante la dirección IP de la regla de reenvío del balanceador de cargas de HTTP(S) interno y que las cargas del tráfico se balanceen en los extremos del NEG.

Conéctate mediante SSH a cada instancia cliente

gcloud compute ssh l7-ilb-client-us-west1-b \
    --zone=us-west1-b

Verifica que la IP entregue su nombre de host

curl 10.1.2.199

Ejecuta 100 solicitudes y confirma que sus cargas estén balanceadas

{
RESULTS=
for i in {1..100}
do
    RESULTS="$RESULTS:$(curl --silent 10.1.2.199)"
done
echo "***"
echo "*** Results of load-balancing to 10.1.2.199: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Ten en cuenta que varios proxies realizan el balanceo de cargas, uno para cada comando curl, y que no coordinan su selección de backends. Por lo tanto, en esta prueba, los backends no reciben la misma cantidad de solicitudes. Sin embargo, a largo plazo (en otras palabras, miles o millones de solicitudes), la fracción de solicitudes recibidas por cada backend se aproxima a una distribución equitativa.

Próximos pasos