Configura Google Kubernetes Engine y los servicios de gRPC sin proxy
En esta guía, se describe cómo configurar Google Kubernetes Engine, las aplicaciones de gRPC y los componentes del balanceo de cargas que requiere Cloud Service Mesh.
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 Cloud Service Mesh con GKE y servicios de gRPC sin proxy implica lo siguiente:
- Preparar tu clúster de GKE
- Implementar una aplicación de servidor de gRPC como un servicio de Kubernetes. Anota la especificación de implementación de GKE a fin de crear de forma automática un grupo de extremos de red (NEG) para el servicio
- Configurar Cloud Service Mesh mediante el NEG y otros componentes de balanceo de cargas de Google Cloud
- 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
Configura clústeres de GKE para Cloud Service Mesh
En esta sección, se proporcionan instrucciones para habilitar el funcionamiento de los clústeres de GKE la malla de servicios en la nube.
Requisitos del clúster de GKE
Los clústeres de GKE deben cumplir con los siguientes requisitos:
- Debes habilitar la compatibilidad para los grupos de extremos de red. Para obtener más información y ejemplos, consulta Grupos de extremos de red independientes. La función de NEG independientes está en fase de disponibilidad general para la malla de servicios en la nube.
- La cuenta de servicio de las instancias de nodos del clúster debe tener permiso para acceder a la API de Cloud Service Mesh. Para obtener más información sobre los permisos requeridos, consulta Habilita la cuenta de servicio para acceder a la API de Cloud Service Mesh.
- Los contenedores deben tener acceso a la API de Cloud Service Mesh, con autenticación de OAuth. Para obtener más información, consulta la configuración del host.
Crea el clúster de GKE
En el siguiente ejemplo, se muestra cómo crear un clúster de GKE llamado grpc-td-cluster
en us-central1-a zone
.
Console
Para crear un clúster con la consola de Google Cloud, sigue estos pasos:
Ve al menú de Kubernetes Engine en la consola de Google Cloud.
Haga clic en Crear clúster.
Elige la plantilla Standard cluster o elige una plantilla adecuada para tu carga de trabajo.
Personaliza la plantilla si es necesario. Los siguientes campos son obligatorios:
- Nombre: Ingresa
grpc-td-cluster
. - Tipo de ubicación:
Zonal
. - Zona:
us-central1-a
- Grupo de nodos:
- Nombre: Ingresa
En el menú de la izquierda, haz clic en default-pool.
Cambia el Nombre a
grpc-td-cluster
.En Tamaño, ingresa la cantidad de nodos que se crearán. Debes tener una cuota de recursos disponible para los nodos y sus recursos (como las rutas de firewall).
En el menú de la izquierda, haz clic en Nodos.
Ve a Configuración de la máquina, en Familia de máquinas, y haz clic en Optimizada para procesamiento.
Selecciona un tipo de máquina. Para obtener información sobre los precios de los tipos de máquina, consulta la página de precios de Compute Engine.
En Herramientas de redes, agrega la etiqueta de red
allow-health-checks
.En el menú de la izquierda, haz clic en Seguridad de nodos.
En Permiso de acceso, selecciona Permitir el acceso total a todas las API de Cloud.
Haga clic en Crear.
Después de crear un clúster en la consola de Google Cloud, debes configurar kubectl
para interactuar con el clúster. Para obtener más información, consulta Genera una entrada kubeconfig
.
gcloud
Crea el clúster.
gcloud container clusters create grpc-td-cluster \ --zone us-central1-a \ --scopes=https://www.googleapis.com/auth/cloud-platform \ --tags=allow-health-checks \ --enable-ip-alias
Obtén los privilegios necesarios del clúster de GKE
Cambia al clúster que acabas de crear mediante el siguiente comando. Esto apunta kubectl
al clúster correcto.
gcloud
gcloud container clusters get-credentials grpc-td-cluster \ --zone us-central1-a
Configura servicios de GKE
En esta sección, se describe cómo preparar las especificaciones de implementación de GKE para trabajar con Cloud Service Mesh. Esto consiste en configurar un servicio de ejemplo helloworld
de GKE con anotaciones de NEG.
El servicio de ejemplo helloworld
es una aplicación de servidor de gRPC que muestra un
mensaje en respuesta a la solicitud de un cliente de gRPC. Ten en cuenta que el servicio helloworld
no tiene nada especial. No es un servicio de gRPC sin proxy y puede responder a las solicitudes de cualquier cliente de gRPC.
La parte “sin proxy” solo se incluye cuando una aplicación cliente de gRPC se conecta con Cloud Service Mesh, aprende sobre el servicio helloworld
y puede enviar tráfico a pods asociados con helloworld
, sin necesidad de depender de las direcciones IP o la resolución de nombres basados en DNS.
Configura servicios de GKE con NEG
El primer paso para configurar los servicios de GKE a fin de usarlos con Cloud Service Mesh es exponer el servicio a través de un NEG. Para exponerse a través de NEG, cada especificación debe tener la siguiente anotación, que coincide con el puerto que deseas exponer.
... metadata: annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
Esta anotación crea un NEG independiente cuando implementas tu servicio por primera vez. Este NEG contiene extremos que son las direcciones IP y los puertos del pod. Para obtener más información y ejemplos, consulta Grupos de extremos de red independientes.
En el siguiente ejemplo, se implementa un servicio de Kubernetes helloworld
que se expone en el puerto 8080
. Este es el puerto en el que el servicio es visible en el clúster. El servicio de gRPC del pod escucha en el targetPort
50051
. Este es el puerto en el pod al que se envía la solicitud. Por lo general, el port
y targetPort
se configuran con el mismo valor para mayor comodidad, pero en este ejemplo se usan valores diferentes a fin de indicar el valor correcto que se usará en la anotación NEG.
cat << EOF > grpc-td-helloworld.yaml apiVersion: v1 kind: Service metadata: name: helloworld annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - port: 8080 name: helloworld protocol: TCP targetPort: 50051 selector: run: app1 type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: labels: run: app1 name: app1 spec: selector: matchLabels: run: app1 replicas: 2 template: metadata: labels: run: app1 spec: containers: - image: grpc/java-example-hostname:1.50.2 name: app1 ports: - protocol: TCP containerPort: 50051 EOF
kubectl apply -f grpc-td-helloworld.yaml
Verifica que se haya creado el nuevo servicio helloworld
:
kubectl get svc
El resultado de kubectl get svc
debería ser similar al siguiente:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE helloworld ClusterIP 10.71.9.71 <none> 8080/TCP 41m [..skip..]
Verifica que el pod de aplicación se esté ejecutando:
kubectl get pods
El resultado de kubectl get pods
debería ser similar al siguiente:
NAME READY STATUS RESTARTS AGE app1-6db459dcb9-zvfg2 1/1 Running 0 6m app1-6db459dcb9-hlvhj 1/1 Running 0 6m [..skip..]
Verifica que el nombre de NEG sea correcto.
Console
Para ver una lista de grupos de extremos de red, ve a la página Grupos de extremos de red en la consola de Google Cloud. Verás un NEG llamado example-grpc-server
.
Ir a la página Grupos de extremos de red
gcloud
# List the NEGs gcloud compute network-endpoint-groups list \ --filter "name=example-grpc-server" --format "value(name)" # Optionally examine the NEG gcloud compute network-endpoint-groups describe example-grpc-server \ --zone us-central1-a # Optionally examine the endpoint(s) contained gcloud compute network-endpoint-groups list-network-endpoints example-grpc-server \ --zone us-central1-a
Configura Cloud Service Mesh con componentes de balanceo de cargas
En esta sección, se describe cómo configurar los componentes de balanceo de cargas de Google Cloud para tus servicios. Estos componentes incluyen información de configuración que permite que los clientes de gRPC sin proxy se comuniquen con tus servicios de GKE.
En el ejemplo de configuración de Cloud Service Mesh que aparece a continuación, se supone lo siguiente:
- Los NEG y todos los demás recursos se crean en la red predeterminada de modo automático, en la zona
us-central1-a
. - Cuando usas Google Cloud CLI, el nombre del NEG para el clúster se
example-grpc-server
Crea la verificación de estado, la regla de firewall y el servicio de backend
En esta sección, crearás una verificación de estado y la regla de firewall para la verificación de estado. La verificación de estado debe usar el protocolo de verificación de estado de gRPC. La regla de firewall permite que los sondeos de verificación de estado se conecten con las VM en tu implementación. Las verificaciones de estado usan la directiva --use-serving-port
a fin de obtener el puerto de escucha configurado para cada extremo.
La regla de firewall permite conexiones de verificación de estado entrantes a instancias en tu red.
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
. Luego, asociarás la verificación de estado con el servicio de backend.
Para obtener más información, consulta Crea verificaciones de estado.
gcloud
Crea la verificación de estado.
gcloud compute health-checks create grpc grpc-gke-helloworld-hc \ --use-serving-port
Crea la regla de firewall.
gcloud compute firewall-rules create grpc-gke-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 el servicio de backend.
gcloud compute backend-services create grpc-gke-helloworld-service \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --protocol=GRPC \ --health-checks grpc-gke-helloworld-hc
Agrega los NEG de backend al servicio de backend.
gcloud compute backend-services add-backend grpc-gke-helloworld-service \ --global \ --network-endpoint-group example-grpc-server \ --network-endpoint-group-zone us-central1-a \ --balancing-mode RATE \ --max-rate-per-endpoint 5
Crea el mapa de reglas de enrutamiento
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-gke
como el nombre de servicio. El cliente de gRPC usa este nombre de servicio en el URI de destino cuando se conecta al servicio helloworld
.
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, se usa el nombre del servicio helloworld-gke
y el puerto 8000
.
Esto significa que el cliente gRPC debe usar xds:///helloworld-gke:8000
para conectarse a este servicio y se debe configurar una regla de host helloworld-gke:8000
en el mapa de URL. Ten en cuenta que el puerto de servicio 8080
que se muestra en las especificaciones del servicio de Kubernetes
de una sección anterior no se usa en Cloud Service Mesh porque helloworld-gke:8000
se
se resuelven en los extremos de NEG que escuchan en el 50051
de targetPort
.
Por lo general, el puerto en la regla de host del mapa de URL y las especificaciones del servicio de Kubernetes
port
y targetPort
están configurados con el mismo valor para mayor comodidad, pero
En este ejemplo, se usan valores diferentes para mostrar que el port
en la especificación del servicio
no se usa en Cloud Service Mesh.
gcloud
Crea el mapa de URL.
gcloud compute url-maps create grpc-gke-url-map \ --default-service grpc-gke-helloworld-service
Crea el comparador de rutas de acceso.
gcloud compute url-maps add-path-matcher grpc-gke-url-map \ --default-service grpc-gke-helloworld-service \ --path-matcher-name grpc-gke-path-matcher \ --new-hosts helloworld-gke:8000
Crea el proxy de gRPC de destino.
gcloud compute target-grpc-proxies create grpc-gke-proxy \ --url-map grpc-gke-url-map \ --validate-for-proxyless
Crea la regla de reenvío.
gcloud compute forwarding-rules create grpc-gke-forwarding-rule \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --address=0.0.0.0 \ --target-grpc-proxy=grpc-gke-proxy \ --ports 8000 \ --network default
Cloud Service Mesh ahora está configurado para balancear las cargas del tráfico en los extremos en el NEG para los servicios especificados en el mapa de URL.
Verifica la configuración
Cuando se complete el proceso de configuración, verifica que puedas acceder al servidor de gRPC helloworld
con un cliente de gRPC sin proxy. Este cliente se conecta con Cloud Service Mesh, obtiene información sobre el servicio helloworld
(configurado con Cloud Service Mesh mediante el servicio de backend grpc-gke-helloworld-service
) y usa esta información para enviar tráfico a los backends del servicio.
También puedes consultar la sección Cloud Service Mesh en la consola de Google Cloud para obtener más información.
en el servicio configurado helloworld-gke
y verifica si los backends están
se informan como en buen estado.
Verificación con un cliente de gRPC sin proxy
En los siguientes ejemplos, se usan clientes de gRPC en diferentes lenguajes o la herramienta de grpcurl
para verificar que Cloud Service Mesh enruta el tráfico de forma correcta en la malla. Crea un pod de cliente, abre un shell y, luego, ejecuta los comandos de verificación desde el shell.
Configura la variable de entorno y el archivo de arranque
La aplicación cliente requiere un archivo de configuración de arranque. Si quieres modificar la especificación de implementación de tu aplicación de Kubernetes, agrega un initContainer
que genere el archivo de arranque y un volumen para transferirlo. Actualiza tu contenedor existente para encontrar el archivo.
Agrega el siguiente initContainer
a las especificaciones de implementación de la aplicación:
initContainers: - args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0 imagePullPolicy: IfNotPresent name: grpc-td-init resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ volumes: - name: grpc-td-conf emptyDir: medium: Memory
Actualiza la sección env
del contenedor de la aplicación de modo que incluya lo siguiente:
env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/
Este es un ejemplo completo de especificación de Kubernetes de un cliente:
cat << EOF | kubectl apply -f - apiVersion: apps/v1 kind: Deployment metadata: labels: run: client name: sleeper spec: selector: matchLabels: run: client template: metadata: labels: run: client spec: containers: - image: openjdk:8-jdk imagePullPolicy: IfNotPresent name: sleeper command: - sleep - 365d env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: "2" memory: 2000Mi requests: cpu: 300m memory: 1500Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - args: - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0 imagePullPolicy: IfNotPresent name: grpc-td-init resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Cuando la implementación esté lista, abre una shell al Pod del cliente.
kubectl exec -it $(kubectl get pods -o custom-columns=:.metadata.name \ --selector=run=client) -- /bin/bash
Para verificar la configuración, ejecuta los ejemplos adecuados en el shell del pod.
Java
Si deseas verificar el servicio con un cliente de gRPC para Java, haz lo siguiente:
Descarga la última versión de gRPC para Java con el parche más reciente y compila la aplicación cliente
xds-hello-world
.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
Ejecuta el cliente con
"world"
como su nombre y"xds:///helloworld-gke:8000"
como el puerto y URI de servicio../build/install/example-xds/bin/xds-hello-world-client "world" \ xds:///helloworld-gke:8000
Go
Si deseas verificar el servicio con un cliente de gRPC para Go, haz lo siguiente:
Descarga la última versión de gRPC para Go con el parche más reciente y crea la aplicación cliente
xds-hello-world
.apt-get update -y 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 .
Ejecuta el cliente con
"world"
como su nombre y"xds:///helloworld-gke:8000"
como el puerto y URI de servicio../client "world" xds:///helloworld-gke:8000
C++
Si deseas verificar el servicio con un cliente de gRPC para C++, haz lo siguiente:
Descarga la última versión de gRPC para C++,con el parche más reciente, y crea el ejemplo de cliente
helloworld
.apt-get update -y 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 make install popd mkdir -p third_party/abseil-cpp/cmake/build pushd third_party/abseil-cpp/cmake/build cmake ../.. make make install popd cd examples/cpp/helloworld mkdir -p cmake/build cd cmake/build/ cmake ../.. make
Ejecuta el cliente con “xds:///helloworld-gke:8000” como el puerto y URI de servicio.
./greeter_client --target=xds:///helloworld-gke:8000
grpcurl
La herramienta de grpcurl
también puede actuar como un cliente de gRPC sin proxy. En este caso,
grpcurl
usa la variable de entorno y la información de arranque para conectarse
en Cloud Service Mesh. Luego, aprende sobre el servicio helloworld
, que
se configuró con Cloud Service Mesh a través de la grpc-gke-helloworld-service
servicio de backend.
Para verificar tu configuración mediante la herramienta de grpcurl
, sigue estos pasos:
Descarga y, luego, 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-gke:8000” como URI de servicio yhelloworld.Greeter/SayHello
como nombre del servicio y método que se invocará. Los parámetros del métodoSayHello
se pasan mediante la opción-d
../grpcurl --plaintext \ -d '{"name": "world"}' \ xds:///helloworld-gke:8000 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.
apt-get update -y apt-get install python3-pip -y 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-gke:8000
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.
apt-get update -y apt-get install -y ruby-full 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-gke:8000
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.
apt-get update -y apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git pecl install grpc curl -sS https://getcomposer.org/installer | php 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-gke:8000
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.
apt-get update -y 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-gke:8000
Deberías ver un resultado similar a este, en el que INSTANCE_HOST_NAME
es el nombre de host de la instancia de VM:
Greetings: Hello world, from INSTANCE_HOST_NAME
Esto verifica que el cliente de gRPC sin proxy se conectó de forma correcta a Cloud Service Mesh y aprendió sobre los backends del servicio helloworld-gke
mediante el agente de resolución de nombres de 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 seguridad del servicio de Cloud Service Mesh.
- 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.