Configurer des VM Compute Engine et des services gRPC sans proxy

Ce guide vous 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 la page Préparer la configuration de Cloud Service Mesh avec des services gRPC sans proxy.

Présentation

Configurer Cloud Service Mesh avec des machines virtuelles Compute Engine (VM) et les services gRPC sans proxy impliquent les éléments suivants:

1. Configurer un groupe d'instances géré qui héberge vos backends
2. Configurer les backends pour exécuter un serveur gRPC qui renvoie hello world en réponse à une requête d'un client
3. Configurer Cloud Service Mesh à l'aide du groupe d'instances géré d'autres composants d'équilibrage de charge Google Cloud.
4. 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, il envoie des informations au client à propos des 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

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

   Accéder à la page Modèles d'instance

2. Cliquez sur Créer un modèle d'instance.

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

4. Sous Pare-feu, cochez les cases Autoriser le trafic HTTP et Autoriser le trafic HTTPS.

5. Cliquez sur Gestion, sécurité, disques, réseau et location unique.

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

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

1. Accédez à la page Groupes d'instances de la console Google Cloud.

   Accéder à la page Groupes d'instances

2. 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.
3. Saisissez grpc-td-mig-us-central1 pour le nom du groupe d'instances géré, puis sélectionnez la zone us-central1-a.
4. Sous Modèle d'instance, sélectionnez grpc-td-vm-template, qui est le modèle d'instance que vous avez créé.
5. Spécifiez 2 comme nombre minimal et maximal d'instances que vous souhaitez créer au sein du groupe.
6. 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

1. Accédez à la page Groupes d'instances de la console Google Cloud.

   Accéder à la page Groupes d'instances

2. Cliquez sur le nom du groupe d'instances grpc-td-mig-us-central1 que vous avez créé.
3. Cliquez sur Modifier le groupe.
4. Dans le champ Nom du port, saisissez grpc-helloworld-port.
5. Dans le champ Numéro de port, saisissez 50051.
6. 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 concernant la configuration de Cloud Service Mesh avec des 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

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

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

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

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

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

1. Créez le mappage d'URL.

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

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

3. Créez le proxy gRPC cible.

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

4. 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 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 à équilibrage de charge Cloud Service Mesh 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 VM (le backend du service gRPC) et vérifiez que le service gRPC s'exécute 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 étant 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.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.0/td-grpc-bootstrap | tee $GRPC_XDS_BOOTSTRAP')

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

Remarque :Conformément à la stratégie, nous encourageons les utilisateurs à rechercher les mises à jour du générateur d'amorçage TD gRPC tous les ans.

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.

Remarque : L'ajout de la génération d'amorçage au script d'initialisation de la VM garantit qu'un fichier d'amorçage à jour est créé à chaque redémarrage de la VM.

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 :

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

2. 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 :

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

2. 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 :

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

2. 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 :

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

2. 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 découvert les backends de 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.

Étape suivante

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