Anthos Service Mesh y Traffic Director ahora son Cloud Service Mesh. Para obtener más información, consulta la descripción general de Cloud Service Mesh.

Se usó la API de Cloud Translation para traducir esta página.

Configura servicios de gRPC sin proxy

En esta guía, se muestra cómo configurar una malla de servicios de gRPC sin proxy con los recursos Mesh y GRPCRoute.

Servicios de gRPC sin proxy con recursos GRPCRoute y Mesh — Servicios de gRPC sin proxy con recursos `GRPCRoute` y `Mesh` (haz clic para ampliar)

Antes de comenzar

Asegúrate de leer Prepárate para configurar con Envoy y cargas de trabajo sin proxy y completar los requisitos previos que se describen en ese documento.

Configura el recurso `Mesh`

Cuando una aplicación de gRPC sin proxy se conecta a xds://hostname, gRPC establece una conexión con Cloud Service Mesh. La biblioteca cliente usa la conexión a fin de obtener la configuración de enrutamiento necesaria para enrutar las solicitudes del nombre de host.

Asegúrate de anotar el nombre del recurso Mesh, que es la clave que usa la aplicación de gRPC sin proxy para solicitar la configuración asociada con esta malla.

Crea la especificación Mesh y guárdala en un archivo llamado mesh.yaml.
```
name: grpc-mesh
```

Crea el recurso Mesh mediante la especificación mesh.yaml:

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

Después de crear el recurso Mesh, Cloud Service Mesh está listo para entregar la configuración, pero como aún no hay servicios definidos, está vacía. En la siguiente sección, debes definir los servicios y adjuntarlos al recurso Mesh.

Configura el servidor de gRPC

A modo de demostración, crearás un servicio de backend con VM con ajuste de escala automático en un grupo de instancias administrado. Las VM entregan la frase hello world mediante el protocolo de gRPC en el puerto 50051.

Crea la plantilla de instancias de VM de Compute Engine con un servicio de gRPC helloworld que se exponga en el puerto 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')

Cree un grupo de instancias administrado basado en la plantilla:

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

Crea el puerto con nombre para el servicio de gRPC. El puerto con nombre es el puerto en el que el servicio de gRPC escucha las solicitudes. En el siguiente ejemplo, el puerto con nombre es 50051:
```
gcloud compute instance-groups set-named-ports grpc-td-mig-us-east1 \
 --named-ports=grpc-helloworld-port:50051 \
 --zone=ZONE
```
Crea una verificación de estado de gRPC. Los servicios deben implementar el protocolo de verificación de estado de gRPC para que las verificaciones de estado de gRPC funcionen de forma correcta. Para obtener más información, consulta Verificaciones de estado.
```
gcloud compute health-checks create grpc grpc-helloworld-health-check \
  --use-serving-port
```

Crea una regla de firewall para permitir las conexiones de verificación de estado a las instancias de tu red:

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

Crea un servicio de backend global con un esquema de balanceo de cargas de INTERNAL_SELF_MANAGED y agrega la verificación de estado al servicio de backend. El puerto que se especifica aquí se usa para conectarse a las VM del grupo de instancias administrado.
```
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
```

Agrega el grupo de instancias administrado al servicio de backend.

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

Los servicios y el recurso Mesh están configurados. En la siguiente sección, configurarás el enrutamiento.

Configura el enrutamiento con `GRPCRoute`

Sigue las instrucciones que se indican a continuación para configurar el enrutamiento.

Crea la especificación GRPCRoute y guárdala en un archivo llamado grpc_route.yaml.

Puedes usar PROJECT_ID o 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

Crea el recurso GrpcRoute mediante la especificación grpc_route.yaml:

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

Cloud Service Mesh ahora está configurado para balancear las cargas del tráfico de los servicios especificado en el recurso GRPCRoute en los backends de la instancia administrada grupo.

Crea un cliente de gRPC

Para verificar la configuración, crea una instancia de gRPC sin proxy. una aplicación y conectarla a Cloud Service Mesh. En su archivo de arranque, la aplicación debe especificar la red de VPC que se indica en la malla.

Después de configurarla, la aplicación puede enviar una solicitud a las instancias o los extremos asociados con helloworld-gce mediante el URI de servicio xds:///helloworld-gce.

En los siguientes ejemplos, usas la herramienta de grpcurl para probar el servicio de gRPC.

Crea una VM de 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.16.0.tar.gz | tar -xz
./td-grpc-bootstrap-0.16.0/td-grpc-bootstrap --config-mesh-experimental grpc-mesh | tee $GRPC_XDS_BOOTSTRAP')

Configura el archivo de arranque

La aplicación cliente debe tener un archivo de configuración de arranque. La secuencia de comandos de inicio de la sección anterior configura la variable de entorno GRPC_XDS_BOOTSTRAP y usa una secuencia de comandos auxiliar para generar el archivo de arranque. Los valores para TRAFFICDIRECTOR_GCP_PROJECT_NUMBER y la zona del archivo de arranque generado se obtienen del servidor de metadatos que conoce estos detalles de las instancias de VM. Puedes proporcionar estos valores a la secuencia de comandos auxiliar de forma manual con la opción --gcp-project-number. Debes proporcionar un nombre de malla que coincida con el recurso Mesh mediante la opción --config-mesh-experimental.

Para verificar la configuración, accede a la VM del cliente y ejecuta la siguientes.

Conéctate a la VM de cliente mediante SSH.
```
gcloud compute ssh grpc-client
```

Descarga e instala la herramienta de grpcurl.

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

Ejecuta la herramienta de grpcurl con xds:///helloworld-gce como el URI del servicio y helloworld.Greeter/SayHello como el nombre del servicio y el método que se invocará. Los parámetros del método SayHello se pasan mediante la opción -d.
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gce helloworld.Greeter/SayHello
```

Deberías ver un resultado similar al siguiente, en el que INSTANCE_HOSTNAME es el nombre de la instancia de VM:

   Greeting: Hello world, from INSTANCE_HOSTNAME

El resultado verifica que el cliente de gRPC sin proxy se conectó de forma correcta a Cloud Service Mesh y aprendiste sobre los backends del Servicio helloworld-gce con el agente de resolución de nombres xds. El cliente envió una solicitud a uno de los backends del servicio sin necesidad de conocer la dirección IP ni realizar la resolución de DNS.

¿Qué sigue?

Para obtener información sobre cómo mostrar una lista de recursos de ruta asociados con una Mesh o Recurso Gateway, consulta Lista de recursos Route. Esta función está en vista previa.