Anthos Service Mesh 1.6 ha raggiunto la fine del ciclo di vita e non è più supportato. Vedi Upgrade da versioni precedenti.

Visualizza la documentazione più recente o seleziona un'altra versione disponibile:

Versioni disponibili

Integrazione di IAP con Anthos Service Mesh

Questa guida descrive come integrare Identity-Aware Proxy (IAP) con Anthos Service Mesh. L'integrazione di IAP con Anthos Service Mesh ti consente di accedere in modo sicuro ai servizi in base ai principi di 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 risorsa. L'integrazione di IAP con Anthos Service Mesh offre i seguenti vantaggi:

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

Prerequisiti

Questa guida presuppone che:

Configurazione di un cluster con Anthos Service Mesh

L'integrazione di IAP richiede impostazioni specifiche per il tuo progetto, il tuo cluster e i file di configurazione utilizzati durante l'installazione di Anthos Service Mesh.

Nuove installazioni

I passaggi di questa sezione integrano i passaggi descritti nella guida Installazione avanzata su GKE. Questi passaggi utilizzano le variabili di ambiente create nella guida all'installazione.

Durante la configurazione del progetto, abilita iap.googleapis.com oltre alle altre API richieste.
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Quando aggiorna il cluster, abilita il componente aggiuntivo HttpLoadBalancing in aggiunta agli altri aggiornamenti obbligatori del cluster. Il componente aggiuntivo HttpLoadBalancing abilita un controller di bilanciamento del carico HTTP (L7) per il cluster.
```
gcloud container clusters update ${CLUSTER_NAME} \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Se non hai impostato una zona o una regione predefinita, devi fornire la regione (--region=${CLUSTER_LOCATION}) o la zona (--zone=${CLUSTER_LOCATION}) nel comando precedente.
Dopo aver aggiornato il cluster, continua a seguire la guida all'installazione per impostare le credenziali e le autorizzazioni e scaricare il file di installazione. Interrompi al Preparazione dei file di configurazione delle risorse e completa i seguenti passaggi.
1. Creare una nuova directory per i file di configurazione delle risorse del pacchetto Anthos Service Mesh. Ti consigliamo di utilizzare il nome del cluster come nome della directory.
2. Passa alla directory da cui vuoi scaricare il pacchetto Anthos Service Mesh.
3. Scarica il pacchetto asm-iap. Questo pacchetto imposta il campo type sul servizio istio-ingressgateway su NodePort. In questa configurazione, istio-ingressgateway apre una porta specifica nel mesh di servizi. Questo ti consente di configurare un bilanciatore del carico, che instrada il traffico inviato al tuo nome di dominio verso questa porta.
```
kpt pkg get https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm-iap@release-1.6-asm asm
```
4. Imposta l'ID del progetto in cui è stato creato il cluster:
```
kpt cfg set asm gcloud.core.project PROJECT_ID
```
5. Imposta il numero del progetto host del parco risorse:
```
kpt cfg set asm gcloud.project.environProjectNumber ${FLEET_PROJECT_NUMBER}
```
6. Imposta il nome del cluster:
```
kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}
```
7. Imposta la zona o la regione predefinita:
```
kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}
```
8. Imposta il webhook di convalida in modo che utilizzi un'etichetta di revisione:
```
kpt cfg set asm anthos.servicemesh.rev asm-1614-2
```
9. Imposta il profilo di configurazione. Per l'integrazione IAP, imposta il profilo asm-gcp:
```
kpt cfg set asm anthos.servicemesh.profile asm-gcp
```
10. Imposta le porte HTTP e di stato per il bilanciatore del carico. La porta predefinita è 31223, mentre la porta HTTP predefinita è 31224. Se queste porte sono già in uso, impostale:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort STATUS_PORT
```
11. Genera i valori dei setter kpt:
```
kpt cfg list-setters asm
```
  Nell'output del comando, verifica che i valori dei seguenti set di valori siano corretti:
  - anthos.servicemesh.rev
  - gcloud.compute.location
  - gcloud.container.cluster
  - gcloud.container.cluster.ingress.httpPort
  - gcloud.container.cluster.ingress.statusPort
  - gcloud.core.project
  - gcloud.project.environProjectNumber
Continua a seguire la guida all'installazione alla sezione Installazione di Anthos Service Mesh. Dopo aver installato Anthos Service Mesh, torna a questa guida e continua con la sezione successiva per configurare l'integrazione con IAP.

Upgrade

I passaggi di questa sezione integrano i passaggi descritti nella guida Eseguire l'upgrade di Anthos Service Mesh su GKE. Questi passaggi utilizzano le variabili di ambiente create nella guida all'upgrade. Questa sezione riguarda i seguenti casi d'uso di upgrade:

Hai già configurato l'integrazione IAP e stai eseguendo l'upgrade di Anthos Service Mesh. In questo caso, hai già abilitato iap.googleapis.com sul tuo progetto e sul componente aggiuntivo HttpLoadBalancing sul tuo cluster, quindi puoi andare al passaggio 3.
Stai eseguendo l'upgrade di Anthos Service Mesh e vuoi configurare l'integrazione con IAP per la prima volta. In questo caso, devi completare tutti i passaggi seguenti, eseguire l'upgrade di Anthos Service Mesh e tornare a questa guida dopo l'upgrade per completare l'integrazione.

Attiva iap.googleapis.com.

gcloud services enable \
  --project=$PROJECT_ID \
  iap.googleapis.com

Attiva il componente aggiuntivo HttpLoadBalancing. Il componente aggiuntivo HttpLoadBalancing abilita un controller di bilanciamento del carico HTTP (L7) per il cluster.
```
gcloud container clusters update ${CLUSTER_NAME} \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Se non hai impostato una zona o una regione predefinita, devi fornire la regione (--region=${CLUSTER_LOCATION}) o la zona (--zone=${CLUSTER_LOCATION}) nel comando precedente.
Continua a seguire la guida all'upgrade per impostare le credenziali e le autorizzazioni e scaricare il file di installazione. Interrompi al Preparazione dei file di configurazione delle risorse e completa i seguenti passaggi.
1. Creare una nuova directory per i file di configurazione delle risorse del pacchetto Anthos Service Mesh. Ti consigliamo di utilizzare il nome del cluster come nome della directory.
2. Passa alla directory da cui vuoi scaricare il pacchetto Anthos Service Mesh.
3. Scarica il pacchetto asm-iap. Questo pacchetto imposta il campo type sul servizio istio-ingressgateway su NodePort. In questa configurazione, istio-ingressgateway apre una porta specifica nel mesh di servizi. Questo ti consente di configurare un bilanciatore del carico, che instrada il traffico inviato al tuo nome di dominio verso questa porta.
```
kpt pkg get https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm-iap@release-1.6-asm asm
```
4. Imposta l'ID del progetto in cui è stato creato il cluster:
```
kpt cfg set asm gcloud.core.project PROJECT_ID
```
5. Imposta il numero del progetto host del parco risorse:
```
kpt cfg set asm gcloud.project.environProjectNumber ${FLEET_PROJECT_NUMBER}
```
6. Imposta il nome del cluster:
```
kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}
```
7. Imposta la zona o la regione predefinita:
```
kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}
```
8. Imposta il webhook di convalida in modo che utilizzi un'etichetta di revisione:
```
kpt cfg set asm anthos.servicemesh.rev asm-1614-2
```
9. Imposta il profilo di configurazione. Per l'integrazione IAP, imposta il profilo asm-gcp:
```
kpt cfg set asm anthos.servicemesh.profile asm-gcp
```
10. Imposta le porte HTTP e di stato per il bilanciatore del carico. La porta predefinita è 31223, mentre la porta HTTP predefinita è 31224.
  
  Se stai aggiornando un bilanciatore del carico HTTP Cloud esistente, esegui il comando seguente per mantenere 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}')
```
  Se necessario, puoi utilizzare i setter kpt precedenti per impostare altri valori per le porte.
11. Genera i valori dei setter kpt:
```
kpt cfg list-setters asm
```
  Nell'output del comando, verifica che i valori dei seguenti set di valori siano corretti:
  - anthos.servicemesh.rev
  - gcloud.compute.location
  - gcloud.container.cluster
  - gcloud.container.cluster.ingress.httpPort
  - gcloud.container.cluster.ingress.statusPort
  - gcloud.core.project
  - gcloud.project.environProjectNumber
Continua a seguire la guida all'upgrade nella sezione Upgrade di Anthos Service Mesh.

Prenotazione di un indirizzo IP statico e configurazione del DNS

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

Prenota un indirizzo IP esterno statico:

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

Recupera l'indirizzo IP statico:

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

Nel registrar del nome di dominio, configura un nome di dominio completo (FQDN) con l'indirizzo IP statico. In genere, si aggiunge un record A alle impostazioni DNS. I passaggi di configurazione e la terminologia per aggiungere un record A per un nome di dominio completo variano a seconda del registrar del nome di dominio.

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

Deployment di un'applicazione di esempio

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

Segui la procedura per eseguire il deployment di Bookinfo. Fino a quando non esegui il deployment del bilanciatore del carico, l'applicazione Bookinfo non è accessibile al di fuori del tuo cluster GKE (ad esempio da un browser).

Richieste esterne

La risorsa Gateway di Bookinfo (definita in samples/bookinfo/networking/bookinfo-gateway.yaml) utilizza il metodo istio-ingressgateway preconfigurato. Ricorda che quando hai eseguito il deployment di Anthos Service Mesh, hai specificato NodePort per istio-ingressgateway, che apre una porta specifica nel mesh di servizi. Anche se i nodi nel tuo cluster hanno indirizzi IP esterni, le richieste provenienti dall'esterno del cluster sono bloccate dalle regole 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 regole firewall, in modo da ignorare IAP.

Per indirizzare le richieste a Bookinfo, configura 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 nel tuo 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 e il bilanciatore del carico inoltra le richieste ai nodi nel cluster.

Abilitazione di IAP

I seguenti passaggi descrivono come abilitare IAP.

Configurazione della schermata per il consenso

Controlla se hai già un brand utilizzando il comando list. Puoi avere un solo brand per progetto.
```
gcloud iap oauth-brands list
```
Di seguito è riportato un esempio di risposta gcloud, se il brand esiste:
```
name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true
```
Nota: se un brand esiste già per un progetto ed è stato configurato per gli utenti esterni (orgInternalOnly: false), ma vuoi limitarlo agli utenti interni, devi apportare manualmente la modifica dalla schermata di consenso OAuth per creare client OAuth con questa API.
Se non esiste alcun brand, utilizza il comando create:
```
gcloud iap oauth-brands create --application_title=APPLICATION_TITLE --support_email=SUPPORT_EMAIL
```
I campi precedenti sono obbligatori quando chiami questa API:
- supportEmail: l'email dell'assistenza visualizzata nella schermata per il consenso OAuth. Può trattarsi dell'indirizzo di un utente o di un alias di Google Gruppi. Anche se gli account di servizio hanno un indirizzo email, non sono indirizzi email validi e non possono essere utilizzati durante la creazione di un brand. Tuttavia, un account di servizio può essere il proprietario di un gruppo Google. Crea un nuovo gruppo Google o configura un gruppo esistente e imposta l'account di servizio desiderato come proprietario del gruppo.
  
  Nota: l'utente che emette la richiesta deve essere un proprietario dell'indirizzo email di assistenza specificato.
- applicationTitle: il nome dell'applicazione visualizzato nella schermata per il consenso OAuth.
La risposta contiene i seguenti campi:
```
name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true
```

Creazione di un client OAuth IAP

Utilizza il comando Crea per creare un client. Utilizza il brand name del passaggio precedente.

gcloud iap oauth-clients create projects/PROJECT_NUMBER/brands/BRAND-ID --display_name=NAME

La risposta contiene i seguenti campi:

name: projects/[PROJECT_NUMBER]/brands/[BRAND_NAME]/identityAwareProxyClients/[CLIENT_ID]
secret: [CLIENT_SECRET]
displayName: [NAME]

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

Deployment del bilanciatore del carico

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

Creare 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, sostituisci 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/v1beta1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - DOMAIN_NAME
EOF
```

Creare una risorsa BackendConfig. Questa risorsa indica a GCLB come eseguire i controlli di integrità sul gateway Ingress e configurare Identity-Aware Proxy. Innanzitutto, raccogli alcuni valori dal gateway Ingress sui controlli di integrità:

Porta di controllo di integrità: è la porta di controllo di integrità in entrata.

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

Percorso di controllo di integrità: è il percorso di controllo dell'integrità di istio-ingress.

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

cat <<EOF | kubectl apply -n istio-system -f -
apiVersion: cloud.google.com/v1beta1
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 prenotato, example-static-ip.
- Imposta serviceName su istio-ingressgateway, che viene utilizzato nella risorsa Gateway per l'esempio di Bookinfo.
```
cat <<EOF | kubectl create -f -
apiVersion: extensions/v1beta1
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:
  backend:
    serviceName: istio-ingressgateway
    servicePort: 80
EOF
```
Nota: il bilanciamento del carico può richiedere fino a 10-20 minuti.
Nella console Google Cloud, vai alla pagina Kubernetes Engine > Servizi e Ingress.

Vai alla pagina Servizi e Ingress

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

Configura l'elenco di accesso IAP

Aggiungi un utente al criterio di accesso per 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. Punta il browser a:
```
http://DOMAIN_NAME/productpage
```
dove DOMAIN_NAME è il nome di dominio che hai configurato con l'indirizzo IP statico esterno.

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

Devi anche testare l'accesso di https a Bookinfo.

Abilita il supporto RCToken sul mesh di servizi

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

Per configurare RCToken:

Crea una variabile di ambiente per il numero di progetto. Si tratta del numero che è stato generato e assegnato automaticamente al progetto quando lo hai creato. (non corrisponde all'ID progetto).
```
export PROJECT_NUMBER=YOUR_PROJECT_NUMBER
```
Crea una variabile di ambiente per il segmento di pubblico RCToken. Puoi scegliere qualsiasi stringa.
```
export RCTOKEN_AUD="your-rctoken-aud"
```

Recupera le impostazioni IAP esistenti

gcloud beta iap settings get --format json \
--project=${PROJECT_NUMBER} --resource-type=compute > iapSettings.json

Aggiorna IapSettings con il pubblico RCToken.

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

gcloud beta iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_NUMBER} --resource-type=compute

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

Assicurati che le richieste al Bookinfo productpage abbiano ancora esito positivo:
```
http://DOMAIN_NAME/productpage
```

Per testare il criterio:

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

echo $(cat <<EOF
{
   "name": "projects/${PROJECT_NUMBER}/iap_web/compute",
   "applicationSettings": {
     "csmSettings": {
       "rctokenAud": "some-other-arbitrary-string"
     }
   }
 }
EOF
) > request.txt

Chiama l'API IapSettings per impostare il segmento di pubblico RCtoken.

curl --request PATCH --header "Authorization: Bearer $(gcloud beta auth application-default print-access-token)" ${IAP_SETTINGS_API}

Invia una richiesta al BookInfo productpage e questa non andrà a buon fine:
```
http://DOMAIN_NAME/productpage
```

Eseguire la pulizia

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

Elimina il certificato gestito:

kubectl delete managedcertificates example-certificate

Elimina il traffico Ingress, che alloca 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 registrar di dominio.
Elimina il cluster, che elimina le risorse che compongono il cluster, ad esempio istanze di calcolo, dischi e risorse di rete:
```
gcloud container clusters delete ${CLUSTER_NAME}
```