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 deployment in modalità privata di Anthos. In questa pagina viene utilizzato un cluster di amministrazione in modalità privata di Anthos come esempio.

Inoltre, devi aver creato un nome di dominio personalizzato per il Centro di gestione in modalità privata di Anthos. Vedi Configurare il nome di dominio per accedere al Centro di gestione.

  1. Esporta il nome del dominio del Centro di gestione come variabile, ad esempio:

    export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
    
  2. 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

  1. Scarica l'immagine Keycloak da dockerhub:

    actl images save \
      --output keycloak-image \
      jboss/keycloak:12.0.2
    
  2. 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.

  1. 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
    
  2. 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}')
    
  3. Aggiungi un "record A" alla configurazione del dominio DNS e impostalo su ${KEYCLOAK_SVC_IP}:

    export KEYCLOAK_SVC=keycloak.example.com
    
  4. 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"
    
  5. Carica il certificato e la chiave privata nel cluster:

    kubectl create secret tls tls-config -n keycloak --cert=tls.crt \
        --key=tls.key
    
  6. 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

  1. Passa il mouse sopra Master in alto a sinistra e fai clic su Aggiungi realm.
  2. Inserisci anthos come nome del nuovo regno e fai clic su Crea.
  3. 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

  1. Nella barra di navigazione a sinistra, fai clic su Utenti e poi su Aggiungi utente.
  2. 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
  3. Nella scheda Credentials, compila i campi Password e Conferma password. Fai clic su Imposta password e convalida quando richiesto.

Creazione di un client

  1. Nella barra di navigazione a sinistra, fai clic su Clienti e poi su Crea.
  2. 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
  3. Vai alla pagina di gestione del client appena creato.
  4. 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.
  5. Nella scheda Credentials della pagina di gestione dei client, seleziona Client ID e Secret come Client Authenticator.
  6. Notare il segreto da qualche parte.
    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 modalità privata di Anthos è "gruppi", 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.

  1. Esegui questo comando:

    export ISSUER_URL=https://${KEYCLOAK_SVC}/auth/realms/anthos
    echo "Issuer URL: ${ISSUER_URL}"
    
  2. 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}"
    
  1. In Console Centro gestione, apri il menu Identità e accesso.
  2. Nella scheda Identity, fai clic su Configura Anthos Identity Service (OIDC)
  3. 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.
  4. Fai clic su Applica profili ai cluster e fai clic sulla scheda Cluster di amministrazione.

  5. Per Profili, scegli il profilo "keycloak" appena creato.

  6. In Nome di dominio, inserisci ANTHOS_MANAGEMENT_CENTER.

  7. 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.

  8. Fai clic su Invia e attendi un minuto per la riconfigurazione dei vari componenti di sistema.

  9. 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

  1. 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
    
  2. 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 private 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
    
  3. 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
    
  4. Sostituisci YOUR_CLIENT_SECRET con il client secret ottenuto dalla scheda Credentials in Keycloak.

  5. Esegui il comando seguente per configurare OIDC:

    kubectl patch ClientConfig default -n kube-public --type=merge \
        --patch "$(cat clientconfig-patch.yaml)"
    
  6. Attendi un minuto per la riconfigurazione dei vari componenti del sistema.

  7. Segui le istruzioni in Configurare i ruoli di autorizzazione per configurare l'account amministratore della piattaforma iniziale.

  8. 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.

  1. Accedi a Google Cloud Console e seleziona un progetto valido.
  2. Accedi alla sezione "API e servizi > Schermata consenso OAuth".
  3. Creare una nuova schermata di consenso OAuth. Queste informazioni vengono mostrate agli utenti.
    1. Imposta la home page dell'applicazione sull'URL dell'amministratore.
  4. 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
  5. Copia il ClientID e il client secret nella configurazione di amministrazione UI.
  6. Imposta l'URL del provider OIDC su https://accounts.google.com.
  7. Imposta Username Claim su email e Scopes su openid email.
  8. Imposta parametri aggiuntivi su prompt=consent,access_type=offline. In caso contrario, non potrai accedere con il server API di Kubernetes.
  9. Aggiungi l'elenco iniziale di indirizzi email degli utenti (separati da virgole) per ottenere le autorizzazioni di amministratore della piattaforma.
  10. Fai clic su Save.

SSO Google

Passaggi successivi