Configura servicios de gRPC sin proxy

Nota: Esta guía solo es compatible con Cloud Service Mesh con las APIs de Google Cloud y no es compatible con las 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 de gRPC sin proxy con los recursos Mesh y GRPCRoute.

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 completa los requisitos previos descritos en ese documento.

Configura el recurso Mesh

Cuando una aplicación de gRPC sin proxy se conecta a un xds://hostname, la biblioteca cliente de 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.

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

   name: grpc-mesh
   

2. 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 el configuración, pero, como aún no hay servicios definidos, la configuración está vacío. 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.

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

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

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

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

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

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

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

Usa las siguientes 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 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 especificados en el recurso GRPCRoute en los backends del grupo de instancias administrado.

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.

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

Nota: Según la política, recomendamos a los usuarios que verifiquen las actualizaciones del generador de arranque gRPC de TD de forma anual.

Para verificar la configuración, accede a la VM de cliente y ejecuta los siguientes ejemplos.

1. Conéctate a la VM de cliente mediante SSH.

   gcloud compute ssh grpc-client
   

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

3. 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 un recurso Mesh o Gateway, consulta Cómo mostrar una lista de recursos Route. Esta función está en vista previa.