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 services gRPC sans proxy

Ce guide explique comment configurer un maillage de services gRPC sans proxy avec des ressources Mesh et GRPCRoute.

Services gRPC sans proxy avec des ressources GRPCRoute et Mesh — Services gRPC sans proxy avec ressources `GRPCRoute` et`Mesh` (cliquez pour agrandir)

Avant de commencer

Veillez à lire la section Préparer la configuration avec Envoy et des charges de travail sans proxy et à remplir les conditions préalables décrites dans ce document.

Configurer la ressource `Mesh`

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

Veillez à noter le nom de la ressource Mesh, qui est la clé utilisée par l'application gRPC sans proxy pour demander la configuration associée à ce maillage.

Créez la spécification Mesh et enregistrez-la dans un fichier nommé mesh.yaml.
```
name: grpc-mesh
```

Créez la ressource Mesh à l'aide de la spécification mesh.yaml :

gcloud network-services meshes import grpc-mesh \
  --source=mesh.yaml \
  --location=global

Une fois la ressource Mesh créée, Cloud Service Mesh est prêt à diffuser la configuration. Toutefois, comme aucun service n'est encore défini, la configuration est vide. Dans la section suivante, vous allez définir les services et les associer à la ressource Mesh.

Configurer le serveur gRPC

À des fins de démonstration, vous créez un service de backend avec des VM avec autoscaling dans un groupe d'instances géré. Les VM diffusent l'expression hello world à l'aide du protocole gRPC sur le port 50051.

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-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.38.0.tar.gz | tar -xz
 cd grpc-java-1.38.0/examples/example-hostname
 ../gradlew --no-daemon installDist
 sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Créez un groupe d'instances géré basé sur le modèle :

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

Créez le port nommé pour le service gRPC. Le port nommé est le port sur lequel le service gRPC écoute les requêtes. Dans l'exemple suivant, le port nommé est 50051 :
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-east1 \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Créer une vérification d'état gRPC 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 la section Vérifications d'état.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Créez une règle de pare-feu pour autoriser les connexions de vérification d'état 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,130.211.0.0/22 \
  --target-tags allow-health-checks \
  --rules=tcp:50051

Créez un service de backend global avec un schéma d'équilibrage de charge INTERNAL_SELF_MANAGED et ajoutez la vérification d'état au service de backend. Le port spécifié ici permet de se connecter aux VM du groupe d'instances géré.
```
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-east1 \
  --instance-group-zone=ZONE \
  --global

La ressource et les services Mesh sont configurés. Dans la section suivante, vous allez configurer le routage.

Configurer le routage avec `GRPCRoute`

Suivez les instructions ci-dessous pour configurer le routage.

Créez la spécification GRPCRoute et enregistrez-la dans un fichier nommé grpc_route.yaml.

Vous pouvez utiliser PROJECT_ID ou PROJECT_NUMBER.

name: helloworld-grpc-route
hostnames:
- helloworld-gce
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-helloworld-service

Créez la ressource GrpcRoute à l'aide de la spécification grpc_route.yaml :

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

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

Créer un client gRPC

Vous pouvez vérifier la configuration en instanciant une application gRPC sans proxy et en la connectant à Cloud Service Mesh. Dans son fichier d'amorçage, l'application doit spécifier le réseau VPC indiqué dans le maillage.

Une fois configurée, l'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, vous utilisez l'outil grpcurl pour tester le service gRPC.

Créer une VM cliente

gcloud compute instances create grpc-client \
  --zone=ZONE\
  --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
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.14.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.14.0/td-grpc-bootstrap --config-mesh-experimental grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Configurer le fichier d'amorçage

L'application cliente doit disposer d'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. 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 Mesh à l'aide de l'option --config-mesh-experimental.

Pour vérifier la configuration, connectez-vous à la VM cliente et exécutez la commande suivante.

Connectez-vous en SSH à la VM cliente.
```
gcloud compute ssh grpc-client
```

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 en tant qu'URI de service et helloworld.Greeter/SayHello en tant que nom de service et 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
```

Un résultat semblable aux lignes suivantes doit s'afficher, où INSTANCE_HOSTNAME correspond au nom de l'instance de VM :

   Greeting: Hello world, from INSTANCE_HOSTNAME

Le résultat vérifie que le client gRPC sans proxy a bien été connecté à Cloud Service Mesh et 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 effectuer la résolution DNS.

Étapes suivantes

Pour savoir comment répertorier les ressources de routage associées à une ressource Mesh ou Gateway, consultez la section Répertorier les ressources Route. Cette fonctionnalité est disponible en version d'évaluation.