Configura el enrutamiento TLS de la puerta de enlace

En esta guía, se muestra cómo configurar una puerta de enlace de entrada basada en el proxy de Envoy con los recursos Gateway y TLSRoute. También puedes adjuntar un recurso TLSRoute.

La implementación que configuras se ilustra en el siguiente diagrama. Un balanceador de cargas de red de transferencia externo regional dirige el tráfico a los proxies de Envoy que actúan como una puerta de enlace de entrada. Los proxies de Envoy usan el enrutamiento de transferencia de TLS y el tráfico directo a los servidores HTTPS que se ejecutan en las instancias de VM de backend.

Antes de comenzar

Asegúrate de completar las tareas que se describen en Prepárate para la configuración con Envoy y cargas de trabajo sin proxy.

Configura reglas de firewall

En esta sección, crearás reglas de firewall para permitir conexiones de verificación de estado entrantes a instancias de VM en la red.

1. Crea una regla de firewall:

   gcloud compute firewall-rules create allow-gateway-health-checks \
    --network=NETWORK_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=NETWORK_NAME \
     --direction=INGRESS \
     --action=ALLOW \
     --rules=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 asignar los roles de IAM correctos a la cuenta de servicio.

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." \
     --role="roles/trafficdirector.client"
   

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

Configura el recurso Gateway

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

   name: gateway443
   scope: gateway-proxy
   ports:
   - 443
   type: OPEN_MESH
   

2. Crea el recurso Gateway mediante la especificación gateway443.yaml:

   gcloud network-services gateways import gateway443 \
       --source=gateway443.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 el permiso establecido en gateway-proxy. No pases el puerto de entrega como un parámetro de la marca --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=NETWORK_NAME,no-address \
     --service-account="gateway-proxy@PROJECT_ID." \
     --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-proxy \
     --region=REGION \
     --size=1 \
     --template=gateway-proxy
   

3. Establece el nombre del puerto de entrega para el grupo de instancias administrado:

   gcloud compute instance-groups managed set-named-ports gateway-proxy \
     --named-ports=https:443 \
     --region=REGION
   

Configura el balanceador de cargas de red de transferencia externo regional

En esta sección, crearás el balanceador de cargas de red de transferencia externo.

1. Crea una dirección IP regional externa estática:

   gcloud compute addresses create xnlb-REGION \
     --region=REGION
   

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

   gcloud compute addresses describe xnlb-REGION \
     --region=REGION --format='value(address)'
   

   Esta dirección IP se usa como la variable IP_ADDRESS más adelante en esta guía de configuración.

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

   gcloud compute health-checks create tcp xnlb-REGION \
     --region=REGION \
     --use-serving-port
   

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=https
   

5. Agrega el grupo de instancias administrado como backend:

   gcloud compute backend-services add-backend xnlb-REGION \
     --instance-group=gateway-proxy \
     --instance-group-region=REGION \
     --region=REGION
   

6. Crea una regla de reenvío para enrutar el tráfico 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=443 \
     --backend-service=xnlb-REGION \
     --backend-service-region=REGION
   

Configura un grupo de instancias administrado que ejecute un servicio HTTPS

A modo de demostración, crearás un servicio de backend con VM con ajuste de escala automático en un grupo de instancias administrado. Con las VM hacen eco de los detalles de las solicitudes web mediante el protocolo HTTPS en el puerto 443.

1. Crea una plantilla de instancias con un servicio HTTPS que se exponga en el puerto 443:

   gcloud compute instance-templates create td-https-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=https-td-server \
     --image-family=debian-10 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /bin/bash
   
   sudo rm -rf /var/lib/apt/lists/*
   sudo apt-get -y clean
   sudo apt-get -y update
   sudo apt-get -y install apt-transport-https ca-certificates curl gnupg2 software-properties-common
   sudo curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
   sudo add-apt-repository -y "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
   sudo apt-get -y update
   sudo apt-get -y install docker-ce
   sudo which docker
   echo "{ \"registry-mirrors\": [\"https://mirror.gcr.io\"] }" | sudo tee -a /etc/docker/daemon.json
   sudo service docker restart
   sudo docker run -e HTTPS_PORT=9999 -p 443:9999 --rm -dt mendhak/http-https-echo:22'
   

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

   gcloud compute instance-groups managed create https-td-mig-us-REGION \
     --zone=ZONE \
     --size=2 \
     --template=td-https-vm-template
   

3. Configura el nombre del puerto de entrega para el grupo de instancias administrado:

   gcloud compute instance-groups managed set-named-ports https-td-mig-us-REGION \
     --named-ports=https:443 \
     --zone=ZONE
   

4. Crea una verificación de estado de la siguiente forma:

   gcloud compute health-checks create https https-helloworld-health-check \
     --port=443
   

5. 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 https-vm-allow-health-checks \
      --network NETWORK_NAME --action allow --direction INGRESS \
      --source-ranges 35.191.0.0/16,130.211.0.0/22 \
      --target-tags https-td-server \
      --rules tcp:443
   

6. Crea un servicio de backend global con un esquema de balanceo de cargas de INTERNAL_SELF_MANAGED y agrega la verificación de estado:

   gcloud compute backend-services create https-helloworld-service \
     --global \
     --load-balancing-scheme=INTERNAL_SELF_MANAGED \
     --port-name=https \
     --health-checks https-helloworld-health-check
   

7. Agrega el grupo de instancias administrado como backend al servicio de backend:

   gcloud compute backend-services add-backend https-helloworld-service \
     --instance-group=https-td-mig-us-REGION \
     --instance-group-zone=ZONE \
     --global
   

Configura el enrutamiento con un recurso TLSRoute

En las secciones anteriores, configuraste un recurso Gateway y un servidor HTTPS. A continuación, conéctalos mediante un recurso TLSRoute que asocie un nombre de host de SNI con un servicio de backend.

1. En un archivo llamado tls_route.yaml, crea la especificación TLSRoute:

   name: helloworld-tls-route
   gateways:
   - projects/PROJECT_NUMBER/locations/global/gateways/gateway443
   rules:
   - matches:
     - sniHost:
       - example.com
       alpn:
       - h2
     action:
      destinations:
      - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/https-helloworld-service
   

   En la instrucción anterior, TLSRoute coincide con example.com como SNI y h2 como ALPN. Si las coincidencias se cambian como se muestra a continuación, TLSRoute coincide con SNIo con ALPN:

   - matches:
     - sniHost:
       - example.com
     - alpn:
       - h2
   

2. Usa la especificación de tls_route.yaml para crear el recurso TLSRoute:

   gcloud network-services tls-routes import helloworld-tls-route \
       --source=tls_route.yaml \
       --location=global
   

Cloud Service Mesh está configurado para balancear las cargas del tráfico de los servicios especificados en el recurso TLSRoute en los backends del grupo de instancias administrado.

Valida la implementación

En esta sección, debes verificar que puedes acceder al servicio desde un cliente externo a través del balanceador de cargas de red de transferencia externo y el recurso Gateway de la malla de servicios de Cloud.

1. Ejecuta el siguiente comando de curl para verificar la conectividad HTTP a los servicios de prueba que creaste:

   curl https://example.com --resolve example.com:443:IP_ADDRESS -k
   

El comando muestra una respuesta de una de las VM del grupo de instancias administrado. Este es el resultado:

 "path": "/",
  "headers": {
    "host": "example.com",
    "user-agent": "curl/7.81.0",
    "accept": "*/*"
  },
  "method": "GET",
  "body": "",
  "fresh": false,
  "hostname": "example.com",
  "ip": "::ffff:10.142.0.2",
  "ips": [],
  "protocol": "https",
  "query": {},
  "subdomains": [],
  "xhr": false,
  "os": {
    "hostname": "0cd3aec9b351"
  },
  "connection": {
    "servername": "example.com"
  }
}

Verifica con una verificación negativa

También puedes ejecutar una verificación negativa. Si ejecutas los comandos de esta sección, la solicitud se descarta porque no coincide con los criterios de coincidencia de TLSRoute.

En el siguiente comando, la SNI no coincide con example.com, por lo que Gateway rechaza la conexión:

curl https://invalid-server.com --resolve invalid-server.com:443:IP_ADDRESS -k

En el siguiente comando, ALPN no coincide con h2 (protocolo HTTP2), por lo que Gateway rechaza la conexión:

curl https://example.com --resolve example.com:443:IP_ADDRESS -k --http1.1

En el siguiente comando, el cliente crea una conexión de texto sin formato (sin encriptar), por lo que Gateway rechaza la conexión:

curl example.com:443 --resolve example.com:443:IP_ADDRESS -k

Todos los comandos anteriores muestran el siguiente error:

curl: (35) OpenSSL SSL_connect: Connection reset by peer in connection.

¿Qué sigue?

• Para obtener información sobre cómo mostrar una lista de recursos de ruta asociados con un recurso Mesh o Gateway, consulta Cómo mostrar una lista de recursos Route.