Configura la sicurezza dei servizi con gRPC senza proxy
Questa guida mostra come configurare un servizio di sicurezza per il mesh di servizi gRPC senza proxy.
Requisiti
Prima di configurare la sicurezza dei servizi per il mesh di servizi gRPC senza proxy, assicurati di soddisfare i seguenti requisiti.
- Il tuo deployment soddisfa i requisiti indicati in Preparati per la configurazione delle API Routes con Envoy e workload senza proxy.
- Devi utilizzare xDS v3.
- Hai accesso alla versione xDS richiesta e alla funzionalità del provider di certificati con uno dei seguenti linguaggi:
- gRPC Java
- gRPC C++
- gRPC Python
- gRPC Go Puoi trovare le versioni dei linguaggi richieste su GitHub
- Hai accesso al generatore di bootstrap, versione 0.19.0. L'immagine del generatore di bootstrap si trova nel repository di container Google Cloud .
- Soddisfi tutti i prerequisiti per il bilanciamento del carico del mesh di servizi gRPC senza proxy.
- Disponi di autorizzazioni sufficienti per creare o aggiornare le risorse Cloud Service Mesh e del mesh di serviziGoogle Cloud per utilizzare la sicurezza PSM. Per informazioni complete sulle autorizzazioni richieste, consulta Preparati a configurare Cloud Service Mesh con servizi gRPC senza proxy.
- Disponi delle autorizzazioni necessarie per utilizzare Certificate Authority Service, descritte in Crea autorità di certificazione per emettere certificati
Configura Identity and Access Management
Devi disporre delle autorizzazioni necessarie per utilizzare Google Kubernetes Engine. Come minimo, devi disporre dei seguenti ruoli:
- Ruolo GKE
roles/container.clusterAdmin - Ruolo Compute Engine
roles/compute.instanceAdmin roles/iam.serviceAccountUserruolo
Per creare le risorse necessarie per la configurazione, devi disporre del ruolo compute.NetworkAdmin. Questo ruolo contiene tutte le autorizzazioni necessarie per creare, aggiornare, eliminare, elencare e utilizzare (ovvero fare riferimento a queste risorse in altre risorse) le risorse richieste. Se sei il proprietario-editor del progetto,
disponi automaticamente di questo ruolo.
Tieni presente che networksecurity.googleapis.com.clientTlsPolicies.use e networksecurity.googleapis.com.serverTlsPolicies.use non vengono applicati quando fai riferimento a queste risorse nella risorsa del servizio di backend.
Se questa applicazione verrà applicata in futuro e utilizzi il ruolo compute.NetworkAdmin, non noterai alcun problema quando verrà applicato questo controllo.
Se utilizzi ruoli personalizzati e questo controllo verrà applicato in futuro, devi assicurarti di includere la rispettiva autorizzazione .use. In caso contrario, in futuro potresti scoprire che il tuo ruolo personalizzato non dispone delle autorizzazioni necessarie per fare riferimento a clientTlsPolicy o serverTlsPolicy dal servizio di backend.
Preparati alla configurazione
La sicurezza del mesh di servizi senza proxy (PSM) aggiunge sicurezza a un mesh di servizi configurato per il bilanciamento del carico in base alla documentazione dei servizi gRPC senza proxy. In un mesh di servizi senza proxy, un client gRPC utilizza lo schema xds: nell'URI per accedere al servizio, il che attiva le funzionalità di bilanciamento del carico e rilevamento degli endpoint PSM.
Aggiorna i client e i server gRPC alla versione corretta
Crea o ricrea le tue applicazioni utilizzando la versione gRPC minima supportata per il tuo linguaggio.
Aggiorna il file di bootstrap
Le applicazioni gRPC utilizzano un singolo file di bootstrap, che deve contenere tutti i campi richiesti dal codice lato client e lato server gRPC. Un generatore di bootstrap genera automaticamente il file di bootstrap per includere i flag e i valori necessari per la sicurezza di PSM. Per saperne di più, consulta la sezione File di bootstrap, che include un file di bootstrap di esempio.
Panoramica della configurazione
Questa procedura di configurazione è un'estensione della configurazione di Cloud Service Mesh con GKE e servizi gRPC senza proxy. I passaggi esistenti non modificati di questa procedura di configurazione sono indicati ovunque siano applicabili.
I principali miglioramenti alla configurazione di Cloud Service Mesh con GKE sono i seguenti:
- Configurazione di Certificate Authority Service, in cui crei pool CA private e le autorità di certificazione richieste.
- Creazione di un cluster GKE con le funzionalità di federazione delle identità per i carichi di lavoro per GKE e dei certificati mesh di GKE e l'integrazione di Certificate Authority Service.
- Configurazione dell'emissione dei certificati mesh sul cluster.
- Creazione dei service account client e server.
- Configurazione del server di esempio che utilizza le API xDS e le credenziali del server xDS per acquisire la configurazione di sicurezza da Cloud Service Mesh.
- Configurazione del client di esempio che utilizza le credenziali xDS.
- Aggiornamento della configurazione di Cloud Service Mesh per includere la configurazione della sicurezza.
Puoi trovare esempi di codice per l'utilizzo delle credenziali xDS nelle seguenti posizioni:
Aggiorna Google Cloud CLI
Per aggiornare Google Cloud CLI, esegui questo comando:
gcloud components update
Imposta le variabili di ambiente
In questa guida utilizzerai i comandi di Cloud Shell e le informazioni ripetute nei comandi sono rappresentate da varie variabili di ambiente. Imposta i valori specifici per le seguenti variabili di ambiente nell'ambiente shell prima di eseguire i comandi. Ogni riga di commento indica il significato della variabile di ambiente associata.
# Your project ID
PROJECT_ID=PROJECT_ID
# GKE cluster name and zone for this example.
CLUSTER_NAME=CLUSTER_NAME
ZONE=ZONE
gcloud config set compute/zone $ZONE
# GKE cluster URL derived from the above
GKE_CLUSTER_URL="https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${ZONE}/clusters/${CLUSTER_NAME}"
# Workload pool to be used with the GKE cluster
WORKLOAD_POOL="${PROJECT_ID}."
# Kubernetes namespace to run client and server demo.
K8S_NAMESPACE='default'
DEMO_BACKEND_SERVICE_NAME='grpc-gke-helloworld-service'
# Compute other values
# Project number for your project
PROJNUM=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
# VERSION is the GKE cluster version. Install and use the most recent version
# from the rapid release channel and substitute its version for
# CLUSTER_VERSION, for example:
# VERSION=latest available version
# Note that the minimum required cluster version is 1.21.4-gke.1801.
VERSION="CLUSTER_VERSION"
SA_GKE=service-${PROJNUM}@container-engine-robot.
Abilita l'accesso alle API richieste
Questa sezione spiega come abilitare l'accesso alle API necessarie.
Esegui questo comando per abilitare Cloud Service Mesh e altre API necessarie per la sicurezza del mesh di servizi gRPC senza proxy.
gcloud services enable \ container.googleapis.com \ cloudresourcemanager.googleapis.com \ compute.googleapis.com \ trafficdirector.googleapis.com \ networkservices.googleapis.com \ networksecurity.googleapis.com \ privateca.googleapis.com \ gkehub.googleapis.comEsegui questo comando per consentire all'account di servizio predefinito di accedere all'API di sicurezza di Cloud Service Mesh.
GSA_EMAIL=$(gcloud iam service-accounts list --format='value(email)' \ --filter='displayName:Compute Engine default service account') gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member serviceAccount:${GSA_EMAIL} \ --role roles/trafficdirector.client
Crea o aggiorna un cluster GKE
La sicurezza dei servizi Cloud Service Mesh dipende dall'integrazione di CA Service con GKE. Il cluster GKE deve soddisfare i seguenti requisiti, oltre ai requisiti per la configurazione:
- Utilizza una versione minima del cluster 1.21.4-gke.1801. Se hai bisogno di funzionalità presenti in una versione successiva, puoi ottenerla dal canale di rilascio rapido.
- Il cluster GKE deve essere abilitato e configurato con i certificati mesh, come descritto in Creazione di autorità di certificazione per l'emissione di certificati.
Crea un nuovo cluster che utilizza Workload Identity Federation for GKE. Se stai aggiornando un cluster esistente, vai al passaggio successivo. Il valore che fornisci per
--tagsdeve corrispondere al nome passato al flag--target-tagsper il comandofirewall-rules createnella sezione Configura Cloud Service Mesh con i componenti di Cloud Load Balancing.# Create a GKE cluster with GKE managed mesh certificates. gcloud container clusters create CLUSTER_NAME \ --release-channel=rapid \ --scopes=cloud-platform \ --image-type=cos_containerd \ --machine-type=e2-standard-2 \ --zone=ZONE \ --workload-pool=PROJECT_ID. \ --enable-mesh-certificates \ --cluster-version=CLUSTER_VERSION \ --enable-ip-alias \ --tags=allow-health-checks \ --workload-metadata=GKE_METADATA
La creazione del cluster potrebbe richiedere alcuni minuti.
Se utilizzi un cluster esistente, attiva Workload Identity Federation for GKE e i certificati mesh GKE. Assicurati che il cluster sia stato creato con il flag
--enable-ip-alias, che non può essere utilizzato con il comandoupdate.gcloud container clusters update CLUSTER_NAME \ --enable-mesh-certificates
Esegui questo comando per passare al nuovo cluster come cluster predefinito per i comandi
kubectl:gcloud container clusters get-credentials CLUSTER_NAME \ --zone ZONE
Registra i cluster in un parco risorse
Registra il cluster che hai creato o aggiornato in Creazione di un cluster GKE con un parco risorse. La registrazione del cluster semplifica la configurazione dei cluster in più progetti.
Tieni presente che il completamento di questi passaggi può richiedere fino a dieci minuti ciascuno.
Registra il cluster nel parco risorse:
gcloud container fleet memberships register CLUSTER_NAME \ --gke-cluster=ZONE/CLUSTER_NAME \ --enable-workload-identity --install-connect-agent \ --manifest-output-file=MANIFEST-FILE_NAME
Sostituisci le variabili in questo modo:
- CLUSTER_NAME: il nome del tuo cluster.
- ZONE: la zona del tuo cluster.
- MANIFEST-FILE_NAME: il percorso in cui questi comandi generano il manifest per la registrazione.
Se la procedura di registrazione va a buon fine, viene visualizzato un messaggio simile al seguente:
Finished registering the cluster CLUSTER_NAME with the fleet.
Applica il file manifest generato al tuo cluster:
kubectl apply -f MANIFEST-FILE_NAME
Se il processo di richiesta va a buon fine, vengono visualizzati messaggi simili ai seguenti:
namespace/gke-connect created serviceaccount/connect-agent-sa created podsecuritypolicy.policy/gkeconnect-psp created role.rbac.authorization.k8s.io/gkeconnect-psp:role created rolebinding.rbac.authorization.k8s.io/gkeconnect-psp:rolebinding created role.rbac.authorization.k8s.io/agent-updater created rolebinding.rbac.authorization.k8s.io/agent-updater created role.rbac.authorization.k8s.io/gke-connect-agent-20210416-01-00 created clusterrole.rbac.authorization.k8s.io/gke-connect-impersonation-20210416-01-00 created clusterrolebinding.rbac.authorization.k8s.io/gke-connect-impersonation-20210416-01-00 created clusterrolebinding.rbac.authorization.k8s.io/gke-connect-feature-authorizer-20210416-01-00 created rolebinding.rbac.authorization.k8s.io/gke-connect-agent-20210416-01-00 created role.rbac.authorization.k8s.io/gke-connect-namespace-getter created rolebinding.rbac.authorization.k8s.io/gke-connect-namespace-getter created secret/http-proxy created deployment.apps/gke-connect-agent-20210416-01-00 created service/gke-connect-monitoring created secret/creds-gcp create
Recupera la risorsa di appartenenza dal cluster:
kubectl get memberships membership -o yaml
L'output deve includere il pool di Workload Identity assegnato dal parco risorse, dove PROJECT_ID è l'ID progetto:
workload_identity_pool: PROJECT_ID.
Ciò significa che il cluster è stato registrato correttamente.
Crea autorità di certificazione per emettere certificati
Per emettere certificati per i tuoi pod, crea un pool di Certificate Authority Service e le seguenti autorità di certificazione (CA):
- CA radice. Questa è la radice di attendibilità per tutti i certificati mesh emessi. Puoi utilizzare una CA root esistente, se ne hai una. Crea la CA radice nel livello
enterprise, destinato all'emissione di certificati di lunga durata e di volume ridotto. - CA subordinata. Questa CA emette certificati per i workload. Crea la CA subordinata nella regione in cui è stato eseguito il deployment del cluster. Crea la CA subordinata nel livello
devops, destinato all'emissione di certificati di breve durata e di volume elevato.
La creazione di una CA subordinata è facoltativa, ma ti consigliamo vivamente di crearne una anziché utilizzare la CA radice per emettere certificati GKE Mesh. Se decidi di utilizzare la CA radice per emettere certificati mesh, assicurati che la modalità di emissione basata sulla configurazione predefinita rimanga consentita.
La CA subordinata può trovarsi in una regione diversa da quella del cluster, ma ti consigliamo vivamente di crearla nella stessa regione del cluster per ottimizzare le prestazioni. Tuttavia, puoi creare le CA principali e CA subordinate in regioni diverse senza alcun impatto sulle prestazioni o sulla disponibilità.
Queste regioni sono supportate per CA Service:
| Nome regione | Descrizione della regione |
|---|---|
asia-east1 |
Taiwan |
asia-east2 |
Hong Kong |
asia-northeast1 |
Tokyo |
asia-northeast2 |
Osaka |
asia-northeast3 |
Seul |
asia-south1 |
Mumbai |
asia-south2 |
Delhi |
asia-southeast1 |
Singapore |
asia-southeast2 |
Giacarta |
australia-southeast1 |
Sydney |
australia-southeast2 |
Melbourne |
europe-central2 |
Varsavia |
europe-north1 |
Finlandia |
europe-southwest1 |
Madrid |
europe-west1 |
Belgio |
europe-west2 |
Londra |
europe-west3 |
Francoforte |
europe-west4 |
Paesi Bassi |
europe-west6 |
Zurigo |
europe-west8 |
Milano |
europe-west9 |
Parigi |
europe-west10 |
Berlino |
europe-west12 |
Torino |
me-central1 |
Doha |
me-central2 |
Dammam |
me-west1 |
Tel Aviv |
northamerica-northeast1 |
Montréal |
northamerica-northeast2 |
Toronto |
southamerica-east1 |
San Paolo |
southamerica-west1 |
Santiago |
us-central1 |
Iowa |
us-east1 |
Carolina del Sud |
us-east4 |
Virginia del Nord |
us-east5 |
Columbus |
us-south1 |
Dallas |
us-west1 |
Oregon |
us-west2 |
Los Angeles |
us-west3 |
Salt Lake City |
us-west4 |
Las Vegas |
L'elenco delle località supportate può essere controllato anche eseguendo il seguente comando:
gcloud privateca locations list
Concedi il ruolo IAM
roles/privateca.caManageralle persone che creano un pool di CA e una CA. Tieni presente che per MEMBER, il formato corretto èuser:userid@example.com. Se questa persona è l'utente corrente, puoi ottenere l'ID utente corrente con il comando shell$(gcloud auth list --filter=status:ACTIVE --format="value(account)").gcloud projects add-iam-policy-binding PROJECT_ID \ --member=MEMBER \ --role=roles/privateca.caManager
Concedi il ruolo
role/privateca.adminper CA Service alle persone che devono modificare le policy IAM, doveMEMBERè una persona che ha bisogno di questo accesso, in particolare tutte le persone che eseguono i passaggi successivi che concedono i ruoliprivateca.auditoreprivateca.certificateManager:gcloud projects add-iam-policy-binding PROJECT_ID \ --member=MEMBER \ --role=roles/privateca.admin
Crea il pool di Certificate Authority Service radice.
gcloud privateca pools create ROOT_CA_POOL_NAME \ --location ROOT_CA_POOL_LOCATION \ --tier enterprise
Crea una CA radice.
gcloud privateca roots create ROOT_CA_NAME --pool ROOT_CA_POOL_NAME \ --subject "CN=ROOT_CA_NAME, O=ROOT_CA_ORGANIZATION" \ --key-algorithm="ec-p256-sha256" \ --max-chain-length=1 \ --location ROOT_CA_POOL_LOCATION
Per questa configurazione dimostrativa, utilizza i seguenti valori per le variabili:
- ROOT_CA_POOL_NAME=td_sec_pool
- ROOT_CA_NAME=pkcs2-ca
- ROOT_CA_POOL_LOCATION=us-east1
- ROOT_CA_ORGANIZATION="TestCorpLLC"
Crea il pool subordinato e la CA subordinata. Assicurati che la modalità di emissione basata sulla configurazione predefinita rimanga consentita.
gcloud privateca pools create SUBORDINATE_CA_POOL_NAME \ --location SUBORDINATE_CA_POOL_LOCATION \ --tier devops
gcloud privateca subordinates create SUBORDINATE_CA_NAME \ --pool SUBORDINATE_CA_POOL_NAME \ --location SUBORDINATE_CA_POOL_LOCATION \ --issuer-pool ROOT_CA_POOL_NAME \ --issuer-location ROOT_CA_POOL_LOCATION \ --subject "CN=SUBORDINATE_CA_NAME, O=SUBORDINATE_CA_ORGANIZATION" \ --key-algorithm "ec-p256-sha256" \ --use-preset-profile subordinate_mtls_pathlen_0
Per questa configurazione dimostrativa, utilizza i seguenti valori per le variabili:
- SUBORDINATE_CA_POOL_NAME="td-ca-pool"
- SUBORDINATE_CA_POOL_LOCATION=us-east1
- SUBORDINATE_CA_NAME="td-ca"
- SUBORDINATE_CA_ORGANIZATION="TestCorpLLC"
- ROOT_CA_POOL_NAME=td_sec_pool
- ROOT_CA_POOL_LOCATION=us-east1
Concedi il ruolo IAM
privateca.auditorper il pool CA principale per consentire l'accesso dall'agente di servizio GKE:gcloud privateca pools add-iam-policy-binding ROOT_CA_POOL_NAME \ --location ROOT_CA_POOL_LOCATION \ --role roles/privateca.auditor \ --member="serviceAccount:service-PROJNUM@container-engine-robot."
Concedi il ruolo IAM
privateca.certificateManagerper il pool CA subordinato per consentire l'accesso dall'agente di servizio GKE:gcloud privateca pools add-iam-policy-binding SUBORDINATE_CA_POOL_NAME \ --location SUBORDINATE_CA_POOL_LOCATION \ --role roles/privateca.certificateManager \ --member="serviceAccount:service-PROJNUM@container-engine-robot."
Salva la seguente configurazione YAML
WorkloadCertificateConfigper indicare al cluster come emettere i certificati mesh:apiVersion: security.cloud.google.com/v1 kind: WorkloadCertificateConfig metadata: name: default spec: # Required. The CA service that issues your certificates. certificateAuthorityConfig: certificateAuthorityServiceConfig: endpointURI: ISSUING_CA_POOL_URI # Required. The key algorithm to use. Choice of RSA or ECDSA. # # To maximize compatibility with various TLS stacks, your workloads # should use keys of the same family as your root and subordinate CAs. # # To use RSA, specify configuration such as: # keyAlgorithm: # rsa: # modulusSize: 4096 # # Currently, the only supported ECDSA curves are "P256" and "P384", and the only # supported RSA modulus sizes are 2048, 3072 and 4096. keyAlgorithm: rsa: modulusSize: 4096 # Optional. Validity duration of issued certificates, in seconds. # # Defaults to 86400 (1 day) if not specified. validityDurationSeconds: 86400 # Optional. Try to start rotating the certificate once this # percentage of validityDurationSeconds is remaining. # # Defaults to 50 if not specified. rotationWindowPercentage: 50Sostituisci quanto segue:
- L'ID progetto del progetto in cui viene eseguito il cluster:
PROJECT_ID
- L'URI completo della CA che emette i certificati del mesh (ISSUING_CA_POOL_URI).
Può essere la CA subordinata (consigliata) o la CA radice. Il formato è:
//privateca.googleapis.com/projects/PROJECT_ID/locations/SUBORDINATE_CA_POOL_LOCATION/caPools/SUBORDINATE_CA_POOL_NAME
- L'ID progetto del progetto in cui viene eseguito il cluster:
Salva la seguente configurazione YAML
TrustConfigper indicare al cluster come considerare attendibili i certificati emessi:apiVersion: security.cloud.google.com/v1 kind: TrustConfig metadata: name: default spec: # You must include a trustStores entry for the trust domain that # your cluster is enrolled in. trustStores: - trustDomain: PROJECT_ID. # Trust identities in this trustDomain if they appear in a certificate # that chains up to this root CA. trustAnchors: - certificateAuthorityServiceURI: ROOT_CA_POOL_URISostituisci quanto segue:
- L'ID progetto del progetto in cui viene eseguito il cluster:
PROJECT_ID
- L'URI completo del pool CA root (ROOT_CA_POOL_URI).
Il formato è:
//privateca.googleapis.com/projects/PROJECT_ID/locations/ROOT_CA_POOL_LOCATION/caPools/ROOT_CA_POOL_NAME
- L'ID progetto del progetto in cui viene eseguito il cluster:
Applica le configurazioni al tuo cluster:
kubectl apply -f WorkloadCertificateConfig.yaml kubectl apply -f TrustConfig.yaml
Crea un servizio gRPC senza proxy con i NEG
Per la sicurezza PSM, hai bisogno di un server gRPC senza proxy in grado di utilizzare xDS per acquisire la configurazione di sicurezza da Cloud Service Mesh. Questo passaggio è simile alla sezione Configura i servizi GKE con i NEG nella guida alla configurazione del bilanciamento del carico PSM, ma utilizzi il server helloworld abilitato per xDS nell'esempio xDS nel repository grpc-java anziché nell'immagine java-example-hostname.
Puoi creare ed eseguire questo server in un container creato da un'immagine openjdk:8-jdk.
Utilizzi anche la funzionalità NEG con nome, che ti consente di specificare un nome per il NEG. In questo modo, i passaggi successivi vengono semplificati perché il deployment conosce il nome del NEG senza doverlo cercare.
Di seguito è riportato un esempio completo della specifica Kubernetes del server gRPC. Tieni presente quanto segue:
- La specifica crea un account di servizio Kubernetes
example-grpc-serverche viene utilizzato dal pod del server gRPC. - La specifica utilizza il campo
namenell'annotazionecloud.google.com/negdel servizio per specificare il nome del NEGexample-grpc-server. - La variabile
${PROJNUM}rappresenta il numero del tuo progetto. - La specifica utilizza la sezione
initContainersper eseguire un generatore di bootstrap per compilare il file di bootstrap necessario alla libreria gRPC senza proxy. Questo file di bootstrap si trova in/tmp/grpc-xds/td-grpc-bootstrap.jsonnel contenitore del server gRPC denominatoexample-grpc-server.
Aggiungi la seguente annotazione alla specifica del pod:
annotations: security.cloud.google.com/use-workload-certificates: ""
Puoi vedere il posizionamento corretto nella specifica completa riportata di seguito.
Al momento della creazione, ogni pod riceve un volume in /var/run/secrets/workload-spiffe-credentials.
Questo volume contiene:
private_key.pemè una chiave privata generata automaticamente.certificates.pemè un bundle di certificati in formato PEM che può essere presentato a un altro pod come catena di certificati client o utilizzato come catena di certificati server.ca_certificates.pemè un bundle di certificati in formato PEM da utilizzare come trust anchor durante la convalida della catena di certificati client presentata da un altro pod o della catena di certificati server ricevuta durante la connessione a un altro pod.
Tieni presente che ca_certificates.pem contiene i certificati per il dominio di attendibilità locale per i workload, ovvero il pool di workload del cluster.
Il certificato foglia in certificates.pem contiene la seguente asserzione di identità SPIFFE in testo normale:
spiffe://WORKLOAD_POOL/ns/NAMESPACE/sa/KUBERNETES_SERVICE_ACCOUNT
In questa asserzione:
- WORKLOAD_POOL è il nome del pool di workload del cluster.
- NAMESPACE è lo spazio dei nomi del tuo account di servizio Kubernetes.
- KUBERNETES_SERVICE_ACCOUNT è il nome del tuo account di servizio Kubernetes.
Le seguenti istruzioni per il tuo linguaggio creano la specifica da utilizzare in questo esempio.
Java
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la specifica:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: openjdk:8-jdk imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 800m memory: 512Mi requests: cpu: 100m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
C++
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la specifica:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Python
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la specifica:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Vai
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la specifica:
cat << EOF > example-grpc-server.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-server namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: v1 kind: Service metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server annotations: cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}' spec: ports: - name: helloworld port: 8080 protocol: TCP targetPort: 50051 selector: k8s-app: example-grpc-server type: ClusterIP --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-server namespace: default labels: k8s-app: example-grpc-server spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-server strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-server spec: containers: - image: golang:1.16-alpine imagePullPolicy: IfNotPresent name: example-grpc-server command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" ports: - protocol: TCP containerPort: 50051 resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" - --node-metadata=app=helloworld resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-server volumes: - name: grpc-td-conf emptyDir: medium: Memory EOFCompleta la procedura come segue.
Applica la specifica:
kubectl apply -f example-grpc-server.yaml
Concedi i ruoli richiesti al account di servizio:
gcloud iam service-accounts add-iam-policy-binding \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:${PROJECT_ID}.[default/example-grpc-server]" \ ${PROJNUM}-compute@ gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member "serviceAccount:${PROJECT_ID}.[default/example-grpc-server]" \ --role roles/trafficdirector.clientEsegui questi comandi per verificare che il servizio e il pod siano stati creati correttamente:
kubectl get deploy/example-grpc-server kubectl get svc/example-grpc-server
Verifica che il nome del NEG sia corretto:
gcloud compute network-endpoint-groups list \ --filter "name=example-grpc-server" --format "value(name)"Il comando dovrebbe restituire il nome del NEG
example-grpc-server.
Configura Cloud Service Mesh con i componenti di bilanciamento del carico Google Cloud
I passaggi descritti in questa sezione sono simili a quelli di Configura Cloud Service Mesh con i componenti di bilanciamento del carico, ma con alcune modifiche, come descritto nelle sezioni seguenti.
Crea il controllo di integrità, la regola firewall e il servizio di backend
Quando il server gRPC è configurato per l'utilizzo di mTLS, i controlli di integrità gRPC non funzionano perché il client di controllo di integrità non può presentare un certificato client valido ai server. Puoi risolvere il problema in due modi.
Nel primo approccio, il server crea una porta di gestione aggiuntiva designata come porta di controllo di integrità. Questo è collegato a un servizio di controllo di integrità speciale, come testo normale o TLS per quella porta.
Il server di esempio xDS helloworld utilizza PORT_NUMBER + 1 come porta di controllo di integrità in testo normale. L'esempio utilizza 50052 come porta di controllo di integrità perché 50051 è la porta del server dell'applicazione gRPC.
Nel secondo approccio, configuri il controllo di integrità in modo da verificare solo la connettività TCP alla porta di pubblicazione dell'applicazione. In questo modo viene controllata solo la connettività e viene generato traffico non necessario verso il server quando i TLS handshake non vanno a buon fine. Per questo motivo, ti consigliamo di utilizzare il primo approccio.
Crea il controllo di integrità. Tieni presente che il controllo di integrità non viene avviato finché non crei e avvii il server.
Se stai creando una porta di gestione designata per il controllo di integrità, che è l'approccio che consigliamo, utilizza questo comando:
gcloud compute health-checks create grpc grpc-gke-helloworld-hc \ --enable-logging --port 50052
Se stai creando un controllo di integrità TCP, che sconsigliamo, utilizza questo comando:
gcloud compute health-checks create tcp grpc-gke-helloworld-hc \ --use-serving-port
Crea il firewall. Assicurati che il valore di
--target-tagscorrisponda al valore fornito per--tagsnella sezione Crea o aggiorna un cluster GKE.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-50052
Crea 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
Collega il NEG 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 ${ZONE} \ --balancing-mode RATE \ --max-rate-per-endpoint 5
Crea le risorse Mesh e GRPCRoute
La procedura è simile a quella per configurare le risorse Mesh e GRPCRoute in Configura i servizi gRPC senza proxy.
Crea la specifica
Meshe salvala in un file denominatomesh.yaml.name: grpc-mesh
Importa la risorsa
Meshdalla specifica.gcloud network-services meshes import grpc-mesh \ --source=mesh.yaml \ --location=global
Crea la specifica
GRPCRoutee salvala in un file denominatogrpc_route.yaml.name: helloworld-grpc-route hostnames: - helloworld-gke:8000 meshes: - projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh rules: - action: destinations: - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-gke-helloworld-serviceImporta la risorsa
GRPCRoutedalla specificagrpc_route.yaml.gcloud network-services grpc-routes import helloworld-grpc-route \ --source=grpc_route.yaml \ --location=global
Configura Cloud Service Mesh con la sicurezza gRPC senza proxy
Questo esempio mostra come configurare mTLS sul lato client e sul lato server.
Formato dei riferimenti alle norme
Tieni presente il seguente formato obbligatorio per fare riferimento alle policy TLS del server e TLS del client:
projects/PROJECT_ID/locations/global/[serverTlsPolicies|clientTlsPolicies]/[server-tls-policy|client-mtls-policy]
Ad esempio:
projects/PROJECT_ID/locations/global/serverTlsPolicies/server-tls-policy
projects/PROJECT_ID/locations/global/clientTlsPolicies/client-mtls-policy
Configura mTLS lato server
Innanzitutto, crea una policy TLS del server. La policy chiede al lato server gRPC di utilizzare la configurazione del plug-in certificateProvicerInstance identificata dal nome google_cloud_private_spiffe per il certificato di identità, che fa parte di serverCertificate. La sezione mtlsPolicy indica la sicurezza mTLS e utilizza lo stesso google_cloud_private_spiffe della configurazione del plug-in per clientValidationCa, ovvero la specifica del certificato radice (convalida).
Successivamente, creerai una policy degli endpoint. Ciò specifica che un backend, ad esempio un server gRPC, che utilizza la porta 50051 con qualsiasi etichetta di metadati o nessuna, riceve la policy TLS del server collegata denominata server-mtls-policy. Specifica le etichette dei metadati utilizzando MATCH_ALL o un valore supportato. Le etichette dei metadati supportate sono disponibili nel campo endpointMatcher.metadataLabelMatcher.metadataLabelMatchCriteria del documento NetworkServicesEndpointPolicy. Crea la policy endpoint con un file temporaneo ep-mtls-psms.yaml che contiene i valori per la risorsa della policy endpoint utilizzando la policy che hai già definito.
Crea un file temporaneo
server-mtls-policy.yamlnella directory attuale con i valori della risorsa della policy TLS del server:name: "projects/PROJECT_ID/locations/global/serverTlsPolicies/server-mtls-policy" serverCertificate: certificateProviderInstance: pluginInstance: google_cloud_private_spiffe mtlsPolicy: clientValidationCa: - certificateProviderInstance: pluginInstance: google_cloud_private_spiffeCrea una risorsa policy TLS del server denominata
server-mtls-policyimportando il file temporaneoserver-mtls-policy.yaml:gcloud network-security server-tls-policies import server-mtls-policy \ --source=server-mtls-policy.yaml --location=global
Crea la policy endpoint creando il file temporaneo
ep-mtls-psms.yaml:name: "ep-mtls-psms" type: "GRPC_SERVER" serverTlsPolicy: "projects/PROJECT_ID/locations/global/serverTlsPolicies/server-mtls-policy" trafficPortSelector: ports: - "50051" endpointMatcher: metadataLabelMatcher: metadataLabelMatchCriteria: "MATCH_ALL" metadataLabels: - labelName: app labelValue: helloworldCrea la risorsa della policy degli endpoint importando il file
ep-mtls-psms.yaml:gcloud beta network-services endpoint-policies import ep-mtls-psms \ --source=ep-mtls-psms.yaml --location=global
Configura mTLS sul lato client
La policy di sicurezza lato client è collegata al servizio di backend. Quando un client accede a un backend (il server gRPC) tramite il servizio di backend, la policy di sicurezza lato client collegata viene inviata al client.
Crea i contenuti della risorsa della policy TLS client in un file temporaneo denominato
client-mtls-policy.yamlnella directory attuale:name: "client-mtls-policy" clientCertificate: certificateProviderInstance: pluginInstance: google_cloud_private_spiffe serverValidationCa: - certificateProviderInstance: pluginInstance: google_cloud_private_spiffeCrea la risorsa dei criteri TLS del client denominata
client-mtls-policyimportando il file temporaneoclient-mtls-policy.yaml:gcloud network-security client-tls-policies import client-mtls-policy \ --source=client-mtls-policy.yaml --location=global
Crea uno snippet in un file temporaneo per fare riferimento a questa policy e aggiungi i dettagli per
subjectAltNamesnel messaggioSecuritySettingscome nell'esempio seguente. Sostituisci${PROJECT_ID}con il valore dell'ID progetto, ovvero il valore della variabile di ambiente${PROJECT_ID}descritta in precedenza. Tieni presente cheexample-grpc-serverinsubjectAltNamesè il nome del service account Kubernetes utilizzato per il pod del server gRPC nella specifica di deployment.if [ -z "$PROJECT_ID" ] ; then echo Please make sure PROJECT_ID is set. ; fi cat << EOF > client-security-settings.yaml securitySettings: clientTlsPolicy: projects/${PROJECT_ID}/locations/global/clientTlsPolicies/client-mtls-policy subjectAltNames: - "spiffe://${PROJECT_ID}./ns/default/sa/example-grpc-server" EOFAggiungi il messaggio
securitySettingsal servizio di backend che hai già creato. Questi passaggi esportano i contenuti del servizio di backend attuale, aggiungono il messaggiosecuritySettingdel client e reimportano i nuovi contenuti per aggiornare il servizio di backend.gcloud compute backend-services export grpc-gke-helloworld-service --global \ --destination=/tmp/grpc-gke-helloworld-service.yaml cat /tmp/grpc-gke-helloworld-service.yaml client-security-settings.yaml \ >/tmp/grpc-gke-helloworld-service1.yaml gcloud compute backend-services import grpc-gke-helloworld-service --global \ --source=/tmp/grpc-gke-helloworld-service1.yaml -q
Verificare la configurazione
La configurazione di Cloud Service Mesh è ora completa, inclusa la sicurezza lato server e lato client. Successivamente, prepara ed esegui i workload del server e del client. L'esempio è completo.
Crea un client gRPC senza proxy
Questo passaggio è simile al passaggio precedente Crea un servizio gRPC senza proxy.
Utilizza il client helloworld abilitato per xDS dalla directory degli esempi xDS nel repository grpc-java. Puoi creare ed eseguire il client in un container creato da un'immagine openjdk:8-jdk. La specifica Kubernetes del client gRPC esegue le seguenti operazioni.
- Crea un account di servizio Kubernetes
example-grpc-clientutilizzato dal pod client gRPC. ${PROJNUM}rappresenta il numero del tuo progetto e deve essere sostituito con il numero effettivo.
Aggiungi la seguente annotazione alla specifica del pod:
annotations:
security.cloud.google.com/use-workload-certificates: ""
Al momento della creazione, ogni pod riceve un volume in /var/run/secrets/workload-spiffe-credentials.
Questo volume contiene:
private_key.pemè una chiave privata generata automaticamente.certificates.pemè un bundle di certificati in formato PEM che può essere presentato a un altro pod come catena di certificati client o utilizzato come catena di certificati server.ca_certificates.pemè un bundle di certificati in formato PEM da utilizzare come trust anchor durante la convalida della catena di certificati client presentata da un altro pod o della catena di certificati server ricevuta durante la connessione a un altro pod.
Tieni presente che ca_certificates.pem contiene i certificati radice per il dominio di attendibilità locale per i workload, ovvero il pool di workload del cluster.
Il certificato foglia in certificates.pem contiene la seguente asserzione di identità SPIFFE in testo normale:
spiffe://WORKLOAD_POOL/ns/NAMESPACE/sa/KUBERNETES_SERVICE_ACCOUNT
In questa asserzione:
- WORKLOAD_POOL è il nome del pool di workload del cluster.
- NAMESPACE è il nome del tuo account di servizio Kubernetes.
- KUBERNETES_SERVICE_ACCOUNT è lo spazio dei nomi del tuo account di servizio Kubernetes.
Le seguenti istruzioni per il tuo linguaggio creano la specifica da utilizzare in questo esempio.
Java
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la seguente specifica:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: openjdk:8-jdk imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 800m memory: 512Mi requests: cpu: 100m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - --config-mesh-experimental - "grpc-mesh" - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
C++
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la seguente specifica:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Python
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la seguente specifica:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: phusion/baseimage:18.04-1.0.0 imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Vai
Esegui questo comando per assicurarti che il numero di progetto sia impostato correttamente:
if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM
Crea la seguente specifica:
cat << EOF > example-grpc-client.yaml apiVersion: v1 kind: ServiceAccount metadata: name: example-grpc-client namespace: default annotations: iam.gke.io/gcp-service-account: ${PROJNUM}-compute@ --- apiVersion: apps/v1 kind: Deployment metadata: name: example-grpc-client namespace: default labels: k8s-app: example-grpc-client spec: replicas: 1 selector: matchLabels: k8s-app: example-grpc-client strategy: {} template: metadata: annotations: security.cloud.google.com/use-workload-certificates: "" labels: k8s-app: example-grpc-client spec: containers: - image: golang:1.16-alpine imagePullPolicy: IfNotPresent name: example-grpc-client command: - /bin/sleep - inf env: - name: GRPC_XDS_BOOTSTRAP value: "/tmp/grpc-xds/td-grpc-bootstrap.json" resources: limits: cpu: 8 memory: 8Gi requests: cpu: 300m memory: 512Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/grpc-xds/ initContainers: - name: grpc-td-init image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0 imagePullPolicy: Always args: - --config-mesh-experimental - "grpc-mesh" - --output - "/tmp/bootstrap/td-grpc-bootstrap.json" resources: limits: cpu: 100m memory: 100Mi requests: cpu: 10m memory: 100Mi volumeMounts: - name: grpc-td-conf mountPath: /tmp/bootstrap/ serviceAccountName: example-grpc-client volumes: - name: grpc-td-conf emptyDir: medium: Memory EOF
Completa la procedura come segue.
Applica la specifica:
kubectl apply -f example-grpc-client.yaml
Concedi i ruoli richiesti al account di servizio:
gcloud iam service-accounts add-iam-policy-binding \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:${PROJECT_ID}.[default/example-grpc-client]" \ ${PROJNUM}-compute@ gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member "serviceAccount:${PROJECT_ID}.[default/example-grpc-client]" \ --role roles/trafficdirector.clientVerifica che il pod client sia in esecuzione:
kubectl get pods
Il comando restituisce un testo simile al seguente:
NAMESPACE NAME READY STATUS RESTARTS AGE default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 104s [..skip..]
Esegui il server
Crea ed esegui il server helloworld abilitato per xDS nel pod del server che hai creato in precedenza.
Java
Recupera il nome del pod creato per il servizio
example-grpc-server:kubectl get pods | grep example-grpc-server
Viene visualizzato un feedback simile al seguente:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
Apri una shell nel pod del server:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
Nella shell, verifica che il file di bootstrap in
/tmp/grpc-xds/td-grpc-bootstrap.jsoncorrisponda allo schema descritto nella sezione File di bootstrap.Scarica gRPC Java versione 1.42.1 e crea l'applicazione server
xds-hello-world.curl -L https://github.com/grpc/grpc-java/archive/v1.42.1.tar.gz | tar -xz cd grpc-java-1.42.1/examples/example-xds ../gradlew --no-daemon installDist
Esegui il server con il flag
--xds-credsper indicare la sicurezza abilitata per xDS, utilizzando50051come porta di ascolto exds-servercome nome di identificazione del server:./build/install/example-xds/bin/xds-hello-world-server --xds-creds 50051 xds-server
Dopo che il server ha ottenuto la configurazione necessaria da Cloud Service Mesh, viene visualizzato il seguente output:
Listening on port 50051 plain text health service listening on port 50052
C++
Recupera il nome del pod creato per il servizio
example-grpc-server:kubectl get pods | grep example-grpc-server
Viene visualizzato un feedback simile al seguente:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
Apri una shell nel pod del server:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
Nella shell, verifica che il file di bootstrap in
/tmp/grpc-xds/td-grpc-bootstrap.jsoncorrisponda allo schema descritto nella sezione File di bootstrap.Scarica gRPC C++ e crea l'applicazione server
xds-hello-world.apt-get update -y && \ apt-get install -y \ build-essential \ clang \ python3 \ python3-dev curl -L https://github.com/grpc/grpc/archive/master.tar.gz | tar -xz cd grpc-master tools/bazel build examples/cpp/helloworld:xds_greeter_serverEsegui il server utilizzando
50051come porta di ascolto exds_greeter_servercome nome di identificazione del server:bazel-bin/examples/cpp/helloworld/xds_greeter_server --port=50051 --maintenance_port=50052 --secure
Per eseguire il server senza credenziali, puoi specificare quanto segue:
bazel-bin/examples/cpp/helloworld/xds_greeter_server --nosecure
Dopo che il server ha ottenuto la configurazione necessaria da Cloud Service Mesh, viene visualizzato il seguente output:
Listening on port 50051 plain text health service listening on port 50052
Python
Recupera il nome del pod creato per il servizio
example-grpc-server:kubectl get pods | grep example-grpc-server
Viene visualizzato un feedback simile al seguente:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
Apri una shell nel pod del server:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash
Nella shell, verifica che il file di bootstrap in
/tmp/grpc-xds/td-grpc-bootstrap.jsoncorrisponda allo schema descritto nella sezione File di bootstrap.Scarica gRPC Python versione 1.41.0 e crea l'applicazione di esempio.
apt-get update -y
apt-get install -y python3 python3-pip
curl -L https://github.com/grpc/grpc/archive/v1.41.x.tar.gz | tar -xz
cd grpc-1.41.x/examples/python/xds/
python3 -m virtualenv venv
source venv/bin/activate
python3 -m pip install -r requirements.txt
Esegui il server con il flag
--xds-credsper indicare la sicurezza abilitata per xDS, utilizzando50051come porta di ascolto.python3 server.py 50051 --xds-creds
Dopo che il server ha ottenuto la configurazione necessaria da Cloud Service Mesh, viene visualizzato il seguente output:
2021-05-06 16:10:34,042: INFO Running with xDS Server credentials 2021-05-06 16:10:34,043: INFO Greeter server listening on port 50051 2021-05-06 16:10:34,046: INFO Maintenance server listening on port 50052
Vai
Recupera il nome del pod creato per il servizio
example-grpc-server:kubectl get pods | grep example-grpc-server
Viene visualizzato un feedback simile al seguente:
default example-grpc-server-77548868d-l9hmf 1/1 Running 0 105s
Apri una shell nel pod del server:
kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/sh
Nella shell, verifica che il file di bootstrap in
/tmp/grpc-xds/td-grpc-bootstrap.jsoncorrisponda allo schema descritto nella sezione File di bootstrap.Scarica gRPC Go versione 1.41.0 e vai alla directory contenente l'applicazione server
xds-hello-world.apk add curl curl -L https://github.com/grpc/grpc-go/archive/v1.42.0.tar.gz | tar -xz cd grpc-go-1.42.0/examples/features/xds/server
Crea ed esegui il server con il flag
--xds_credsper indicare la sicurezza abilitata per xDS, utilizzando50051come porta di ascolto:GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \ go run main.go \ -xds_creds \ -port 50051
Dopo che il server ha ottenuto la configurazione necessaria da Cloud Service Mesh, viene visualizzato il seguente output:
Using xDS credentials... Serving GreeterService on 0.0.0.0:50051 and HealthService on 0.0.0.0:50052
Il processo di controllo di integrità richiede da 3 a 5 minuti per mostrare che il servizio è integro dopo l'avvio del server.
Esegui il client e verifica la configurazione
Crea ed esegui il client helloworld abilitato per xDS nel pod client che hai creato in precedenza.
Java
Recupera il nome del pod client:
kubectl get pods | grep example-grpc-client
Viene visualizzato un feedback simile al seguente:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
Apri una shell nel pod client:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
Nella shell dei comandi, scarica gRPC Java versione 1.42.1 e crea l'applicazione client
xds-hello-world.curl -L https://github.com/grpc/grpc-java/archive/v1.42.1.tar.gz | tar -xz cd grpc-java-1.42.1/examples/example-xds ../gradlew --no-daemon installDist
Esegui il client con il flag
--xds-credsper indicare la sicurezza abilitata per xDS, il nome del client e la stringa di connessione di destinazione:./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \ xds:///helloworld-gke:8000Dovresti visualizzare un output simile al seguente:
Greeting: Hello xds-client, from xds-server
C++
Recupera il nome del pod client:
kubectl get pods | grep example-grpc-client
Viene visualizzato un feedback simile al seguente:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
Apri una shell nel pod client:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
Una volta all'interno della shell, scarica gRPC C++ e crea l'applicazione client
xds-hello-world.apt-get update -y && \ apt-get install -y \ build-essential \ clang \ python3 \ python3-devcurl -L https://github.com/grpc/grpc/archive/master.tar.gz | tar -xz
cd grpc-master
tools/bazel build examples/cpp/helloworld:xds_greeter_client
Esegui il client con il flag
--xds-credsper indicare la sicurezza abilitata per xDS, il nome del client e la stringa di connessione di destinazione:bazel-bin/examples/cpp/helloworld/xds_greeter_client --target=xds:///helloworld-gke:8000
Per eseguire il client senza credenziali, utilizza quanto segue:
bazel-bin/examples/cpp/helloworld/xds_greeter_client --target=xds:///helloworld-gke:8000 --nosecure
Dovresti visualizzare un output simile al seguente:
Greeter received: Hello world
Python
Recupera il nome del pod client:
kubectl get pods | grep example-grpc-client
Viene visualizzato un feedback simile al seguente:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
Apri una shell nel pod client:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
Una volta all'interno della shell, scarica gRPC Python versione 1.41.0 e crea l'applicazione client di esempio.
apt-get update -y apt-get install -y python3 python3-pip python3 -m pip install virtualenv curl -L https://github.com/grpc/grpc/archive/v1.41.x.tar.gz | tar -xz cd grpc-1.41.x/examples/python/xds/ python3 -m virtualenv venv source venv/bin/activate python3 -m pip install -r requirements.txt
Esegui il client con il flag
--xds-credsper indicare la sicurezza abilitata per xDS, il nome del client e la stringa di connessione di destinazione:python3 client.py xds:///helloworld-gke:8000 --xds-creds
Dovresti visualizzare un output simile al seguente:
Greeter client received: Hello you from example-host!
Vai
Recupera il nome del pod client:
kubectl get pods | grep example-grpc-client
Viene visualizzato un feedback simile al seguente:
default example-grpc-client-7c969bb997-9fzjv 1/1 Running 0 105s
Apri una shell nel pod client:
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/sh
Una volta all'interno della shell, scarica gRPC Go versione 1.42.0 e vai alla directory contenente l'applicazione client
xds-hello-world.apk add curl curl -L https://github.com/grpc/grpc-go/archive/v1.42.0.tar.gz | tar -xz cd grpc-go-1.42.0/examples/features/xds/client
Crea ed esegui il client con il flag
--xds_credsper indicare la sicurezza abilitata per xDS, il nome del client e la stringa di connessione di destinazione:GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \ go run main.go \ -xds_creds \ -name xds-client \ -target xds:///helloworld-gke:8000
Dovresti visualizzare un output simile al seguente:
Greeting: Hello xds-client, from example-grpc-server-77548868d-l9hmf
Configura l'accesso a livello di servizio con una policy di autorizzazione
Il supporto di gRFC A41 è necessario per il supporto delle policy di autorizzazione. Puoi trovare le versioni dei linguaggi richieste su GitHub.
Segui queste istruzioni per configurare l'accesso a livello di servizio con le policy di autorizzazione. Prima di creare policy di autorizzazione, leggi l'avviso in Limita l'accesso utilizzando l'autorizzazione.
Per semplificare la verifica della configurazione, crea un nome host aggiuntivo che il client può utilizzare per fare riferimento al servizio helloworld-gke.
Aggiorna la specifica
GRPCRoutearchiviata in precedenza ingrpc_route.yamlname: helloworld-grpc-route hostnames: - helloworld-gke:8000 - helloworld-gke-noaccess:8000 meshes: - projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh rules: - action: destinations: - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-gke-helloworld-serviceImporta di nuovo la risorsa
GRPCRoutedalla specificagrpc_route.yaml.gcloud network-services grpc-routes import helloworld-grpc-route \ --source=grpc_route.yaml \ --location=global
Le seguenti istruzioni creano una policy di autorizzazione che consente le richieste inviate dall'account example-grpc-client in cui il nome host è helloworld-gke:8000 e la porta è 50051.
gcloud
Crea una policy di autorizzazione creando un file denominato
helloworld-gke-authz-policy.yaml.action: ALLOW name: helloworld-gke-authz-policy rules: - sources: - principals: - spiffe://PROJECT_ID./ns/default/sa/example-grpc-client destinations: - hosts: - helloworld-gke:8000 ports: - 50051Importa la policy.
gcloud network-security authorization-policies import \ helloworld-gke-authz-policy \ --source=helloworld-gke-authz-policy.yaml \ --location=global
Aggiorna la policy degli endpoint in modo che faccia riferimento alla nuova policy di autorizzazione aggiungendo quanto segue al file
ep-mtls-psms.yaml.authorizationPolicy: projects/${PROJECT_ID}/locations/global/authorizationPolicies/helloworld-gke-authz-policyLa policy endpoint ora specifica che sia mTLS sia la policy di autorizzazione devono essere applicate alle richieste in entrata ai pod i cui file di bootstrap gRPC contengono l'etichetta
app:helloworld.Importa la policy:
gcloud network-services endpoint-policies import ep-mtls-psms \ --source=ep-mtls-psms.yaml --location=global
Convalida la policy di autorizzazione
Utilizza queste istruzioni per verificare che la policy di autorizzazione funzioni correttamente.
Java
Apri una shell nel pod client che hai utilizzato in precedenza.
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
Nella shell dei comandi, esegui i seguenti comandi per convalidare la configurazione.
cd grpc-java-1.42.1/examples/example-xds ./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \ xds:///helloworld-gke:8000Dovresti visualizzare un output simile al seguente:
Greeting: Hello xds-client, from xds-server
Esegui di nuovo il client con il nome del server alternativo. Tieni presente che questo è un caso di errore. La richiesta non è valida perché la policy di autorizzazione consente l'accesso solo al nome host
helloworld-gke:8000../build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \ xds:///helloworld-gke-noaccess:8000Dovresti visualizzare un output simile al seguente:
WARNING: RPC failed: Status{code=PERMISSION_DENIED}Se non vedi questo output, è possibile che la policy di autorizzazione non sia ancora in uso. Attendi qualche minuto e riprova l'intera procedura di verifica.
Vai
Apri una shell nel pod client che hai utilizzato in precedenza.
kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash
Nella shell dei comandi, esegui i seguenti comandi per convalidare la configurazione.
cd grpc-go-1.42.0/examples/features/xds/client GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \ go run main.go \ -xds_creds \ -name xds-client \ -target xds:///helloworld-gke:8000
Dovresti visualizzare un output simile al seguente:
Greeting: Hello xds-client, from example-grpc-server-77548868d-l9hmf
Esegui di nuovo il client con il nome del server alternativo. Tieni presente che questo è un caso di errore. La richiesta non è valida perché la policy di autorizzazione consente l'accesso solo al nome host
helloworld-gke:8000.GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \ go run main.go \ -xds_creds \ -name xds-client \ -target xds:///helloworld-gke-noaccess:8000
Dovresti visualizzare un output simile al seguente:
could not greet: rpc error: code = PermissionDenied desc = Incoming RPC is not allowed: rpc error: code = PermissionDenied desc = incoming RPC did not match an allow policy exit status 1
Se non vedi questo output, è possibile che la policy di autorizzazione non sia ancora in uso. Attendi qualche minuto e riprova l'intera procedura di verifica.
Utilizza TLS anziché mTLS
L'utilizzo di TLS in questo esempio richiede solo una piccola modifica.
Nella
ServerTlsPolicy, eliminamtlsPolicy:cat << EOF > server-tls-policy.yaml name: "server-tls-policy" serverCertificate: certificateProviderInstance: pluginInstance: google_cloud_private_spiffe EOFUtilizza invece questa policy in
EndpointPolicy:cat << EOF > ep-tls-psms.yaml name: "ep-mtls-psms" type: "GRPC_SERVER" serverTlsPolicy: "projects/${PROJECT_ID}/locations/global/serverTlsPolicies/server-tls-policy" trafficPortSelector: ports: - "50051" endpointMatcher: metadataLabelMatcher: metadataLabelMatchCriteria: "MATCH_ALL" metadataLabels: [] EOFLa
ClientTlsPolicyper mTLS funziona anche nel caso di TLS, ma la sezioneclientCertificatedella policy può essere eliminata perché non è richiesta per TLS:cat << EOF > client-tls-policy.yaml name: "client-tls-policy" serverValidationCa: - certificateProviderInstance: pluginInstance: google_cloud_private_spiffe EOF
Utilizza la sicurezza dei servizi con l'esempio di Wallet
Questa sezione fornisce una panoramica di alto livello su come abilitare l'esempio Wallet con la sicurezza dei servizi per Java, C++ e Go.
Java
Puoi trovare il codice sorgente di esempio per Java su GitHub.
Il codice utilizza già le credenziali XdsChannel e XdsServer quando configuri la sicurezza senza proxy.
Queste istruzioni descrivono la configurazione dell'esempio di Wallet con Go. La procedura è simile per Java. Le istruzioni utilizzano un'immagine Docker preesistente che ottieni dal repository di containerGoogle Cloud .
Per creare l'esempio, segui queste istruzioni:
- Clona il repository e recupera i file nella directory Esempi gRPC.
- Modifica il file
00-common-env.sh. Commenta la riga esistente che imposta il valore diWALLET_DOCKER_IMAGEsull'immagine Docker Go e rimuovi il commento dalla riga che imposta il valore diWALLET_DOCKER_IMAGEsull'immagine Docker Java. - Crea e configura le istanze del router Cloud seguendo le istruzioni riportate in Crea e configura le istanze del router Cloud o utilizzando la funzione
create_cloud_router_instancesnello script10.apis.sh. - Crea un cluster seguendo le istruzioni per l'esempio
hello worldo la funzionecreate_clusternello script20-cluster.sh. - Crea autorità di certificazione private seguendo le istruzioni per CA Service o utilizzando lo script
30-private-ca-setup.sh. - Crea risorse Kubernetes, tra cui service account, spazi dei nomi, servizi Kubernetes, NEG e deployment lato server per tutti i servizi:
account,stats,stats_premium,wallet_v1,wallet_v2, utilizzando lo script40-k8s-resources.sh. - Per ciascuno dei servizi che hai creato, crea un controllo di integrità e un servizio di backend utilizzando
create_health_checkecreate_backend_servicenello script50-td-components.sh. - Crea i componenti di routing di Cloud Service Mesh utilizzando
create_routing_componentsnello script60-routing-components.sh. - Crea i componenti di sicurezza di Cloud Service Mesh per ogni servizio di backend utilizzando
create_security_componentsnello script70-security-components.sh. - Crea il deployment del client Wallet utilizzando
create_client_deploymentnello script75-client-deployment.sh. - Verifica la configurazione avviando il client come descritto in Verifica con i client grpc-wallet.
C++
Puoi trovare il codice sorgente di esempio per C++ su GitHub. Il codice utilizza già le credenziali XdsChannel e XdsServer quando configuri la sicurezza senza proxy.
Queste istruzioni descrivono la configurazione dell'esempio di Wallet con Go. Il processo è simile per C++. Le istruzioni utilizzano un'immagine Docker preesistente che ottieni dal repository di containerGoogle Cloud .
Per creare l'esempio, segui queste istruzioni:
- Clona il repository e recupera i file nella directory Esempi gRPC.
- Modifica il file
00-common-env.sh. Commenta la riga esistente che imposta il valore diWALLET_DOCKER_IMAGEsull'immagine Docker Go e rimuovi il commento dalla riga che imposta il valore diWALLET_DOCKER_IMAGEsull'immagine Docker C++. - Crea e configura le istanze del router Cloud seguendo le istruzioni riportate in Crea e configura le istanze del router Cloud o utilizzando la funzione
create_cloud_router_instancesnello script10.apis.sh. - Crea un cluster seguendo le istruzioni per l'esempio
hello worldo la funzionecreate_clusternello script20-cluster.sh. - Crea autorità di certificazione private seguendo le istruzioni per Certificate Authority Service o utilizzando lo script
30-private-ca-setup.sh. - Crea risorse Kubernetes, tra cui service account, spazi dei nomi, servizi Kubernetes, NEG e deployment lato server per tutti i servizi:
account,stats,stats_premium,wallet_v1,wallet_v2, utilizzando lo script40-k8s-resources.sh. - Per ciascuno dei servizi che hai creato, crea un controllo di integrità e un servizio di backend utilizzando
create_health_checkecreate_backend_servicenello script50-td-components.sh. - Crea i componenti di routing di Cloud Service Mesh utilizzando
create_routing_componentsnello script60-routing-components.sh. - Crea i componenti di sicurezza di Cloud Service Mesh per ogni servizio di backend utilizzando
create_security_componentsnello script70-security-components.sh. - Crea il deployment del client Wallet utilizzando
create_client_deploymentnello script75-client-deployment.sh. - Verifica la configurazione avviando il client come descritto in Verifica con i client grpc-wallet.
Vai
Puoi trovare il codice sorgente di esempio per Go su GitHub. Il codice utilizza già le credenziali XdsChannel e XdsServer quando configuri la sicurezza senza proxy.
Le istruzioni utilizzano un'immagine Docker preesistente che ottieni dal repository di containerGoogle Cloud .
Per creare l'esempio, segui queste istruzioni:
- Clona il repository e recupera i file nella directory Esempi gRPC.
- Modifica il file
00-common-env.shper impostare i valori corretti per le variabili di ambiente. - Crea e configura le istanze del router Cloud seguendo le istruzioni riportate in Crea e configura le istanze del router Cloud o utilizzando la funzione
create_cloud_router_instancesnello script10.apis.sh. - Crea un cluster seguendo le istruzioni per l'esempio
hello worldo la funzionecreate_clusternello script20-cluster.sh. - Crea autorità di certificazione private seguendo le istruzioni per CA Service o utilizzando lo script
30-private-ca-setup.sh. - Crea risorse Kubernetes, tra cui service account, spazi dei nomi, servizi Kubernetes, NEG e deployment lato server per tutti i servizi:
account,stats,stats_premium,wallet_v1,wallet_v2, utilizzando lo script40-k8s-resources.sh. - Per ciascuno dei servizi che hai creato, crea un controllo di integrità e un servizio di backend utilizzando
create_health_checkecreate_backend_servicenello script50-td-components.sh. - Crea i componenti di routing di Cloud Service Mesh utilizzando
create_routing_componentsnello script60-routing-components.sh. - Crea i componenti di sicurezza di Cloud Service Mesh per ogni servizio di backend utilizzando
create_security_componentsnello script70-security-components.sh. - Crea il deployment del client Wallet utilizzando
create_client_deploymentnello script75-client-deployment.sh. - Verifica la configurazione avviando il client come descritto in Verifica con i client grpc-wallet.
File di bootstrap
La procedura di configurazione descritta in questa guida utilizza un generatore di bootstrap per creare il file di bootstrap richiesto. Questa sezione fornisce informazioni di riferimento sul file di bootstrap stesso.
Il file di bootstrap contiene le informazioni di configurazione richieste dal codice gRPC senza proxy, incluse le informazioni di connessione per il server xDS. Il file di bootstrap contiene la configurazione di sicurezza richiesta dalla funzionalità di sicurezza gRPC senza proxy. Il server gRPC richiede un campo aggiuntivo. Un file di bootstrap di esempio ha il seguente aspetto:
{
"xds_servers": [
{
"server_uri": "trafficdirector.googleapis.com:443",
"channel_creds": [
{
"type": "google_default"
}
],
"server_features": [
"xds_v3"
]
}
],
"authorities": {
"traffic-director-c2p.xds.googleapis.com": {
"xds_servers": [
{
"server_uri": "dns:///directpath-pa.googleapis.com",
"channel_creds": [
{
"type": "google_default"
}
],
"server_features": [
"xds_v3",
"ignore_resource_deletion"
]
}
],
"client_listener_resource_name_template": "xdstp://traffic-director-c2p.xds.googleapis.com/envoy.config.listener.v3.Listener/%s"
}
},
"node": {
"id": "projects/9876012345/networks/mesh:grpc-mesh/nodes/b59f49cc-d95a-4462-9126-112f794d5dd3",
"cluster": "cluster",
"metadata": {
"INSTANCE_IP": "10.28.2.8",
"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE": true,
"TRAFFICDIRECTOR_GCP_PROJECT_NUMBER": "223606568246",
"TRAFFICDIRECTOR_NETWORK_NAME": "default",
"app": "helloworld"
},
"locality": {
"zone": "us-central1-c"
}
},
"certificate_providers": {
"google_cloud_private_spiffe": {
"plugin_name": "file_watcher",
"config": {
"certificate_file": "/var/run/secrets/workload-spiffe-credentials/certificates.pem",
"private_key_file": "/var/run/secrets/workload-spiffe-credentials/private_key.pem",
"ca_certificate_file": "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem",
"refresh_interval": "600s"
}
}
},
"server_listener_resource_name_template": "grpc/server?xds.resource.listening_address=%s"
}
Aggiornamenti al file di bootstrap per il servizio di sicurezza
I seguenti campi riflettono le modifiche relative alla sicurezza e all'utilizzo di xDS v3:
Il campo id all'interno di node fornisce un'identità univoca per il client gRPC per Cloud Service Mesh. Devi fornire il numero di progetto e il nome della rete Google Cloud utilizzando l'ID nodo nel seguente formato:
projects/{project number}/networks/{network name}/nodes/[UNIQUE_ID]
Un esempio per il progetto numero 1234 e la rete predefinita è:
projects/1234/networks/default/nodes/client1
Il campo INSTANCE_IP è l'indirizzo IP del pod o 0.0.0.0 per indicare INADDR_ANY. Questo campo viene utilizzato dal server gRPC per recuperare la risorsa Listener da Cloud Service Mesh per la sicurezza lato server.
Campi di configurazione della sicurezza nel file di bootstrap
| Chiave JSON | Tipo | Valore | Note |
|---|---|---|---|
server_listener_resource_name_template |
Stringa | grpc/server?xds.resource.listening_address=%s |
Obbligatorio per i server gRPC. gRPC utilizza questo valore per comporre il nome della risorsa per recuperare la risorsa "Listener" da Cloud Service Mesh per la sicurezza lato server e altre configurazioni. gRPC lo utilizza per formare la stringa del nome della risorsa |
certificate_providers |
Struct JSON | google_cloud_private_spiffe |
Obbligatorio. Il valore è una struttura JSON che rappresenta una mappa di nomi per le istanze del fornitore di certificati. Un'istanza del provider di certificati viene utilizzata per recuperare i certificati radice e di identità. Il file di bootstrap di esempio contiene un nome: google_cloud_private_spiffe con la struttura JSON dell'istanza del provider di certificati come valore. Ogni struttura JSON dell'istanza del provider di certificati ha due campi:
|
I contenuti della struttura JSON config per il plug-in file_watcher sono:
certificate_file: stringa obbligatoria. Questo valore è la posizione del certificato di identità.private_key_file: stringa obbligatoria. Il valore è la posizione del file della chiave privata, che deve corrispondere al certificato di identità.ca_certificate_file: stringa obbligatoria. Il valore è la posizione del certificato radice, noto anche come bundle di attendibilità.refresh_interval: stringa facoltativa. Il valore indica l'intervallo di aggiornamento, specificato utilizzando la rappresentazione di stringa della mappatura JSON di una durata. Il valore predefinito è "600s", ovvero una durata di 10 minuti.
Generatore di bootstrap
L'immagine container del generatore di bootstrap è disponibile all'indirizzo gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.19.0. Il suo codice sorgente è disponibile all'indirizzo https://github.com/GoogleCloudPlatform/traffic-director-grpc-bootstrap.
Le opzioni della riga di comando di uso comune sono le seguenti:
--output: utilizza questa opzione per specificare dove viene scritto il file di bootstrap di output, ad esempio il comando--output /tmp/bootstrap/td-grpc-bootstrap.jsongenera il file di bootstrap in/tmp/bootstrap/td-grpc-bootstrap.jsonnel file system del pod.--config-mesh-experimental: utilizza questa opzione per specificare il nome della mesh, che corrisponde alla risorsaMesh.--node-metadata: utilizza questo flag per compilare i metadati del nodo nel file di bootstrap. Questo è obbligatorio quando utilizzi i matcher delle etichette dei metadati inEndpointPolicy, dove Cloud Service Mesh utilizza i dati delle etichette forniti nella sezione dei metadati del nodo del file di bootstrap. L'argomento viene fornito nel formato chiave=valore, ad esempio:--node-metadata version=prod --node-metadata type=grpc
Le informazioni precedenti aggiungono quanto segue nella sezione dei metadati del nodo del file di bootstrap:
{
"node": {
...
"metadata": {
"version": "prod",
"type": "grpc",
...
},
...
},
...
}
Elimina il deployment
Se vuoi, puoi eseguire questi comandi per eliminare il deployment che hai creato utilizzando questa guida.
Per eliminare il cluster, esegui questo comando:
gcloud container clusters delete CLUSTER_NAME --zone ZONE --quiet
Per eliminare le risorse che hai creato, esegui questi comandi:
gcloud compute backend-services delete grpc-gke-helloworld-service --global --quiet
gcloud compute network-endpoint-groups delete example-grpc-server --zone ZONE --quiet
gcloud compute firewall-rules delete grpc-gke-allow-health-checks --quiet
gcloud compute health-checks delete grpc-gke-helloworld-hc --quiet
gcloud network-services endpoint-policies delete ep-mtls-psms \
--location=global --quiet
gcloud network-security authorization-policies delete helloworld-gke-authz-policy \
--location=global --quiet
gcloud network-security client-tls-policies delete client-mtls-policy \
--location=global --quiet
gcloud network-security server-tls-policies delete server-tls-policy \
--location=global --quiet
gcloud network-security server-tls-policies delete server-mtls-policy \
--location=global --quiet
Risoluzione dei problemi
Segui queste istruzioni per risolvere i problemi relativi al deployment della sicurezza.
I workload non riescono a recuperare la configurazione da Cloud Service Mesh
Se visualizzi un errore simile al seguente:
PERMISSION_DENIED: Request had insufficient authentication scopes.
Verifica quanto segue:
- Hai creato il cluster GKE con l'argomento
--scopes=cloud-platform. - Hai assegnato il
roles/trafficdirector.clientai tuoi service account Kubernetes. - Hai assegnato
roles/trafficdirector.cliental tuo service account Google Cloud predefinito (${GSA_EMAIL} sopra). - Hai abilitato il servizio (API)
trafficdirector.googleapis.com.
Il server gRPC non utilizza TLS/mTLS anche con la configurazione corretta di Cloud Service Mesh
Assicurati di specificare GRPC_SERVER nella configurazione delle policy degli endpoint. Se hai specificato SIDECAR_PROXY, gRPC ignora la configurazione.
Non puoi creare il cluster GKE con la versione del cluster richiesta
Il comando di creazione del cluster GKE potrebbe non riuscire con un errore simile al seguente:
Node version "1.20.5-gke.2000" is unsupported.
Assicurati di utilizzare l'argomento --release-channel rapid nel comando di creazione del cluster. Per ottenere la versione corretta per questa release, devi utilizzare il canale di rilascio rapido.
Viene visualizzato un errore No usable endpoint
Se un client non riesce a comunicare con il server a causa di un errore No usable endpoint, il controllo di integrità potrebbe aver contrassegnato i backend del server come non integri.
Per controllare l'integrità dei backend, esegui questo comando gcloud:
gcloud compute backend-services get-health grpc-gke-helloworld-service --global
Se il comando restituisce lo stato non integro del backend, il motivo potrebbe essere uno dei seguenti:
- Il firewall non è stato creato o non contiene l'intervallo IP di origine corretto.
- I tag di destinazione sul firewall non corrispondono ai tag sul cluster che hai creato.
I workload non sono in grado di comunicare nella configurazione di sicurezza
Se i workload non sono in grado di comunicare dopo aver configurato la sicurezza per il mesh di servizi senza proxy, segui queste istruzioni per determinare la causa.
- Disattivare la sicurezza senza proxy ed eliminare i problemi nei casi d'uso del bilanciamento del carico del mesh di servizi senza proxy. Per disattivare la sicurezza nel mesh, esegui una delle seguenti operazioni:
- Utilizza credenziali in testo normale sul lato client e sul lato server OPPURE
- non configurare la sicurezza per il servizio di backend e la policy endpoint nella configurazione di Cloud Service Mesh.
Segui i passaggi descritti in Risoluzione dei problemi relativi ai deployment di Cloud Service Mesh senza proxy, perché nel tuo deployment non è presente alcuna configurazione di sicurezza.
Modifica i workload in modo che utilizzino le credenziali xDS con credenziali in testo normale o non sicure come credenziali di riserva. Mantieni la configurazione di Cloud Service Mesh con la sicurezza disattivata, come descritto in precedenza. In questo caso, sebbene gRPC consenta a Cloud Service Mesh di configurare la sicurezza, Cloud Service Mesh non invia informazioni sulla sicurezza, nel qual caso gRPC dovrebbe tornare alle credenziali in testo normale (o non sicure), che dovrebbero funzionare in modo simile al primo caso precedente. Se questo caso non funziona, procedi nel seguente modo:
- Aumenta il livello di logging sia sul lato client che sul lato server in modo da poter visualizzare i messaggi xDS scambiati tra gRPC e Cloud Service Mesh.
- Assicurati che Cloud Service Mesh non abbia la sicurezza abilitata nelle risposte CDS e LDS inviate ai workload.
- Assicurati che i workload non utilizzino le modalità TLS o mTLS nei loro canali. Se visualizzi messaggi di log relativi ai TLS handshake, controlla il codice sorgente dell'applicazione e assicurati di utilizzare credenziali non sicure o in testo normale come credenziali di riserva. Se il codice sorgente dell'applicazione è corretto, potrebbe trattarsi di un bug nella libreria gRPC
Verifica che l'integrazione di CA Service con GKE funzioni correttamente per il tuo cluster GKE seguendo i passaggi per la risoluzione dei problemi descritti nella guida dell'utente. Assicurati che i certificati e le chiavi forniti da questa funzionalità siano resi disponibili nella directory specificata,
/var/run/secrets/workload-spiffe-credentials/.Attiva TLS (anziché mTLS) nel mesh, come descritto in precedenza, e riavvia i workload client e server.
- Aumenta il livello di logging sia sul lato client che sul lato server per poter visualizzare i messaggi xDS scambiati tra gRPC e Cloud Service Mesh.
- Assicurati che Cloud Service Mesh abbia abilitato la sicurezza nelle risposte CDS e LDS inviate ai workload.
Il client non va a buon fine con un CertificateException e un messaggio Peer certificate SAN check failed
Ciò indica un problema con i valori subjectAltNames nel messaggio SecuritySettings. Tieni presente che questi valori si basano sui servizi Kubernetes che hai creato per il tuo servizio di backend. Per ogni servizio Kubernetes creato, esiste un ID SPIFFE associato, in questo formato:
spiffe://${WORKLOAD_POOL}/ns/${K8S_NAMESPACE}/sa/${SERVICE_ACCOUNT}
Questi valori sono:
WORKLOAD_POOL: il pool di workload per il cluster, ovvero${PROJECT_ID}.K8S_NAMESPACE: lo spazio dei nomi Kubernetes utilizzato nel deployment del servizioSERVICE_ACCOUNT: il account di servizio Kubernetes utilizzato nel deployment del servizio
Per ogni servizio Kubernetes collegato al servizio di backend come gruppo di endpoint di rete, assicurati di aver calcolato correttamente l'ID SPIFFE e di averlo aggiunto al campo subjectAltNames nel messaggio SecuritySettings.
Le applicazioni non possono utilizzare i certificati mTLS con la libreria gRPC
Se le tue applicazioni non riescono a utilizzare i certificati mTLS con la libreria gRPC, segui questi passaggi:
Verifica che la specifica del pod contenga l'annotazione
security.cloud.google.com/use-workload-certificatesdescritta in Creazione di un servizio gRPC senza proxy con NEG.Verifica che i file contenenti la catena di certificati insieme al certificato foglia, alla chiave privata e ai certificati CA attendibili siano accessibili nei seguenti percorsi all'interno del pod:
- Catena di certificati insieme al certificato end-entity: "/var/run/secrets/workload-spiffe-credentials/certificates.pem"
- Chiave privata: "/var/run/secrets/workload-spiffe-credentials/private_key.pem"
- CA Bundle: "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem"
Se i certificati del passaggio precedente non sono disponibili, segui questi passaggi:
gcloud privateca subordinates describe SUBORDINATE_CA_POOL_NAME
--location=LOCATIONVerifica che il control plane di GKE abbia l'associazione del ruolo IAM corretta, che gli concede l'accesso a Certificate Authority Service:
# Get the IAM policy for the CA gcloud privateca roots get-iam-policy ROOT_CA_POOL_NAME # Verify that there is an IAM binding granting access in the following format - members: - serviceAccount:service-projnumber@container-engine-robot. role: roles/privateca.certificateManager # Where projnumber is the project number (e.g. 2915810291) for the GKE cluster.
Verifica che il certificato non sia scaduto. Si tratta della catena di certificati e del certificato foglia all'indirizzo
/var/run/secrets/workload-spiffe-credentials/certificates.pem. Per controllare, esegui questo comando:cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"
Verifica che il tipo di chiave sia supportato dalla tua applicazione eseguendo questo comando:
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3
Verifica che l'applicazione gRPC Java abbia il seguente
keyAlgorithmnel file YAMLWorkloadCertificateConfig:
keyAlgorithm: rsa: modulusSize: 4096Verifica che la CA utilizzi la stessa famiglia di chiavi della chiave del certificato.
Il certificato di un'applicazione viene rifiutato dal client, dal server o dal peer
- Verifica che l'applicazione peer utilizzi lo stesso bundle di attendibilità per verificare il certificato.
- Verifica che il certificato in uso non sia scaduto (catena di certificati insieme al certificato foglia: "/var/run/secrets/workload-spiffe-credentials/certificates.pem").
I pod rimangono in stato In attesa
Se i pod rimangono in stato di attesa durante il processo di configurazione, aumenta le risorse di CPU e memoria per i pod nella specifica di deployment.
Impossibile creare il cluster con il flag --enable-mesh-certificates
Assicurati di utilizzare l'ultima versione di gcloud CLI:
gcloud components update
Tieni presente che il flag --enable-mesh-certificates funziona solo con gcloud beta.
I pod non si avviano
I pod che utilizzano i certificati mesh GKE potrebbero non avviarsi se il provisioning dei certificati non va a buon fine. Ciò può verificarsi in situazioni come le seguenti:
WorkloadCertificateConfigoTrustConfigè configurato in modo errato o mancante.- Le CSR non vengono approvate.
Puoi verificare se il provisioning dei certificati non va a buon fine controllando gli eventi del pod.
Controlla lo stato del pod:
kubectl get pod -n POD_NAMESPACE POD_NAMESostituisci quanto segue:
POD_NAMESPACE: lo spazio dei nomi del pod.POD_NAME: il nome del pod.
Controlla gli eventi recenti per il pod:
kubectl describe pod -n POD_NAMESPACE POD_NAMESe il provisioning dei certificati non va a buon fine, vedrai un evento con
Type=Warning,Reason=FailedMount,From=kubelete un campoMessageche inizia conMountVolume.SetUp failed for volume "gke-workload-certificates". Il campoMessagecontiene informazioni per la risoluzione dei problemi.Events: Type Reason Age From Message ---- ------ ---- ---- ------- Warning FailedMount 13s (x7 over 46s) kubelet MountVolume.SetUp failed for volume "gke-workload-certificates" : rpc error: code = Internal desc = unable to mount volume: store.CreateVolume, err: unable to create volume "csi-4d540ed59ef937fbb41a9bf5380a5a534edb3eedf037fe64be36bab0abf45c9c": caPEM is nil (check active WorkloadCertificateConfig)Consulta i seguenti passaggi per la risoluzione dei problemi se i pod non si avviano a causa di oggetti configurati in modo errato o di CSR rifiutate.
WorkloadCertificateConfig o TrustConfig non è configurato correttamente
Assicurati di aver creato correttamente gli oggetti WorkloadCertificateConfig e TrustConfig. Puoi diagnosticare errori di configurazione su uno di questi
oggetti utilizzando kubectl.
Recupera lo stato attuale.
Per
WorkloadCertificateConfig:kubectl get WorkloadCertificateConfig default -o yamlPer
TrustConfig:kubectl get TrustConfig default -o yamlEsamina l'output dello stato. Un oggetto valido avrà una condizione con
type: Readyestatus: "True".status: conditions: - lastTransitionTime: "2021-03-04T22:24:11Z" message: WorkloadCertificateConfig is ready observedGeneration: 1 reason: ConfigReady status: "True" type: ReadyPer gli oggetti non validi, viene visualizzato
status: "False". I campireasonemessagecontengono ulteriori dettagli per la risoluzione dei problemi.
Le CSR non sono approvate
Se si verifica un problema durante la procedura di approvazione della CSR, puoi controllare i dettagli dell'errore nelle condizioni type: Approved e type: Issued della CSR.
Elenca le CSR pertinenti utilizzando
kubectl:kubectl get csr \ --field-selector='spec.signerName=spiffe.gke.io/spiffe-leaf-signer'Scegli una CSR che sia
Approvede nonIssuedo che non siaApproved.Recupera i dettagli della CSR selezionata utilizzando kubectl:
kubectl get csr CSR_NAME -o yamlSostituisci
CSR_NAMEcon il nome del CSR che hai scelto.
Una CSR valida ha una condizione con type: Approved e status: "True" e un certificato valido nel campo status.certificate:
status:
certificate: <base64-encoded data>
conditions:
- lastTransitionTime: "2021-03-04T21:58:46Z"
lastUpdateTime: "2021-03-04T21:58:46Z"
message: Approved CSR because it is a valid SPIFFE SVID for the correct identity.
reason: AutoApproved
status: "True"
type: Approved
Le informazioni per la risoluzione dei problemi relativi alle CSR non valide vengono visualizzate nei campi message e reason.
I pod non hanno certificati
Recupera la specifica del pod:
kubectl get pod -n POD_NAMESPACE POD_NAME -o yamlSostituisci quanto segue:
POD_NAMESPACE: lo spazio dei nomi del pod.POD_NAME: il nome del pod.
Verifica che la specifica del pod contenga l'annotazione
security.cloud.google.com/use-workload-certificatesdescritta in Configura i pod per ricevere le credenziali mTLS.Verifica che il controller di ammissione dei certificati mesh GKE abbia inserito correttamente un volume del driver CSI di tipo
workloadcertificates.security.cloud.google.comnella specifica del pod:volumes: ... -csi: driver: workloadcertificates.security.cloud.google.com name: gke-workload-certificates ...Verifica la presenza di un montaggio del volume in ciascuno dei container:
containers: - name: ... ... volumeMounts: - mountPath: /var/run/secrets/workload-spiffe-credentials name: gke-workload-certificates readOnly: true ...Verifica che i seguenti bundle di certificati e la chiave privata siano disponibili nelle seguenti posizioni nel pod:
- Bundle della catena di certificati:
/var/run/secrets/workload-spiffe-credentials/certificates.pem - Chiave privata:
/var/run/secrets/workload-spiffe-credentials/private_key.pem - Bundle trust anchor CA:
/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem
- Bundle della catena di certificati:
Se i file non sono disponibili, segui questi passaggi:
Recupera l'istanza di CA Service (anteprima) per il cluster:
kubectl get workloadcertificateconfigs default -o jsonpath '{.spec.certificateAuthorityConfig.certificateAuthorityServiceConfig.endpointURI}'Recupera lo stato dell'istanza di Certificate Authority Service (anteprima):
gcloud privateca ISSUING_CA_TYPE describe ISSUING_CA_NAME \ --location ISSUING_CA_LOCATIONSostituisci quanto segue:
ISSUING_CA_TYPE: il tipo di CA emittente, che deve esseresubordinatesoroots.ISSUING_CA_NAME: il nome della CA emittente.ISSUING_CA_LOCATION: la regione della CA emittente.
Recupera la policy IAM per la CA radice:
gcloud privateca roots get-iam-policy ROOT_CA_NAMESostituisci
ROOT_CA_NAMEcon il nome della CA principale.Nella policy IAM, verifica che l'associazione della policy
privateca.auditoresista:... - members: - serviceAccount:service-PROJECT_NUMBER@container-engine-robot. role: roles/privateca.auditor ...In questo esempio,
PROJECT_NUMBERè il numero di progetto del tuo cluster.Recupera la policy IAM per la CA subordinata:
gcloud privateca subordinates get-iam-policy SUBORDINATE_CA_NAMESostituisci
SUBORDINATE_CA_NAMEcon il nome della CA subordinata.Nella policy IAM, verifica che esista l'associazione della policy
privateca.certificateManager:... - members: - serviceAccount: service-PROJECT_NUMBER@container-engine-robot. role: roles/privateca.certificateManager ...In questo esempio,
PROJECT_NUMBERè il numero di progetto del tuo cluster.
Le applicazioni non possono utilizzare le credenziali mTLS emesse
Verifica che il certificato non sia scaduto:
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"Verifica che il tipo di chiave utilizzato sia supportato dalla tua applicazione.
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3Verifica che la CA emittente utilizzi la stessa famiglia di chiavi della chiave del certificato.
Ottieni lo stato dell'istanza di CA Service (anteprima):
gcloud privateca ISSUING_CA_TYPE describe ISSUING_CA_NAME \ --location ISSUING_CA_LOCATIONSostituisci quanto segue:
ISSUING_CA_TYPE: il tipo di CA emittente, che deve esseresubordinatesoroots.ISSUING_CA_NAME: il nome della CA emittente.ISSUING_CA_LOCATION: la regione della CA emittente.
Verifica che
keySpec.algorithmnell'output sia lo stesso algoritmo della chiave che hai definito nel manifest YAMLWorkloadCertificateConfig. L'output ha il seguente aspetto:config: ... subjectConfig: commonName: td-sub-ca subject: organization: TestOrgLLC subjectAltName: {} createTime: '2021-05-04T05:37:58.329293525Z' issuingOptions: includeCaCertUrl: true keySpec: algorithm: RSA_PKCS1_2048_SHA256 ...
I certificati vengono rifiutati
- Verifica che l'applicazione peer utilizzi lo stesso bundle di attendibilità per verificare il certificato.
Verifica che il certificato non sia scaduto:
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"Verifica che il codice client, se non utilizza l'API Credentials Reloading di gRPC Go, aggiorni periodicamente le credenziali dal file system.
Verifica che i tuoi workload si trovino nello stesso dominio di attendibilità della CA. I certificati mesh GKE supportano la comunicazione tra i workload in un unico dominio di attendibilità.
Limitazioni
La sicurezza dei servizi Cloud Service Mesh è supportata solo con GKE. Non puoi eseguire il deployment della sicurezza dei servizi con Compute Engine.
Cloud Service Mesh non supporta scenari in cui sono presenti due o più risorse di policy endpoint che corrispondono in modo uguale a un endpoint, ad esempio due policy con le stesse etichette e porte o due o più policy con etichette diverse che corrispondono in modo uguale alle etichette di un endpoint. Per saperne di più su come le policy degli endpoint vengono abbinate alle etichette di un endpoint, consulta le API per EndpointPolicy.EndpointMatcher.MetadataLabelMatcher. In questi casi, Cloud Service Mesh non genera la configurazione di sicurezza da nessuna delle policy in conflitto.