Configura Google Kubernetes Engine e i servizi gRPC senza proxy
Questa guida descrive come configurare Google Kubernetes Engine, le applicazioni gRPC e dei componenti di bilanciamento del carico richiesti da Cloud Service Mesh.
Prima di seguire le istruzioni di questa guida, consulta Preparazione della configurazione di Cloud Service Mesh con servizi gRPC senza proxy.
Panoramica
La configurazione di Cloud Service Mesh con GKE e servizi gRPC senza proxy prevede le seguenti:
- Preparazione del cluster GKE.
- Deployment di un'applicazione server gRPC come servizio Kubernetes. Annota le Specifica del deployment GKE per creare automaticamente un gruppo di endpoint di rete (NEG) per il servizio.
- Configurazione di Cloud Service Mesh utilizzando il NEG e un altro carico di Google Cloud di bilanciamento del carico.
- Verifica del corretto funzionamento del deployment utilizzando un client gRPC senza proxy per inviare il traffico all'applicazione server gRPC.
Configurazione dei cluster GKE per Cloud Service Mesh
Questa sezione fornisce istruzioni per abilitare il funzionamento dei cluster GKE Cloud Service Mesh.
Requisiti dei cluster GKE
I cluster GKE devono soddisfare i seguenti requisiti:
- Devi abilitare il supporto per i gruppi di endpoint di rete. Per ulteriori informazioni e vedi Gruppi di endpoint di rete autonomi. La funzionalità NEG standalone è disponibile in disponibilità generale per Cloud Service Mesh.
- Le istanze dei nodi cluster l'account di servizio deve disporre dell'autorizzazione per accedere l'API Cloud Service Mesh. Per ulteriori informazioni sulle autorizzazioni richieste, consulta Abilitazione dell'account di servizio per l'accesso all'API Cloud Service Mesh.
- I container devono avere accesso all'API Cloud Service Mesh, protetti dall'autenticazione OAuth. Per ulteriori informazioni, vedi configurazione host.
Creazione del cluster GKE
L'esempio seguente mostra come creare un cluster GKE denominato grpc-td-cluster
nel us-central1-a zone
.
Console
Per creare un cluster utilizzando la console Google Cloud, esegui queste operazioni: passaggi:
Vai al menu Kubernetes Engine nella console Google Cloud.
Fai clic su Crea cluster.
Scegli il modello di cluster Standard oppure scegli un modello appropriato per il tuo carico di lavoro.
Personalizza il modello, se necessario. I seguenti campi sono obbligatorio:
- Nome: inserisci
grpc-td-cluster
. - Tipo di posizione:
Zonal
. - Zona:
us-central1-a
. - Pool di nodi:
- Nome: inserisci
Nel menu a sinistra, fai clic su default-pool.
Cambia il Nome in
grpc-td-cluster
.In Dimensioni, inserisci il numero di nodi da creare. Devi avere quota di risorse disponibile per i nodi e le relative risorse (ad esempio le route del firewall).
Nel menu a sinistra, fai clic su Nodi.
In Configurazione macchina, in Famiglia di macchine, fai clic su Ottimizzato per il calcolo.
Seleziona un Tipo di macchina. Per informazioni sui prezzi dei tipo di macchina, vedi la pagina dei prezzi di Compute Engine.
In Networking, aggiungi il tag di rete
allow-health-checks
.Nel menu a sinistra, fai clic su Sicurezza nodo.
In Ambiti di accesso, seleziona Consenti l'accesso completo a tutte le API Cloud.
Fai clic su Crea.
Dopo aver creato un cluster nella console Google Cloud, devi configurare
kubectl
per interagire con il cluster. Per saperne di più, consulta:
Generazione di una voce kubeconfig
in corso...
gcloud
Crea il cluster.
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 necessari per il cluster GKE
Passa al cluster che hai appena creato eseguendo il comando seguente. Questo
indirizza kubectl
al cluster corretto.
gcloud
gcloud container clusters get-credentials grpc-td-cluster \ --zone us-central1-a
Configurazione dei servizi GKE
Questa sezione descrive come preparare il deployment GKE
perché siano compatibili con Cloud Service Mesh. A questo scopo, devi configurare
un servizio di esempio GKE helloworld
con annotazioni NEG.
Il servizio di esempio helloworld
è un'applicazione server gRPC che restituisce un
in risposta a una richiesta di un client gRPC. Tieni presente che
niente di speciale nel servizio helloworld
. Non è una gRPC senza proxy
e può rispondere alle richieste da qualsiasi client gRPC.
L'opzione "senza proxy" entra in gioco solo quando un'applicazione client gRPC
si connette a Cloud Service Mesh, apprende il servizio helloworld
e può
quindi inviare il traffico ai pod associati a helloworld
, senza dover fare affidamento
sugli indirizzi IP o sulla risoluzione dei nomi basata su DNS.
Configurazione di servizi GKE con NEG
Il primo passaggio per la configurazione dei servizi GKE da utilizzare con Cloud Service Mesh deve esporre il servizio tramite un NEG. Da esporre tramite NEG, ogni specifica deve avere la seguente annotazione, la porta che vuoi esporre.
... metadata: annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
Questa annotazione crea un NEG autonomo quando esegui il primo deployment del servizio. Questo NEG contiene endpoint che corrispondono agli indirizzi IP e alle porte del pod. Per maggiori informazioni informazioni ed esempi, vedi Gruppi di endpoint di rete autonomi.
Nell'esempio seguente, esegui il deployment di un servizio Kubernetes helloworld
che è
esposta sulla porta 8080
. Questa è la porta sulla quale è visibile il servizio
in un cluster Kubernetes. Il servizio gRPC nel pod è in ascolto su targetPort
50051
. Questo
è la porta sul pod a cui viene inviata la richiesta. In genere, port
e
I valori di targetPort
sono impostati sullo stesso valore, ma in 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 sia stato creato il nuovo servizio helloworld
:
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 del NEG sia corretto.
Console
Per visualizzare un elenco dei gruppi di endpoint di rete, vai a Gruppi di endpoint di rete
nella console Google Cloud. Vedi un NEG denominato example-grpc-server
.
Vai alla pagina Gruppi di endpoint di rete
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
Configurazione di Cloud Service Mesh con componenti di bilanciamento del carico
Questa sezione descrive come configurare il bilanciamento del carico di Google Cloud per i tuoi servizi. Questi componenti contengono informazioni di configurazione. che consente ai client gRPC senza proxy di comunicare con GKE i servizi di machine learning.
L'esempio di configurazione di Cloud Service Mesh che segue fa queste ipotesi:
- 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 del NEG per il cluster è
example-grpc-server
.
Creazione del controllo di integrità, della regola firewall e del servizio di backend in corso...
In questa sezione creerai un controllo di integrità e la regola firewall per
controllo di integrità. Il controllo di integrità deve utilizzare il protocollo di controllo di integrità gRPC. La
una regola firewall consente ai probe del controllo di integrità di connettersi alle VM nel tuo
e deployment continuo. L'istruzione --use-serving-port
viene utilizzata dai controlli di integrità
per ottenere la porta di ascolto configurata per ciascun endpoint.
La regola firewall consente le connessioni del controllo di integrità in entrata alle istanze in della tua rete.
In questa sezione, creerai un servizio di backend globale
con uno schema di bilanciamento del carico di INTERNAL_SELF_MANAGED
e il protocollo GRPC
,
e poi associare il controllo di integrità
al servizio di backend.
Per saperne di più, consulta Creazione di controlli di integrità.
gcloud
Crea il controllo di integrità.
gcloud compute health-checks create grpc grpc-gke-helloworld-hc \ --use-serving-port
Crea la regola 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
Creare il servizio di 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
Aggiungi i NEG di backend al servizio di 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
Creazione della mappa di regole di routing
In questa sezione, creerai una mappa URL, uno strumento di abbinamento del percorso e una regola host da indirizzare
per il tuo servizio, in base al nome host e a un percorso. Nell'esempio che segue
usa helloworld-gke
come nome del servizio. Il client gRPC utilizza questo
nome del servizio nell'URI di destinazione quando ti connetti al servizio helloworld
.
Creerai anche il proxy gRPC di destinazione e la regola di forwarding.
Per ulteriori informazioni, consulta Mappe di 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 deve essere configurata una regola host helloworld-gke:8000
nel
Mappa URL. Tieni presente che la porta di servizio 8080
mostrata nelle specifiche del servizio Kubernetes
in una sezione precedente non è utilizzato da Cloud Service Mesh perché helloworld-gke:8000
è
risolto negli endpoint NEG che stanno ascoltando l'50051
targetPort
.
In genere, la porta nella regola host della mappa URL e nella specifica del servizio Kubernetes
Per comodità di port
e targetPort
è stato impostato lo stesso valore, ma
in questo esempio vengono utilizzati valori diversi per indicare che port
nella specifica del servizio
non viene utilizzato da Cloud Service Mesh.
gcloud
Crea la mappa URL.
gcloud compute url-maps create grpc-gke-url-map \ --default-service grpc-gke-helloworld-service
Crea il matcher del percorso.
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 il proxy gRPC di destinazione.
gcloud compute target-grpc-proxies create grpc-gke-proxy \ --url-map grpc-gke-url-map \ --validate-for-proxyless
Crea la regola di forwarding.
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 è ora configurato per bilanciare il carico del traffico tra nel NEG per i servizi specificati nella mappa URL.
Verifica della configurazione in corso...
Una volta completato il processo di configurazione, verifica di poter raggiungere le
helloworld
server gRPC 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 metodo grpc-gke-helloworld-service
servizio di backend) e utilizza queste informazioni per inviare il traffico al servizio
di backend.
Per informazioni, puoi anche consultare la sezione Cloud Service Mesh nella console Google Cloud
sul servizio configurato helloworld-gke
e controlla se i backend sono
segnalato come stato integro.
Verifica con un client gRPC senza proxy
Nei seguenti esempi, utilizzi client gRPC in linguaggi diversi o la
Strumento grpcurl
per verificare che Cloud Service Mesh stia eseguendo il routing del traffico
in modo corretto nella mesh. Crei un pod del client, quindi apri una shell ed esegui
i comandi di verifica della shell.
Configurazione della variabile di ambiente e del file di bootstrap
L'applicazione client richiede un file di configurazione di bootstrap. Modifica il tuo
specifiche del deployment delle applicazioni Kubernetes aggiungendo un initContainer
che genera il file di bootstrap e un volume per trasferire il file. Aggiorna il tuo
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.11.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 di applicazioni per 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/
Questo è 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.11.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 sul pod del 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.
Java
Per verificare il servizio con un client Java gRPC:
Scarica la versione più recente di gRPC Java, con la patch e la build più recenti l'applicazione client
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
Esegui il client con
"world"
come nome e"xds:///helloworld-gke:8000"
come URI e porta del servizio../build/install/example-xds/bin/xds-hello-world-client "world" \ xds:///helloworld-gke:8000
Vai
Per verificare il servizio con un client gRPC Go:
Scarica l'ultima versione di gRPC Go con la patch più recente e crea
xds-hello-world
applicazione client.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 .
Esegui il client con
"world"
come nome e"xds:///helloworld-gke:8000"
come URI e porta del servizio../client "world" xds:///helloworld-gke:8000
C++
Per verificare il servizio con un client gRPC C++:
Scarica l'ultima versione di gRPC C++,con la patch più recente, e crea Esempio di client
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
Esegui il client con "xds:///helloworld-gke:8000" come URI e porta del servizio.
./greeter_client --target=xds:///helloworld-gke:8000
Gripcurl
Lo strumento grpcurl
può anche fungere da client gRPC senza proxy. In questo caso,
grpcurl
utilizza la variabile di ambiente e le informazioni di bootstrap per connettersi
in Cloud Service Mesh. Apprende poi il servizio helloworld
, che
è stata configurata con Cloud Service Mesh tramite grpc-gke-helloworld-service
di servizio di backend.
Per verificare la configurazione utilizzando lo strumento grpcurl
:
Scarica e installa lo strumento
grpcurl
.curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.8.1/grpcurl_1.8.1_linux_x86_64.tar.gz | tar -xz
Esegui lo strumento
grpcurl
con "xds:///helloworld-gke:8000" come URI del servizio ehelloworld.Greeter/SayHello
come nome del servizio e metodo da richiamare. La I parametri al metodoSayHello
vengono passati utilizzando l'opzione-d
../grpcurl --plaintext \ -d '{"name": "world"}' \ xds:///helloworld-gke:8000 helloworld.Greeter/SayHello
Python
Per verificare il servizio con un client Python gRPC, esegui quanto segue. Utilizza le funzionalità di la versione più recente di gRPC con la patch più recente.
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
Per verificare il servizio con un client Ruby gRPC, esegui quanto segue. Utilizza le funzionalità di la versione più recente di gRPC con la patch più recente.
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
Per verificare il servizio con un client PHP gRPC, esegui il comando riportato di seguito. Utilizza le funzionalità di la versione più recente di gRPC con la patch più recente.
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
Per verificare il servizio con un client Node.js gRPC, esegui quanto segue. Utilizza le funzionalità di la versione più recente di gRPC con la patch più recente.
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 vedere un output simile a questo, dove INSTANCE_HOST_NAME
è
il nome host dell'istanza VM:
Greetings: Hello world, from INSTANCE_HOST_NAME
Questo verifica che il client gRPC senza proxy si sia connesso correttamente
Cloud Service Mesh e abbiamo imparato a conoscere i backend per il servizio helloworld-gke
utilizzando il resolver xds name. Il client ha inviato una richiesta a uno dei backend del servizio senza dover conoscere l'indirizzo IP o eseguire una risoluzione DNS.
Passaggi successivi
- Scopri di più sulla sicurezza del servizio 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.