Questa pagina è stata tradotta dall'API Cloud Translation.

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 di 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, ad esempio identità dell'utente, indirizzo IP e tipo di dispositivo. Puoi combinare i tuoi criteri di accesso con limitazioni basate sul nome host e sul percorso di un URL di richiesta.
Attiva il supporto per le rivendicazioni sensibili al contesto nell'autorizzazione Anthos Service Mesh.
Accesso scalabile, sicuro e a disponibilità elevata alla tua applicazione tramite un bilanciatore del carico Google Cloud. Il bilanciamento del carico ad alte prestazioni fornisce la protezione integrata degli attacchi denial of service (DDoS) distribuiti e il supporto per gli indirizzi IP anycast globali.

Prerequisiti

Segui i passaggi descritti in Installare 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 configurare l'integrazione IAP per le nuove installazioni di Anthos Service Mesh e per gli upgrade.

Nuove installazioni

Attiva iap.googleapis.com. Nel seguente comando, sostituisci PROJECT_ID con il progetto in cui installerai Anthos Service Mesh:
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Per il cluster che stai aggiornando deve essere impostata l'opzione --addons=HttpLoadBalancing. Il componente aggiuntivo HttpLoadBalancing consente un controller di bilanciamento del carico HTTP (L7) per il cluster. Esegui il comando seguente per aggiornare il cluster con le opzioni richieste da Anthos Service Mesh. A meno che tu 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 porta di stato e la porta 31224 impostata come porta http. Se la porta 31223 è già in uso nel cluster, esegui questo comando 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 il comando seguente per impostare un'altra porta http:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```
Segui i passaggi in Installare funzionalità predefinite e Mesh CA per utilizzare uno script fornito da Google per installare Anthos Service Mesh. 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
```
Quando installi Anthos Service Mesh, il file iap-operator.yaml imposta il campo type sul servizio istio-ingressgateway su NodePort, che configura il gateway in modo da aprire una porta specifica sul 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.
Se stai installando Anthos Service Mesh gestito, completa anche i passaggi seguenti:
1. Aggiungi l'etichetta di revisione allo spazio dei nomi istio-system.
2. Scarica la specifica del servizio gateway in entrata Istio per IAP e denominala iap_operator.yaml.
3. Installa il traffico in entrata come servizio NodePort. Per ulteriori informazioni, consulta la pagina Eseguire 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 Anthos Service Mesh, torna a questa guida e vai alla sezione successiva per configurare l'integrazione con IAP.

Upgrade

Questa sezione illustra i seguenti casi d'uso relativi all'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 nel tuo progetto e nel componente aggiuntivo HttpLoadBalancing nel tuo cluster. Vai al passaggio 3: per scaricare il pacchetto asm ed eseguire l'upgrade di Anthos Service Mesh.
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, dopo l'upgrade, tornare a questa guida per completare l'integrazione.

Attiva iap.googleapis.com. Nel comando seguente, sostituisci PROJECT_IDcon il progetto in cui installerai Anthos Service Mesh.
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Per il cluster che stai aggiornando deve essere impostata l'opzione --addons=HttpLoadBalancing. Il componente aggiuntivo HttpLoadBalancing consente un controller di bilanciamento del carico HTTP (L7) per il cluster. Esegui il comando seguente per aggiornare il cluster con le opzioni richieste da Anthos Service Mesh. A meno che tu 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
```

Se aggiorni un bilanciatore del carico HTTP esistente e funzionante, 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}')

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

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

Per impostazione predefinita, il file iap-operator.yaml ha la porta 31223 impostata come porta di 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 sui tuoi carichi di lavoro. Per maggiori dettagli, consulta la sezione Deployment e nuovo deployment dei carichi di lavoro.

Dopo aver completato l'upgrade, torna a questa guida e continua con la sezione successiva per configurare l'integrazione con IAP.

Prenotazione di un indirizzo IP statico e configurazione di 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 rimandi 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.

Prenotare 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

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

La propagazione dell'impostazione DNS per l'impostazione DNS può richiedere da 24 a 48 ore. Puoi continuare la configurazione di questa guida, ma non sarai in grado di testare la configurazione fino a quando le impostazioni DNS non saranno propagate.

Deployment di un'applicazione di esempio

Prima di abilitare IAP, è necessaria un'applicazione in esecuzione sul tuo 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 all'esterno 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 la risorsa istio-ingressgateway preconfigurata. Ricorda che, quando hai eseguito il deployment di Anthos Service Mesh, hai specificato NodePort per istio-ingressgateway, che apre una porta specifica sul mesh di servizi. Sebbene i nodi nel tuo cluster abbiano indirizzi IP esterni, le richieste provenienti dall'esterno del tuo cluster sono bloccate dalle regole firewall di Google Cloud. Con IAP, il modo corretto di esporre le applicazioni alla rete Internet pubblica è utilizzare un bilanciatore del carico. Non esporre gli indirizzi dei nodi utilizzando regole del firewall, per ignorare gli IAP.

Per indirizzare le richieste a Bookinfo, configura un bilanciatore del carico HTTP(S) nel progetto Cloud. Poiché il bilanciatore del carico è nel tuo progetto, si trova all'interno del firewall e può accedere ai nodi nel 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.

Attivazione di IAP

I seguenti passaggi spiegano come abilitare IAP.

Configurazione della schermata per il consenso

Controlla se ne hai già uno 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 esiste già un brand per un progetto ed è stato configurato per gli utenti esterni (orgInternalOnly: false), ma vuoi limitarlo agli utenti interni, devi apportare la modifica manualmente 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 di assistenza visualizzata nella schermata per il consenso OAuth. Questo indirizzo email può essere l'indirizzo di un utente o un alias di Google Gruppi. Anche se gli account di servizio hanno anche un indirizzo email, non sono indirizzi email effettivi validi e non possono essere utilizzati durante la creazione di un brand. Tuttavia, un account di servizio può essere 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 invia 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 di IAP

Utilizza il comando create per creare un client. Utilizza il brand name nel 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 tuo client OAuth:
```
kubectl create secret generic -n istio-system my-secret --from-literal=client_id=CLIENT_ID \
--from-literal=client_secret=CLIENT_SECRET
```

Esegui il deployment 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 sottoposti a provisioning, rinnovo 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 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/v1
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 per i controlli di integrità:

Porta di controllo di integrità: la porta di 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 di controllo di integrità: questo è il percorso di 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 la risorsa 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 di 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: il bilanciatore del carico può richiedere fino a 10-20 minuti per funzionare.
Nella console Google Cloud, vai alla pagina Kubernetes Engine > Servizi & Ingress.

Vai alla pagina Servizi e Ingress

Dovresti vedere il messaggio "Creazione di 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. Una volta eseguito il provisioning della risorsa Ingress, potresti visualizzare lo stato "Ok" o l'errore "Tutti i servizi di backend si trovano in stato NON SALUTE". Una delle risorse offerte da GKE è un controllo di integrità predefinito. Un messaggio di errore indica 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.

Testare 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 l'applicazione productpage di Bookinfo. Se aggiorni la pagina più volte, dovresti vedere diverse versioni delle recensioni presentate in uno stile round robin: stelle rosse, stelle nere, nessuna stella.

Dovresti anche testare l'accesso di https a Bookinfo.

Attiva 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 consente di configurare il pubblico di JWT in una stringa arbitraria, che può essere utilizzata nei criteri di Anthos Service Mesh per un'autorizzazione granulare.

Per configurare RCToken:

Crea una variabile di ambiente per il pubblico RCToken. Può essere qualsiasi stringa che vuoi.
```
export RCTOKEN_AUD="your-rctoken-aud"
```
Facoltativo: il passaggio seguente richiede l'elemento BACKEND_SERVICE_ID. Se vuoi scoprire 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\"}". 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 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 hanno JWT valide 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 al Bookinfo productpage vadano a buon fine:
```
http://DOMAIN_NAME/productpage
```

Per verificare 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 segmento di pubblico RCtoken.

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

Fai una richiesta al productpage di Bookinfo e l'operazione non andrà a buon fine:
```
http://DOMAIN_NAME/productpage
```

Eseguire la pulizia

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

Elimina il certificato gestito:

kubectl delete managedcertificates example-certificate

Elimina la risorsa 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, come le istanze di calcolo, i dischi e le risorse di rete:
```
gcloud container clusters delete CLUSTER_NAME
```