Cloud Service Mesh régional

Preview — Regional Cloud Service Mesh

Cette fonctionnalité est soumise(s) aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités de pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Avec l'isolation régionale, les clients qui se connectent à une région spécifique du plan de contrôle Cloud Service Mesh ne peuvent accéder qu'aux ressources de cette région. De même, les ressources d'API d'une région spécifique ne peuvent faire référence qu'à d'autres ressources de cette région.

Les limites suivantes s'appliquent à la version régionale de Cloud Service Mesh :

• L'API Istio n'est pas compatible. Vous ne pouvez pas utiliser Kubernetes avec l'API Istio à l'aide de Traffic Director régional. Seules les API  Google Cloud sont acceptées dans cet aperçu.
• Les considérations et limites existantes des API de routage de services mondiaux s'appliquent.
• La version minimale d'Envoy compatible avec les schémas de dénomination xdSTP est la version 1.31.1.
• L'API Gateway for Mesh n'est pas compatible.
• La version minimale de gRPC est la version 1.65.

• Seules les régions suivantes sont acceptées :

  africa-south1
  asia-east1
  asia-east2
  asia-northeast1
  asia-northeast2
  asia-northeast3
  asia-south1
  asia-south2
  asia-southeast1
  asia-southeast2
  australia-southeast1
  australia-southeast2
  europe-central2
  europe-north1
  europe-north2
  europe-southwest1
  europe-west10
  europe-west12
  europe-west1
  europe-west2
  europe-west3
  europe-west4
  europe-west6
  europe-west8
  europe-west9
  me-central1
  me-central2
  me-west1
  northamerica-northeast1
  northamerica-northeast2
  northamerica-south1
  southamerica-east1
  southamerica-west1
  us-central1
  us-east1
  us-east4
  us-east5
  us-south1
  us-west1
  us-west2
  us-west3
  us-west4
  

Tarifs

Chaque région dans laquelle Cloud Service Mesh régional est disponible disposera d'un SKU régional lorsque cette fonctionnalité sera disponible pour tous les utilisateurs. Pour le moment, la tarification est la même que pour global.

Préparer le client xDS pour Cloud Service Mesh

Envoy xDS de VM Compute Engine

Manuel

Les étapes manuelles s'appuient sur Configurer des VM avec un déploiement Envoy manuel. La principale différence est que ENVOY_CONTROL_PLANE_REGION est défini et injecté dans l'amorçage.

1. Créez le modèle d'instance :

   gcloud compute instance-templates create td-vm-templategcloud compute instance-templates create td-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=http-td-tag,http-server,https-server \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /usr/bin/env bash
   
   # Set variables
   export ENVOY_CONTROL_PLANE_REGION="us-central1"
   export ENVOY_USER="envoy"
   export ENVOY_USER_UID="1337"
   export ENVOY_USER_GID="1337"
   export ENVOY_USER_HOME="/opt/envoy"
   export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
   export ENVOY_PORT="15001"
   export ENVOY_ADMIN_PORT="15000"
   export ENVOY_TRACING_ENABLED="false"
   export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
   export ENVOY_ACCESS_LOG="/dev/stdout"
   export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
   export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
   export GCE_METADATA_SERVER="169.254.169.254/32"
   export INTERCEPTED_CIDRS="*"
   export GCP_PROJECT_NUMBER=PROJECT_NUMBER
   export VPC_NETWORK_NAME=mesh:sidecar-mesh
   export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)
   
   # Create system user account for Envoy binary
   sudo groupadd ${ENVOY_USER} \
     --gid=${ENVOY_USER_GID} \
     --system
   sudo adduser ${ENVOY_USER} \
     --uid=${ENVOY_USER_UID} \
     --gid=${ENVOY_USER_GID} \
     --home=${ENVOY_USER_HOME} \
     --disabled-login \
     --system
   # Download and extract the Cloud Service Mesh tar.gz file
   cd ${ENVOY_USER_HOME}
   sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
   sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
     -C bootstrap_template.yaml \
     --strip-components 1
   sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
     -C iptables.sh \
     --strip-components 1
   sudo rm traffic-director-xdsv3.tar.gz
   
   # Generate Envoy bootstrap configuration
   cat "${BOOTSTRAP_TEMPLATE}" \
     | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
     | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
     | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
     | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
     | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
     | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
     | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
     | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
     | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
     | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
     | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
     | sudo tee "${ENVOY_CONFIG}"
   
   # Install Envoy binary
   wget -O envoy_key https://apt.envoyproxy.io/signing.key
   cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
   sudo apt-get update
   sudo apt-get install envoy
   
   # Run Envoy as systemd service
   sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
     --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
     bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"
   
   # Configure iptables for traffic interception and redirection
   sudo ${ENVOY_USER_HOME}/iptables.sh \
     -p "${ENVOY_PORT}" \
     -u "${ENVOY_USER_UID}" \
     -g "${ENVOY_USER_GID}" \
     -m "REDIRECT" \
     -i "${INTERCEPTED_CIDRS}" \
     -x "${GCE_METADATA_SERVER}"
   

Compute VM gRPC xDS

Comme pour le maillage de services Cloud Service Mesh global, les clients gRPC doivent configurer un bootstrap pour indiquer comment se connecter à Cloud Service Mesh régional.

Vous pouvez utiliser le générateur d'amorçage gRPC pour générer cet amorçage. Pour définir l'utilisation de Cloud Service Mesh régional, spécifiez un nouveau indicateur : --xds-server-region.

Dans cet exemple, la définition de xds-server-region sur us-central1 détermine automatiquement le point de terminaison régional Cloud Service Mesh : trafficdirector.us-central1.rep.googleapis.com:443.

Injection manuelle d'Envoy dans K8s

Les étapes manuelles s'appuient sur Configurer des pods Google Kubernetes Engine avec injection Envoy manuelle. Toutefois, vous n'avez besoin de modifier que la section sur l'injection manuelle de pods.

1. Faites passer le plan de contrôle de mondial à régional :

   wget -q -O - https://storage.googleapis.com/traffic-director/demo/trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s/PROJECT_NUMBER/PROJECT_NUMBER/g" trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s/MESH_NAME/MESH_NAME/g" trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s|trafficdirector.googleapis.com|trafficdirector.${REGION}.rep.googleapis.com|g" trafficdirector_client_new_api_sample_xdsv3.yaml
   
   sed -i "s|gcr.io/google-containers/busybox|busybox:stable|g" trafficdirector_client_new_api_sample_xdsv3.yaml
   

   1. Appliquez les modifications :

      kubectl apply -f trafficdirector_client_new_api_sample_xdsv3.yaml
        ```
      

Guides de configuration

Cette section couvre cinq configurations et modèles de déploiement indépendants. Il s'agit de versions régionalisées des guides de configuration existants pour les API de routage de service mondiales.

• Configurer des services gRPC sans proxy avec des ressources GRPCRoute régionales et Cloud Service Mesh régional
• Configurer la configuration du proxy side-car Envoy avec des services HTTP, HTTPRoute régional et Cloud Service Mesh régional
• Configurer des services TCP avec TCPRoute régional
• Routage TLS de la passerelle
• Configurer des références multiprojets pour les ressources régionales Cloud Service Mesh et Route

Configurer des services gRPC sans proxy avec des ressources GRPCRoute régionales et Cloud Service Mesh régional

Cette section explique comment configurer un maillage de services gRPC sans proxy avec des ressources Cloud Service Mesh et GRPCRoute régionales.

Pour plus de commodité, stockez le numéro du projet Google Cloud dans lequel vous effectuez la configuration, afin de pouvoir copier et coller tous les exemples de ce guide dans la ligne de commande :

export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

Remplacez PROJECT_NUMBER par votre numéro de projet.

Vous pouvez également remplacer les éléments suivants :

• us-central1 par une autre région que vous souhaitez utiliser.
• us-central1-a par une autre zone que vous souhaitez utiliser.
• default avec un autre VPC_NAME.

Configuration du réseau maillé

Lorsqu'une application gRPC sans proxy se connecte à un xds://hostname, la bibliothèque cliente gRPC établit une connexion avec Cloud Service Mesh pour obtenir la configuration de routage requise pour router les requêtes pour le nom d'hôte.

1. Créez une spécification Mesh et stockez-la dans le fichier mesh.yaml :

   cat <<EOF > mesh.yaml
   name: grpc-mesh
   EOF
   

2. Créez un maillage à l'aide de la spécification mesh.yaml :

   gcloud network-services meshes import grpc-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

   Une fois le maillage régional créé, Cloud Service Mesh est prêt à diffuser la configuration. Toutefois, comme aucun service n'est encore défini, la configuration est vide.

Configuration du service gRPC

À des fins de démonstration, vous allez créer un service de backend régional avec des VM avec autoscaling (à l'aide de groupes d'instances gérés, MIG) qui diffusera hello world à l'aide du protocole gRPC sur le port 50051.

1. Créez le modèle d'instance de VM Compute Engine avec un service gRPC helloworld exposé sur le port 50051 :

   gcloud compute instance-templates create grpc-td-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=allow-health-checks \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata-from-file=startup-script=<(echo '#! /bin/bash
   set -e
   cd /root
   sudo apt-get update -y
   sudo apt-get install -y openjdk-11-jdk-headless
   curl -L https://github.com/grpc/grpc-java/archive/v1.38.0.tar.gz | tar -xz
   cd grpc-java-1.38.0/examples/example-hostname
   ../gradlew --no-daemon installDist
   # Server listens on 50051
   sudo systemd-run ./build/install/hostname-server/bin/hostname-server')
   

2. Créez un MIG basé sur le modèle :

   gcloud compute instance-groups managed create grpc-td-mig-us-central1 \
     --zone=${ZONE} \
     --size=2 \
     --template=grpc-td-vm-template
   

3. Configurez un port nommé pour le service gRPC. Il s'agit du port sur lequel le service gRPC est configuré pour écouter les requêtes.

   gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
     --named-ports=grpc-helloworld-port:50051 \
     --zone=${ZONE}
   

   Dans cet exemple, le port est 50051.

4. Créez des vérifications d'état gRPC.

   gcloud compute health-checks create grpc grpc-helloworld-health-check \
     --use-serving-port --region=${REGION}
   

   Les services doivent mettre en œuvre le protocole de vérification de l'état gRPC pour que les vérifications d'état gRPC fonctionnent correctement. Pour en savoir plus, consultez Créer des vérifications d'état.

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 grpc-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:50051
   

6. Créez un service de backend régional avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED, puis ajoutez la vérification d'état et un groupe d'instances géré créé précédemment au service de backend. Le port indiqué dans le nom de port permet de se connecter aux VM du groupe d'instances géré.

   gcloud compute backend-services create grpc-helloworld-service \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=GRPC \
       --port-name=grpc-helloworld-port \
     --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/grpc-helloworld-health-check" \
       --region=${REGION}
   

7. Ajoutez le groupe d'instances géré à BackendService :

   gcloud compute backend-services add-backend grpc-helloworld-service \
     --instance-group=grpc-td-mig-us-central1 \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

Configurer le routage avec une ressource GRPCRoute régionale

À ce stade, le maillage régional et le service de serveur gRPC sont configurés. Vous pouvez maintenant configurer le routage requis.

1. Créez une spécification GRPCRoute régionale et stockez-la dans le fichier grpc_route.yaml :

   cat <<EOF > grpc_route.yaml
   name: helloworld-grpc-route
   hostnames:
   - helloworld-gce
   meshes:
   - projects/${PROJECT_NUMBER}/locations/${REGION}/meshes/grpc-mesh
   rules:
   - action:
       destinations:
       - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/grpc-helloworld-service
   EOF
   

2. Créez un GRPCRoute régional à l'aide de la spécification grpc_route.yaml :

   gcloud network-services grpc-routes import helloworld-grpc-route \
       --source=grpc_route.yaml \
       --location=${REGION}
   

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

Créer un service client gRPC

Pour vérifier la configuration, instanciez une application cliente avec un plan de données gRPC sans proxy. Cette application doit spécifier (dans son fichier d'amorçage) le nom du maillage.

Une fois configurée, cette application peut envoyer une requête aux instances ou aux points de terminaison associés à helloworld-gce à l'aide de l'URI du service xds:///helloworld-gce.

Dans les exemples suivants, utilisez l'outil grpcurl pour tester le service gRPC.

1. Créer une VM cliente :

   gcloud compute instances create grpc-client \
     --zone=${ZONE}\
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata-from-file=startup-script=<(echo '#! /bin/bash
   set -ex
   export PROJECT=PROJECT_NUMBER
   export REGION=us-central1
   export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
   echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
   curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.18.0.tar.gz | tar -xz
   ./td-grpc-bootstrap-0.18.0/td-grpc-bootstrap --config-mesh=grpc-mesh --xds-server-uri=trafficdirector.${REGION}.rep.googleapis.com:443 --gcp-project-number=${PROJECT} | sudo tee $GRPC_XDS_BOOTSTRAP
   sudo sed -i "s|\"authorities\": {|\"authorities\": {\n    \"traffic-director.${REGION}.xds.googleapis.com\": {\"xds_servers\":[{\"server_uri\": \"trafficdirector.${REGION}.rep.googleapis.com:443\", \"channel_creds\": [ { \"type\": \"google_default\" } ], \"server_features\": [ \"xds_v3\", \"ignore_resource_deletion\" ]}], \"client_listener_resource_name_template\": \"xdstp://traffic-director.${REGION}.xds.googleapis.com/envoy.config.listener.v3.Listener/${PROJECT}/mesh:grpc-mesh/%s\"},|g" $GRPC_XDS_BOOTSTRAP
   sudo sed -i "s|\"client_default_listener_resource_name_template\": \"xdstp://traffic-director-global.xds.googleapis.com|\"client_default_listener_resource_name_template\": \"xdstp://traffic-director.${REGION}.xds.googleapis.com|g" $GRPC_XDS_BOOTSTRAP')
   

Configurer la variable d'environnement et le fichier d'amorçage

L'application cliente nécessite un fichier de configuration d'amorçage. Le script de démarrage de la section précédente définit la variable d'environnement GRPC_XDS_BOOTSTRAP et utilise un script d'aide pour générer le fichier d'amorçage. Les valeurs de TRAFFICDIRECTOR_GCP_PROJECT_NUMBER et de la zone du fichier d'amorçage généré sont obtenues auprès du serveur de métadonnées qui connaissent ces détails sur vos instances de VM Compute Engine.

Vous pouvez fournir manuellement ces valeurs au script d'aide à l'aide de l'option -gcp-project-number. Vous devez fournir un nom de maillage correspondant à la ressource de maillage à l'aide de l'option -config-mesh-experimental.

1. Pour vérifier la configuration, connectez-vous au client :

   gcloud compute ssh grpc-client --zone=${ZONE}
   

2. Téléchargez et installez l'outil grpcurl :

   curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.9.3/grpcurl_1.9.3_linux_x86_64.tar.gz | tar -xz
   

3. Exécutez l'outil grpcurl avec xds:///helloworld-gce en tant qu'URI de service et helloworld.Greeter/SayHello en tant que nom de service et méthode à appeler.

   ./grpcurl --plaintext \
     -d '{"name": "world"}' \
     xds:///helloworld-gce helloworld.Greeter/SayHello
   

   Les paramètres de la méthode SayHello sont transmis à l'aide de l'option -d.

   Un résultat semblable à ce qui suit doit s'afficher, où INSTANCE_NAME correspond au nom de l'instance de VM :

   Greeting: Hello world, from INSTANCE_HOSTNAME
   

Cela confirme que le client gRPC sans proxy a bien été connecté à Cloud Service Mesh et a découvert les backends du service helloworld-gce à l'aide du résolveur de nom xDS. Le client a envoyé une requête à l'un des backends du service sans avoir à connaître l'adresse IP ou la résolution DNS.

Configurer la configuration du proxy side-car Envoy avec des services HTTP, avec HTTPRoute et Mesh régionaux

Cette section explique comment configurer un maillage de services basé sur un proxy Envoy avec des ressources de maillage régional et HTTPRoute régional.

Pour plus de commodité, stockez le numéro du projet Google Cloud dans lequel vous effectuez la configuration, afin de pouvoir copier et coller tous les exemples de ce guide dans la ligne de commande :

export PROJECT_ID="PROJECT_ID"
export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

Remplacez les éléments suivants

• PROJECT_ID par l'ID de votre projet.
• PROJECT_NUMBER par votre numéro de projet.

Vous pouvez également remplacer les éléments suivants :

• us-central1 par une autre région que vous souhaitez utiliser.
• us-central1-a par une autre zone que vous souhaitez utiliser.

Configuration du réseau maillé

Le proxy Envoy side-car reçoit la configuration de routage du service depuis Cloud Service Mesh. Le side-car présente le nom de la ressource de maillage régional pour identifier le maillage de services spécifique configuré. La configuration de routage reçue de Cloud Service Mesh est utilisée pour diriger le trafic transitant par le proxy side-car vers différents services de backend régionaux en fonction des paramètres de requête, tels que le nom d'hôte ou les en-têtes, configurés dans les ressources de route.

Notez que le nom du maillage est la clé utilisée par le proxy side-car pour demander la configuration associée à ce maillage.

1. Créez la spécification de maillage régional et stockez-la dans le fichier mesh.yaml :

   cat <<EOF > mesh.yaml
   name: sidecar-mesh
   EOF
   

   Le port d'interception est défini par défaut sur 15001 s'il n'est pas spécifié.

2. Créez un maillage régional à l'aide de la spécification mesh.yaml :

   gcloud network-services meshes import sidecar-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

   Une fois le maillage régional créé, Cloud Service Mesh est prêt à diffuser la configuration. Toutefois, comme aucun service n'est encore défini, la configuration sera vide.

Configuration du serveur HTTP

À des fins de démonstration, vous allez créer un service de backend régional avec des VM avec autoscaling (à l'aide de groupes d'instances gérés, MIG) qui diffusera "hello world" à l'aide du protocole gRPC sur le port 80.

1. Créez le modèle d'instance de VM Compute Engine avec un service HTTP helloworld exposé sur le port 80 :

   gcloud compute instance-templates create td-httpd-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=http-td-server \
     --image-family=debian-11 \
     --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. Créez un MIG basé sur le modèle :

   gcloud compute instance-groups managed create http-td-mig-us-central1 \
     --zone=${ZONE} \
     --size=2 \
     --template=td-httpd-vm-template
   

3. Créez les vérifications d'état :

   gcloud compute health-checks create http http-helloworld-health-check --region=${REGION}
   

4. 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 http-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 http-td-server \
     --rules tcp:80
   

5. Créez un service de backend régional avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED :

   gcloud compute backend-services create http-helloworld-service \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=HTTP \
   --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/http-helloworld-health-check" \
       --region=${REGION}
   

6. Ajoutez la vérification de l'état et un groupe d'instances géré ou non géré au service de backend :

   gcloud compute backend-services add-backend http-helloworld-service \
     --instance-group=http-td-mig-us-central1 \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

   Cet exemple utilise le groupe d'instances géré avec le modèle de VM Compute Engine qui exécute l'exemple de service HTTP que nous avons créé précédemment.

Configurer le routage avec HTTPRoute régional

La ressource de maillage et le serveur HTTP sont configurés. Vous pouvez maintenant les connecter à l'aide d'une ressource HTTPRoute qui associe un nom d'hôte à un service de backend.

1. Créez une spécification HTTPRoute et enregistrez-la sous le nom http_route.yaml :

   cat <<EOF > http_route.yaml
   name: helloworld-http-route
   hostnames:
   - helloworld-gce
   meshes:
   - projects/${PROJECT_NUMBER}/locations/${REGION}/meshes/sidecar-mesh
   rules:
   - action:
       destinations:
       - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/http-helloworld-service
   EOF
   

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

   gcloud network-services http-routes import helloworld-http-route \
       --source=http_route.yaml \
       --location=${REGION}
   

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

Créer un client HTTP avec un side-car Envoy

Dans cette section, vous allez instancier une VM cliente avec un proxy side-car Envoy pour demander la configuration Cloud Service Mesh créée précédemment. Notez que le paramètre mesh de la commande Google Cloud CLI fait référence à la ressource de maillage créée précédemment.

gcloud compute instance-templates create td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=http-td-tag,http-server,https-server \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
export ENVOY_CONTROL_PLANE_REGION="us-central1"
export ENVOY_USER="envoy"
export ENVOY_USER_UID="1337"
export ENVOY_USER_GID="1337"
export ENVOY_USER_HOME="/opt/envoy"
export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
export ENVOY_PORT="15001"
export ENVOY_ADMIN_PORT="15000"
export ENVOY_TRACING_ENABLED="false"
export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
export ENVOY_ACCESS_LOG="/dev/stdout"
export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
export GCE_METADATA_SERVER="169.254.169.254/32"
export INTERCEPTED_CIDRS="*"
export GCP_PROJECT_NUMBER=PROJECT_NUMBER
export VPC_NETWORK_NAME=mesh:sidecar-mesh
export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)

# Create system user account for Envoy binary
sudo groupadd ${ENVOY_USER} \
  --gid=${ENVOY_USER_GID} \
  --system
sudo adduser ${ENVOY_USER} \
  --uid=${ENVOY_USER_UID} \
  --gid=${ENVOY_USER_GID} \
  --home=${ENVOY_USER_HOME} \
  --disabled-login \
  --system
# Download and extract the Cloud Service Mesh tar.gz file
cd ${ENVOY_USER_HOME}
sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
  -C bootstrap_template.yaml \
  --strip-components 1
sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
  -C iptables.sh \
  --strip-components 1
sudo rm traffic-director-xdsv3.tar.gz

# Generate Envoy bootstrap configuration
cat "${BOOTSTRAP_TEMPLATE}" \
  | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
  | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
  | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
  | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
  | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
  | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
  | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
  | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
  | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
  | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
  | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
wget -O envoy_key https://apt.envoyproxy.io/signing.key
cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
sudo apt-get update
sudo apt-get install envoy

# Run Envoy as systemd service
sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
  --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
  bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"

# Configure iptables for traffic interception and redirection
sudo ${ENVOY_USER_HOME}/iptables.sh \
  -p "${ENVOY_PORT}" \
 -u "${ENVOY_USER_UID}" \
  -g "${ENVOY_USER_GID}" \
  -m "REDIRECT" \
  -i "${INTERCEPTED_CIDRS}" \
  -x "${GCE_METADATA_SERVER}"
'

gcloud compute instances create td-vm-client \
  --zone=${ZONE} \
  --source-instance-template td-vm-template

1. Connectez-vous à la VM créée :

   gcloud compute ssh td-vm-client --zone=${ZONE}
   

2. Vérifiez la connectivité HTTP aux services de test créés :

   curl -H "Host: helloworld-gce" http://10.0.0.1/
   

   La commande renvoie une réponse de l'une des VM du groupe d'instances géré, avec son nom d'hôte imprimé sur la console.

Configurer des services TCP avec TCPRoute régional

Ce flux de configuration est très semblable à Configurer des proxys Envoy avec des services HTTP, à la différence que le service de backend fournit un service TCP et que le routage basé sur les paramètres TCP/IP est utilisé plutôt que celui basé sur le protocole HTTP.

Pour plus de commodité, stockez le numéro du projet Google Cloud dans lequel vous effectuez la configuration, afin de pouvoir copier et coller tous les exemples de ce guide dans la ligne de commande :

export PROJECT_ID="PROJECT_ID"
export PROJECT="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-a"

Remplacez les éléments suivants

• PROJECT_ID par l'ID de votre projet.
• PROJECT_NUMBER par votre numéro de projet.

Vous pouvez également remplacer les éléments suivants :

• us-central1 par une autre région que vous souhaitez utiliser.
• us-central1-a par une autre zone que vous souhaitez utiliser.

Configuration du réseau maillé

1. Créez la spécification de maillage régional et stockez-la dans le fichier mesh.yaml :

   cat <<EOF > mesh.yaml
   name: sidecar-mesh
   EOF
   

2. Créez un maillage régional à l'aide de la spécification mesh.yaml :

   gcloud network-services meshes import sidecar-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

Configuration du serveur TCP

À des fins de démonstration, vous allez créer un service de backend régional avec des VM avec autoscaling (à l'aide de groupes d'instances gérés, MIG) qui diffusera "hello world" à l'aide du protocole gRPC sur le port 10000.

1. Créez le modèle d'instance de VM Compute Engine avec un service de test sur le port 10000 à l'aide de l'utilitaire 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-11 \
     --image-project=debian-cloud \
     --metadata=startup-script="#! /bin/bash
   sudo apt-get update -y
   sudo apt-get install netcat -y
   while true;
     do echo 'Hello from TCP service' | nc -l -s 0.0.0.0 -p 10000;
   done &"
   

2. Créez un MIG basé sur le modèle :

   gcloud compute instance-groups managed create tcp-td-mig-us-central1 \
     --zone=${ZONE} \
     --size=1 \
     --template=tcp-td-vm-template
   

3. Définissez les ports nommés du groupe d'instances géré créé sur port 10000 :

   gcloud compute instance-groups set-named-ports tcp-td-mig-us-central1 \
     --zone=${ZONE} --named-ports=tcp:10000
   

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

   gcloud compute health-checks create tcp tcp-helloworld-health-check --port 10000 --region=${REGION}
   

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 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:10000
   

6. Créez un service de backend régional avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED, puis ajoutez la vérification de l'état et un groupe d'instances géré ou non géré au service de backend.

   gcloud compute backend-services create tcp-helloworld-service \
       --region=${REGION} \
       --load-balancing-scheme=INTERNAL_SELF_MANAGED \
       --protocol=TCP \
       --port-name=tcp \
       --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/tcp-helloworld-health-check"
   

7. Ajoutez le MIG au BackendService :

   gcloud compute backend-services add-backend tcp-helloworld-service \
     --instance-group tcp-td-mig-us-central1 \
     --instance-group-zone=${ZONE} \
     --region=${REGION}
   

Configurer le routage avec TCPRoute régional

1. Créez la spécification TCPRoute et stockez-la dans le fichier tcp_route.yaml :

   cat <<EOF > tcp_route.yaml
   name: helloworld-tcp-route
   meshes:
   - projects/$PROJECT_NUMBER/locations/$REGION/meshes/sidecar-mesh
   rules:
   - action:
       destinations:
       - serviceName: projects/$PROJECT_NUMBER/locations/$REGION/backendServices/tcp-helloworld-service
     matches:
     - address: '10.0.0.1/32'
       port: '10000'
   EOF
   

2. Créez TCPRoute à l'aide de la spécification tcp_route.yaml :

   gcloud network-services tcp-routes import helloworld-tcp-route \
       --source=tcp_route.yaml \
       --location=${REGION}
   

Créer un client TCP avec un side-car Envoy

1. Créez une VM avec Envoy connecté à Cloud Service Mesh :

   gcloud compute instance-templates create td-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=http-td-tag,http-server,https-server \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --metadata=startup-script='#! /usr/bin/env bash
   
   # Set variables
   export ENVOY_CONTROL_PLANE_REGION="us-central1"
   export ENVOY_USER="envoy"
   export ENVOY_USER_UID="1337"
   export ENVOY_USER_GID="1337"
   export ENVOY_USER_HOME="/opt/envoy"
   export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
   export ENVOY_PORT="15001"
   export ENVOY_ADMIN_PORT="15000"
   export ENVOY_TRACING_ENABLED="false"
   export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
   export ENVOY_ACCESS_LOG="/dev/stdout"
   export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
   export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
   export GCE_METADATA_SERVER="169.254.169.254/32"
   export INTERCEPTED_CIDRS="*"
   export GCP_PROJECT_NUMBER=PROJECT_NUMBER
   export VPC_NETWORK_NAME=mesh:sidecar-mesh
   
   export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)
   
   # Create system user account for Envoy binary
   sudo groupadd ${ENVOY_USER} \
     --gid=${ENVOY_USER_GID} \
     --system
   sudo adduser ${ENVOY_USER} \
     --uid=${ENVOY_USER_UID} \
     --gid=${ENVOY_USER_GID} \
     --home=${ENVOY_USER_HOME} \
     --disabled-login \
     --system
   # Download and extract the Cloud Service Mesh tar.gz file
   cd ${ENVOY_USER_HOME}
   sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
   sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
     -C bootstrap_template.yaml \
     --strip-components 1
   sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
     -C iptables.sh \
     --strip-components 1
   sudo rm traffic-director-xdsv3.tar.gz
   
   # Generate Envoy bootstrap configuration
   cat "${BOOTSTRAP_TEMPLATE}" \
     | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
     | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
     | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
     | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
     | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
     | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
     | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
     | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
     | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
     | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
     | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
     | sudo tee "${ENVOY_CONFIG}"
   
   # Install Envoy binary
   wget -O envoy_key https://apt.envoyproxy.io/signing.key
   cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
   sudo apt-get update
   sudo apt-get install envoy
   
   # Run Envoy as systemd service
   sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
     --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
     bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"
   
   # Configure iptables for traffic interception and redirection
   sudo ${ENVOY_USER_HOME}/iptables.sh \
     -p "${ENVOY_PORT}" \
   -u "${ENVOY_USER_UID}" \
     -g "${ENVOY_USER_GID}" \
     -m "REDIRECT" \
     -i "${INTERCEPTED_CIDRS}" \
     -x "${GCE_METADATA_SERVER}"
   '
   
   gcloud compute instances create td-vm-client \
     --zone=${ZONE} \
     --source-instance-template td-vm-template
   

2. Connectez-vous à la VM créée :

   gcloud compute ssh td-vm-client --zone=${ZONE}
   

3. Vérifiez la connectivité aux services de test créés :

   curl 10.0.0.1:10000 --http0.9 -v
   

   Vous devriez voir le texte Hello from TCP service renvoyé, ainsi que tout texte saisi renvoyé par le service netcat qui s'exécute sur la VM distante.

Configuration du maillage régional dans le projet hôte

Désignez un projet comme projet hôte. Tout compte de service autorisé à créer, mettre à jour ou supprimer des mailles dans ce projet peut contrôler les configurations de routage associées aux mailles régionales de ce projet.

1. Définissez une variable qui sera utilisée tout au long de l'exemple :

   export REGION="us-central1"
   

   Vous pouvez éventuellement remplacer us-central1 par une autre région que vous souhaitez utiliser.

2. Créez la spécification de maillage et stockez-la dans le fichier mesh.yaml :

   cat <<EOF > mesh.yaml
   name: shared-mesh
   EOF
   

3. Définissez une ressource de maillage dans ce projet avec la configuration requise :

   gcloud network-services meshes import shared-mesh \
       --source=mesh.yaml \
       --location=${REGION}
   

   Notez l'URI complet de cette ressource de maillage. Les propriétaires de services en auront besoin à l'avenir pour associer leurs routes à ce maillage.

4. Accordez l'autorisation IAM networkservices.meshes.use à ce maillage et aux comptes de service multi-projets capables d'associer leurs informations de services à ce maillage :

   gcloud projects add-iam-policy-binding HOST_PROJECT_NUMBER --member='HTTP_ROUTE_SERVICE_OWNER_ACCOUNT' --role='roles/compute.networkAdmin'
   

   Tous les propriétaires de service auxquels l'autorisation networkservices.meshes.use est accordée peuvent désormais ajouter leurs règles de routage à ce maillage.

Configuration des routes dans les projets de service

Chaque propriétaire de service doit créer un ou plusieurs services de backend régionaux et des ressources de routage régionales dans son projet, comme dans Configurer des proxys Envoy avec des services HTTP. La seule différence est que chaque HTTPRoute/GRPCRoute/TCPRoute aurait l'URI de la ressource de maillage du projet hôte dans le champ meshes.

1. Créez une route HTTP sharedvpc-http-route :

   echo "name: sharedvpc-http-route
   hostnames:
   - helloworld-gce
   meshes:
   - /projects/HOST_PROJECT_NUMBER/locations/${REGION}/meshes/shared-mesh
   rules:
   - action:
       destinations:
       - serviceName: \"SERVICE_URL\"" | \
   gcloud network-services http-routes import sharedvpc-http-route \
       --source=- \
       --location=${REGION}
   

Configurer des services clients dans des projets de service

Lors de la configuration d'un client Cloud Service Mesh (proxy Envoy ou sans proxy) situé dans un projet de service, vous devez spécifier le numéro du projet dans lequel se trouve la ressource de maillage et le nom du maillage dans sa configuration d'amorçage :

TRAFFICDIRECTOR_GCP_PROJECT_NUMBER=HOST_PROJECT_NUMBER
TRAFFICDIRECTOR_MESH_NAME=MESH_NAME

Routage TLS de la passerelle

Cette section explique comment configurer une passerelle d'entrée basée sur un proxy Envoy avec des ressources Gateway et TLSRoute régionales.

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.

Définissez des variables qui seront utilisées tout au long de l'exemple.

export PROJECT_ID="PROJECT_ID"
export PROJECT_NUMBER="PROJECT_NUMBER"
export REGION="us-central1"
export ZONE="us-central1-b"
export NETWORK_NAME = "default"

Remplacez les éléments suivants : default

• PROJECT_ID par l'ID de votre projet.
• PROJECT_NUMBER par votre numéro de projet.

Vous pouvez également remplacer les éléments suivants :

• us-central1 par une autre région que vous souhaitez utiliser.
• us-central1-b par une autre zone que vous souhaitez utiliser.
• default par le nom du réseau que vous souhaitez utiliser.

Référencer des ressources de maillage et de route régionales dans un environnement VPC partagé multiprojets

Dans certains cas, la configuration du maillage de services inclut des services qui appartiennent à différents projets. Par exemple, dans les déploiements de VPC partagé ou de VPC appairés, chaque propriétaire de projet peut définir son propre ensemble de services afin de rendre ces services disponibles pour tous les autres projets.

Cette configuration est "inter-projets", car plusieurs ressources définies dans différents projets sont combinées pour former une seule configuration pouvant être diffusée à un proxy ou à un client sans proxy.

Remarque : Les références entre ressources régionales doivent exister dans la même région.

Configurer des règles de pare-feu

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

Configurer les autorisations IAM

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"
   

Configurez la passerelle régionale :

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

   cat <<EOF > gateway8443.yaml
   name: gateway8443
   scope: gateway-proxy-8443
   ports:
   - 8443
   type: OPEN_MESH
   EOF
   

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

   gcloud network-services gateways import gateway8443 \
       --source=gateway8443.yaml \
       --location=${REGION}
   

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

Dans cette section, vous allez créer 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.

1. Créez un groupe d'instances géré avec des proxys Envoy :

   gcloud beta compute instance-templates create gateway-proxy \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=gateway-proxy,http-td-tag,http-server,https-server \
     --image-family=debian-11 \
     --image-project=debian-cloud \
     --network-interface=network=${NETWORK_NAME} \
     --service-account="gateway-proxy@${PROJECT_ID}.iam.gserviceaccount.com" \
     --metadata=startup-script='#! /usr/bin/env bash
   
   # Set variables
   export ENVOY_CONTROL_PLANE_REGION="us-central1"
   export GCP_PROJECT_NUMBER=PROJECT_NUMBER
   export VPC_NETWORK_NAME=scope:gateway-proxy-8443
   export ENVOY_USER="envoy"
   export ENVOY_USER_UID="1337"
   export ENVOY_USER_GID="1337"
   export ENVOY_USER_HOME="/opt/envoy"
   export ENVOY_CONFIG="${ENVOY_USER_HOME}/config.yaml"
   export ENVOY_PORT="15001"
   export ENVOY_ADMIN_PORT="15000"
   export ENVOY_TRACING_ENABLED="false"
   export ENVOY_XDS_SERVER_CERT="/etc/ssl/certs/ca-certificates.crt"
   export ENVOY_ACCESS_LOG="/dev/stdout"
   export ENVOY_NODE_ID="$(cat /proc/sys/kernel/random/uuid)~$(hostname -i)"
   export BOOTSTRAP_TEMPLATE="${ENVOY_USER_HOME}/bootstrap_template.yaml"
   export GCE_METADATA_SERVER="169.254.169.254/32"
   export INTERCEPTED_CIDRS="*"
   
   export GCE_ZONE=$(curl -sS -H "Metadata-Flavor: Google" http://metadata.google.internal/computeMetadata/v1/instance/zone | cut -d"/" -f4)
   
   # Create system user account for Envoy binary
   sudo groupadd ${ENVOY_USER} \
     --gid=${ENVOY_USER_GID} \
     --system
   sudo adduser ${ENVOY_USER} \
     --uid=${ENVOY_USER_UID} \
     --gid=${ENVOY_USER_GID} \
     --home=${ENVOY_USER_HOME} \
     --disabled-login \
     --system
   # Download and extract the Cloud Service Mesh tar.gz file
   cd ${ENVOY_USER_HOME}
   sudo curl -sL https://storage.googleapis.com/traffic-director/traffic-director-xdsv3.tar.gz -o traffic-director-xdsv3.tar.gz
   sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/bootstrap_template.yaml \
     -C bootstrap_template.yaml \
     --strip-components 1
   sudo tar -xvzf traffic-director-xdsv3.tar.gz traffic-director-xdsv3/iptables.sh \
     -C iptables.sh \
     --strip-components 1
   sudo rm traffic-director-xdsv3.tar.gz
   
   # Generate Envoy bootstrap configuration
   cat "${BOOTSTRAP_TEMPLATE}" \
     | sed -e "s|ENVOY_NODE_ID|${ENVOY_NODE_ID}|g" \
     | sed -e "s|ENVOY_ZONE|${GCE_ZONE}|g" \
     | sed -e "s|VPC_NETWORK_NAME|${VPC_NETWORK_NAME}|g" \
     | sed -e "s|CONFIG_PROJECT_NUMBER|${GCP_PROJECT_NUMBER}|g" \
     | sed -e "s|ENVOY_PORT|${ENVOY_PORT}|g" \
     | sed -e "s|ENVOY_ADMIN_PORT|${ENVOY_ADMIN_PORT}|g" \
     | sed -e "s|XDS_SERVER_CERT|${ENVOY_XDS_SERVER_CERT}|g" \
     | sed -e "s|TRACING_ENABLED|${ENVOY_TRACING_ENABLED}|g" \
     | sed -e "s|ACCESSLOG_PATH|${ENVOY_ACCESS_LOG}|g" \
     | sed -e "s|BACKEND_INBOUND_PORTS|${BACKEND_INBOUND_PORTS}|g" \
     | sed -e "s|trafficdirector.googleapis.com|trafficdirector.${ENVOY_CONTROL_PLANE_REGION}.rep.googleapis.com|g" \
     | sudo tee "${ENVOY_CONFIG}"
   
   # Install Envoy binary
   wget -O envoy_key https://apt.envoyproxy.io/signing.key
   cat envoy_key | sudo gpg --dearmor > $(pwd)/envoy-keyring.gpg
   echo "deb [arch=$(dpkg --print-architecture) signed-by=$(pwd)/envoy-keyring.gpg] https://apt.envoyproxy.io bullseye main" | sudo tee /etc/apt/sources.list.d/envoy.list
   sudo apt-get update
   sudo apt-get install envoy
   
   # Run Envoy as systemd service
   sudo systemd-run --uid=${ENVOY_USER_UID} --gid=${ENVOY_USER_GID} \
     --working-directory=${ENVOY_USER_HOME} --unit=envoy.service \
     bash -c "/usr/bin/envoy --config-path ${ENVOY_CONFIG} | tee"
   
   # Configure iptables for traffic interception and redirection
   sudo ${ENVOY_USER_HOME}/iptables.sh \
     -p "${ENVOY_PORT}" \
   -u "${ENVOY_USER_UID}" \
     -g "${ENVOY_USER_GID}" \
     -m "REDIRECT" \
     -i "${INTERCEPTED_CIDRS}" \
     -x "${GCE_METADATA_SERVER}"
   '
   

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:8443 \
     --region=${REGION}
   

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

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)'
   

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=8443 \
     --backend-service=xnlb-${REGION} \
     --backend-service-region=${REGION}
   

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

1. Créez un modèle d'instance avec un service HTTPS exposé sur le port 8443 :

   gcloud compute instance-templates create td-https-vm-template \
     --scopes=https://www.googleapis.com/auth/cloud-platform \
     --tags=https-td-server \
     --image-family=debian-11 \
     --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 8443: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:8443 \
     --zone=${ZONE}
   

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

   gcloud compute health-checks create https https-helloworld-health-check \
     --port=8443 --region=${REGION}
   

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:8443
   

6. Créez un service de backend régional avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED, puis ajoutez la vérification de l'état'état :

   gcloud compute backend-services create https-helloworld-service \
     --region=${REGION} \
     --load-balancing-scheme=INTERNAL_SELF_MANAGED \
     --port-name=https \
     --health-checks="https://www.googleapis.com/compute/v1/projects/${PROJECT}/regions/${REGION}/healthChecks/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} \
     --region=${REGION}
   

Configurer le routage avec une ressource TLSRoute

1. Dans un fichier nommé tls_route.yaml, créez la spécification TLSRoute :

   cat <<EOF > tls_route.yaml
   name: helloworld-tls-route
   gateways:
   - projects/${PROJECT_NUMBER}/locations/${REGION}/gateways/gateway8443
   rules:
   - matches:
     - sniHost:
       - example.com
       alpn:
       - h2
     action:
       destinations:
       - serviceName: projects/${PROJECT_NUMBER}/locations/${REGION}/backendServices/https-helloworld-service
   EOF
   

   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 ALPN :

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

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

   gcloud network-services tls-routes import helloworld-tls-route \
       --source=tls_route.yaml \
       --location=${REGION}
   

Validez le déploiement.

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:8443 --resolve example.com:8443:${IP_ADDRESS} -k
   

2. La commande renvoie une réponse de l'une des VM du groupe d'instances géré. Le résultat ressemble à ce qui suit :

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

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

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

   curl https://invalid-server.com:8443 --resolve invalid-server.com:8443:${IP_ADDRESS} -k
   

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

   curl https://example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k --http1.1
   

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

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

3. Dans la commande suivante, le client crée une connexion en texte brut (non chiffrée). Par conséquent, la passerelle rejette la connexion avec une erreur 404 (Not Found) :

   curl example.com:8443 --resolve example.com:8443:${IP_ADDRESS} -k