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 les services TCP

Ce guide vous explique comment configurer Cloud Service Mesh pour utiliser les services TCP et les ressources TCPRoute.

Cloud Service Mesh avec les services TCP et TCPRoute est semblable à la configuration du proxy side-car Envoy avec les services HTTP. Il existe toutefois une exception : le service de backend fournit un service TCP et le routage est basé sur les paramètres TCP/IP plutôt que sur le protocole HTTP.

Ressource Mesh avec la ressource TCPRoute — ressource `Mesh` avec Ressource `TCPRoute` (cliquez pour agrandir)

Avant de commencer

Veillez à effectuer les tâches décrites dans la section Préparer la configuration avec Envoy et des charges de travail sans proxy.

Configurer la ressource `Mesh`

Dans un fichier nommé mesh.yaml, créez la spécification de ressource mesh.
```
name: sidecar-mesh
```

Créez la ressource mesh à l'aide du fichier mesh.yaml.

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

Configurer le serveur TCP

Cette partie du guide n'est pas spécifique aux nouvelles API et utilise les ressources de service de backend, de vérification d'état et de MIG existantes.

À des fins de démonstration, vous créez un service de backend avec des VM avec autoscaling à l'aide de groupes d'instances gérés qui diffusent un service TCP de test sur le port 10000.

Créez un modèle d'instance de VM Compute Engine avec un service de test sur le port 10000.

gcloud compute instance-templates create tcp-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-10 \
  --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 &"

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

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

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

gcloud compute instance-groups set-named-ports tcp-td-mig-us-east1 

  --zone=ZONE 

  --named-ports=tcp:10000

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

gcloud compute health-checks create tcp tcp-helloworld-health-check --port 10000

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,130.211.0.0/22 \
   --target-tags allow-health-checks \
   --rules tcp:10000

Créez un service de backend global avec un schéma d'équilibrage de charge de INTERNAL_SELF_MANAGED et associez la vérification d'état au service de backend. L'exemple utilise le groupe d'instances géré qui exécute l'exemple de service TCP que vous avez créé précédemment.
```
gcloud compute backend-services create tcp-helloworld-service \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=TCP \
    --health-checks tcp-helloworld-health-check
```

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

gcloud compute backend-services add-backend tcp-helloworld-service \
  --instance-group tcp-td-mig-us-east1 \
  --instance-group-zone=ZONE \
  --global

Configurer le routage avec `TCPRoute`

Dans cette section, vous allez configurer le routage.

Dans un fichier nommé tcp_route.yaml, créez la spécification TcpRoute.

Vous pouvez utiliser $PROJECT_ID ou $PROJECT_NUMBER.

name: helloworld-tcp-route
meshes:
- projects/$PROJECT_NUMBER/locations/global/meshes/sidecar-mesh
rules:
- action:
    destinations:
    - serviceName: projects/$PROJECT_NUMBER/locations/global/backendServices/tcp-helloworld-service
  matches:
  - address: '10.0.0.1/32'
    port: '10000'

À l'aide de la spécification tcp_route.yaml, créez la ressource TcpRoute.

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

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

Créer un modèle d'instance, puis créer avec Envoy une VM connectée à Cloud Service Mesh.

gcloud beta compute instance-templates create td-vm-client-template \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --service-proxy=enabled,mesh=sidecar-mesh \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install netcat -y"

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

Connectez-vous à la VM que vous avez créée.
```
gcloud compute ssh td-vm-client
```
Vérifiez la connectivité aux services de test que vous avez créés à l'aide de l'utilitaire netcat.
```
echo 'Hi TCP Service' | nc 10.0.0.1 10000
```

Le service de test doit renvoyer l'expression Hello from TCP service. Vous devriez également voir tout texte saisi renvoyé par le service netcat qui s'exécute sur la VM distante.

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