Configurer le routage TLS d'une passerelle

Ce guide explique comment configurer une passerelle d'entrée basée sur un proxy Envoy avec des ressources Gateway et TLSRoute. Vous pouvez également joindre une ressource TLSRoute.

Le déploiement que vous configurez est illustré dans le schéma suivant. Un équilibreur de charge réseau passthrough externe régional dirige le trafic vers les proxys Envoy qui agissent en tant que passerelle d'entrée. Les proxys Envoy utilisent le routage de la transmission TLS et dirigent le trafic vers les serveurs HTTPS exécutés sur les instances de VM backend.

Transmission TLS avec une passerelle d'entrée
Transmission TLS avec une passerelle d'entrée (cliquez pour agrandir)

Avant de commencer

Assurez-vous d'effectuer les tâches décrites dans la section Préparer la configuration avec Envoy et les charges de travail sans proxy.

Configurer des règles de pare-feu

Dans cette section, vous allez créer des règles de pare-feu pour autoriser les connexions de vérification d'état entrantes aux instances de VM de votre réseau.

  1. Créez une règle de pare-feu :

    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. Configurer des règles de pare-feu pour autoriser le trafic provenant de n'importe quelle source Modifiez les commandes pour vos ports et vos plages d'adresses IP sources :

    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

Configurer les autorisations Identity and Access Management

Dans cette section, vous désignez le compte de service des proxys de passerelle et lui attribuez les rôles IAM appropriés.

  1. Créez une identité de compte de service pour les proxys de passerelle :

    gcloud iam service-accounts create gateway-proxy

  2. Attribuez les rôles IAM requis à l'identité du compte de service :

    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"

Configurer la ressource Gateway

  1. Dans un fichier nommé gateway443.yaml, créez la spécification Gateway pour le trafic HTTP :

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

  2. Créez la ressource Gateway à l'aide de la spécification gateway443.yaml:

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

Créer un groupe d'instances géré avec des proxys Envoy

Dans cette section, vous allez créer les proxys Envoy associés à la passerelle d'entrée.

  1. Créez un modèle d'instance pour une VM exécutant un proxy de service Envoy déployé automatiquement. Le champ d'application des proxys Envoy est défini sur gateway-proxy. Ne transmettez pas le port de diffusion en tant que paramètre de l'option --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. Créez un groupe d'instances géré régional à partir du modèle d'instance :

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

  3. Définissez le nom du port de diffusion du groupe d'instances géré :

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

Configurer l'équilibreur de charge réseau passthrough externe régional

Dans cette section, vous allez créer l'équilibreur de charge réseau passthrough externe.

  1. Créez une adresse IP externe régionale statique :

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

  2. Obtenez l'adresse IP réservée pour l'équilibreur de charge externe :

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

    Cette adresse IP sera utilisée comme variable IP_ADDRESS plus loin dans ce guide de configuration.

  3. Créez une vérification d'état pour les proxys de passerelle :

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

  4. Créez un service de backend pour les proxys de passerelle :

    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. Ajoutez le groupe d'instances géré en tant que backend :

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

  6. Créez une règle de transfert pour acheminer le trafic vers les proxys de passerelle :

    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

Configurer un groupe d'instances géré exécutant un service HTTPS

À des fins de démonstration, vous créez un service de backend avec des VM avec autoscaling dans un groupe d'instances géré. Les VM renvoient des informations détaillées sur les requêtes Web utilisant le protocole HTTPS sur le port 443.

  1. Créez un modèle d'instance avec un service HTTPS exposé sur le port 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. Créez un groupe d'instances géré basé sur le modèle d'instance :

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

  3. Définissez le nom du port de diffusion du groupe d'instances géré :

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

  4. Créez une vérification d'état :

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

  5. Créez une règle de pare-feu pour autoriser les connexions de vérification d'état entrantes aux instances de votre réseau :

    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. Créez un service de backend global avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED, puis ajoutez la vérification d'état :

    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. Ajoutez le groupe d'instances géré en tant que backend au service de backend :

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

Configurer le routage avec une ressource TLSRoute

Dans les sections précédentes, vous avez configuré une ressource Gateway et un serveur HTTPS. Ensuite, connectez-les à l'aide d'une ressource TLSRoute qui associe un nom d'hôte SNI à un service de backend.

  1. Dans un fichier nommé tls_route.yaml, créez la spécification 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

    Dans l'instruction précédente, TLSRoute fait correspondre example.com à une extension SNI et h2 à une extension ALPN. Si les correspondances sont modifiées comme suit, TLSRoute correspond à une extension SNI ou à une extension ALPN :

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

  2. Utilisez la spécification dans tls_route.yaml pour créer la ressource TLSRoute :

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

Cloud Service Mesh est configuré pour équilibrer la charge du trafic des services spécifiés dans la ressource TLSRoute sur les backends du groupe d'instances géré.

Validez le déploiement.

Dans cette section, vous allez vérifier que vous pouvez accéder au service depuis un client externe via l'équilibreur de charge réseau passthrough externe et la ressource Gateway Cloud Service Mesh.

  1. Exécutez la commande curl suivante pour vérifier la connectivité HTTP aux services de test que vous avez créés :

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

La commande renvoie une réponse de l'une des VM du groupe d'instances géré. Le résultat est le suivant :

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

Valider à l'aide d'une vérification négative

Vous pouvez également effectuer une vérification négative. Si vous exécutez les commandes de cette section, la requête est supprimée, car elle ne correspond pas aux critères de correspondance TLSRoute.

Dans la commande suivante, l'extension SNI ne correspond pas à example.com. Par conséquent, Gateway rejette la connexion :

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

Dans la commande suivante, l'extension ALPN ne correspond pas à h2 (protocole HTTP2). Par conséquent, Gateway rejette la connexion :

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

Dans la commande suivante, le client crée une connexion en texte brut (non chiffrée). Par conséquent, Gateway rejette la connexion :

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

Les commandes précédentes renvoient toutes l'erreur suivante:

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

Étape suivante

  • Pour savoir comment lister les ressources de parcours associées à une ressource Mesh ou Gateway, consultez Lister les ressources Route. Cette fonctionnalité est disponible en version d'évaluation.