Demo: autentica con Keycloak o SSO di Google

Questa pagina è rivolta agli amministratori della piattaforma.

Puoi provare l'autenticazione con Keycloak o Single Sign-On (SSO) di Google solo a scopo dimostrativo o di test.

Autentica con Keycloak

Keycloak è un prodotto open source per la gestione di identità e accessi software. Puoi configurarlo come provider OIDC per una rapida demo.

Prima di iniziare

Per installare e abilitare Keycloak, devi avere un cluster Kubernetes con un indirizzo Ingress accessibile dal tuo Anthos in esecuzione in modalità disconnessa. In questa pagina viene utilizzato come esempio un cluster di amministrazione in modalità disconnessa di Anthos.

Devi anche aver creato un nome di dominio personalizzato per Anthos in esecuzione in modalità disconnessa Centro gestione. Vedi Configurare il nome di dominio per accedere al Centro di gestione.

Esporta il nome del dominio del Centro di gestione come variabile, ad esempio:
```
export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
```
Esporta un registro privato come variabile, ad esempio:
```
export PRIVATE_REGISTRY=10.200.0.2/library
```

Scarica l'immagine Keycloak ed esegui il push nel registro privato

Scarica l'immagine Keycloak da dockerhub:
```
actl images save \
  --output keycloak-image \
  jboss/keycloak:12.0.2
```
Nota: keycloak:12.0.2 è l'unica versione che abbiamo testato per questa demo come provider OIDC per Anthos in esecuzione in modalità disconnessa.

Esegui il push dell'immagine Keycloak al registro privato:

actl images push \
  --images keycloak-image \
  --private-registry=${PRIVATE_REGISTRY}

Esegui il deployment di Keycloak

Aggiorna la configurazione DNS e genera un certificato per eseguire il deployment di Keycloak.

Crea il servizio Keycloak per esporre l'IP per Keycloak:

kubectl create -f - <<EOF
apiVersion: v1
kind: Namespace
metadata:
  name: keycloak
---
apiVersion: v1
kind: Service
metadata:
  name: keycloak-svc
  namespace: keycloak
  labels:
    app: keycloak
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  - name: https
    port: 443
    targetPort: 8443
  selector:
    app: keycloak
  type: LoadBalancer
EOF

Dopo aver assegnato un IP da LoadBalancer, esportalo in una variabile, ad esempio:

export KEYCLOAK_SVC_IP=$(kubectl get services -n keycloak \
    -o jsonpath='{.items[0].status.loadBalancer.ingress[0].ip}')

Aggiungi un "record A" alla configurazione del dominio DNS e impostalo su ${KEYCLOAK_SVC_IP}:
```
export KEYCLOAK_SVC=keycloak.example.com
```

Genera un certificato autofirmato per Keycloak da utilizzare per TLS.

openssl req -new -newkey rsa:4096 -x509 -sha256 -days 365 -nodes -subj \
    "/CN=${KEYCLOAK_SVC}" \
    -addext "subjectAltName = DNS:localhost,DNS:${KEYCLOAK_SVC},IP:${KEYCLOAK_SVC_IP}" \
    -out "tls.crt" -keyout "tls.key"

Carica il certificato e la chiave privata nel cluster:

kubectl create secret tls tls-config -n keycloak --cert=tls.crt \
    --key=tls.key

Esegui questo comando per eseguire il deployment di Keycloak:

kubectl create -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: keycloak
  namespace: keycloak
  labels:
    app: keycloak
spec:
  replicas: 1
  selector:
    matchLabels:
      app: keycloak
  template:
    metadata:
      labels:
        app: keycloak
    spec:
      volumes:
      - name: tls-config-volume
        secret:
          secretName: tls-config
          items:
          - key: tls.crt
            path: tls.crt
          - key: tls.key
            path: tls.key
      containers:
      - name: keycloak
        # Set the image as original path but the actual image will be pulled from the registry mirror,
        # which was configured by 'actl push' command.
        image: jboss/keycloak:12.0.2
        # Keycloak uses certificates stored in /etc/x509/https to set up TLS.
        # https://github.com/keycloak/keycloak-containers/blob/master/server/README.md#setting-up-tlsssl
        volumeMounts:
        - name: tls-config-volume
          mountPath: "/etc/x509/https"
        env:
        - name: KEYCLOAK_USER
          value: "admin"
        - name: KEYCLOAK_PASSWORD
          value: "admin"
        - name: PROXY_ADDRESS_FORWARDING
          value: "true"
        ports:
        - name: http
          containerPort: 8080
        - name: https
          containerPort: 8443
        readinessProbe:
          httpGet:
            path: /auth/realms/master
            port: 8080
EOF

Configurare l'utente e il client Keycloak

Apri la console Keycloak sulla workstation di amministrazione e accedi con KEYCLOAK_USER e KEYCLOAK_PASSWORD nel file keycloak.yaml. Per impostazione predefinita, i valori sono KEYCLOAK_USER=admin e KEYCLOAK_PASSWORD=admin. Se necessario, accetta il certificato autofirmato nel browser. Se in Chrome viene richiesto un avviso relativo a un certificato non attendibile, inserisci thisisunsafe nella finestra di dialogo.

echo "Keycloak console: https://${KEYCLOAK_SVC}"

Crea un regno

Passa il mouse sopra Master in alto a sinistra e fai clic su Aggiungi realm.
Inserisci anthos come nome del nuovo regno e fai clic su Crea.
In Impostazioni di area di autenticazione > Token, modifica la durata del token di accesso in 1 Hour per evitare che il token scada troppo presto e fai clic su Salva.

Crea un utente

Nella barra di navigazione a sinistra, fai clic su Utenti e poi su Aggiungi utente.
Configura le impostazioni seguenti per l'utente e fai clic su Salva.
1. Nome utente: anthos-platform-admin
2. Indirizzo email: anthos-platform-admin@example.com
3. Utente abilitato: ON
4. Email verificata: ON
Nella scheda Credentials, compila i campi Password e Conferma password. Fai clic su Imposta password e convalida quando richiesto.

Creazione di un client

Nella barra di navigazione a sinistra, fai clic su Clienti e poi su Crea.
Configura le impostazioni seguenti per il client e fai clic su Salva. ANTHOS_MANAGEMENT_CENTER è il nome di dominio personalizzato che utilizzi per il Centro gestione.
1. ID client: anthos
2. Protocollo client: openid-connect
3. URL principale: https://ANTHOS_MANAGEMENT_CENTER
Vai alla pagina di gestione del client appena creato.
Nella scheda Impostazioni della pagina di gestione del client:
1. Imposta il Tipo di accesso su confidential.
2. Aggiungi gli URI seguenti a URI di reindirizzamento validi.
  - http://localhost:9879/callback
  - https://ANTHOS_MANAGEMENT_CENTER/_gcp_anthos_oidc_callback
3. Fai clic su Salva.
Nella scheda Credentials della pagina di gestione dei client, seleziona Client ID e Secret come Client Authenticator.
Notare il segreto da qualche parte.
(Consigliato) Configurare l'appartenenza ai gruppi in Keycloak
1. Nella barra di navigazione a sinistra, fai clic su Gruppi e poi su Nuovo.
2. Inserisci il nome del tuo gruppo: anthos-platform-admin-group.
3. Torna alla scheda Utente a sinistra e fai clic su Visualizza tutti gli utenti.
4. Fai clic sull'utente appena creato (anthos-platform-admin) e fai clic sulla scheda Gruppi.
5. In Gruppi disponibili, seleziona il gruppo che hai creato, anthos-platform-admin-group e fai clic su Iscriviti.
6. Torna alla pagina di gestione dei client di anthos.
7. Fai clic sulla scheda Mappers (Mappatori), quindi fai clic su Create (Crea):
  1. Inserisci il nome di questo mappatore: anthos-platform-admin-group-mapper.
  2. Nell'elenco a discesa Mapper Type (Tipo di mappatore), seleziona Group Membership (Appartenenza al gruppo).
  3. Token Claim Name è il valore dell'attributo mostrato nel token di autenticazione. Il valore predefinito in Anthos in esecuzione in modalità disconnessa è "groups", quindi puoi utilizzare groups in questo campo. Ricorda che se il nome Token Claim Name non è groups, devi modificare il valore del campo GroupsClaim della configurazione OIDC.
  4. Assicurati che l'opzione Percorso gruppo completo sia disattivata.
  5. Assicurati che le opzioni Aggiungi al token ID, Aggiungi al token di accesso e Aggiungi alle informazioni utente siano tutte attivate.
  6. Fai clic su Salva.

Abilita autenticazione OIDC

Ottieni l'URL del provider OIDC da utilizzare nei passaggi seguenti.

Esegui questo comando:

export ISSUER_URL=https://${KEYCLOAK_SVC}/auth/realms/anthos
echo "Issuer URL: ${ISSUER_URL}"

Utilizzando il comando tls.crt precedente, genera il certificato codificato in Base64.

export BASE64_CERT=$(openssl base64 -A -in tls.crt)
echo "Use the following string as the base64-encoded certificate for the OIDC provider: ${BASE64_CERT}"

Approccio consigliato utilizzando la Console Centro gestione

In Console Centro gestione, apri il menu Identità e accesso.
Nella scheda Identity, fai clic su Configura Anthos Identity Service (OIDC)
Crea il profilo per Keycloak completando i campi seguenti, quindi fai clic su Invia:
1. Nome profilo: keycloak
2. URL provider OIDC: l'URL dell'emittente dalla sezione Abilita autenticazione OIDC.
3. ID client OIDC: anthos
4. Client secret OIDC: il client secret della sezione Create a client
5. Rivendicazione del nome utente: email
6. Prefisso nome utente: keycloak-
7. Rivendicazione di gruppi: la rivendicazione di gruppi dalla sezione Configura appartenenza al gruppo. Se lasci questo campo vuoto, il valore è groups.
8. Prefisso gruppo: keycloak-
9. Ambiti: email openid
10. Parametri extra: access_type=offline
11. Dati dell'autorità di certificazione: utilizza il certificato con codifica base64 riportato nella sezione Abilita autenticazione OIDC.
Nota: Prefisso nome utente e Prefisso gruppo possono essere definiti come valori diversi. Ricorda di aggiungere questi prefissi quando associ gli account ai ruoli.
Fai clic su Applica profili ai cluster e fai clic sulla scheda Cluster di amministrazione.
Per Profili, scegli il profilo "keycloak" appena creato.
In Nome di dominio, inserisci ANTHOS_MANAGEMENT_CENTER.
In Amministratore piattaforma iniziale, aggiungi sempre il prefisso dell'utente prima del nome utente. Ad esempio, se aggiungi anthos-platform-admin@example.com, inserisci keycloak-anthos-platform-admin@example.com.
Fai clic su Invia e attendi un minuto per la riconfigurazione dei vari componenti di sistema.
In una finestra di navigazione in incognito, vai all'indirizzo https://ANTHOS_MANAGEMENT_CENTER. Si aprirà una pagina di accesso di Keycloak, in cui potrai accedere come anthos-platform-admin (dopo aver impostato una password permanente).

Approccio alternativo mediante l'applicazione di un file YAML

Imposta il provider IdP per il dominio. Se DomainConfig è già creato per il dominio, applica la patch all'oggetto per impostare il nome del metodo di autenticazione da utilizzare per il dominio con questo comando:

kubectl patch domainconfig anthos.example.com --type=json -p='[{"op": "replace", "path":
"/spec/authMethodName", "value":"keycloak"}]'

Se DomainConfig non viene creato per il dominio, crealo con questo comando:

kubectl create -f - <<EOF
apiVersion: managementcenter.anthos.cloud.google.com/v1
kind: DomainConfig
metadata:
  name: anthos.example.com
spec:
  authMethodName: keycloak
EOF

Crea clientconfig-patch.yaml con i seguenti contenuti:

# Use this to set the OIDC configuration of Keycloak:
# kubectl patch ClientConfig default -n kube-public --type=merge --patch $(cat clientconfig-patch.yaml)
spec:
  authentication:
  # The name of the OIDC configuration to create.
  - name: keycloak
    oidc:
      # ID for the client application that makes authentication requests to the OpenID provider.
      clientID: anthos
      # ID for the client application that makes authentication requests to the OpenID provider.
      clientSecret: YOUR_CLIENT_SECRET
      # The URI to redirect users going through the OAuth flow using cloud console.
      # This is not supported by Anthos running in disconnected mode.
      cloudConsoleRedirectURI: http://cloud.console.not.enabled
      # Additional key-value parameters (comma-separated) to send to the OpenID provider.
      extraParams: access_type=offline
      # URL where authorization requests are sent to your OpenID.
      issuerURI: YOUR_ISSUER_URI
      # The redirect URL that kubectl uses for authorization.
      kubectlRedirectURI: http://localhost:9879/callback
      # Additional scopes to send to the OpenID provider.
      scopes: openid email
      # JWT claim to use as the username. You can choose other claims, such as email or name,
      # depending on the OpenID provider. However, claims other than email are prefixed
      # with the issuer URL to prevent naming clashes.
      userClaim: email
      # A base64-encoded PEM-encoded certificate for the OIDC provider. To create the string,
      # encode the certificate, including headers, into base64. Include the resulting string
      # in certificateAuthorityData as a single line.
      certificateAuthorityData: YOUR_CERTIFICATE

Modifica clientconfig-patch.yaml con le impostazioni per Keycloak.

sed -i "s|YOUR_ISSUER_URI|${ISSUER_URL}|g" clientconfig-patch.yaml
sed -i "s|YOUR_CERTIFICATE|${BASE64_CERT}|g" clientconfig-patch.yaml

Sostituisci YOUR_CLIENT_SECRET con il client secret ottenuto dalla scheda Credentials in Keycloak.

Esegui il comando seguente per configurare OIDC:

kubectl patch ClientConfig default -n kube-public --type=merge \
    --patch "$(cat clientconfig-patch.yaml)"

Attendi un minuto per la riconfigurazione dei vari componenti del sistema.
Segui le istruzioni in Configurare i ruoli di autorizzazione per configurare l'account amministratore della piattaforma iniziale.
In una finestra di navigazione in incognito, vai alla pagina https://ANTHOS_MANAGEMENT_CENTER. Si aprirà una pagina di accesso di Keycloak, in cui potrai accedere come anthos-platform-admin (dopo aver impostato una password permanente).

Elimina keycloak

Dopo aver finito di utilizzare la demo di Keycloak, elimina l'installazione di Keycloak.

kubectl delete ns keycloak

Autenticazione con SSO Google

Il servizio SSO di Google non è disponibile nella modalità privata di Anthos. Se vuoi utilizzare il servizio SSO di Google, sia il cluster sia i browser devono essere in grado di contattare i server SSO di Google. I server SSO di Google non devono essere in grado di contattare i cluster utente.

Accedi a Google Cloud Console e seleziona un progetto valido.
Accedi alla sezione "API e servizi > Schermata consenso OAuth".
Creare una nuova schermata di consenso OAuth. Queste informazioni vengono mostrate agli utenti.
1. Imposta la home page dell'applicazione sull'URL dell'amministratore.
Nella sezione API e servizi & gt; Credenziali:
1. Fai clic su Crea credenziali.
2. Crea un nuovo ID client OAuth.
3. Imposta il tipo di applicazione su Applicazione web.
4. Scegli un nome pertinente.
5. Per le origini JavaScript, imposta https://anthos.example.com (supponendo che https://anthos.example.com sia il tuo nome di dominio per il Centro di gestione).
6. Per gli URI di reindirizzamento autorizzati, imposta:
  - https://anthos.example.com/_gcp_anthos_oidc_callback
  - http://localhost:9879/callback
Copia il ClientID e il client secret nella configurazione di amministrazione UI.
Imposta l'URL del provider OIDC su https://accounts.google.com.
Imposta Username Claim su email e Scopes su openid email.
Imposta parametri aggiuntivi su prompt=consent,access_type=offline. In caso contrario, non potrai accedere con il server API di Kubernetes.
Aggiungi l'elenco iniziale di indirizzi email degli utenti (separati da virgole) per ottenere le autorizzazioni di amministratore della piattaforma.
Fai clic su Save.

SSO Google

Passaggi successivi

Configura l'identità e la sicurezza sui cluster utente.