Configura Google Kubernetes Engine e i servizi gRPC senza proxy

Questa guida descrive come configurare Google Kubernetes Engine, le applicazioni gRPC e i componenti di bilanciamento del carico richiesti da Cloud Service Mesh.

Prima di seguire le istruzioni riportate in questa guida, consulta Preparati a configurare Cloud Service Mesh con i servizi gRPC senza proxy.

Panoramica

La configurazione di Cloud Service Mesh con GKE e i servizi gRPC senza proxy prevede i seguenti passaggi:

1. Preparazione del cluster GKE.
2. Deployment di un'applicazione server gRPC come servizio Kubernetes. Annota la specifica di deployment GKE per creare automaticamente un gruppo di endpoint di rete (NEG) per il servizio.
3. Configurazione di Cloud Service Mesh utilizzando il NEG e altri Google Cloud componenti di bilanciamento del carico.
4. Verifica che il deployment funzioni correttamente utilizzando un'applicazione client gRPC senza proxy per inviare traffico all'applicazione server gRPC.

Configurazione dei cluster GKE per Cloud Service Mesh

Questa sezione fornisce istruzioni per abilitare i cluster GKE a utilizzare Cloud Service Mesh.

Requisiti del cluster GKE

I cluster GKE devono soddisfare i seguenti requisiti:

• Devi abilitare il supporto per i gruppi di endpoint di rete. Per ulteriori informazioni ed esempi, consulta Gruppi di endpoint di rete autonomi. La funzionalità NEG autonomi è in disponibilità generale per Cloud Service Mesh.
• Il account di servizio delle istanze dei nodi del cluster deve disporre dell'autorizzazione per accedere all'API Cloud Service Mesh. Per ulteriori informazioni sulle autorizzazioni richieste, consulta Abilitare il account di servizio per accedere all'API Cloud Service Mesh.
• I container devono avere accesso all'API Cloud Service Mesh, protetta dall'autenticazione OAuth. Per ulteriori informazioni, consulta la configurazione dell'host.

Creazione del cluster GKE

L'esempio seguente mostra come creare un cluster GKE denominato grpc-td-cluster nella us-central1-a zone.

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

Ottenere i privilegi del cluster GKE richiesti

Passa al cluster che hai appena creato eseguendo il seguente comando. In questo modo, kubectl punta al cluster corretto.

gcloud container clusters get-credentials grpc-td-cluster \
    --zone us-central1-a

Configurazione dei servizi GKE

Questa sezione descrive come preparare le specifiche di deployment GKE per l'utilizzo con Cloud Service Mesh. Consiste nella configurazione di un servizio di esempio helloworld GKE con annotazioni NEG.

Il servizio di esempio helloworld è un'applicazione server gRPC che restituisce un messaggio in risposta alla richiesta di un client gRPC. Tieni presente che non c'è nulla di speciale nel servizio helloworld. Non è un servizio gRPC senza proxy e può rispondere alle richieste di qualsiasi client gRPC.

La parte "senza proxy" entra in gioco solo quando un'applicazione client gRPC si connette a Cloud Service Mesh, scopre il servizio helloworld e può quindi inviare traffico ai pod associati a helloworld, senza dover fare affidamento su indirizzi IP o risoluzione dei nomi basata su DNS.

Configurazione dei servizi GKE con i NEG

Il primo passaggio nella configurazione dei servizi GKE per l'utilizzo con Cloud Service Mesh consiste nell'esporre il servizio tramite un NEG. Per essere esposta tramite i NEG, ogni specifica deve avere la seguente annotazione, corrispondente alla porta che vuoi esporre.

...
metadata:
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'

Questa annotazione crea un NEG autonomo al primo deployment del servizio. Questo NEG contiene endpoint che sono gli indirizzi IP e le porte del pod. Per ulteriori informazioni ed esempi, consulta Gruppi di endpoint di rete autonomi.

Nell'esempio seguente, esegui il deployment di un servizio Kubernetes helloworld esposto sulla porta 8080. Questa è la porta su cui il servizio è visibile nel cluster. Il servizio gRPC nel pod è in ascolto su targetPort 50051. Questa è la porta del pod a cui viene inviata la richiesta. In genere, port e targetPort sono impostati sullo stesso valore per comodità, ma questo esempio utilizza valori diversi per indicare il valore corretto da utilizzare nell'annotazione 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 che il nuovo servizio helloworld sia stato creato:

kubectl get svc

L'output di kubectl get svc dovrebbe essere simile al seguente:

NAME           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
helloworld     ClusterIP   10.71.9.71   <none>        8080/TCP  41m
[..skip..]

Verifica che il pod dell'applicazione sia in esecuzione:

kubectl get pods

L'output di kubectl get pods dovrebbe essere simile al seguente:

NAME                        READY     STATUS    RESTARTS   AGE
app1-6db459dcb9-zvfg2   1/1       Running   0          6m
app1-6db459dcb9-hlvhj   1/1       Running   0          6m
[..skip..]

Verifica che il nome NEG sia corretto.

# 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

Configurazione di Cloud Service Mesh con i componenti di bilanciamento del carico

Questa sezione descrive come configurare Google Cloud i componenti di bilanciamento del carico per i tuoi servizi. Questi componenti contengono informazioni di configurazione che consentono ai client gRPC senza proxy di comunicare con i servizi GKE.

L'esempio di configurazione di Cloud Service Mesh riportato di seguito presuppone quanto segue:

• I NEG e tutte le altre risorse vengono creati nella rete predefinita in modalità automatica, nella zona us-central1-a.
• Quando utilizzi Google Cloud CLI, il nome NEG per il cluster è example-grpc-server.

Creazione del controllo di integrità, della regola firewall e del servizio di backend

In questa sezione creerai un controllo di integrità e la regola firewall per il controllo di integrità. Il controllo di integrità deve utilizzare il protocollo di controllo di integrità gRPC. La regola firewall consente ai probe del controllo di integrità di connettersi alle VM nel deployment. La direttiva --use-serving-port viene utilizzata dai controlli di integrità per ottenere la porta di ascolto configurata per ogni endpoint.

La regola firewall consente le connessioni di controllo di integrità in entrata alle istanze nella rete.

In questa sezione creerai un servizio di backend globale con uno schema di bilanciamento del carico INTERNAL_SELF_MANAGED e il protocollo GRPC, quindi assocerai il controllo di integrità al servizio di backend.

Per saperne di più, consulta Creazione di controlli di integrità.

Creazione della mappa delle regole di routing

In questa sezione creerai una mappa URL, un matcher di percorso e una regola host per instradare il traffico per il tuo servizio, in base al nome host e a un percorso. L'esempio seguente utilizza helloworld-gke come nome del servizio. Il client gRPC utilizza questo nome di servizio nell'URI di destinazione quando si connette al servizio helloworld. Creerai anche il proxy gRPC di destinazione e la regola di forwarding.

Per saperne di più, consulta Mappe delle regole di routing.

L'esempio seguente utilizza il nome del servizio helloworld-gke e la porta 8000. Ciò significa che il client gRPC deve utilizzare xds:///helloworld-gke:8000 per connettersi a questo servizio e che nella mappa URL deve essere configurata una regola host helloworld-gke:8000. Tieni presente che la porta di servizio 8080 mostrata nella specifica del servizio Kubernetes in una sezione precedente non viene utilizzata da Cloud Service Mesh perché helloworld-gke:8000 viene risolta direttamente negli endpoint NEG in ascolto su targetPort 50051. In genere, la porta nella regola host della mappa URL e le specifiche del servizio Kubernetes port e targetPort sono impostate sullo stesso valore per comodità, ma questo esempio utilizza valori diversi per mostrare che la port nella specifica del servizio non viene utilizzata da Cloud Service Mesh.

Cloud Service Mesh è ora configurato per bilanciare il carico del traffico tra gli endpoint nel NEG per i servizi specificati nella mappa URL.

Verifica della configurazione

Al termine della procedura di configurazione, verifica di poter raggiungere il server gRPC helloworld utilizzando un client gRPC senza proxy. Questo client si connette a Cloud Service Mesh, ottiene informazioni sul servizio helloworld(configurato con Cloud Service Mesh utilizzando il servizio di backend grpc-gke-helloworld-service ) e utilizza queste informazioni per inviare traffico ai backend del servizio.

Puoi anche controllare la sezione Cloud Service Mesh nella Google Cloud console per informazioni sul servizio configurato helloworld-gke e verificare se i backend sono segnalati come integri.

Verifica con un client gRPC senza proxy

Negli esempi seguenti, utilizzerai i client gRPC in lingue diverse o lo strumento grpcurl per verificare che Cloud Service Mesh stia instradando correttamente il traffico nel mesh. Creerai un pod client, quindi aprirai una shell ed eseguirai i comandi di verifica dalla shell.

Configurazione della variabile di ambiente e del file di bootstrap

L'applicazione client richiede un file di configurazione di bootstrap. Modifica la specifica di deployment dell'applicazione Kubernetes aggiungendo un initContainer che genera il file di bootstrap e un volume per trasferire il file. Aggiorna il container esistente per trovare il file.

Aggiungi il seguente initContainer alla specifica di deployment dell'applicazione:

      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.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

Aggiorna la sezione env del container dell'applicazione in modo da includere quanto segue:

        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/

Di seguito è riportato un esempio completo di una specifica Kubernetes del client:

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

Quando il deployment è pronto, apri una shell nel pod client.

kubectl exec -it $(kubectl get pods -o custom-columns=:.metadata.name \
    --selector=run=client) -- /bin/bash

Per verificare la configurazione, esegui gli esempi appropriati nella shell del pod.

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

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

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

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

Dovresti visualizzare un output simile al seguente, dove INSTANCE_HOST_NAME è il nome host dell'istanza VM:

Greetings: Hello world, from INSTANCE_HOST_NAME

In questo modo, verifichi che il client gRPC senza proxy si sia connesso correttamente a Cloud Service Mesh e abbia appreso i backend del servizio helloworld-gke utilizzando il resolver di nomi xds. Il client ha inviato una richiesta a uno dei backend del servizio senza dover conoscere l'indirizzo IP o eseguire la risoluzione DNS.

Passaggi successivi

• Scopri di più sulla sicurezza dei servizi Cloud Service Mesh.
• Scopri di più sulla gestione avanzata del traffico.
• Scopri come configurare l'osservabilità.
• Scopri come risolvere i problemi dei deployment di Cloud Service Mesh senza proxy.