Stai visualizzando la documentazione di Service Mesh precedente alla versione 1.20.

Versioni disponibili

Cloud Service Mesh
Archivio 1.22
Archivio 1.21
Archivio 1.20
Archivio 1.19
Archivio 1.18

Questa pagina è stata tradotta dall'API Cloud Translation.

Integrazione di IAP con Cloud Service Mesh

Questa guida descrive come integrare Identity-Aware Proxy (IAP) con Cloud Service Mesh. L'integrazione di IAP con Cloud Service Mesh ti consente di accedere in sicurezza ai servizi in base ai principi BeyondCorp di Google. IAP verifica l'identità dell'utente e il contesto della richiesta per determinare se un utente può essere autorizzato ad accedere a un'applicazione o una risorsa. L'integrazione di IAP con Cloud Service Mesh offre i seguenti vantaggi:

Completa il controllo dell'accesso sensibile al contesto al in esecuzione su Cloud Service Mesh. Puoi impostare criteri di accesso granulari in base agli attributi della richiesta di origine, come l'identità utente, l'indirizzo IP e il tipo di dispositivo. Puoi combinare i criteri di accesso con le limitazioni in base al nome host e al percorso di un URL richiesta.
Attiva il supporto per le attestazioni sensibili al contesto nell'autorizzazione Cloud Service Mesh.
Accesso scalabile, sicuro e ad alta disponibilità alla tua applicazione tramite un bilanciatore del carico Google Cloud. Il bilanciamento del carico ad alte prestazioni offre protezione integrata contro gli attacchi DDoS (distributed denial of service) e il supporto per l'indirizzamento IP anycast globale.

Prerequisiti

Segui i passaggi descritti in Installare gli strumenti dipendenti e convalidare il cluster per:

Inoltre, questa guida presuppone che tu abbia:

Configurazione di un cluster con Anthos Service Mesh

Questa sezione spiega come eseguire la configurazione per l'integrazione di IAP sia per le nuove installazioni di Cloud Service Mesh sia per gli upgrade.

Nuove installazioni

Attiva iap.googleapis.com. Nel comando seguente, sostituisci PROJECT_IDcon il progetto che installerai Cloud Service Mesh in:
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Il cluster che stai aggiornando deve avere l'oggetto --addons=HttpLoadBalancing insieme di opzioni. Il componente aggiuntivo HttpLoadBalancing abilita un carico HTTP (L7) di bilanciamento del carico per il cluster. Esegui il comando seguente per aggiornare il cluster con le opzioni richieste da Cloud Service Mesh. A meno che non abbia impostato una zona o una regione predefinita, devi fornire la regione (--region=REGION) o la zona (--zone=ZONE) nel comando.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Per impostazione predefinita, il file iap-operator.yaml ha la porta 31223 impostata come stato e la porta 31224 impostata come porta HTTP. Se la porta 31223 è già in uso nel cluster, esegui quanto segue per impostare un'altra porta di stato:

Importante: devi utilizzare una versione di kpt precedente alla 1.0.
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort STATUS_PORT
```
Se la porta 31224 è già in uso nel cluster, esegui quanto segue per impostare un'altra porta HTTP:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```
Segui i passaggi descritti in Installare le funzionalità predefinite e la CA Mesh per utilizzare uno script fornito da Google per installare Cloud Service Mesh. Quando esegui il comando includi la seguente opzione:
```
--option iap-operator
```
Ad esempio:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Quando installi Cloud Service Mesh, iap-operator.yaml imposta il campo type del servizio istio-ingressgateway su NodePort, che configura il gateway in modo che apra una porta specifica sul mesh di servizi. In questo modo puoi configurare un bilanciatore del carico che indirizzi il traffico inviato al tuo nome di dominio a questa porta.
Se stai installando Cloud Service Mesh gestito, completa anche i seguenti passaggi:
1. Aggiungi l'etichetta di revisione allo spazio dei nomi istio-system.
2. Scarica Specifiche del servizio Istio Ingress Gateway per IAP e assegnagli il nome iap_operator.yaml.
3. Installa l'ingress come servizio NodePort. Per ulteriori informazioni, vedi Esegui la migrazione da IstioOperator.
```
asmcli experimental mcp-migrate-check -f iap_operator.yaml

istioctl install -f /asm-generated-configs/gateways-istiooperator/"GATEWAY_NAME".yaml
```

Dopo aver installato Cloud Service Mesh, torna a questa guida e continua con il sezione successiva per configurare l'integrazione con IAP.

Upgrade

Questa sezione riguarda i seguenti casi d'uso di upgrade:

Hai già configurato l'integrazione di IAP e stai eseguendo l'upgrade di Cloud Service Mesh. In questo caso, hai già attivato iap.googleapis.com nel tuo progetto e il componente aggiuntivo HttpLoadBalancing nel tuo cluster. Vai al passaggio 3 per scaricare il pacchetto asm e eseguire l'upgrade di Cloud Service Mesh.
Stai eseguendo l'upgrade di Cloud Service Mesh e vuoi configurare l'integrazione con IAP per la prima volta. In questo caso, devi completare tutti i passaggi che seguono, eseguire l'upgrade di Cloud Service Mesh e tornare a questa guida dopo l'upgrade per completare l'integrazione.

Attiva iap.googleapis.com. Nel comando seguente, sostituisci PROJECT_IDcon il progetto che installerai Cloud Service Mesh.
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Il cluster che stai aggiornando deve avere l'oggetto --addons=HttpLoadBalancing insieme di opzioni. Il componente aggiuntivo HttpLoadBalancing abilita un carico HTTP (L7) di bilanciamento del carico per il cluster. Esegui il comando seguente per aggiornare il cluster con le opzioni richieste da Cloud Service Mesh. A meno che tu non abbia devi impostare una zona o una regione predefinite, devi fornire la regione (--region=REGION) o zona (--zone=ZONE) nel comando.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID
  --update-addons=HttpLoadBalancing=ENABLED
```

Se stai aggiornando un bilanciatore del carico HTTP Cloud funzionante esistente, esegui procedi come segue per conservare le porte HTTP e di stato esistenti:

kpt cfg set asm gcloud.container.cluster.ingress.httpPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')

kpt cfg set asm gcloud.container.cluster.ingress.statusPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

Segui i passaggi in Upgrade di Cloud Service Mesh per utilizzare uno script fornito da Google per eseguire l'upgrade di Cloud Service Mesh.

Quando esegui l'upgrade di Cloud Service Mesh, il file iap-operator.yaml imposta il campo type del servizio istio-ingressgateway su NodePort, che configura il gateway in modo da aprire una porta specifica nel mesh di servizi. In questo modo, puoi configurare un bilanciatore del carico che instrada il traffico inviato al tuo nome di dominio a questa porta.

Per impostazione predefinita, il file iap-operator.yaml ha la porta 31223 impostata come stato e la porta 31224 impostata come porta HTTP.

Quando esegui lo script, includi la seguente opzione:
```
--option iap-operator
```
Ad esempio:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Completa l'upgrade attivando l'inserimento automatico del proxy sidecar su per i carichi di lavoro. Per maggiori dettagli, consulta Eseguire il deployment e il ricoinvolgimento dei carichi di lavoro.

Una volta completato l'upgrade, torna a questa guida e vai alla sezione successiva per configurare l'integrazione con l'IAP.

Prenotazione di un indirizzo IP statico e configurazione del DNS

Per integrare Identity-Aware Proxy con Cloud Service Mesh, devi configurare un Bilanciatore del carico HTTP(S) di Google Cloud, che richiede un nome di dominio che punti a un indirizzo IP statico. Puoi riservare un indirizzo IP esterno statico, che assegna l'indirizzo al tuo progetto a tempo indeterminato finché non esplicitamente rilascialo.

Prenota un indirizzo IP esterno statico:

gcloud compute addresses create example-static-ip --global

Ottieni l'indirizzo IP statico:

gcloud compute addresses describe example-static-ip --global

Configura un nome di dominio completo nel tuo registrar dei nomi di dominio. (FQDN) con l'indirizzo IP statico. In genere, aggiungi un record A al tuo Impostazioni DNS. I passaggi di configurazione e la terminologia per aggiungere un A per un nome di dominio completo variano a seconda del registrar dei nomi di dominio.

La propagazione dell'impostazione DNS può richiedere da 24 a 48 ore. Puoi continuare a configurare tutto quanto indicato in questa guida, ma non potrai testare la configurazione finché le impostazioni DNS non saranno propagate.

Deployment di un'applicazione di esempio

Prima di attivare l'IAP, devi avere un'applicazione in esecuzione sul tuo cluster GKE per poter verificare che tutte le richieste abbiano un'identità. Questa guida utilizza l'esempio di Bookinfo per dimostrare come configurare il HTTP(S) e abilitare IAP.

Segui i passaggi per eseguire il deployment di Bookinfo. Fino a quando non esegui il deployment del bilanciatore del carico, l'applicazione Bookinfo non è accessibile dall'esterno del cluster GKE (ad esempio da un browser).

Richieste esterne

Risorsa Gateway di Bookinfo (definita in samples/bookinfo/networking/bookinfo-gateway.yaml) utilizza lo stato preconfigurato istio-ingressgateway Ricorda che quando hai eseguito il deployment di Cloud Service Mesh, hai specificato NodePort per istio-ingressgateway, che apre una porta specifica nel service mesh. Sebbene i nodi del cluster abbiano indirizzi IP esterni, le richieste provenienti dall'esterno del cluster vengono bloccate dalle regole del firewall di Google Cloud. Con IAP, il modo corretto per esporre le applicazioni alla rete internet pubblica è utilizzare un bilanciatore del carico. Non esporre gli indirizzi dei nodi utilizzando firewall, che ignorano IAP.

Per instradare le richieste a Bookinfo, devi configurare un bilanciatore del carico HTTP(S) nel progetto Google Cloud. Poiché il bilanciatore del carico si trova nel tuo progetto, si trova all'interno del firewall e può accedere ai nodi del cluster. Dopo aver configurato il bilanciatore del carico con l'indirizzo IP statico e il nome di dominio, puoi inviare richieste al nome di dominio, che il bilanciatore del carico inoltra ai nodi del cluster.

Attivazione di IAP

I passaggi riportati di seguito descrivono come attivare IAP.

Utilizza l'ID client (CLIENT_ID nel passaggio precedente) e CLIENT_SECRET per attivare Cloud Service Mesh. Crea un secret di Kubernetes con i materiali del tuo client OAuth:
```
kubectl create secret generic -n istio-system my-secret --from-literal=client_id=CLIENT_ID \
--from-literal=client_secret=CLIENT_SECRET
```

Implementazione del bilanciatore del carico

Puoi utilizzare una risorsa Ingress per creare un bilanciatore del carico HTTP(S) con certificati SSL configurati automaticamente. I certificati SSL gestiti vengono eseguiti in provisioning, rinnovati e gestiti per il tuo dominio.

Crea una risorsa ManagedCertificate. Questa risorsa specifica il dominio per il certificato SSL. L'elenco spec.domains deve contenere un solo dominio. I domini con caratteri jolly non sono supportati. Nel seguente codice YAML, DOMAIN_NAME con il nome di dominio che hai configurato per l'indirizzo IP statico esterno.
```
cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - DOMAIN_NAME
EOF
```

Crea una risorsa BackendConfig. Questa risorsa indica a GCLB come eseguire controlli di integrità su Ingress Gateway e come configurare Identity-Aware Proxy. Innanzitutto, raccogli alcuni valori da Ingress Gateway relativi ai controlli di salute:

Porta in entrata per il controllo di integrità: questa è la porta per il controllo di integrità di istio-ingress.

export HC_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

Percorso in entrata del controllo di integrità: si tratta del percorso del controllo di integrità di istio-ingress.

export HC_INGRESS_PATH=$(kubectl get pods -n istio-system -l app=istio-ingressgateway -o jsonpath='{.items[0].spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

cat <<EOF | kubectl apply -n istio-system -f -
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
  name: http-hc-config
spec:
  healthCheck:
    checkIntervalSec: 2
    timeoutSec: 1
    healthyThreshold: 1
    unhealthyThreshold: 10
    port: ${HC_INGRESS_PORT}
    type: HTTP
    requestPath: ${HC_INGRESS_PATH}
  iap:
    enabled: true
    oauthclientCredentials:
      secretName: my-secret
EOF

Annota il servizio in entrata con BackendConfig.

    kubectl annotate -n istio-system service/istio-ingressgateway --overwrite \
      cloud.google.com/backend-config='{"default": "http-hc-config"}' \
      cloud.google.com/neg='{"ingress":false}'

Crea il bilanciatore del carico definendo la risorsa Ingress.
- Imposta l'annotazione networking.gke.io/managed-certificates sul nome del certificato che hai creato nel passaggio precedente, example-certificate.
- Imposta l'annotazione kubernetes.io/ingress.global-static-ip-name sul nome dell'indirizzo IP statico che hai prenotato, example-static-ip.
- Imposta serviceName su istio-ingressgateway, che viene utilizzato nella risorsa Gateway per l'esempio Bookinfo.
```
cat <<EOF | kubectl apply -f -
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  namespace: istio-system
  annotations:
    kubernetes.io/ingress.global-static-ip-name: example-static-ip
    networking.gke.io/managed-certificates: example-certificate
spec:
  defaultBackend:
    service:
      name: istio-ingressgateway
      port:
        number: 80
EOF
```
Nota: possono essere necessari fino a 10-20 minuti prima che il bilanciatore del carico sia operativo.
Nella console Google Cloud, vai a Kubernetes Engine > Servizi & in entrata.

Vai alla sezione Servizi e Pagina Ingress

Dovresti vedere il messaggio "Creazione di un traffico in entrata" nella colonna Stato. Attendi che GKE esegua il provisioning completo di Ingress prima continua. Aggiorna la pagina ogni pochi minuti per ottenere lo stato più aggiornato dell'Ingress. Dopo il provisioning di Ingress, potresti visualizzare lo stato "Ok" o l'errore "Tutti i servizi di backend sono in stato NON VALIDO". Una delle risorse di cui GKE esegue il provisioning è un controllo di stato predefinito. Se viene visualizzato il messaggio di errore, significa che Ingress è stato provisionato e che è stato eseguito il controllo di integrità predefinito. Quando vedi "OK" stato predefinito o l'errore, continua con la sezione successiva per configurare di integrità per il bilanciatore del carico.

Configurare l'elenco di accesso IAP

Aggiungi un utente al criterio di accesso per l'IAP:

gcloud beta iap web add-iam-policy-binding \
    --member=user:EMAIL_ADDRESS \
    --role=roles/iap.httpsResourceAccessor

dove EMAIL_ADDRESS è l'indirizzo email completo dell'utente ad esempio alice@example.com.

Testa il bilanciatore del carico. Accedi con il browser a:
```
http://DOMAIN_NAME/productpage
```
dove DOMAIN_NAME è il nome di dominio che configurato con l'indirizzo IP statico esterno.

Dovresti vedere productpage dell'applicazione Bookinfo. Se aggiorni pagina più volte, dovresti vedere versioni diverse delle recensioni, in stile round robin: stelle rosse, stelle nere, nessuna stella.

Dovresti anche testare l'accesso di https a Bookinfo.

Attivare il supporto di RCToken nel service mesh

Per impostazione predefinita, IAP genera un token web JSON (JWT) che ha come ambito il client OAuth. Per Cloud Service Mesh, puoi configurare IAP per generare una RequestContextToken (RCToken), che è un JWT ma con un pubblico configurabile. RCToken consente di configurare il pubblico del JWT con una stringa arbitraria, che può essere utilizzato nei criteri di Cloud Service Mesh per un'autorizzazione granulare.

Per configurare l'RCToken:

Crea una variabile di ambiente per il segmento di pubblico RCToken. Può essere qualsiasi stringa.
```
export RCTOKEN_AUD="your-rctoken-aud"
```
(Facoltativo) Il passaggio successivo richiede BACKEND_SERVICE_ID. Se hai bisogno di conoscere BACKEND_SERVICE_ID, esegui questo comando:
```
kubectl -n istio-system get Ingress example-ingress -o json | jq \
 '.metadata.annotations."ingress.kubernetes.io/backends"'
```
L'output previsto è simile a "{\"BACKEND_SERVICE_ID\":\"HEALTHY\"}". Ad esempio: "ingress.kubernetes.io/backends": "{\"k8s-be-31224--51f3b55cd1457fb6\":\"HEALTHY\"}". Il valore BACKEND_SERVICE_ID in questo esempio è k8s-be-31224--51f3b55cd1457fb6.

Recupera le impostazioni IAP esistenti.

gcloud iap settings get --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID > iapSettings.json

Aggiorna IapSettings con il segmento di pubblico RCToken.

cat iapSettings.json | jq --arg RCTOKEN_AUD_STR $RCTOKEN_AUD \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> updatedIapSettings.json

gcloud iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID

Abilita l'autenticazione RCToken sul gateway in entrata Istio.

cat <<EOF | kubectl apply -f -
apiVersion: "security.istio.io/v1beta1"
kind: "RequestAuthentication"
metadata:
  name: "ingressgateway-jwt-policy"
  namespace: "istio-system"
spec:
  selector:
    matchLabels:
      app: istio-ingressgateway
  jwtRules:
  - issuer: "https://cloud.google.com/iap"
    jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
    audiences:
    - $RCTOKEN_AUD
    fromHeaders:
    - name: ingress-authorization
      prefix: "Istio "
    outputPayloadToHeader: "verified-jwt"
    forwardOriginalToken: true
EOF

(Facoltativo) Assicurati che le richieste che non dispongono di JWT validi vengano rifiutate:

  cat <<EOF | kubectl apply -f -
  apiVersion: security.istio.io/v1beta1
  kind: AuthorizationPolicy
  metadata:
    name: iap-gateway-require-jwt
    namespace: istio-system
  spec:
    selector:
      matchLabels:
        app: istio-iap-ingressgateway
    action: DENY
    rules:
      - from:
          - source:
              notRequestPrincipals: ["*"]
  EOF

Assicurati che le richieste inviate a productpage di Bookinfo vengano comunque andate a buon fine:
```
http://DOMAIN_NAME/productpage
```

Per testare il criterio:

Crea un oggetto richiesta IapSettings, ma imposta rctokenAud su una stringa diversa:

cat iapSettings.json | jq --arg RCTOKEN_AUD_STR wrong-rctoken-aud \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> wrongIapSettings.json

Chiama l'API IapSettings per impostare il pubblico RCtoken.

gcloud beta iap settings set wrongIapSettings.json --project=PROJECT_ID --resource-type=compute --service=BACKEND_SERVICE

Se invii una richiesta a productpage di Bookinfo, l'operazione dovrebbe non andare a buon fine:
```
http://DOMAIN_NAME/productpage
```

Pulizia

Dopo aver completato questo tutorial, rimuovi le seguenti risorse per evitare che sul tuo account vengano addebitati costi indesiderati:

Elimina il certificato gestito:

kubectl delete managedcertificates example-certificate

Elimina Ingress, che disalloca le risorse di bilanciamento del carico:
```
kubectl -n istio-system delete ingress example-ingress
```
Elimina l'indirizzo IP statico:
```
gcloud compute addresses delete example-static-ip --global
```
In questo caso, assicurati di eliminare l'indirizzo IP dal tuo registrar del dominio.
Elimina il cluster, che elimina le risorse che lo compongono, ad esempio le istanze di calcolo, i dischi e le risorse di rete:
```
gcloud container clusters delete CLUSTER_NAME
```