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.

Configurazione dell'autenticazione utente di Cloud Service Mesh

L'autenticazione utente di Cloud Service Mesh è una soluzione integrata per l'autenticazione degli utenti finali basata su browser e controllo dell'accesso ai carichi di lavoro di cui è stato eseguito il deployment. Ti consente di integrarti con gli Identity Provider (IDP) esistenti per l'autenticazione degli utenti e utilizza le API e i criteri di autorizzazione di Istio per la gestione dell'accesso. È un'alternativa user-friendly all'autenticazione JWT (JSON Web Token) di Istio.

Un caso d'uso tipico è quando un'organizzazione utilizza Cloud Service Mesh per ospitare un'applicazione web a cui la sua forza lavoro può accedere tramite un browser web. Inoltre, l'organizzazione deve utilizzare il proprio provider di identità esistente per gestire le identità degli utenti. L'autenticazione utente di Cloud Service Mesh semplifica l'autenticazione degli utenti tramite un flusso di accesso e consenso OpenID Connect (OIDC) web standard. Quando l'utente si autentica, Cloud Service Mesh applica i criteri di autorizzazione Istio e, al termine dell'autorizzazione, trasmette l'identità ai carichi di lavoro in un formato di credenziali sicuro.

Come funziona

L'autenticazione utente di Cloud Service Mesh introduce un nuovo componente, authservice. Questo componente si integra con l'ingress basato su Envoy come servizio di autorizzazione esterno che intercetta tutte le richieste in arrivo per l'autenticazione. authservice implementa il lato client del protocollo OIDC e consente agli utenti di accedere alle applicazioni tramite un browser, dove completano un flusso di autenticazione e consenso interattivo per stabilire una sessione di breve durata. authservice implementa protocolli standard di settore per l'integrazione con qualsiasi fornitore di identità che può fungere da server di autorizzazione OIDC. Quando l'utente viene autenticato, le informazioni sull'entità vengono incapsulate in un RCToken in formato JWT, firmato da authservice, che viene inoltrato al livello di autorizzazione Istio nell'ingress. Questo modello fornisce controllo dell'accesso al perimetro per il traffico in mesh. Se l'utente è autorizzato ad accedere a una risorsa, questo token RC viene anche inoltrato ai microservizi per ottenere le informazioni sull'entità e applicare controllo dell'accesso granulare.

Il seguente diagramma mostra la posizione di authservice nel mesh e il suo rapporto con le altre parti del mesh, ad esempio l'ingresso, i carichi di lavoro, il browser dell'utente e qualsiasi IdP esistente.

autenticazione dell'utente finale

Gli amministratori possono installare authservice come componente aggiuntivo su un'installazione di Cloud Service Mesh. Una volta installato, authservice legge la configurazione dell'endpoint OIDC e altre impostazioni associate definite nella risorsa personalizzata UserAuth. L'amministratore può utilizzare le API ExternalAuthorization di Cloud Service Mesh per configurare auth_server come filtro sull'ingresso.

Installa il servizio di autenticazione utente

I passaggi riportati di seguito spiegano come configurare authservice.

Prerequisiti

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

Se utilizzi Cloud Service Mesh gestito su un cluster privato, assicurati che il cluster sia in grado di inviare traffico in uscita all'IDP.

Importante: kpt è uno strumento open source che ti aiuta a pacchettizzare, personalizzare, verificare e applicare le risorse Kubernetes. Assicurati di avere kpt v1.0 o versioni successive
.
Scarica il pacchetto kpt:
```
kpt pkg get https://github.com/GoogleCloudPlatform/asm-user-auth.git/@v1.2.3 .
cd asm-user-auth/
```
Questo comando recupera un pacchetto kpt con la configurazione authservice consigliata dal repository pubblico. Il package contiene manifest per eseguire il deployment del contenitore authservice come pod nello suo spazio dei nomi.asm-user-auth Inoltre, configura il gateway in entrata in modo che richieda l'autorizzazione per tutte le richieste.

Configura un provider di autorizzazione esterno ed esegui il deployment di un gateway di ingresso

Per installare il servizio di autenticazione utente, personalizzi l'installazione di Cloud Service Mesh per aggiungere un provider di autorizzazione esterno. I passaggi richiesti dipendono dal fatto che tu stia utilizzando Cloud Service Mesh gestito o in cluster.

Gestito

Aggiorna la configurazione del mesh nel ConfigMap Istio per aggiungere un provider di autorizzazione esterno. Nel seguente comando, utilizza lo stesso REVISION_LABEL utilizzato durante il provisioning di Cloud Service Mesh gestito (ad esempio asm-managed, asm-managed-rapid o asm-managed-stable):
```
kubectl edit configmap istio-REVISION_LABEL -n istio-system
```

Aggiungi il fornitore dell'estensione nel campo mesh:

mesh: |-
...
  extensionProviders:
  - name: "asm-userauth-grpc"
    envoyExtAuthzGrpc:
      service: "authservice.asm-user-auth.svc.cluster.local"
      port: "10003"

Crea e etichetta lo spazio dei nomi asm-user-auth.

kubectl create namespace asm-user-auth
kubectl label namespace asm-user-auth istio.io/rev=REVISION_LABEL --overwrite

Installa un gateway di ingresso nello spazio dei nomi asm-user-auth.
```
kubectl apply -n asm-user-auth -f DIR_PATH/samples/gateways/istio-ingressgateway
```
Nota: DIR_PATH si riferisce alla posizione del repository anthos-service-mesh-packages sul computer. Se non hai questo repository sulla tua macchina, clonalo: git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git

All'interno del cluster

Recupera l'overlay di autenticazione utente di esempio e aggiornalo se sono presenti personalizzazioni nel mesh. È una best practice consigliata gestire questo file overlay nel controllo delle versioni.
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/asm-user-auth/v1.2.3/overlay/user-auth-overlay.yaml > user-auth-overlay.yaml
```
Segui la procedura per installare Cloud Service Mesh con overlay per utilizzare uno script fornito da Google per installare Cloud Service Mesh con l'overlay di autenticazione utente. 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 \
  --custom_overlay user-auth-overlay.yaml
```
Importante: se personalizzi l'installazione con più overlay, assicurati che l'opzione --custom_overlay includa tutti i file di overlay.

I pacchetti kpt per l'autenticazione utente creano un AuthorizationPolicy per fare riferimento al provider di autorizzazione esterno specificato da pkg/ext-authz.yaml.
Crea e etichetta lo spazio dei nomi asm-user-auth.
```
kubectl create namespace asm-user-auth
kubectl label namespace asm-user-auth istio.io/rev=REVISION --overwrite
```
Puoi trovare il valore dell'etichetta REVISION selezionando kubectl get pod -n istio-system -L istio.io/rev
Installa il gateway Istio nello spazio dei nomi asm-user-auth.
```
kubectl apply -n asm-user-auth -f DIR_PATH/samples/gateways/istio-ingressgateway
```
Nota: DIR_PATH si riferisce alla posizione del repository anthos-service-mesh-packages sul computer. Se non hai questo repository sulla tua macchina, clonalo: git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git

Prepara la configurazione del client OIDC

Imposta la configurazione del client OIDC seguendo i passaggi riportati di seguito. Questa guida utilizza Google come provider di identità, ma puoi utilizzare qualsiasi provider di identità che supporti l'autenticazione OIDC.

Nella console Google Cloud, vai a API e servizi > Credenziali.

Vai a credenziali
Vai a Crea credenziali e scegli ID client OAuth. Se necessario, imposta le opzioni della schermata per il consenso OAuth, quindi configura le seguenti opzioni:
- Imposta Tipo di applicazione su Applicazione web.
- Imposta URI di reindirizzamento autorizzato su https://REDIRECT_HOST/REDIRECT_PATH. Ad esempio, per localhost puoi impostarehttps://localhost:8443/_gcp_asm_authenticate.
Quindi, fai clic su Salva.

Inoltre, salva la configurazione del client OIDC per utilizzarla in un secondo momento.

export OIDC_CLIENT_ID=CLIENT_ID
export OIDC_CLIENT_SECRET=CLIENT_SECRET
export OIDC_ISSUER_URI=ISSUER_URI
export OIDC_REDIRECT_HOST=REDIRECT_HOST
export OIDC_REDIRECT_PATH=REDIRECT_PATH

Imposta l'URL di reindirizzamento e il secret per il gateway di ingresso

OAuth2 richiede un URL di reindirizzamento ospitato su un endpoint protetto da HTTPS. Questi comandi sono solo a scopo di esempio e semplificano la configurazione generando un certificato autofirmato per il gateway di ingresso Istio.

Genera un certificato autofirmato:

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem \
 -days 365 -nodes -subj '/CN=localhost'

Crea un secret per il gateway in entrata per ospitare il traffico HTTPS:

kubectl create -n asm-user-auth secret tls userauth-tls-cert --key=key.pem \
--cert=cert.pem

Applica le chiavi di crittografia e firma

authservice ha bisogno di due serie di chiavi per funzionare correttamente. La prima è una chiave simmetrica per la crittografia e la decriptazione. Questa chiave viene utilizzata per criptare lo stato della sessione prima di impostarlo come cookie.

Il secondo insieme di chiavi è una coppia di chiave pubblica/privata. Questa chiave viene utilizzata per firmare le informazioni sull'utente autenticato in formato JWT come RCToken. La chiave pubblica di questa coppia viene pubblicata in un endpoint predefinito che i sidecar possono utilizzare per convalidare il JWT.

Il pacchetto di autenticazione utente kpt contiene due chiavi di esempio per una configurazione rapida. Tuttavia, puoi utilizzare il tuo sistema di gestione delle chiavi preferito per generare queste chiavi.

Prepara la chiave di crittografia della sessione con il seguente formato o utilizza l'esempio del pacchetto, che puoi visualizzare tramite cat ./samples/cookie_encryption_key.json.
```
{
  "keys":[
     {
        "kty":"oct",
        "kid":"key-0",
        "k":"YOUR_AES_KEY",
        "useAfter": 1612813735
     }
  ]
}
```
Puoi generare una chiave AES di test con il seguente comando:
```
openssl rand -base64 32
```

Prepara la chiave di firma RCToken con il seguente formato o utilizza il sample del pacchetto, che puoi visualizzare tramite cat ./samples/rctoken_signing_key.json.

{
  "keys":[
     {
        "kty":"RSA",
        "kid":"rsa-signing-key",
        "k":"YOUR_AES_KEY",  # k contains a Base64 encoded PEM format RSA signing key.
        "useAfter": 1612813735  # unix timestamp
     }
  ]
}

Puoi generare una chiave privata RSA di prova a 256 bit con il seguente comando:

openssl genpkey -algorithm RSA -out rsa_private.pem -pkeyopt rsa_keygen_bits:256

Crea il secret Kubernetes, che authservice monterà nel proprio sistema file.

kubectl create secret generic secret-key  \
    --from-file="session_cookie.key"="./samples/cookie_encryption_key.json" \
    --from-file="rctoken.key"="./samples/rctoken_signing_key.json"  \
    --namespace=asm-user-auth

Esegui il deployment del servizio di autenticazione utente

I seguenti comandi creano il servizio e il deployment di autenticazione utente nello spazio dei nomi asm-user-auth.

Imposta i valori necessari per la configurazione dell'autenticazione utente. L'ID client e il secret vengono archiviati come secret di Kubernetes, pertanto utilizziamo Base64 per codificarli. Visita il repository pubblico per visualizzare tutti i settati disponibili.

kpt fn eval pkg --image gcr.io/kpt-fn/apply-setters:v0.2 --truncate-output=false -- \
  client-id="$(echo -n ${OIDC_CLIENT_ID} | base64 -w0)" \
  client-secret="$(echo -n ${OIDC_CLIENT_SECRET} | base64 -w0)" \
  issuer-uri="${OIDC_ISSUER_URI}" \
  redirect-host="${OIDC_REDIRECT_HOST}" \
  redirect-path="${OIDC_REDIRECT_PATH}"

Applica il pacchetto kpt:

# Remove the potential alpha version CRD if exists.
kubectl delete crd userauthconfigs.security.anthos.io
kubectl apply -f ./pkg/asm_user_auth_config_v1beta1.yaml
kubectl apply -f ./pkg

authservice utilizza il CRD UserAuthConfig per fornire l'autenticazione degli utenti finali. UserAuthConfig è configurabile in fase di esecuzione e puoi actualizarlo per modificare il comportamento di authservice e configurarlo con gli endpoint per qualsiasi server di autorizzazione OIDC.

Puoi visualizzare il file cat pkg/user_auth_config.yaml, che contiene i seguenti campi:

apiVersion: security.anthos.io/v1beta1
kind: UserAuthConfig
metadata:
  name: user-auth-config
  namespace: asm-user-auth
spec:
  authentication:
    oidc:
      certificateAuthorityData: ""  # kpt-set: ${ca-cert}
      issuerURI: "<your issuer uri>"  # kpt-set: ${issuer-uri}
      proxy: ""  # kpt-set: ${proxy}
      oauthCredentialsSecret:
        name: "oauth-secret"  # kpt-set: ${secret-name}
        namespace: "asm-user-auth"  # kpt-set: ${secret-namespace}
      redirectURIHost: ""  # kpt-set: ${redirect-host}
      redirectURIPath: "/_gcp_asm_authenticate"  # kpt-set: ${redirect-path}
      scopes: ""  # kpt-set: ${scopes}
      groupsClaim: ""  # kpt-set: ${groups}
  outputJWTAudience: "test_audience"  # kpt-set: ${jwt-audience}

Per descrizioni dettagliate dei campi user_auth_config.yaml, consulta dettagli sulla configurazione dell'autenticazione utente.

Esegui attività di post-installazione

Le seguenti attività sono necessarie dopo aver completato i passaggi di installazione.

Attivare l'autenticazione utente per le applicazioni

Questa sezione mostra come attivare l'autenticazione utente utilizzando come esempio l'applicazione di esempio httpbin.

L'autenticazione utente di Cloud Service Mesh utilizza un CUSTOM criterio di autorizzazione definito per attivare il flusso OIDC.

Dopo aver installato il gateway Istio, configuralo in modo da gestire il traffico HTTPS utilizzando il certificato TLS userauth-tls-cert che hai creato sopra. Di seguito è riportata la configurazione di pkg/gateway.yaml che hai appena installato.

apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: userauth
  namespace: asm-user-auth
spec:
  selector:
    istio: ingressgateway
  servers:
  - hosts:
    - '*'
    port:
      name: https
      number: 443
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: userauth-tls-cert
---
# This ensures the OIDC endpoint has at least some route defined.
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: userauth-oidc
  namespace: asm-user-auth
spec:
  gateways:
  - userauth
  hosts:
  - '*'
  http:
  - match:
    - uri:
        prefix: /status
    - uri:
        prefix: "your-oidc-redirect-path"
    name: user-auth-route
    route:
    - destination:
        host: authservice
        port:
          number: 10004

Etichetta lo spazio dei nomi default per attivare l'iniezione automatica di istio-proxy per i deployment.
```
kubectl label namespace default istio.io/rev=REVISION --overwrite
```

Esegui il deployment di httpbin nello spazio dei nomi default.

kubectl apply -f https://raw.githubusercontent.com/istio/istio/master/samples/httpbin/httpbin.yaml -n default

Aggiorna httpbin in modo da utilizzare questo gateway per gestire il traffico HTTPS e utilizza il forwarding delle porte per accedere all'applicazione localmente:

kubectl apply -f./samples/httpbin-route.yaml -n default
kubectl port-forward service/istio-ingressgateway 8443:443 -n asm-user-auth

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: httpbin
  namespace: default
spec:
  gateways:
  - asm-user-auth/userauth
  hosts:
  - '*'
  http:
  - match:
    - uri:
        prefix: /ip
    - uri:
        prefix: /headers
    name: httpbin-routes
    route:
    - destination:
        host: httpbin.default.svc.cluster.local
        port:
          number: 8000

Il gateway in ingresso sulla porta 8443 verrà inoltrato a localhost per rendere l'applicazione accessibile localmente.

Esegui il deployment di samples/rctoken-authz.yaml per consentire a RequestAuthentication e AuthorizationPolicy di verificare il token RC per le richieste.

kubectl apply -f ./samples/rctoken-authz.yaml -n asm-user-auth

Esempio samples/rctoken-authz.yaml:

apiVersion: security.istio.io/v1beta1
kind: RequestAuthentication
metadata:
  name: require-rc-token
spec:
  selector:
    matchLabels:
      istio: ingressgateway
  jwtRules:
  - issuer: "authservice.asm-user-auth.svc.cluster.local"
    audiences:
    - "test_audience"
    jwksUri: "http://authservice.asm-user-auth.svc.cluster.local:10004/_gcp_user_auth/jwks"
    fromHeaders:
    - name: X-ASM-RCTOKEN
    forwardOriginalToken: true
---
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: require-rc-token
spec:
  selector:
    matchLabels:
      istio: ingressgateway
  action: ALLOW
  rules:
  - when:
    - key: request.auth.claims[iss]
      values:
      - authservice.asm-user-auth.svc.cluster.local
    - key: request.auth.claims[aud]
      values:
      - test_audience

Verificare l'autenticazione utente

httpbin serve due percorsi: /ip è accessibile pubblicamente e /headers richiede all'utente finale di accedere tramite il proprio IdP configurato.

Verifica di poter accedere direttamente a /ip visitando https://localhost:8443/ip.
Verifica di visualizzare la pagina di accesso OIDC visitando https://localhost:8443/headers.
Dopo aver eseguito l'accesso, fai clic su Avanti e verifica che ti reindirizzi alla pagina /headers.

Configurare i criteri di autorizzazione

Dopo aver completato la configurazione nei passaggi precedenti, ogni utente verrà reindirizzato tramite un flusso di autenticazione basato sul web. Al termine del flusso, authservice genera un RCToken in formato JWT, che utilizza per trasmettere le informazioni sull'utente autenticato.

Aggiungi i criteri di autorizzazione Istio all'ingresso per assicurarti che venga eseguito un controllo di autorizzazione per ogni utente autenticato:
```
kubectl apply -f ./samples/httpbin-authz.yaml -n asm-user-auth
```

Il file httpbin-authz.yaml configura il gateway di ingresso per convalidare il token RC emesso da authservice e concede l'autorizzazione solo quando il JWT contiene i campi desiderati, come segmenti di pubblico ed emittenti.

Vedi il seguente esempio di criterio di autorizzazione:

apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: require-rc-token
spec:
  selector:
    matchLabels:
      istio: ingressgateway
  action: ALLOW
  rules:
  - to:
    - operation:
        paths: ["/ip"]
  - to:
    when:
    - key: request.auth.claims[iss]
      values:
      - authservice.asm-user-auth.svc.cluster.local
    - key: request.auth.claims[aud]
      values:
      - test_audience
    - key: request.auth.claims[sub]
      values:
      - allowed_user_sub_1  # Change this with the "sub" claim in the RC token. Wildcard '*' will match everything.

Configura le impostazioni specifiche dell'ambiente

I passaggi precedenti utilizzano localhost e un certificato HTTPS autofirmato per una configurazione rapida. Per l'utilizzo in produzione reale, utilizza il tuo dominio, ad esempio example.com.

Inoltre, assicurati che certificateAuthorityData abbia i contenuti del certificato radice previsti. Ad esempio, se l'IDP è attendibile con i certificati principali del sistema, puoi lasciare il campo vuoto. Se è presente un proxy HTTPS che termina la connessione HTTPS, deve essere impostato sul certificato principale del proxy.

Gestire e ruotare le chiavi

authservice utilizza due set di chiavi. Puoi ruotare ogni chiave indipendentemente. Tuttavia, prima di ruotare le chiavi, è importante comprendere come funziona la rotazione.

Entrambe le chiavi sono in formato JSON. Il campo useAfter specifica il timestamp da quando la chiave verrà considerata in uso. Durante una rotazione della chiave, devi includere sia le chiavi vecchie che quelle nuove nel file JSON. Ad esempio, nel seguente esempio, new-key verrà utilizzato solo dopo il timestamp 1712813735.

{
   "keys":[
      {
         "kty":"RSA",
         "kid":"old-key",
         "K":"...", # k contains a Base64 encoded PEM format RSA signing key.
         "useAfter": 1612813735, # unix timestamp
      }
      {
      "kty":"RSA",
         "kid":"new-key",
         "K":"...", # k contains a Base64 encoded PEM format RSA signing key.
         "useAfter": 1712813735, # unix timestamp
      }
   ]
}

Cloud Service Mesh utilizza la chiave simmetrica per criptare i dati della sessione memorizzati nei cookie del browser. Per garantire la validità delle sessioni esistenti, authservice tenta la decrittografia con tutte le chiavi nell'insieme di chiavi. Durante la rotazione, authservice utilizzerà la nuova chiave per criptare le nuove sessioni e continuerà a tentare la decrittografia con le vecchie chiavi.

La coppia di chiave pubblica/privata viene utilizzata per firmare RCToken. La chiave pubblica viene trasmessa ai sidecar da istiod per la verifica JWT. È fondamentale che i sidecar ricevano la nuova chiave pubblica prima che authservice inizi a utilizzare la nuova chiave privata per firmare il RCToken. A tal fine, authservice inizia a pubblicare la chiave pubblica immediatamente dopo l'aggiunta, ma attende un periodo di tempo significativo prima di iniziare a utilizzarla per firmare RCToken.

In sintesi, quando esegui la rotazione delle chiavi, ti consigliamo di:

Esegui rotazioni regolari delle chiavi o su richiesta, in base alle tue esigenze.
Nel formato JSON, includi sia le chiavi attuali che quelle nuove. Le nuove chiavi devono essere associate a un timestamp in futuro. Ti consigliamo di specificare un timestamp almeno un paio d'ore prima dell'ora corrente.
Monitora e verifica che i servizi siano ancora operativi dopo l'utilizzo della nuova chiave. Prima di procedere con il passaggio successivo, attendi almeno un giorno dall'utilizzo della nuova chiave.
Rimuovi le vecchie chiavi dalle voci JSON. Non sono più necessari.

Deployment multi-cluster

L'autenticazione utente di Cloud Service Mesh supporta il deployment multi-cluster. Devi eseguire il deployment dell'autenticazione utente in ogni cluster come descritto sopra. La configurazione dell'autenticazione utente, come la risorsa personalizzata UserAuth, il client secret OIDC e le chiavi di crittografia, deve essere replicata in ogni cluster.

Per impostazione predefinita, il gateway di ingresso eseguirà il bilanciamento del carico delle richieste di autenticazione su una qualsiasi delle istanze authservice. Puoi utilizzare una regola di destinazione per configurare il gateway di ingresso in modo che invii le richieste al authservice nello stesso cluster e effettui il failover solo al authservice di altri cluster.

apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: authservice-fail-over
  namespace: asm-user-auth
spec:
  host: authservice.asm-user-auth.svc.cluster.local
  trafficPolicy:
    loadBalancer:
      localityLbSetting:
        enabled: true
        failover:
        - from:  us-east
          to: us-west
        - from: us-west
          to: us-east

Come per le altre configurazioni, questa deve essere configurata in ogni cluster.

Mapping delle rivendicazioni personalizzate

Per configurare la mappatura delle attestazioni personalizzate, configura spec.authentication.oidc.attributeMapping per definire eventuali mappature dall'ID token del provider di identità originale. La chiave sarà il nome della rivendicazione nell'RCToken e il valore è un'espressione CEL su come analizzare la rivendicazione dall'IDToken. Utilizza assertion per fare riferimento all'IDToken.

Esempio:

spec:
  authentication:
    oidc:
      attributeMapping:
        aud_copy: assertion.aud
        decision: 'assertion.sub.startsWith("123") ? "success" : "fail"'

Nell'RCToken, un'affermazione nidificata attributes contiene le affermazioni configurate:

"attributes": {
    "aud_copy": "foo.googleusercontent.com",
    "decision": "success"
}

Se l'espressione CEL non riesce ad analizzare il valore dall'IDToken, ignorerà la rivendicazione senza interrompere il flusso di autenticazione.

Upgrade dell'autenticazione utente

Installa di nuovo i pacchetti user-auth, in quanto contengono il file binario aggiornato per la nuova versione di user-auth:
```
kpt pkg get https://github.com/GoogleCloudPlatform/asm-user-auth.git/@v1.2.3 .
cd asm-user-auth/
```

Salva la configurazione del client OIDC:

export OIDC_CLIENT_ID=CLIENT_ID
export OIDC_CLIENT_SECRET=CLIENT_SECRET
export OIDC_ISSUER_URI=ISSUER_URI
export OIDC_REDIRECT_HOST=REDIRECT_HOST
export OIDC_REDIRECT_PATH=REDIRECT_PATH

Esegui il deployment del servizio di autenticazione utente per eseguire l'upgrade a una nuova versione.

Dettagli sulla configurazione dell'autenticazione utente

La tabella seguente descrive ciascun campo nel file CRD:

Nome campo	Descrizione
`authentication.oidc`	Questa sezione contiene la configurazione dell'endpoint OIDC e i parametri utilizzati nel flusso OIDC.
`authentication.oidc.certificateAuthorityData`	Si tratta del certificato SSL principale del dominio del server di autorizzazione OIDC o del proxy HTTPS, se presente.
`authentication.oidc.oauthCredentialsSecret`	Riferimenti ai secret di tipo Opaque di Kubernetes che contengono client_id e client_secret di OAuth2 OIDC nel payload JSON.
`authentication.oidc.issuerURI`	L'URI da utilizzare come emittente nell'RCToken di output.
`authentication.oidc.proxy`	Server proxy per l'IdP OIDC, se applicabile. Con il formato http://user:password@10.10.10.10:8888.
`authentication.oidc.redirectURIHost`	L'host da utilizzare per l'URI di interruzione OAuth. Se lasci vuoto questo campo, verrà utilizzato l'host dell'URL di destinazione e l'URI di reindirizzamento verrà assemblato dinamicamente. Questo valore può essere utilizzato quando è richiesta una sessione SSO di autenticazione utente in un dominio di livello superiore. Ad esempio, per attivare l'SSO tra profile.example.com/ e admin.example.com/, questo valore può essere impostato su example.com. Verrà attivata una sessione di autenticazione dell'utente su example.com che verrà condivisa tra tutti i sottodomini. Nota: se vengono pubblicati più domini dalla stessa mesh, ad esempio example1.com ed example2.com, la funzionalità non può essere utilizzata e consigliamo di lasciarla vuota.
`authentication.oidc.redirectURIPath`	Il percorso dell'endpoint in cui `authservice` terminerà il flusso OAuth. Devi registrare questo percorso URI più l'host come URI di reindirizzamento autorizzato nel server di autorizzazione per `authentication.oidc.clientID`. Inoltre, questo URI deve essere pubblicato dallo stesso mesh di servizi e dall'ingress in cui è abilitato `authservice`.
`authentication.oidc.scopes`	L'ambito OAuth che deve essere richiesto nella richiesta di autenticazione. Elenco separato da virgole di identificatori utilizzati per specificare quali privilegi di accesso vengono richiesti oltre all'ambito "openid", ad es. "groups,allatclaim".
`authentication.oidc.groupsClaim`	Se `idtoken` contiene una rivendicazione di gruppi, utilizza questo campo per indicarne il nome. Se specificato, il servizio trasmette i dati di questa rivendicazione alla rivendicazione `groups` nell'RCToken di output. Questa rivendicazione deve contenere un elenco di stringhe separate da virgole, ad es. ["group1", "group2"].
`authentication.oidc.attributeMapping`	Contiene una o più mappature di rivendicazioni da `idtoken` seguite da espressioni CEL. A tutti i claim deve essere fatto riferimento tramite `assertion.X`, mentre `assertion` fa riferimento all'IDToken originale, ad esempio `aud_copy: assertion.aud.`
`authentication.outputJWTAudience`	Il pubblico dell'RCToken generato da `authservice`. I sidecar possono convalidare l'RCToken in entrata in base a questo valore del segmento di pubblico.

Risoluzione dei problemi

Accessibilità di rete all'IDP.

Possibile log: error: TLS handshake failed..

Verifica eseguendo curl dal contenitore istio-proxy all'URI dell'emittente dell'IDP. Se non riesce a connettersi, l'utente può controllare le regole del firewall o altre configurazioni di rete per il cluster.
Certificato CA radice.

Log possibile: error: The server's TLS certificate did not match expectations. o error: TLS handshake failed..

Assicurati che certificateAuthorityData contenga il certificato CA radice corretto. Se non è presente un proxy HTTPS che termina il traffico HTTPS, deve contenere il certificato CA radice per l'IDP. Se è presente, dovrebbe contenere il proxy.
Configurazione del percorso di reindirizzamento.

Possibile osservazione: ricezione di una pagina di errore 404 durante il flusso di autenticazione OIDC.

L'autenticazione utente restituisce l'intestazione "Set-Cookie" senza utilizzare l'attributo path, per impostazione predefinita il browser utilizza la directory dell'URL della richiesta come percorso del cookie (ambito del cookie relativo al percorso). Ti consigliamo quindi di non includere "/" nel percorso del reindirizzamento, a meno che non sia tua intenzione.
Il sidecar non è in grado di recuperare jwksUri.

In alcuni scenari, una limitazione del sidecar potrebbe causare l'errore di recupero di jwksUri. Se lo spazio dei nomi non è presente utilizzando un carattere jolly (ad esempio ./* o istio-system/*), questa operazione non funzionerà. Devi aggiungere manualmente il relativo spazio dei nomi nel sidecar di uscita.

Domande frequenti

Come faccio a eseguire l'upgrade di Cloud Service Mesh con l'autenticazione utente abilitata?

Se utilizzi Cloud Service Mesh all'interno del cluster, segui la procedura di upgrade di Cloud Service Mesh e specifica il file overlay aggiungendo --custom_overlay user-auth-overlay.yaml sulla riga di comando a asmcli install.

Viene eseguito automaticamente l'upgrade di Cloud Service Mesh gestito.
Quanta CPU e memoria devo eseguire il provisioning per authservice? E quante richieste al secondo può gestire?

Per impostazione predefinita, authservice è configurato con 2, 0 vCPU e 256 Mi di memoria. Con questa configurazione, authservice è in grado di gestire 500 richieste al secondo. Per gestire un maggior numero di richieste, devi eseguire il provisioning di più CPU, in proporzione alla capacità di gestione delle richieste. Puoi anche configurare più repliche di authservice per aumentare la scalabilità orizzontale.