Anthos Service Mesh y Traffic Director ahora son Cloud Service Mesh. Para obtener más información, consulta la Descripción general de Cloud Service Mesh.

Se usó la API de Cloud Translation para traducir esta página.

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

Transferencia de TLS con una puerta de enlace de entrada (haz clic para ampliar)

Antes de comenzar

Asegúrate de completar las tareas que se describen en Prepárate para realizar 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.

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

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.

Crea una identidad de cuenta de servicio para los proxies de puerta de enlace:
```
gcloud iam service-accounts create gateway-proxy
```

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 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
```

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.

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.iam.gserviceaccount.com" \
  --service-proxy=enabled,scope=gateway-proxy

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

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 regional externo

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

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

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

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.

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

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

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

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.

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'

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

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

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

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

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

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

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.

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

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, verificarás que puedas acceder al servicio desde un cliente externo a través del balanceador de cargas de red de transferencia externo y el recurso Gateway de Cloud Service Mesh.

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 devuelven el siguiente error:

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

¿Qué sigue?

Para obtener información sobre cómo enumerar recursos de ruta asociados con un recurso Mesh o Gateway, consulta Enumera recursos Route. Esta función está en vista previa.