Configurar o roteamento de TLS do gateway

Este guia demonstra como configurar um gateway de entrada baseado em proxy do Envoy com recursos Gateway e TLSRoute. Também é possível anexar um recurso TLSRoute.

A implantação configurada é ilustrada no diagrama a seguir. Um balanceador de carga de rede de passagem regional externo direciona o tráfego para proxies do Envoy que atuam como um gateway de entrada. Os proxies do Envoy usam roteamento de passagem de TLS e tráfego direto para servidores HTTPS em execução nas instâncias de VM de back-end.

Passagem de TLS com um gateway de entrada
Passagem de TLS com um gateway de entrada (clique para ampliar)

Antes de começar

Conclua as tarefas descritas em Prepare-se para configurar com o Envoy e as cargas de trabalho sem proxy.

Configurar regras de firewall

Nesta seção, você criará regras de firewall para permitir conexões de verificação de integridade recebidas com instâncias de VM na sua rede.

  1. Criar uma regra 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. Configure regras de firewall para permitir tráfego de qualquer origem. Edite os comandos para suas portas e intervalos de endereços IP de origem.

    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

Configurar as permissões do Gerenciamento de identidade e acesso

Nesta seção, você designará a conta de serviço para os proxies do gateway e atribuirá os papéis do IAM corretos à conta de serviço.

  1. Crie uma identidade de conta de serviço para os proxies de gateway:

    gcloud iam service-accounts create gateway-proxy

  2. Atribua os papéis do IAM necessários à identidade da conta de serviço:

    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"

Configurar o recurso Gateway

  1. Em um arquivo chamado gateway443.yaml, crie a especificação Gateway para o tráfego HTTP:

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

  2. Crie o recurso Gateway usando a especificação gateway443.yaml:

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

Criar um grupo de instâncias gerenciadas com proxies do Envoy

Nesta seção, você cria os proxies do Envoy que estão associados ao gateway de entrada.

  1. Crie um modelo de instância para uma VM que executa um proxy de serviço do Envoy implantado automaticamente. O escopo do Envoys é definido como gateway-proxy. Reprovação a porta de disponibilização como um parâmetro da flag --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

  2. Crie um grupo de instâncias gerenciadas por região a partir do modelo de instância:

    gcloud compute instance-groups managed create gateway-proxy \
  --region=REGION \
  --size=1 \
  --template=gateway-proxy

  3. Defina o nome da porta de exibição para o grupo de instâncias gerenciadas:

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

Configurar o balanceador de carga de rede de passagem regional externo

Nesta seção, você criará o balanceador de carga de rede de passagem externo.

  1. Crie um endereço IP regional e estático externo:

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

  2. Consiga o endereço IP reservado para o balanceador de carga externo:

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

    Esse endereço IP é usado como a variável IP_ADDRESS mais adiante neste guia de configuração.

  3. Crie uma verificação de integridade para os proxies de gateway:

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

  4. Crie um serviço de back-end para os proxies de gateway:

    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. Adicione o grupo de instâncias gerenciadas como o back-end:

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

  6. Crie uma regra de encaminhamento para encaminhar o tráfego para os proxies do gateway:

    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

Configurar um grupo gerenciado de instâncias com um serviço HTTPS

Para fins de demonstração, você cria um serviço de back-end com VMs com escalonamento automático em um grupo de instâncias gerenciadas. As VMs exibem detalhes sobre solicitações da Web usando o protocolo HTTPS na porta 443.

  1. Crie um modelo de instância com um serviço HTTPS exposto na porta 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. Crie um grupo gerenciado de instâncias com base no modelo de instância:

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

  3. Defina o nome da porta de exibição para o grupo de instâncias gerenciadas:

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

  4. Crie uma verificação de integridade:

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

  5. Crie uma regra de firewall para permitir conexões de verificação de integridade de entrada com instâncias na sua rede:

    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. Crie um serviço de back-end global com um esquema de balanceamento de carga de INTERNAL_SELF_MANAGED e adicione a verificação de integridade:

    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. Adicione o grupo de instâncias gerenciadas como um back-end ao serviço de back-end:

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

Configurar o roteamento com um recurso TLSRoute

Nas seções anteriores, você configurou um recurso Gateway e um servidor HTTPS. Em seguida, conecte-os usando um recurso TLSRoute que associa um nome de host SNI a um serviço de back-end.

  1. Em um arquivo chamado tls_route.yaml, crie a especificação 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

    Na instrução anterior, TLSRoute corresponde a example.com como SNI e h2 como ALPN. Se as correspondências forem alteradas da seguinte maneira, TLSRoute corresponderá a SNI ou ALPN:

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

  2. Use a especificação tls_route.yaml para criar o recurso TLSRoute:

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

O Cloud Service Mesh está configurado para balancear a carga do tráfego dos serviços especificado no recurso TLSRoute nos back-ends da instância gerenciada grupo.

Validar a implantação

Nesta seção, você verifica se é possível acessar o serviço de um cliente externo pelo balanceador de carga da rede de passagem e pelo recurso Gateway da Cloud Service Mesh.

  1. Execute o seguinte comando curl para verificar a conectividade HTTP dos serviços de teste que você criou:

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

O comando retorna uma resposta de uma das VMs no grupo gerenciado de instâncias. A saída é esta:

 "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"
  }
}

Verificar com uma verificação negativa

Você também pode fazer uma verificação negativa. Se você executar os comandos nesta seção, a solicitação será descartada porque não corresponde aos critérios de correspondência TLSRoute.

No comando a seguir, a SNI não corresponde a example.com. Portanto, o Gateway rejeita a conexão:

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

No comando a seguir, o ALPN não corresponde a h2 (protocolo HTTP2), então o Gateway rejeita a conexão:

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

No comando a seguir, o cliente está criando uma conexão de texto simples (não criptografado). Portanto, o Gateway rejeita a conexão:

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

Todos os comandos anteriores retornam o seguinte erro:

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

A seguir

  • Para informações sobre como listar recursos de rota associados a um Mesh ou Gateway, consulte Listar recursos Route. Esse recurso está na visualização.