Configuración de Traffic Director para una puerta de enlace de entrada

En esta guía, se muestra cómo configurar Traffic Director con una puerta de enlace de entrada.

En esta configuración, un balanceador de cargas de red dirige el tráfico de Internet a la malla de servicios a través de una puerta de enlace de entrada. Un recurso Gateway administra un proxy de Envoy que actúa como una puerta de enlace a la malla de servicios. Una puerta de enlace también se conoce como entrada o proxy intermedio. Los proxies de Envoy implementados para que actúen como una puerta de enlace de entrada son proxies independientes en lugar de un sidecar a una carga de trabajo. De este modo, Envoy escucha en una lista bien definida de direcciones IP y puertos y reenvía el tráfico de acuerdo con las reglas de enrutamiento que configures. Se usa un recurso de API Gateway nuevo para configurar estos clientes de Envoy.

Puerta de enlace de entrada con proxy de Envoy, balanceador de cargas de red y recurso de puerta de enlace
Puerta de enlace de entrada con proxy de Envoy, balanceador de cargas de red y recurso Gateway (haz clic para ampliar)

Configura el enrutamiento para asegurarte de que el tráfico destinado a los proxies Gateway se dirija a las VM que alojan los Envoys. El servicio de entrada se puede vincular con un balanceador de cargas HTTP(S) externo o un balanceador de cargas TCP/UDP interno, pero esas configuraciones no se incluyen en esta configuración de demostración.

En esta guía, no se abarca la comunicación de servicio a servicio y el recurso Mesh detrás de la puerta de enlace.

Requisitos previos

Asegúrate de cumplir los requisitos previos de las siguientes guías:

Configura reglas de firewall

En esta sección, configurarás dos reglas de firewall. Una regla permite sondear la verificación de estado en la red de nube privada virtual. La otra regla permite el tráfico desde cualquier origen a la red.

  1. Configura las reglas de firewall para permitir las verificaciones de estado.

    gcloud compute firewall-rules create allow-gateway-health-checks \
  --network=${VPC_NAME} \
  --direction=INGRESS \
  --action=ALLOW \
  --rules=tcp \
  --source-ranges="35.191.0.0/16,209.85.152.0/22,209.85.204.0/22" \
  --target-tags=gateway-proxy

  2. Configura las reglas de firewall para permitir el tráfico desde cualquier fuente. Edita los comandos para tus puertos y rangos de direcciones IP de origen.

    gcloud compute firewall-rules create allow-gateway-ingress-traffic \
  --network=${VPC_NAME} \
  --direction=INGRESS \
  --action=ALLOW \
  --rules=tcp:80,tcp:443 \
  --source-ranges="0.0.0.0/0" \
  --target-tags=gateway-proxy

Configura los permisos de Identity and Access Management

En esta sección, debes designar la cuenta de servicio para los proxies de puerta de enlace y asignarles los roles correctos de IAM.

  1. Crea una identidad de cuenta de servicio para los proxies de puerta de enlace.

    gcloud iam service-accounts create gateway-proxy

  2. Asigna los roles de IAM necesarios a la identidad de la cuenta de servicio.

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/trafficdirector.client"

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/logging.logWriter"

Configura el recurso Gateway

En esta sección, configurarás el recurso de puerta de enlace.

  1. En un archivo llamado gateway80.yaml, crea la especificación Gateway para el tráfico HTTP.

    cat <<EOF | tee gateway80.yaml
name: gateway80
scope: gateway-proxy
ports:
- 80
type: OPEN_MESH
EOF

  2. Crea el recurso Gateway a partir de la especificación gateway80.yaml:

    gcloud alpha network-services gateways import gateway80 \
    --source=gateway80.yaml \
    --location=global

Crea un grupo de instancias administrado con proxies de Envoy

En esta sección, crearás los proxies de Envoy que están asociados con la puerta de enlace de entrada.

  1. Crea una plantilla de instancias para una VM que ejecute un proxy de servicio de Envoy implementado de forma automática. Los Envoys tienen un alcance de gateway-proxy. No pases el puerto de entrega como un parámetro de --service-proxy.

    gcloud beta compute instance-templates create gateway-proxy \
  --machine-type=n1-standard-1 \
  --boot-disk-size=10GB \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=gateway-proxy \
  --network-interface=network=${VPC_NAME},no-address \
  --service-account="gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
  --service-proxy=enabled,scope=gateway-proxy \

  2. Crea un grupo de instancias administrado regional a partir de la plantilla de instancias.

    gcloud compute instance-groups managed create gateway-proxies-${REGION} \
  --region=${REGION} \
  --size=2 \
  --template=gateway-proxy \
  --target-distribution-shape=EVEN

  3. Configura un puerto con nombre a fin de habilitar la verificación de estado de TCP para el balanceador de cargas de red.

    gcloud compute instance-groups managed set-named-ports \
  gateway-proxies-${REGION} \
  --region=${REGION} \
  --named-ports=healthz:80

  4. Habilita el ajuste de escala automático para el grupo de instancias.

    gcloud compute instance-groups managed set-autoscaling \
  gateway-proxies-${REGION} \
  --region=${REGION} \
  --cool-down-period=60 \
  --min-num-replicas=3 \
  --max-num-replicas=10 \
  --mode=on \
  --target-cpu-utilization=0.6

Configura el balanceo de cargas de red regional

En esta sección, crearás el balanceador de cargas de red, un servicio de backend, una regla de reenvío y una verificación de estado.

  1. Crea el balanceador de cargas de red.

    gcloud compute addresses create xnlb-${REGION} \
  --region=${REGION}

  2. Obtén la dirección IP que está reservada para el balanceador de cargas de red.

    export IP_ADDRESS=$(gcloud compute addresses describe xnlb-${REGION} \
  --region=${REGION} --format='value(address)')

  3. Crea una verificación de estado para los proxies de puerta de enlace.

    gcloud compute health-checks create tcp xnlb-${REGION} \
  --region=${REGION} \
  --port-name=healthz

  4. Crea un servicio de backend para los proxies de puerta de enlace.

    gcloud compute backend-services create xnlb-${REGION} \
  --health-checks=xnlb-${REGION} \
  --health-checks-region=${REGION} \
  --load-balancing-scheme=EXTERNAL \
  --protocol=TCP \
  --region=${REGION} \
  --port-name=healthz

  5. Agrega el grupo de instancias administrado como los backends.

    gcloud compute backend-services add-backend xnlb-${REGION} \
  --instance-group=gateway-proxies-${REGION} \
  --instance-group-region=${REGION} \
  --region=${REGION}

  6. Crea una regla de reenvío que apunte a los proxies de puerta de enlace.

    gcloud compute forwarding-rules create xnlb-${REGION} \
  --region=${REGION} \
  --load-balancing-scheme=EXTERNAL \
  --address=${IP_ADDRESS} \
  --ip-protocol=TCP \
  --ports=80 \
  --backend-service=xnlb-${REGION} \
  --backend-service-region=${REGION}

Configura el servidor HTTP

En esta sección, crearás un servicio de prueba en la malla de servicios.

  1. Crea una plantilla de instancias con un servicio de prueba en el puerto 10000 mediante la utilidad netcat

    gcloud compute instance-templates create tcp-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-9 \
  --image-project=debian-cloud \
  --metadata=startup-script="#! /bin/bash

sudo apt-get update -y
sudo apt-get install apache2 -y
sudo service apache2 restart
echo '<!doctype html><html><body><h1>'\`/bin/hostname\`'</h1></body></html>' | sudo tee /var/www/html/index.html"

  2. Crea un grupo de instancias administrado basado en la plantilla.

    gcloud compute instance-groups managed create tcp-td-mig-us-east1 \
  --zone=us-east1-a \
  --size=1 \
  --template=tcp-td-vm-template

  3. Crea una verificación de estado de HTTP.

    gcloud compute health-checks create http helloworld-health-check

  4. Crea una regla de firewall que permita las conexiones de verificación de estado entrantes a las instancias de tu red.

    gcloud compute firewall-rules create tcp-vm-allow-health-checks \
   --network default \
   --action allow \
   --direction INGRESS \
   --source-ranges 35.191.0.0/16,209.85.152.0/22,209.85.204.0/22 \
   --target-tags allow-health-checks \
   --rules tcp:80

  5. Crea un servicio de backend global con un esquema de balanceo de cargas de INTERNAL_SELF_MANAGED y adjunta la verificación de estado.

    gcloud compute backend-services create tcp-helloworld-service \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=HTTP \
    --health-checks helloworld-health-check

  6. Agrega el grupo de instancias administrado al servicio de backend.

    gcloud compute backend-services add-backend tcp-helloworld-service \
  --instance-group td-mig-us-east1 \
  --instance-group-zone us-east1-a \
  --global

Configura el enrutamiento con HTTPRoute

Ahora tienes un recurso Gateway de Traffic Director y un servicio configurados. A continuación, los conectas mediante un recurso HTTPRoute que asocia un nombre de host con un servicio de backend. El HTTPRoute también hace referencia a Gateway.

  1. En un archivo llamado http_route.yaml, crea la especificación HTTPRoute. La especificación hace referencia a gateway80, que es el recurso Gateway que creaste antes, y apunta al servicio de backend http-helloworld-service.

    name: helloworld-http-route
hostnames:
- helloworld-gce
gateways:
- projects/$PROJECT_NUMBER/locations/global/gateways/gateway80
rules:
- action:
  destinations:
   - serviceName: "projects/$PROJECT_NUMBER/locations/global/backendServices/http-helloworld-service"

  2. Usa la especificación de http_route.yaml para crear el recurso HTTPRoute.

    gcloud alpha network-services http-routes import helloworld-http-route \
    --source=http_route.yaml \
    --location=global

  3. Verifica que puedas acceder al servicio desde un cliente externo a través del balanceador de cargas de red y la Gateway de Traffic Director.

    curl -H "Host: helloworld-gce" ${IP_ADDRESS}