Configurar servicios gRPC sin proxy

Nota: Esta guía solo admite Cloud Service Mesh con APIs de Google Cloud y no admite APIs de Istio. Para obtener más información, consulta la descripción general de Cloud Service Mesh.

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

Servicios de gRPC sin proxy con recursos GRPCRoute y Mesh (haz clic en la imagen para ampliarla)

Antes de empezar

Lee el artículo Preparar la configuración con Envoy y cargas de trabajo sin proxy y completa los requisitos previos que se describen en él.

Configurar el recurso Mesh

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

Anota el nombre del recurso Mesh, que es la clave que usa la aplicación de gRPC sin proxy para solicitar la configuración asociada a esta malla.

1. Crea la especificación Mesh y guárdala en un archivo llamado mesh.yaml.

   name: grpc-mesh
   

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

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

Una vez creado el recurso Mesh, Cloud Service Mesh estará listo para proporcionar la configuración, pero, como aún no se ha definido ningún servicio, la configuración estará vacía. En la siguiente sección, definirá los servicios y los asociará al recurso Mesh.

Configurar el servidor gRPC

Para hacer una demostración, creas un servicio de backend con VMs autoescaladas en un grupo de instancias gestionado. Las VMs sirven la frase hello world mediante el protocolo gRPC en el puerto 50051.

1. Crea la plantilla de instancia de VM de Compute Engine con un servicio de gRPC helloworldque 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')
    

2. Crea un grupo de instancias gestionado basado en la plantilla:

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

3. Crea el puerto con nombre para el servicio gRPC. El puerto con nombre es el puerto en el que el servicio 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
   

4. Crea una comprobación del estado de gRPC. Los servicios deben implementar el protocolo de comprobación del estado de gRPC para que las comprobaciones del estado de gRPC funcionen correctamente. Para obtener más información, consulta Comprobaciones del estado.

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

5. Crea una regla de cortafuegos para permitir las conexiones de comprobación del 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
   

6. Crea un servicio de backend global con un esquema de balanceo de carga INTERNAL_SELF_MANAGED y añade la comprobación de estado al servicio de backend. El puerto especificado aquí se usa para conectar con las VMs del grupo de instancias gestionado.

   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
   

7. Añade el grupo de instancias gestionado 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
   

Se han configurado los Mesh recursos y servicios. En la siguiente sección, configurará el enrutamiento.

Configurar el enrutamiento con GRPCRoute

Sigue estas instrucciones para configurar el enrutamiento.

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

2. Crea el recurso GrpcRoute con 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 la carga del tráfico de los servicios especificados en el recurso GRPCRoute entre los backends del grupo de instancias gestionado.

Crear un cliente gRPC

Para verificar la configuración, crea una instancia de una aplicación gRPC sin proxy y conéctala a Cloud Service Mesh. En su archivo de arranque, la aplicación debe especificar la red de VPC indicada en la malla.

Una vez configurada, la aplicación puede enviar una solicitud a las instancias o los endpoints asociados a helloworld-gce mediante el URI de servicio xds:///helloworld-gce.

En los ejemplos siguientes, se usa la herramienta grpcurl para probar el servicio gRPC.

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

Configurar 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 define la variable de entorno GRPC_XDS_BOOTSTRAP y usa una secuencia de comandos auxiliar para generar el archivo de arranque. Los valores de TRAFFICDIRECTOR_GCP_PROJECT_NUMBER y de la zona del archivo de arranque generado se obtienen del servidor de metadatos, que conoce estos detalles sobre tus instancias de VM. Puede proporcionar estos valores al script auxiliar manualmente mediante 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.

Nota: De acuerdo con la política, recomendamos a los usuarios que comprueben si hay actualizaciones del generador de bootstrap de gRPC de TD cada año.

Para verificar la configuración, inicia sesión en la VM del cliente y ejecuta lo siguiente.

1. Accede a la VM cliente mediante SSH.

   gcloud compute ssh grpc-client
   

2. Descarga e instala la herramienta grpcurl.

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

3. Ejecuta la herramienta grpcurl con xds:///helloworld-gce como URI de servicio y helloworld.Greeter/SayHello como nombre de servicio y método que invocar. Los parámetros del método SayHello se transfieren mediante la opción -d.

   ./grpcurl --plaintext \
     -d '{"name": "world"}' \
     xds:///helloworld-gce helloworld.Greeter/SayHello
   

Debería ver un resultado similar al siguiente, donde 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 ha conectado correctamente a Cloud Service Mesh y ha obtenido información sobre los backends del servicio helloworld-gce mediante el resolvedor de nombres xds. El cliente ha enviado una solicitud a uno de los back-ends del servicio sin necesidad de conocer la dirección IP ni de realizar la resolución de DNS.

Siguientes pasos

• Para obtener información sobre cómo enumerar los recursos de ruta asociados a un recurso Mesh o Gateway, consulta Enumerar recursos de Route.