Configurar máquinas virtuales de Compute Engine y servicios de gRPC sin proxy

En esta guía se explica cómo configurar hosts de máquinas virtuales de Compute Engine, aplicaciones gRPC y los componentes de balanceo de carga que requiere Cloud Service Mesh.

Antes de seguir las instrucciones de esta guía, consulta el artículo Prepararse para configurar Cloud Service Mesh con servicios de gRPC sin proxy.

Información general

Para configurar Cloud Service Mesh con máquinas virtuales (VMs) de Compute Engine y servicios de gRPC sin proxy, debes hacer lo siguiente:

1. Configurar un grupo de instancias gestionado que aloje tus backends.
2. Configurar los back-ends para que ejecuten un servidor gRPC que devuelva hello world en respuesta a una solicitud de un cliente.
3. Configurar Cloud Service Mesh con el grupo de instancias gestionado y otros Google Cloud componentes de balanceo de carga.
4. Verificar que el despliegue funciona correctamente mediante una aplicación cliente de gRPC sin proxy para enviar tráfico a la aplicación de servidor de gRPC.

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

Configurar un grupo de instancias gestionado para Cloud Service Mesh

Los grupos de instancias gestionadas usan el autoescalado para crear nuevas VMs de backend según las necesidades de tu implementación. En este ejemplo se muestra cómo hacer lo siguiente:

• Crea una plantilla de instancia con un servicio de muestra que proporcione un servicio hello world mediante el protocolo gRPC.
• Configura un grupo de instancias gestionado con la plantilla.

Crear la plantilla de instancia

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

Consola

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

   Ir a la página Plantillas de instancia

2. Haz clic en Crear plantilla de instancia.

3. Rellena los campos como se indica a continuación:

   • 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
   • Permisos de acceso: permitir el acceso completo a todas las APIs de Google Cloud

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

5. Haz clic en Gestión, seguridad, discos, redes, único cliente.

6. En la pestaña Gestió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 instancia.

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

Crear el grupo de instancias gestionadas

En esta sección, crearás un grupo de instancias gestionado con la plantilla de instancia que has creado en la sección anterior.

Consola

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

   Ir a la página Grupos de instancias

2. Haga clic en Crear un grupo de instancias. De forma predeterminada, se muestra la página para crear un grupo de instancias gestionado.
3. Introduce grpc-td-mig-us-central1 como nombre del grupo de instancias gestionado y selecciona la zona us-central1-a.
4. En Plantilla de instancia, selecciona grpc-td-vm-template, que es la plantilla de instancia que has creado.
5. Especifica 2 como número mínimo y máximo de instancias que quieras crear en el grupo.
6. Haz clic en Crear.

gcloud

Crea el grupo de instancias gestionado.

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

Configurar el puerto con nombre

En esta sección, configurarás el puerto con nombre del servicio gRPC. El puerto con nombre es el puerto en el que el servicio gRPC escucha las solicitudes. En este ejemplo, el puerto con nombre es el 50051.

Consola

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

   Ir a la página Grupos de instancias

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

gcloud

Configura el puerto identificado.

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

Configurar Cloud Service Mesh con componentes de Google Cloud balanceo de carga

En esta sección se proporcionan instrucciones para configurar Cloud Service Mesh conGoogle Cloud componentes de balanceo de carga para tus servicios.

Crear la comprobación del estado, la regla de cortafuegos y el servicio de backend

En esta sección, crearás un servicio de backend global con un esquema de balanceo de carga INTERNAL_SELF_MANAGED y un protocolo GRPC. A continuación, asociarás la comprobación de estado y el grupo de instancias al servicio de backend. En este ejemplo, se usa el grupo de instancias gestionado que has creado en Crear el grupo de instancias gestionado. Este grupo de instancias gestionado ejecuta el servicio gRPC de ejemplo. El puerto de la marca --port-name es el puerto con nombre que has creado en Configurar el puerto con nombre.

gcloud

1. Crea la comprobación del estado.

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

2. Crea la regla de cortafuegos de comprobación del 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. 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-central1 \
    --instance-group-zone us-central1-a \
    --global
   

Crear 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 URLs, un comparador de rutas y una regla de host para enrutar el tráfico de tu servicio en función del nombre de host y de una ruta. En el siguiente ejemplo, se usa helloworld-gce como nombre del servicio. La aplicación gRPC usa este nombre de servicio en el URI de destino al conectarse a este servicio. De forma predeterminada, el comparador de rutas coincide con todas las solicitudes de ruta (/*) de este host. También debes crear el proxy 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 URLs.

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

2. Crea el comparador de rutas.

   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 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 la carga del tráfico entre los backends del grupo de instancias gestionado de los servicios especificados en el mapa de URLs.

Verificar la configuración

Cuando se haya completado el proceso de configuración, comprueba que puedes establecer una conexión gRPC con el servicio con balanceo de carga de Cloud Service Mesh que has creado anteriormente.

Para comprobar que el servicio está disponible, haz una de las siguientes acciones:

• Inicia sesión en uno de los hosts de la VM (el backend del servicio gRPC) y comprueba que el servicio gRPC se esté ejecutando en el puerto de escucha. En el ejemplo, el puerto es 50051.
• Consulta la página Cloud Service Mesh de la consola para obtener información sobre el servicio helloworld-gce configurado y confirma que los back-ends se indican como correctos.
• Sigue estas instrucciones para usar un cliente gRPC de Compute Engine para la verificación.

Verificar el servicio con una aplicación cliente gRPC

En los siguientes ejemplos, se usa un cliente gRPC en el idioma que elijas o la herramienta grpcurl para probar el servicio gRPC.

Primero, crea una VM cliente en la que ejecutar el cliente 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')

Configurar la variable de entorno y el archivo de arranque

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.

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

Nota: Si añades la generación de bootstrap al script de inicialización de la VM, se creará un archivo de bootstrap actualizado cada vez que se reinicie la VM.

Para verificar la configuración, inicia sesión en la VM cliente y ejecuta los siguientes ejemplos.

Java

Para verificar el servicio con un cliente Java de gRPC, sigue estos pasos:

1. Descarga la última versión de gRPC 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 nombre y xds:///helloworld-gce como URI de servicio.

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

Go

Para verificar el servicio con un cliente gRPC Go, sigue estos pasos:

1. Descarga la versión más reciente de gRPC Go, 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 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 nombre y xds:///helloworld-gce como URI de servicio.

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

C++

Para verificar el servicio con un cliente gRPC C++, sigue estos pasos:

1. Descarga la versión más reciente de gRPC C++, con el parche más reciente, y compila 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 URI de servicio.

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

grpcurl

Para verificar el servicio con la herramienta grpcurl, sigue estos pasos:

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

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

Python

Para verificar el servicio con un cliente de Python de gRPC, 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

Para verificar el servicio con un cliente gRPC 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

Para verificar el servicio con un cliente gRPC 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 de Node.js gRPC, 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 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ía ver un resultado similar a este, donde INSTANCE_NAME es el nombre de la instancia de VM:

Greeting: Hello world, from INSTANCE_HOSTNAME

De esta forma, se 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 una resolución de DNS.

Siguientes pasos

• Consulta información sobre la gestión avanzada del tráfico.
• Consulta cómo configurar la observabilidad.
• Consulta cómo solucionar problemas con las implementaciones de Cloud Service Mesh sin proxy.