Anthos Service Mesh et Traffic Director sont désormais Cloud Service Mesh. Pour en savoir plus, consultez la présentation de Cloud Service Mesh.

Cette page a été traduite par l'API Cloud Translation.

Configurer des VM avec un déploiement Envoy manuel

Ce document est destiné aux administrateurs réseau qui souhaitent configurer Cloud Service Mesh manuellement. Le processus manuel est un ancien mécanisme uniquement pour les utilisateurs avancés qui configurent Cloud Service Mesh avec la charge API d'équilibrage de charge.

Nous vous recommandons vivement de configurer Cloud Service Mesh à l'aide des API de routage des services plutôt que des anciennes API d'équilibrage de charge. Si vous devez utiliser les API d'équilibrage de charge, nous vous recommandons d'utiliser le déploiement automatisé d'Envoy plutôt que le processus manuel décrit sur cette page.

Avant de suivre les instructions de ce guide, effectuez les tâches préalables décrites dans la section Préparer la configuration des API de routage de service avec Envoy et des charges de travail sans proxy.

Ce guide explique comment déployer manuellement un plan de données constitué de proxys side-car Envoy avec des machines virtuelles (VM) Compute Engine, comment le configurer à l'aide de Cloud Service Mesh et comment vérifier votre configuration pour vous assurer qu'il fonctionne correctement. Ce processus implique les actions suivantes :

Créer un service de test
Déployer un plan de données simple sur Compute Engine à l'aide de proxys Envoy
Configurer Cloud Service Mesh à l'aide des API Compute Engine, qui activer Cloud Service Mesh pour configurer vos proxys side-car Envoy.
Vous connecter à une VM qui exécute un proxy Envoy et envoyer une requête à un backend à équilibrage de charge via le proxy Envoy

Les exemples de configuration dans ce document sont présentés à des fins de démonstration. Pour un environnement de production, vous devrez peut-être déployer des composants supplémentaires en fonction de votre environnement et des conditions requises.

Présentation du processus de configuration

Cette section décrit le processus de configuration manuel des services exécutés sur des VM Compute Engine. Le processus de configuration des VM clientes consiste à configurer un proxy side-car et une interception de trafic sur un hôte de VM Compute Engine. Vous configurez ensuite l'équilibrage de charge à l'aide des API d'équilibrage de charge Google Cloud.

Cette section explique comment obtenir et injecter des proxys Envoy provenant de sources tierces qui ne sont pas gérées par Google.

Lorsqu'une application envoie du trafic au service configuré Cloud Service Mesh, le trafic est intercepté et redirigé vers l'instance xDS proxy side-car compatible avec l'API, puis équilibrage de charge en fonction des backends à la configuration des composants d'équilibrage de charge Google Cloud. Pour en savoir plus sur la mise en réseau de l'hôte et l'interception du trafic, consultez la section Interception du trafic de proxy side-car dans Cloud Service Mesh.

Pour chaque hôte de VM nécessitant un accès aux services Cloud Service Mesh, procédez comme suit :

Attribuez un compte de service à la VM.
Définissez le niveau d'accès de la VM aux API pour autoriser l'accès complet aux API Google Cloud.
- Lorsque vous créez les VM, dans la section Identité et accès aux API, cliquez sur Autoriser l'accès complet à toutes les API Cloud.
  Accéder à la page "Instances de VM"
- Avec gcloud CLI, spécifiez les éléments suivants :
  
  --scopes=https://www.googleapis.com/auth/cloud-platform.
Autorisez les connexions sortantes à trafficdirector.googleapis.com (TCP, port 443) à partir de la VM pour que le proxy side-car puisse se connecter au plan de contrôle du service de maillage de services Cloud via gRPC. Les connexions sortantes au port 443 sont activées par défaut.
Déployez un proxy side-car compatible avec l'API xDS (tel que Envoy) avec une configuration d'amorçage pointant vers trafficdirector.googleapis.com:443 en tant que serveur xDS. Pour obtenir un exemple de configuration d'amorçage , ouvrez le fichier compressé traffic-director-xdsv3.tar.gz et modifiez le fichier bootstrap_template.yaml selon vos besoins.
Redirigez le trafic IP destiné aux services vers le port d'écoute d'interception du proxy side-car.
- Le port d'écoute d'interception du proxy side-car est défini en tant que TRAFFICDIRECTOR_INTERCEPTION_PORT dans la configuration des métadonnées d'amorçage du proxy. Il est défini sur 15001 dans l'exemple de fichier de configuration d'amorçage dans ce fichier compressé.
- Le script iptables.sh Istio dans le fichier compressé pour configurer l'interception du trafic.

Créer le service de test `Hello World`

Cette section explique comment créer un service de test simple qui renvoie le nom d'hôte de la VM qui a diffusé la requête du client. Le service de test n'est pas complexe. Il s'agit d'un serveur Web déployé sur un groupe d'instances géré Compute Engine.

Créer le modèle d'instance

Le modèle d'instance que vous créez configure un exemple de serveur Web Apache2 à l'aide du paramètre startup-script.

Console

Dans la console Google Cloud, accédez à la page Modèles d'instances.

Accéder à la page "Modèles d'instances"
Cliquez sur Créer un modèle d'instance.
Dans les champs, saisissez les informations suivantes :
- Nom : td-demo-hello-world-template
- Disque de démarrage : Debian GNU/Linux 10 (buster)
- Compte de service : compte de service par défaut de Compute Engine
- Niveaux d'accès : autorisez l'accès complet à toutes les API Cloud
Cliquez sur Gestion, sécurité, disques, réseau et location unique.
Dans le champ Tags réseau de l'onglet Mise en réseau, ajoutez le paramètre Balise td-http-server.

Dans l'onglet Gestion, copiez le script suivant dans le champ Script de démarrage.

#! /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

Cliquez sur Créer.

gcloud

Créez le modèle d'instance :

gcloud compute instance-templates create td-demo-hello-world-template \
  --machine-type=n1-standard-1 \
  --boot-disk-size=20GB \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=td-http-server \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install apache2 -y
sudo service apache2 restart
sudo mkdir -p /var/www/html/
echo '<!doctype html><html><body><h1>'`/bin/hostname`'</h1></body></html>' | sudo tee /var/www/html/index.html"

Créer le groupe d'instances géré

Dans cette section, vous allez indiquer que le groupe d'instances géré comporte toujours deux instances du service de test. Cette présentation vous est fournie à des fins de démonstration. Cloud Service Mesh est compatible avec les groupes d'instances gérés avec autoscaling.

Console

Dans la console Google Cloud, accédez à la page Groupes d'instances.

Accéder à la page "Groupes d'instances"
Cliquez sur Créer un groupe d'instances.
Sélectionnez Nouveau groupe d'instances géré (sans état). Pour plus d'informations, consultez la page Groupes d'instances gérés (MIG) sans état ou avec état.
Saisissez td-demo-hello-world-mig pour le nom du groupe d'instances géré, puis sélectionnez la zone us-central1-a.
Sous Modèle d'instance, sélectionnez td-demo-hello-world-template, qui est le modèle d'instance que vous avez créé.
Sous Mode autoscaling, sélectionnez Ne pas procéder à un autoscaling.
Sous Nombre d'instances, spécifiez au moins deux pour le nombre d'instances que vous souhaitez créer dans le groupe.
Cliquez sur Créer.

gcloud

Utilisez gcloud CLI pour créer un groupe d'instances géré avec le modèle d'instance que vous avez créé précédemment.

gcloud compute instance-groups managed create td-demo-hello-world-mig \
  --zone us-central1-a \
  --size=2 \
  --template=td-demo-hello-world-template

Créer le modèle d'instance et le groupe d'instances géré dans lequel Envoy est déployé

Suivez les instructions de cette section pour créer manuellement un modèle d'instance et un groupe d'instances géré pour Cloud Service Mesh. Les groupes d'instances gérés créent des VM de backend à l'aide de l'autoscaling.

Cet exemple montre comment :

Créez un modèle de VM avec une configuration Envoy complète et un exemple de service qui diffuse son nom d'hôte à l'aide du protocole HTTP.
configurer un groupe d'instances géré à l'aide de ce modèle.

Créer le modèle d'instance

Commencez par créer le modèle d'instance de VM Compute Engine. Ce modèle configure automatiquement le proxy side-car Envoy et l'exemple de service Web apache2 via le paramètre startup-script.

Console

Dans la console Google Cloud, accédez à la page Modèles d'instances.

Accéder à la page "Modèles d'instances"
Cliquez sur Créer un modèle d'instance.
Remplissez les champs comme suit :
- Nom : td-vm-template
- Disque de démarrage:Debian GNU/Linux 10 (buster)
- Compte de service:compte de service Compute Engine par défaut
- Niveaux d'accès : autorisez l'accès complet à toutes les API Cloud.
Sous Pare-feu, cochez les cases Autoriser le trafic HTTP et Autoriser le trafic HTTPS.
Cliquez sur Gestion, sécurité, disques, réseau et location unique.

Dans l'onglet Gestion, copiez le script suivant dans le fichier Script de démarrage.

#! /usr/bin/env bash

# Set variables
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=NETWORK_NAME
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" \
 | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
curl -sL "https://deb.dl.getenvoy.io/public/gpg.8115BA8E629CC074.key" | sudo gpg --dearmor -o /usr/share/keyrings/getenvoy-keyring.gpg
echo a077cb587a1b622e03aa4bf2f3689de14658a9497a9af2c427bba5f4cc3c4723 /usr/share/keyrings/getenvoy-keyring.gpg | sha256sum --check
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/getenvoy-keyring.gpg] https://deb.dl.getenvoy.io/public/deb/debian $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/getenvoy.list
sudo apt update
sudo apt -y install getenvoy-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}"

Cliquez sur Créer pour générer le modèle.

gcloud

Créez le modèle d'instance.

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-10 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /usr/bin/env bash

# Set variables
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=NETWORK_NAME
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" \
  | sudo tee "${ENVOY_CONFIG}"

# Install Envoy binary
curl -sL "https://deb.dl.getenvoy.io/public/gpg.8115BA8E629CC074.key" | sudo gpg --dearmor -o /usr/share/keyrings/getenvoy-keyring.gpg
echo a077cb587a1b622e03aa4bf2f3689de14658a9497a9af2c427bba5f4cc3c4723 /usr/share/keyrings/getenvoy-keyring.gpg | sha256sum --check
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/getenvoy-keyring.gpg] https://deb.dl.getenvoy.io/public/deb/debian $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/getenvoy.list
sudo apt update
sudo apt -y install getenvoy-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}"
'

Créer le groupe d'instances géré

Si vous n'avez pas de groupe d'instances géré avec des services en cours d'exécution, créez-en un à l'aide d'un modèle de VM tel que celui présenté dans la section précédente. Cet exemple utilise le modèle d'instance créé dans la section précédente pour illustrer les fonctionnalités. Vous n'avez pas besoin d'utiliser le modèle d'instance.

Console

Dans la console Google Cloud, accédez à la page Groupes d'instances.

Accéder à la page "Groupes d'instances"
Cliquez sur Créer un groupe d'instances. Par défaut, la page de création d'un groupe d'instances géré s'affiche.
Choisissez Nouveau groupe d'instances géré (sans état). Pour plus d'informations, consultez la page Groupes d'instances gérés (MIG) sans état ou avec état.
Saisissez td-vm-mig-us-central1 pour le nom du groupe d'instances géré, puis sélectionnez la zone us-central1-a.
Dans la section Modèle d'instance, sélectionnez le modèle d'instance que vous avez créé.
Spécifiez 2 comme nombre d'instances que vous souhaitez créer dans le groupe.
Cliquez sur Créer.

gcloud

Utilisez gcloud CLI pour créer un groupe d'instances géré avec le modèle d'instance que vous avez créé précédemment.

gcloud compute instance-groups managed create td-vm-mig-us-central1 \
    --zone us-central1-a --size=2 --template=td-vm-template

Configurer Cloud Service Mesh avec les composants d'équilibrage de charge Google Cloud

Les instructions de cette section vous expliquent comment configurer Cloud Service Mesh de sorte que vos proxys Envoy équilibrent le trafic sortant sur deux instances backend. Vous configurez les composants suivants :

Une vérification de l'état Pour en savoir plus sur les vérifications d'état, consultez les pages Présentation des vérifications d'état et Créer des vérifications d'état.
Une règle de pare-feu pour permettre aux vérifications d'état d'atteindre les backends. Pour en savoir plus, consultez la section Présentation des vérifications d'état.
Un service de backend Pour en savoir plus sur les services de backend, consultez la page Présentation des services de backend.
Une carte des règles de routage. Comprend la création d'une règle de transfert et d'un mappage d'URL. Pour en savoir plus, consultez les pages Présentation des règles de transfert et Utiliser des mappages d'URL.

Créer la vérification de l'état

Suivez les instructions ci-dessous pour créer une vérification d'état. Pour en savoir plus, consultez la section Créer des vérifications d'état.

Console

Dans Google Cloud Console, accédez à la page Vérifications d'état.

Accéder à la page "Vérifications d'état"
Cliquez sur Créer une vérification de l'état.
Dans le champ du nom, saisissez td-vm-health-check.
Comme protocole, sélectionnez HTTP.
Cliquez sur Create (Créer).

gcloud

Créez la vérification d'état :

gcloud compute health-checks create http td-vm-health-check

Créez la règle de pare-feu:

gcloud compute firewall-rules create fw-allow-health-checks \
  --action ALLOW \
  --direction INGRESS \
  --source-ranges 35.191.0.0/16,130.211.0.0/22 \
  --target-tags http-td-tag,http-server,https-server \
  --rules tcp

Créez le service de backend :

Si vous utilisez Google Cloud CLI, vous devez désigner le service de backend en tant que service de backend global avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED. Ajoutez la vérification d'état et un groupe d'instances géré ou non géré au service de backend. Notez que 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 créé dans la section Créer le groupe d'instances géré.

Console

Dans la console Google Cloud, accédez à la page Cloud Service Mesh.

Accéder à Cloud Service Mesh
Dans l'onglet Services, cliquez sur Créer un service.
Cliquez sur Continuer.
Pour le nom du service, saisissez td-vm-service.
Sélectionnez le réseau VPC approprié.
Assurez-vous que le type de backend est bien défini sur Groupes d'instances.
Sélectionnez le groupe d'instances géré que vous avez créé.
Saisissez les numéros de port appropriés.
Sélectionnez Utilisation ou Taux comme mode d'équilibrage. La valeur par défaut est Taux.
Cliquez sur OK.
Sélectionnez la vérification d'état que vous avez créée.
Cliquez sur Enregistrer et continuer.
Cliquez sur Créer.

gcloud

Créez le service de backend :

gcloud compute backend-services create td-vm-service \
  --global \
  --load-balancing-scheme=INTERNAL_SELF_MANAGED \
  --health-checks td-vm-health-check

Ajoutez les backends au service de backend:

gcloud compute backend-services add-backend td-vm-service \
   --instance-group td-demo-hello-world-mig \
   --instance-group-zone us-central1-a \
   --global

Créer la carte des règles de routage

La carte des règles de routage définit la manière dont Cloud Service Mesh achemine le trafic dans votre maillage.

Suivez ces instructions pour créer la règle de routage, la règle de transfert, le proxy cible et l'adresse IP interne de votre configuration Cloud Service Mesh.

Le trafic envoyé à l'adresse IP interne est intercepté par le proxy Envoy et envoyé au service approprié conformément aux règles d'hôte et de chemin d'accès.

La règle de transfert est créée en tant que règle de transfert mondiale dont le paramètre load-balancing-scheme est défini sur INTERNAL_SELF_MANAGED.

Vous pouvez définir l'adresse de votre règle de transfert sur 0.0.0.0. Dans ce cas, le trafic est acheminé en fonction du nom d'hôte HTTP et des informations de chemin d'accès configurées dans le mappage d'URL, quelle que soit l'adresse IP de destination réelle de la requête. De plus, les noms d'hôte de vos services, tels que configurés dans les règles d'hôte, doivent être uniques dans la configuration de votre maillage de services. Autrement dit, vous ne pouvez pas disposer de deux services différents, avec des ensembles de backends différents, qui utilisent le même nom d'hôte.

Vous pouvez également activer le routage en fonction de l'adresse IP virtuelle de destination réelle du service. Si vous configurez l'adresse IP virtuelle de votre service en tant que paramètre address de la règle de transfert, seules les requêtes destinées à cette adresse sont acheminées en fonction des paramètres HTTP spécifiés dans le mappage d'URL.

Cet exemple utilise 10.0.0.1 comme paramètre d'adresse, ce qui signifie que le routage de votre service est effectué en fonction de l'adresse IP virtuelle de destination réelle du service.

Console

Dans la console Google Cloud, le proxy cible est associé à la règle de transfert. Lorsque vous créez la règle de transfert, Google Cloud crée automatiquement un proxy HTTP cible et l'associe au mappage d'URL.

Dans la console Google Cloud, accédez à la page Cloud Service Mesh.

Accéder à Cloud Service Mesh
Dans l'onglet Cartes des règles de routage, cliquez sur Créer une carte des règles de routage.
Saisissez un nom.
Cliquez sur Ajoutez une règle de transfert.
Pour le nom de la règle de transfert, saisissez td-vm-forwarding-rule.
Sélectionnez votre réseau.
Sélectionnez votre adresse IP interne. Le trafic envoyé à l'adresse IP interne est intercepté par le proxy Envoy et envoyé au service approprié conformément aux règles d'hôte et de chemin d'accès.

La règle de transfert est créée en tant que règle de transfert mondiale avec le paramètre load-balancing-scheme défini sur INTERNAL_SELF_MANAGED.
Dans le champs Adresse IP personnalisée, saisissez 10.0.0.1. Lorsque votre VM envoie du trafic à cette adresse IP, le proxy Envoy l'intercepte et le dirige vers le point de terminaison du service de backend approprié conformément aux règles de gestion du trafic définies dans le mappage d'URL.

Chaque règle de transfert sur un réseau VPC doit correspondre à une adresse IP et un port uniques par réseau VPC. Si vous créez plusieurs règles de transfert avec la même adresse IP et le même port dans un réseau VPC particulier, seule la première règle de transfert est valide. Les autres sont ignorées. Si 10.0.0.1 n'est pas disponible sur votre réseau, choisissez une adresse IP différente.
Assurez-vous que le port est défini sur la valeur 80.
Cliquez sur Enregistrer.
Dans la section Règles de routage, sélectionnez Règle d'hôte et de chemin d'accès simple.
Dans la section Règles d'hôte et de chemin d'accès, sélectionnez td-vm-service comme service.
Cliquez sur Ajouter une règle d'hôte et de chemin d'accès.
Dans le champ Hôtes, saisissez hello-world.
Dans le champ Service, sélectionnez td-vm-service.
Cliquez sur Enregistrer.

gcloud

Créez un mappage d'URL qui utilise le service de backend:

gcloud compute url-maps create td-vm-url-map \
   --default-service td-vm-service

Créez un outil de mise en correspondance des chemins d'accès de mappage d'URL et une règle d'hôte pour acheminer le trafic de votre service en fonction du nom d'hôte et du chemin d'accès. Cet exemple utilise service-test comme nom de service et un outil de mise en correspondance des chemins d'accès par défaut qui correspond à toutes les requêtes de chemin pour cet hôte (/*).
```
gcloud compute url-maps add-path-matcher td-vm-url-map \
   --default-service td-vm-service --path-matcher-name td-vm-path-matcher
```
```
gcloud compute url-maps add-host-rule td-vm-url-map --hosts service-test \
   --path-matcher-name td-vm-path-matcher \
   --hosts hello-world
```

Créez le proxy HTTP cible :

gcloud compute target-http-proxies create td-vm-proxy \
   --url-map td-vm-url-map

Créez la règle de transfert. La règle de transfert doit être globale et être créée avec la valeur load-balancing-scheme définie sur INTERNAL_SELF_MANAGED.

gcloud compute forwarding-rules create td-vm-forwarding-rule \
   --global \
   --load-balancing-scheme=INTERNAL_SELF_MANAGED \
   --address=10.0.0.1 \
   --target-http-proxy=td-vm-proxy \
   --ports 80 \
   --network default

À ce stade, Cloud Service Mesh est configuré pour équilibrer la charge du trafic pour les services spécifiés dans le mappage d'URL entre les backends du d'un groupe d'instances.

Vérifier la configuration

Dans cette dernière partie du guide de configuration de Cloud Service Mesh pour les VM Compute Engine, vous allez vérifier que le trafic envoyé depuis la VM cliente destinée à la règle de transfert VIP est intercepté et redirigé vers le proxy Envoy, lequel achemine votre requête vers les VM hébergeant le service Hello World.

Tout d'abord, vérifiez que les backends sont opérationnels en procédant comme suit :

Console

Dans la console Google Cloud, accédez à la page Cloud Service Mesh.

Accéder à Cloud Service Mesh

La section Summary (Résumé) vous indique si les services sont opérationnels.
Cliquez sur le nom d'un service. La page Détails du service contient des informations sur l'état des backends.
Si les backends ne sont pas opérationnels, vous pouvez les réinitialiser en cliquant sur le nom des backends, puis sur Réinitialiser sur la page Informations sur l'instance de VM.

gcloud

Utilisez la commande compute backend-services get-health pour vérifier que les backends sont opérationnels :

gcloud compute backend-services get-health td-vm-service \
    --global \
    --format=get(name, healthStatus)

Après avoir vérifié l'état de vos backends, connectez-vous à la VM cliente qui a été configurée pour intercepter le trafic et redirigez-le vers Envoy. Envoyez une requête curl à l'adresse IP virtuelle associée à votre carte de règles de routage. Envoy inspecte la requête curl, détermine le service auquel il doit répondre, puis la transfère vers un backend associé à ce service.

Console

Dans la console Google Cloud, accédez à la page Groupes d'instances.

Accéder à la page "Groupes d'instances"
Sélectionnez le groupe d'instances td-vm-mig-us-central1.
Sous Se connecter, cliquez sur SSH.
Une fois connecté à la VM cliente, utilisez l'outil curl pour envoyer une requête au service Hello World via Envoy :
```
curl -H "Host: hello-world" http://10.0.0.1/
```

Lorsque vous exécutez cette commande à plusieurs reprises, vous obtiendrez différentes réponses HTML contenant les noms d'hôte des backends dans le groupe d'instances géré Hello World. En effet, Envoy utilise l'équilibrage de charge "round robin" (à tour de rôle), l'algorithme d'équilibrage de charge par défaut, pour envoyer le trafic vers les backends du service Hello World.

Une fois la configuration terminée, chaque VM Compute Engine disposant d'un proxy side-car peut accéder aux services configurés dans Cloud Service Mesh à l'aide du protocole HTTP.

Si vous avez suivi les exemples spécifiques de ce guide à l'aide de la modèle de VM Compute Engine avec le serveur HTTP de démonstration et nom d'hôte du service service-test, procédez comme suit pour vérifier la configuration:

Connectez-vous à l'un des hôtes de VM sur lesquels un proxy side-car est installé.
Exécutez la commande curl -H 'Host: service-test' 10.0.0.1. Cette requête renvoie le nom d'hôte du backend du groupe d'instances géré qui a diffusé la requête.

À l'étape 2, notez que vous pouvez utiliser n'importe quelle adresse IP. Par exemple, la commande curl -I -H 'Host: service-test' 1.2.3.4 fonctionnerait pour cette étape.

En effet, le paramètre d'adresse de la règle de transfert est défini sur 0.0.0.0, qui indique à Cloud Service Mesh d'effectuer une mise en correspondance en fonction de l'hôte défini dans le mappage d'URL. Dans l'exemple de configuration, le nom d'hôte est service-test.

Étape suivante

En savoir plus sur la gestion avancée du trafic.
Découvrez comment résoudre les problèmes de déploiement de Cloud Service Mesh.
Découvrez comment configurer l'observabilité avec Envoy.

Configurer des VM avec un déploiement Envoy manuel

Présentation du processus de configuration

Créer le service de test Hello World

Créer le modèle d'instance

Console

gcloud

Créer le groupe d'instances géré

Console

gcloud

Créer le modèle d'instance et le groupe d'instances géré dans lequel Envoy est déployé

Créer le modèle d'instance

Console

gcloud

Créer le groupe d'instances géré

Console

gcloud

Configurer Cloud Service Mesh avec les composants d'équilibrage de charge Google Cloud

Créer la vérification de l'état

Console

gcloud

Créez le service de backend :

Console

gcloud

Créer la carte des règles de routage

Console

gcloud

Vérifier la configuration

Console

gcloud

Console

Étape suivante

Créer le service de test `Hello World`