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

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

Configurer des VM Compute Engine et des services gRPC sans proxy

Ce guide explique comment configurer les hôtes de VM Compute Engine, les applications gRPC et les composants d'équilibrage de charge requis par Cloud Service Mesh.

Avant de suivre les instructions de ce guide, consultez Préparer la configuration de Cloud Service Mesh avec des services gRPC sans proxy.

Présentation

La configuration de Cloud Service Mesh avec des machines virtuelles (VM) Compute Engine et des services gRPC sans proxy implique les opérations suivantes:

Configurer un groupe d'instances géré qui héberge vos backends
Configurer les backends pour exécuter un serveur gRPC qui renvoie hello world en réponse à une requête d'un client
configurer Cloud Service Mesh à l'aide du groupe d'instances géré et d'autres composants d'équilibrage de charge Google Cloud ;
Vérifier que le déploiement fonctionne correctement en utilisant une application cliente gRPC sans proxy pour envoyer du trafic vers l'application de serveur gRPC

Le client gRPC sans proxy se connecte à Cloud Service Mesh à l'aide de xDS. Lorsque le client se connecte à Cloud Service Mesh, Cloud Service Mesh lui envoie des informations sur les backends associés au service hello world. À l'aide de ces informations, le client gRPC sans proxy envoie des requêtes au serveur gRPC hello world.

Configurer un groupe d'instances géré pour Cloud Service Mesh

Les groupes d'instances gérés utilisent l'autoscaling pour créer des VM de backend, selon les besoins de votre déploiement. Cet exemple vous montre comment effectuer les opérations suivantes :

Créer un modèle d'instance avec un exemple de service qui diffuse un service hello world à l'aide du protocole gRPC
Configurer un groupe d'instances géré à l'aide du modèle

Créer le modèle d'instance

Cette section fournit des instuctions concernant la création d'un modèle d'instance. Dans l'exemple, vous déployez un service gRPC helloworld exposé sur le port 50051.

Console

Dans la console Google Cloud, accédez à la page Modèles d'instances.
Accéder à la page Modèles d'instance
Cliquez sur Créer un modèle d'instance.
Remplissez les champs comme suit :
- Nom : grpc-td-vm-template
- Version du disque de démarrage : Debian/Linux 10
- Compte de service : compte de service par défaut de Compute Engine
- Niveaux d'accès : autorisez l'accès complet à toutes les API Google 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 champ Script de démarrage.

#! /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.37.0.tar.gz | tar -xz
cd grpc-java-1.37.0/examples/example-hostname
../gradlew --no-daemon installDist
# Server listens on 50051
sudo systemd-run ./build/install/hostname-server/bin/hostname-server

Cliquez sur Créer.

gcloud

Créez le modèle d'instance.

gcloud compute instance-templates create grpc-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-10 \
  --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.37.0.tar.gz | tar -xz
cd grpc-java-1.37.0/examples/example-hostname
../gradlew --no-daemon installDist
# Server listens on 50051
sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

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

Dans cette section, vous allez créer un groupe d'instances géré à l'aide du modèle d'instance que vous avez créé à la section précédente.

Console

Accédez à la page "Groupes d'instances" de la console Google Cloud.
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.
Saisissez grpc-td-mig-us-central1 pour le nom du groupe d'instances géré, puis sélectionnez la zone us-central1-a.
Sous Modèle d'instance, sélectionnez grpc-td-vm-template, qui est le modèle d'instance que vous avez créé.
Spécifiez 2 comme nombre minimal et maximal d'instances que vous souhaitez créer au sein du groupe.
Cliquez sur Créer.

gcloud

Créez le groupe d'instances géré.

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

Configurer le port nommé

Dans cette section, vous configurez le port nommé pour le service gRPC. Le port nommé est le port sur lequel le service gRPC écoute les requêtes. Dans cet exemple, le port nommé est le port 50051.

Console

Accédez à la page "Groupes d'instances" de la console Google Cloud.
Accéder à la page Groupes d'instances
Cliquez sur le nom du groupe d'instances grpc-td-mig-us-central1 que vous avez créé.
Cliquez sur Modifier le groupe.
Dans le champ Nom du port, saisissez grpc-helloworld-port.
Dans le champ Numéro de port, saisissez 50051.
Cliquez sur Enregistrer.

gcloud

Configurez le port nommé.

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

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

Cette section fournit des instructions pour configurer Cloud Service Mesh avec les composants d'équilibrage de charge Google Cloud pour vos services.

Créer la vérification d'état, la règle de pare-feu et le service de backend

Dans cette section, vous allez créer un service de backend global avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED et le protocole GRPC, puis associer la vérification d'état et le groupe d'instances au service de backend. Dans cet exemple, vous utilisez le groupe d'instances géré que vous avez créé à la section Créer le groupe d'instances géré. Ce groupe d'instances géré exécute l'exemple de service gRPC. Le port correspondant à l'option --port-name est le port nommé que vous avez créé dans Configurer le port nommé.

gcloud

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

gcloud compute health-checks create grpc grpc-helloworld-health-check \
 --use-serving-port

Créez la règle de pare-feu de vérification d'état.

gcloud compute firewall-rules create grpc-vm-allow-health-checks \
  --network default --action allow --direction INGRESS \
  --source-ranges=35.191.0.0/16,130.211.0.0/22 \
  --target-tags allow-health-checks \
  --rules tcp:50051

Créez le service de backend :

gcloud compute backend-services create grpc-helloworld-service \
   --global \
   --load-balancing-scheme=INTERNAL_SELF_MANAGED \
   --protocol=GRPC \
   --port-name=grpc-helloworld-port \
   --health-checks=grpc-helloworld-health-check

Ajoutez le groupe d'instances géré au service de backend.

gcloud compute backend-services add-backend grpc-helloworld-service \
 --instance-group grpc-td-mig-us-central1 \
 --instance-group-zone us-central1-a \
 --global

Créer la carte des règles de routage, le proxy cible et la règle de transfert

Dans cette section, vous allez créer un mappage d'URL, un outil de mise en correspondance des chemins d'accès et une règle d'hôte pour acheminer le trafic de votre service en fonction du nom d'hôte et d'un chemin d'accès. L'exemple suivant utilise helloworld-gce comme nom de service. L'application gRPC utilise ce nom de service dans l'URI cible lors de la connexion à ce service. Par défaut, l'outil de mise en correspondance des chemins d'accès correspond à toutes les requêtes de chemin d'accès (/*) de cet hôte. Vous créez également le proxy gRPC cible et la règle de transfert.

Pour en savoir plus, consultez la section Cartes des règles de routage.

Dans l'exemple suivant, le port 80 est le port spécifié.

gcloud

Créez le mappage d'URL.

gcloud compute url-maps create grpc-vm-url-map \
  --default-service grpc-helloworld-service

Créez l'outil de mise en correspondance des chemins d'accès.

gcloud compute url-maps add-path-matcher grpc-vm-url-map \
  --default-service grpc-helloworld-service \
  --path-matcher-name grpc-vm-path-matcher \
  --new-hosts helloworld-gce

Créez le proxy gRPC cible.

gcloud compute target-grpc-proxies create grpc-vm-proxy \
 --url-map grpc-vm-url-map \
 --validate-for-proxyless

Créez la règle de transfert.

gcloud compute forwarding-rules create grpc-vm-forwarding-rule \
 --global \
 --load-balancing-scheme=INTERNAL_SELF_MANAGED \
 --address=0.0.0.0 --address-region=us-central1 \
 --target-grpc-proxy=grpc-vm-proxy \
 --ports 80 \
 --network default

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

Vérifier la configuration

Une fois le processus de configuration terminé, vérifiez que vous pouvez établir une connexion gRPC avec le service Cloud Service Mesh à équilibrage de charge que vous avez créé précédemment.

Pour vérifier que le service est disponible, effectuez l'une des opérations suivantes :

Connectez-vous à l'un des hôtes de la VM (le backend du service gRPC) et vérifiez que le service gRPC est en cours d'exécution sur le port d'écoute. Dans l'exemple, le port est 50051.
Consultez la page Cloud Service Mesh dans la console pour en savoir plus sur le service configuré helloworld-gce et vérifiez que les backends sont signalés comme opérationnels.
Suivez les instructions ci-dessous pour utiliser un client gRPC Compute Engine à des fins de vérification.

Vérifier le service avec une application cliente gRCP

Dans les exemples suivants, vous utilisez un client gRPC dans le langage de votre choix ou l'outil grpcurl pour tester le service gRPC.

Créez tout d'abord une VM cliente sur laquelle vous exécutez le client gRPC pour tester le service.

gcloud compute instances create grpc-client \
  --zone us-central1-a \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata-from-file=startup-script=<(echo '#! /bin/bash
set -e
export GRPC_XDS_BOOTSTRAP=/run/td-grpc-bootstrap.json
# Expose bootstrap variable to SSH connections
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
# Create the bootstrap file
curl -L https://storage.googleapis.com/traffic-director/td-grpc-bootstrap-0.11.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.11.0/td-grpc-bootstrap | tee $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, TRAFFICDIRECTOR_NETWORK_NAME et zone dans le fichier d'amorçage généré sont obtenues auprès du serveur de métadonnées qui connaît ces informations sur vos instances de VM Compute Engine. Vous pouvez fournir manuellement ces valeurs au script d'aide en utilisant les options -gcp-project-number et -vpc-network-name.

Pour vérifier la configuration, connectez-vous à la VM cliente et exécutez les exemples suivants.

Java

Pour vérifier le service avec un client Java gRPC, procédez comme suit :

Téléchargez la dernière version de gRPC Java, avec le dernier correctif et créez l'application cliente xds-hello-world.

sudo apt-get update -y
sudo apt-get install -y openjdk-11-jdk-headless
curl -L https://github.com/grpc/grpc-java/archive/v1.37.0.tar.gz | tar -xz
cd grpc-java-1.37.0/examples/example-xds
../gradlew --no-daemon installDist

Exécutez le client avec world comme nom et xds:///helloworld-gce comme URI du service.

./build/install/example-xds/bin/xds-hello-world-client "world" \
   xds:///helloworld-gce

Go

Pour vérifier le service avec un client Go gRPC, procédez comme suit :

Téléchargez la dernière version de gRPC Go avec le correctif le plus récent, puis créez l'application cliente xds-hello-world.

sudo apt-get update -y
sudo apt-get install -y golang git
curl -L https://github.com/grpc/grpc-go/archive/v1.37.0.tar.gz | tar -xz
cd grpc-go-1.37.0/examples/features/xds/client
go get google.golang.org/grpc@v1.37.0
go build .

Exécutez le client avec world comme nom et xds:///helloworld-gce comme URI du service.
```
./client "world" xds:///helloworld-gce
```

C++

Pour vérifier le service avec un client C++ gRPC, procédez comme suit :

Téléchargez la dernière version de gRPC C++, avec le dernier correctif, et créez l'exemple de client helloworld.

sudo apt-get update -y
sudo apt-get install -y build-essential cmake git
git clone --recurse-submodules -b v1.37.1 https://github.com/grpc/grpc
cd grpc
mkdir -p cmake/build
pushd cmake/build
cmake ../..
make
sudo make install
popd
mkdir -p third_party/abseil-cpp/cmake/build
pushd third_party/abseil-cpp/cmake/build
cmake ../..
make
sudo make install
popd
cd examples/cpp/helloworld
mkdir -p cmake/build
cd cmake/build/
cmake ../..
make

Exécutez le client avec "xds:///helloworld-gce" comme URI du service.
```
./greeter_client --target=xds:///helloworld-gce
```

grpcurl

Pour vérifier le service à l'aide de l'outil grpcurl, procédez comme suit :

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

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

Exécutez l'outil grpcurl avec "xds:///helloworld-gce" comme URI du service et helloworld.Greeter/SayHello comme nom du service et la méthode à appeler. Les paramètres de la méthode SayHello sont transmis à l'aide de l'option -d.
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gce helloworld.Greeter/SayHello
```

Python

Pour vérifier le service avec un client Python gRPC, exécutez la commande suivante. Utilisez la dernière version de gRPC avec le correctif le plus récent.

sudo apt-get update
sudo apt-get -y install python3-pip
sudo pip3 install virtualenv
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/python/xds
virtualenv venv -p python3
source venv/bin/activate
pip install -r requirements.txt
python client.py  xds:///helloworld-gce

Ruby

Pour vérifier le service avec un client Ruby gRPC, exécutez la commande suivante : Utilisez la dernière version de gRPC avec le correctif le plus récent.

sudo apt-get update
sudo apt-get install -y ruby-full
sudo gem install grpc
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/ruby
ruby greeter_client.rb john xds:///helloworld-gce

PHP

Pour vérifier le service avec un client PHP gRPC, exécutez la commande suivante : Utilisez la dernière version de gRPC avec le correctif le plus récent.

sudo apt-get update
sudo apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
sudo pecl install grpc
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1
export CC=/usr/bin/gcc
./tools/bazel build @com_google_protobuf//:protoc
./tools/bazel build src/compiler:grpc_php_plugin
cd examples/php
composer install
./../../bazel-bin/external/com_google_protobuf/protoc --proto_path=../protos \
--php_out=. --grpc_out=. \
--plugin=protoc-gen-grpc=../../bazel-bin/src/compiler/grpc_php_plugin \
../protos/helloworld.proto
php -d extension=grpc.so greeter_client.php john xds:///helloworld-gce

Node.js

Pour vérifier le service avec un client Node.js gRPC, exécutez la commande suivante : Utilisez la dernière version de gRPC avec le correctif le plus récent.

sudo apt-get update
sudo apt-get install -y nodejs npm
curl -L https://github.com/grpc/grpc/archive/v1.34.0.tar.gz | tar -xz
cd grpc-1.34.0/examples/node/xds
npm install
node ./greeter_client.js --target=xds:///helloworld-gce

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 permet de vérifier que le client gRPC sans proxy s'est bien connecté à Cloud Service Mesh et qu'il a appris l'existence des backends du service helloworld-gce à l'aide du résolveur de noms 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.

Étapes suivantes

En savoir plus sur la gestion avancée du trafic.
Apprenez à configurer l'observabilité.
Découvrez comment résoudre les problèmes liés aux déploiements Cloud Service Mesh sans proxy.