Configura VM de Compute Engine y servicios de gRPC sin proxy

En esta guía, se muestra cómo configurar hosts de VM de Compute Engine, gRPC aplicaciones y los componentes del balanceo de cargas que la infraestructura y los procesos que requiere la administración de datos.

Antes de seguir las instrucciones de esta guía, revisa Prepárate para configurar Cloud Service Mesh con servicios de gRPC sin proxy.

Descripción general

La configuración de la malla de servicios de Cloud con máquinas virtuales (VM) de Compute Engine y servicios de gRPC sin proxy implica lo siguiente:

1. Configurar un grupo de instancias administrado que aloje tus backends
2. Configurar los backends para que ejecuten un servidor de gRPC que muestre hello world en respuesta a una solicitud de un cliente
3. Configurar Cloud Service Mesh mediante el grupo de instancias administrado y otros componentes del balanceo de cargas de Google Cloud
4. Verificar que la implementación funcione de forma correcta mediante una aplicación cliente de gRPC sin proxy para enviar tráfico a la aplicación del servidor de gRPC

El cliente de gRPC sin proxy se conecta a Cloud Service Mesh mediante xDS. Cuando el cliente se conecta a Cloud Service Mesh, este servicio le envía información sobre los backends asociados con el servicio hello world. Con esta información, el cliente de gRPC sin proxy envía solicitudes al servidor de gRPC hello world.

Configura un grupo de instancias administrado para Cloud Service Mesh

Los grupos de instancias administrados usan el ajuste de escala automático para crear VM de backend nuevas, según sea necesario en tu implementación. En este ejemplo, se muestra cómo hacer lo siguiente:

• Crear una plantilla de instancias con un servicio de muestra que entregue un servicio hello world mediante el protocolo gRPC
• Configurar un grupo de instancias administrado con la plantilla

Crea la plantilla de instancias

En esta sección, se proporcionan instrucciones para crear una plantilla de instancias. En el ejemplo, implementarás un servicio de gRPC helloworld que se expone en el puerto 50051.

Console

1. En la consola de Google Cloud, ve a la página Plantillas de instancia.

   Ir a la página Plantillas de instancias

2. Haz clic en Crear plantilla de instancias.

3. Completa los campos de la siguiente manera:

   • Nombre: grpc-td-vm-template
   • Versión del disco de arranque: Debian o Linux 10
   • Cuenta de servicio: Cuenta de servicio predeterminada de Compute Engine
   • Permiso de acceso: Permitir el acceso total a todas las API de Google Cloud

4. En Firewall, selecciona las casillas junto a Permitir tráfico HTTP y Permitir tráfico HTTPS.

5. Haz clic en Administración, seguridad, discos, redes, usuario único.

6. En la pestaña Administración, copia la siguiente secuencia de comandos en el campo Secuencia de comandos de inicio.

   #! /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.37.0.tar.gz | tar -xz
   cd grpc-java-1.37.0/examples/example-hostname
   ../gradlew --no-daemon installDist
   # Server listens on 50051
   sudo systemd-run ./build/install/hostname-server/bin/hostname-server
   

7. Haz clic en Crear.

gcloud

Crea la plantilla de instancias.

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.37.0.tar.gz | tar -xz
cd grpc-java-1.37.0/examples/example-hostname
../gradlew --no-daemon installDist
# Server listens on 50051
sudo systemd-run ./build/install/hostname-server/bin/hostname-server')

Crea el grupo de instancias administrado

En esta sección, crearás un grupo de instancias administrado con la plantilla de instancias que creaste en la sección anterior.

Console

1. Ve a la página Grupos de instancias en la consola de Google Cloud.

   Ir a la página Grupos de instancias

2. Haz clic en Crear un grupo de instancias. De forma predeterminada, verás la página para crear un grupo de instancias administrado.
3. Ingresa grpc-td-mig-us-central1 para el nombre del grupo de instancias administrado y selecciona la zona us-central1-a.
4. En Plantilla de instancias, selecciona grpc-td-vm-template, que es la plantilla de instancias que creaste.
5. Especifica 2 como la cantidad mínima y máxima de instancias que quieres crear en el grupo.
6. Haz clic en Crear.

gcloud

Crea el grupo de instancias administrado.

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

Configura el puerto con nombre

En esta sección, configurarás 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 este ejemplo, el puerto con nombre es el puerto 50051.

Console

1. Ve a la página Grupos de instancias en la consola de Google Cloud.

   Ir a la página Grupos de instancias

2. Haz clic en el nombre del grupo de instancias grpc-td-mig-us-central1 que creaste.
3. Haz clic en Editar grupo.
4. En el campo Nombre del puerto, ingresa grpc-helloworld-port.
5. En el campo Número de puerto, ingresa 50051.
6. Haz clic en Guardar.

gcloud

Configura el puerto con nombre.

gcloud compute instance-groups set-named-ports grpc-td-mig-us-central1 \
  --named-ports=grpc-helloworld-port:50051 \
  --zone us-central1-a

Configura Cloud Service Mesh con componentes de Google Cloud Load Balancing

En esta sección, se proporcionan instrucciones para configurar Cloud Service Mesh con componentes del balanceo de cargas de Google Cloud para tus servicios.

Crea la verificación de estado, la regla de firewall y el servicio de backend

En esta sección, crearás un servicio de backend global con un esquema de balanceo de cargas de INTERNAL_SELF_MANAGED y el protocolo GRPC y, luego, asociarás la verificación de estado y el grupo de instancias con el servicio de backend. En este ejemplo, se usa el grupo de instancias administrado que creaste en Crea el grupo de instancias administrado. Este grupo de instancias administrado ejecuta el servicio de gRPC de muestra. El puerto en la marca --port-name es el puerto con nombre que creaste en Configura el puerto con nombre.

gcloud

1. Crea la verificación de estado.

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

2. Cree la regla de firewall de la verificación de estado.

   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
   

3. Crea el servicio de backend.

   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
   

4. 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-central1 \
    --instance-group-zone us-central1-a \
    --global
   

Crea el mapa de reglas de enrutamiento, el proxy de destino y la regla de reenvío

En esta sección, crearás un mapa de URL, un comparador de rutas de acceso y una regla de host para enrutar el tráfico de tu servicio según el nombre de host y una ruta de acceso. En el siguiente ejemplo, se usa helloworld-gce como el nombre del servicio. La aplicación de gRPC usa este nombre de servicio en el URI de destino cuando se conecta a este servicio. De forma predeterminada, el comparador de rutas de acceso coincide con todas las solicitudes de ruta (/*) para este host. También debes crear el proxy de gRPC de destino y la regla de reenvío.

Para obtener más información, consulta Mapas de reglas de enrutamiento.

En el siguiente ejemplo, el puerto 80 es el puerto especificado.

gcloud

1. Crea el mapa de URL.

   gcloud compute url-maps create grpc-vm-url-map \
     --default-service grpc-helloworld-service
   

2. Crea el comparador de rutas de acceso.

   gcloud compute url-maps add-path-matcher grpc-vm-url-map \
     --default-service grpc-helloworld-service \
     --path-matcher-name grpc-vm-path-matcher \
     --new-hosts helloworld-gce
   

3. Crea el proxy de gRPC de destino.

   gcloud compute target-grpc-proxies create grpc-vm-proxy \
    --url-map grpc-vm-url-map \
    --validate-for-proxyless
   

4. Crea la regla de reenvío.

   gcloud compute forwarding-rules create grpc-vm-forwarding-rule \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --address=0.0.0.0 --address-region=us-central1 \
    --target-grpc-proxy=grpc-vm-proxy \
    --ports 80 \
    --network default
   

Cloud Service Mesh ahora está configurado para balancear las cargas del tráfico en el backends en el grupo de instancias administrado para los servicios especificados en el mapa de URL.

Verifica la configuración

Cuando se complete el proceso de configuración, verifica que puedas establecer una conexión gRPC con el servicio con balanceo de cargas de Cloud Service Mesh que creaste antes.

Para verificar que el servicio esté disponible, realiza una de las siguientes acciones:

• Accede a uno de los hosts de VM (backend del servicio de gRPC) y verifica que el servicio de gRPC se ejecute en el puerto de escucha. En el ejemplo, el puerto es 50051.
• Consulta la página de Cloud Service Mesh en la consola. para obtener información sobre el servicio configurado helloworld-gce y confirma que que los backends estén en buen estado.
• Usa las siguientes instrucciones para usar un cliente de gRPC de Compute Engine en la verificación.

Verifica el servicio con una aplicación cliente de gRPC

En los siguientes ejemplos, usarás un cliente de gRPC en el lenguaje que prefieras o la herramienta de grpcurl para probar el servicio de gRPC.

Primero, crea una VM de cliente en la que desees ejecutar el cliente de gRPC para probar el servicio.

gcloud compute instances create grpc-client \
  --zone us-central1-a \
  --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
# Expose bootstrap variable to SSH connections
echo export GRPC_XDS_BOOTSTRAP=$GRPC_XDS_BOOTSTRAP | sudo tee /etc/profile.d/grpc-xds-bootstrap.sh
# Create the bootstrap file
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 | tee $GRPC_XDS_BOOTSTRAP')

Configura la variable de entorno y el archivo de arranque

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

La aplicación cliente necesita 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, TRAFFICDIRECTOR_NETWORK_NAME y zone del archivo de arranque generado se obtienen del servidor de metadatos que conoce estos detalles de las instancias de VM de Compute Engine. Puedes proporcionar estos valores a la secuencia de comandos auxiliar de forma manual con las opciones -gcp-project-number y -vpc-network-name.

Nota: Agregar la generación de arranque a la secuencia de comandos init de la VM garantiza que se cree un archivo de arranque actualizado cada vez que se reinicia la VM.

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

Java

Si deseas verificar el servicio con un cliente de gRPC para Java, haz lo siguiente:

1. Descarga la última versión de gRPC para Java con el parche más reciente y compila la aplicación cliente xds-hello-world.

   sudo apt-get update -y
   sudo apt-get install -y openjdk-11-jdk-headless
   curl -L https://github.com/grpc/grpc-java/archive/v1.37.0.tar.gz | tar -xz
   cd grpc-java-1.37.0/examples/example-xds
   ../gradlew --no-daemon installDist
   

2. Ejecuta el cliente con world como su nombre y xds:///helloworld-gce como el URI de servicio.

   ./build/install/example-xds/bin/xds-hello-world-client "world" \
      xds:///helloworld-gce
   

Go

Si deseas verificar el servicio con un cliente de gRPC para Go, haz lo siguiente:

1. Descarga la última versión de gRPC para Go con el parche más reciente y crea la aplicación cliente xds-hello-world.

   sudo apt-get update -y
   sudo apt-get install -y golang git
   curl -L https://github.com/grpc/grpc-go/archive/v1.37.0.tar.gz | tar -xz
   cd grpc-go-1.37.0/examples/features/xds/client
   go get google.golang.org/grpc@v1.37.0
   go build .
   

2. Ejecuta el cliente con world como su nombre y xds:///helloworld-gce como el URI de servicio.

   ./client "world" xds:///helloworld-gce
   

C++

Si deseas verificar el servicio con un cliente de gRPC para C++, haz lo siguiente:

1. Descarga la última versión de gRPC para C++,con el parche más reciente, y crea el ejemplo de cliente helloworld.

   sudo apt-get update -y
   sudo apt-get install -y build-essential cmake git
   git clone --recurse-submodules -b v1.37.1 https://github.com/grpc/grpc
   cd grpc
   mkdir -p cmake/build
   pushd cmake/build
   cmake ../..
   make
   sudo make install
   popd
   mkdir -p third_party/abseil-cpp/cmake/build
   pushd third_party/abseil-cpp/cmake/build
   cmake ../..
   make
   sudo make install
   popd
   cd examples/cpp/helloworld
   mkdir -p cmake/build
   cd cmake/build/
   cmake ../..
   make
   

2. Ejecuta el cliente con “xds:///helloworld-gce” como el URI de servicio.

   ./greeter_client --target=xds:///helloworld-gce
   

grpcurl

Para verificar el servicio mediante la herramienta de grpcurl, haz lo siguiente:

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

2. 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 con la opción -d.

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

Python

Si deseas verificar el servicio con un cliente de gRPC para Python, ejecuta lo siguiente. Usa la versión más reciente de gRPC con el parche más reciente.

sudo apt-get update
sudo apt-get -y install python3-pip
sudo pip3 install virtualenv
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/python/xds
virtualenv venv -p python3
source venv/bin/activate
pip install -r requirements.txt
python client.py  xds:///helloworld-gce

Ruby

Si deseas verificar el servicio con un cliente de gRPC para Ruby, ejecuta lo siguiente. Usa la versión más reciente de gRPC con el parche más reciente.

sudo apt-get update
sudo apt-get install -y ruby-full
sudo gem install grpc
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/ruby
ruby greeter_client.rb john xds:///helloworld-gce

PHP

Si deseas verificar el servicio con un cliente de gRPC para PHP, ejecuta lo siguiente. Usa la versión más reciente de gRPC con el parche más reciente.

sudo apt-get update
sudo apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
sudo pecl install grpc
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1
export CC=/usr/bin/gcc
./tools/bazel build @com_google_protobuf//:protoc
./tools/bazel build src/compiler:grpc_php_plugin
cd examples/php
composer install
./../../bazel-bin/external/com_google_protobuf/protoc --proto_path=../protos \
--php_out=. --grpc_out=. \
--plugin=protoc-gen-grpc=../../bazel-bin/src/compiler/grpc_php_plugin \
../protos/helloworld.proto
php -d extension=grpc.so greeter_client.php john xds:///helloworld-gce

Node.js

Para verificar el servicio con un cliente Node.js de gRPC, ejecuta el siguiente comando. Usa la versión más reciente de gRPC con el parche más reciente.

sudo apt-get update
sudo apt-get install -y nodejs npm
curl -L https://github.com/grpc/grpc/archive/v1.34.0.tar.gz | tar -xz
cd grpc-1.34.0/examples/node/xds
npm install
node ./greeter_client.js --target=xds:///helloworld-gce

Deberías ver un resultado similar a este, en el que INSTANCE_NAME es el nombre de la instancia de VM:

Greeting: Hello world, from INSTANCE_HOSTNAME

Esto verifica que el cliente de gRPC sin proxy se conectó correctamente a Cloud Service Mesh y aprendió sobre los backends de 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?

• Obtén información sobre la administración avanzada del tráfico.
• Obtén más información sobre cómo configurar la observabilidad.
• Obtén más información sobre cómo solucionar problemas de implementaciones de Cloud Service Mesh sin proxy.