Demo: Mit Keycloak oder Google SSO authentifizieren

Diese Seite richtet sich an Plattformadministratoren.

Sie können die Authentifizierung nur zu Demonstrations- oder Testzwecken mit Keycloak oder der Google-Einmalanmeldung (SSO) versuchen.

Mit Keycloak authentifizieren

Keycloak ist ein Open-Source-Software-Produkt zur Identitäts- und Zugriffsverwaltung. Sie können es als OIDC-Anbieter einrichten, um eine kurze Demo zu erhalten.

Hinweis

Zur Installation und Aktivierung von Keycloak benötigen Sie einen Kubernetes-Cluster mit einer Ingress-Adresse, auf die über das Deployment im privaten Modus von Anthos zugegriffen werden kann. Auf dieser Seite wird ein Administratorcluster für den privaten Anthos-Modus verwendet.

Außerdem müssen Sie einen benutzerdefinierten Domainnamen für Management Center im privaten Anthos-Modus erstellt haben. Weitere Informationen finden Sie unter Domainnamen für den Zugriff auf Management Center konfigurieren.

Exportieren Sie den Domainnamen von Management Center als Variable. Beispiel:
```
export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
```
Exportieren Sie eine private Registry als Variable. Beispiel:
```
export PRIVATE_REGISTRY=10.200.0.2/library
```

Keycloak-Image herunterladen und in die private Registry per Push übertragen

Laden Sie das Keycloak-Image aus dockerhub herunter:
```
actl images save \
  --output keycloak-image \
  jboss/keycloak:12.0.2
```
Hinweis: keycloak:12.0.2 ist die einzige Version, die wir für diese Demo als OIDC-Anbieter für den privaten Modus von Anthos getestet haben.

Übertragen Sie das Keycloak-Image per Push in die private Registry:

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

Keycloak bereitstellen

Aktualisieren Sie Ihre DNS-Konfiguration und generieren Sie ein Zertifikat für die Bereitstellung von Keycloak.

Erstellen Sie den Keycloak-Dienst, um die IP-Adresse für Keycloak freizugeben:

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

Nachdem eine IP-Adresse vom Load-Balancer zugewiesen wurde, exportieren Sie sie in eine Variable. Beispiel:

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

Fügen Sie der DNS-Domainkonfiguration einen A-Eintrag hinzu und legen Sie ihn auf ${KEYCLOAK_SVC_IP} fest:
```
export KEYCLOAK_SVC=keycloak.example.com
```

Generieren Sie ein selbst signiertes Zertifikat für Keycloak zur Verwendung von 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"

Laden Sie das Zertifikat und den privaten Schlüssel in den Cluster hoch:

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

Führen Sie den folgenden Befehl aus, um Keycloak bereitzustellen:

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

Keycloak-Nutzer und -Client einrichten

Öffnen Sie die Keycloak-Konsole auf der Administrator-Workstation und melden Sie sich mit KEYCLOAK_USER und KEYCLOAK_PASSWORD in der Datei keycloak.yaml an. Standardmäßig sind diese Werte KEYCLOAK_USER=admin und KEYCLOAK_PASSWORD=admin. Akzeptieren Sie gegebenenfalls das selbst signierte Zertifikat in Ihrem Browser. Wenn Sie in Chrome eine Warnung zu einem nicht vertrauenswürdigen Zertifikat erhalten, geben Sie im Dialogfeld thisisunsafe ein.

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

Bereich erstellen

Bewegen Sie links oben den Mauszeiger auf Master und klicken Sie auf Bereich hinzufügen.
Geben Sie anthos als Namen des neuen Bereichs ein und klicken Sie auf Erstellen.
Ändern Sie unter Bereichseinstellungen > Tokens die Laufzeit des Zugriffstokens in 1 Hour, um zu verhindern, dass das Token zu früh abläuft, und klicken Sie auf Speichern.

Nutzer erstellen

Klicken Sie in der linken Navigationsleiste auf Nutzer und dann auf Nutzer hinzufügen.
Konfigurieren Sie folgende Einstellungen für den Client und klicken Sie dann auf Speichern.
1. Nutzername: anthos-platform-admin
2. E-Mail: anthos-platform-admin@example.com
3. Nutzer aktiviert: EIN
4. E-Mail-Adresse bestätigt: EIN
Füllen Sie auf dem Tab Anmeldedaten die Felder Passwort und Passwortbestätigung aus. Klicken Sie auf Passwort festlegen und validieren Sie die Eingabe, wenn Sie dazu aufgefordert werden.

Client erstellen

Klicken Sie in der linken Navigationsleiste auf Clients und dann auf Erstellen.
Konfigurieren Sie folgende Einstellungen für den Client und klicken Sie dann auf Speichern. ANTHOS_MANAGEMENT_CENTER ist der benutzerdefinierte Domainname, den Sie für das Management Center verwenden.
1. Client-ID: anthos
2. Clientprotokoll: openid-connect
3. Stamm-URL: https://ANTHOS_MANAGEMENT_CENTER
Wechseln Sie zur Verwaltungsseite des neu erstellten Clients.
Führen Sie im Tab Einstellungen der Seite zur Clientverwaltung die folgenden Schritte aus:
1. Legen Sie als Zugriffstyp confidential fest.
2. Fügen Sie die folgenden URIs unter Gültige Weiterleitungs-URIs hinzu.
  - http://localhost:9879/callback
  - https://ANTHOS_MANAGEMENT_CENTER/_gcp_anthos_oidc_callback
3. Klicken Sie auf Speichern.
Wählen Sie auf der Seite „Clientverwaltung“ im Tab Anmeldedaten die Option Client-ID und Secret als Client-Authenticator aus.
Notieren Sie sich das Secret.
(Empfohlen) Gruppenmitgliedschaft in Keycloak einrichten
1. Klicken Sie in der linken Navigationsleiste auf Gruppen und dann auf Neu.
2. Geben Sie den Namen der Gruppe ein: anthos-platform-admin-group.
3. Wechseln Sie auf der linken Seite zurück zum Tab Nutzer und klicken Sie auf Alle Nutzer ansehen.
4. Klicken Sie auf den Nutzer, den Sie soeben erstellt haben (anthos-platform-admin) und dann auf den Tab Gruppen.
5. Wählen Sie unter Verfügbare Gruppen die von Ihnen erstellte Gruppe anthos-platform-admin-group aus und klicken Sie auf Beitreten.
6. Kehren Sie zur Seite Anthos-Clientverwaltung zurück.
7. Klicken Sie auf den Tab Mappers und dann auf Erstellen:
  1. Geben Sie den Namen des folgenden Mappers ein: anthos-platform-admin-group-mapper.
  2. Wählen Sie aus der Drop-down-Liste Mapper-Typ die Option Gruppenmitgliedschaft aus.
  3. Token Claim Name ist der im Authentifizierungstoken angezeigte Attributwert. Der Standardwert im privaten Modus von Anthos ist "groups". Sie können in diesem Feld groups verwenden. Denken Sie daran, dass Sie das Feld GroupsClaim der OIDC-Konfigurationen mit diesem Wert ändern müssen, wenn der Token Claim Name-Name nicht groups ist.
  4. Achten Sie darauf, dass Vollständiger Gruppenpfad deaktiviert ist.
  5. Die Optionen Zum ID-Token hinzufügen, Zum Zugriffstoken hinzufügen und Zu Nutzerinformationen hinzufügen müssen aktiviert sein.
  6. Klicken Sie auf Speichern.

OIDC-Authentifizierung aktivieren

Rufen Sie die OIDC-Anbieter-URL ab, die in den folgenden Schritten verwendet werden soll.

Führen Sie dazu diesen Befehl aus:

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

Generieren Sie mit der vorherigen Datei tls.crt das Base64-codierte Zertifikat.

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}"

Empfohlener Ansatz bei der Verwendung der Management Center Console

Öffnen Sie in der Management Center Console das Menü Identität und Zugriff.
Klicken Sie auf dem Tab Identität auf Anthos Identity Service (OIDC) einrichten.
Erstellen Sie das Profil für Keycloak. Füllen Sie dazu die folgenden Felder aus und klicken Sie dann auf Senden:
1. Profilname: keycloak
2. OIDC-Anbieter-URL: Die Aussteller-URL aus dem Abschnitt OIDC-Authentifizierung aktivieren.
3. OIDC-Client-ID: anthos
4. OIDC-Clientschlüssel: Der Clientschlüssel aus dem Abschnitt Client erstellen.
5. Nutzername-Anforderung: email
6. Nutzernamenpräfix: keycloak-
7. Gruppenanforderung: Die Gruppenanforderung aus dem Abschnitt Gruppenmitgliedschaft einrichten. Wenn Sie dieses Feld leer lassen, lautet der Wert groups.
8. Gruppenpräfix: keycloak-
9. Bereiche: email openid
10. Zusätzliche Parameter: access_type=offline
11. Daten der Zertifizierungsstelle: Verwenden Sie das base64-codierte Zertifikat aus dem Abschnitt OIDC-Authentifizierung aktivieren.
Hinweis: Nutzernamenspräfix und Gruppenpräfix können als verschiedene Werte definiert werden. Denken Sie daran, diese Präfixe hinzuzufügen, wenn Sie Konten an Rollen binden.
Klicken Sie auf Profile auf Cluster anwenden und dann auf den Tab Administratorcluster.
Wählen Sie unter Profile das Profil „keycloak“ aus, das Sie soeben erstellt haben.
Geben Sie im Feld Domainname ANTHOS_MANAGEMENT_CENTER ein.
Fügen Sie im Feld Anfänglicher Plattformadministrator immer das Nutzerpräfix vor Ihrem Nutzernamen hinzu. Wenn Sie beispielsweise anthos-platform-admin@example.com hinzufügen, geben Sie keycloak-anthos-platform-admin@example.com ein.
Klicken Sie auf Senden und warten Sie eine Minute, bis die verschiedenen Systemkomponenten neu konfiguriert wurden.
Rufen Sie in einem Inkognitofenster https://ANTHOS_MANAGEMENT_CENTER auf. Sie werden auf eine Keycloak-Anmeldeseite weitergeleitet und können sich als anthos-platform-admin anmelden, wenn Sie ein permanentes Passwort festgelegt haben.

Alternativer Ansatz: Anwendung einer YAML-Datei

Legen Sie den IDP-Anbieter für die Domain fest. Wenn DomainConfig bereits für die Domain erstellt wurde, patchen Sie das Objekt, um den Namen der Authentifizierungsmethode für die Domain mit diesem Befehl festzulegen:
```
kubectl patch domainconfig anthos.example.com --type=json -p='[{"op": "replace", "path":
"/spec/authMethodName", "value":"keycloak"}]'
```
Wenn die DomainConfig nicht für die Domain erstellt wird, erstellen Sie sie mit dem folgenden Befehl:
```
kubectl create -f - <<EOF
apiVersion: managementcenter.anthos.cloud.google.com/v1
kind: DomainConfig
metadata:
  name: anthos.example.com
spec:
  authMethodName: keycloak
EOF
```

Erstellen Sie clientconfig-patch.yaml mit folgendem Inhalt:

# 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

Bearbeiten Sie clientconfig-patch.yaml mit den Einstellungen für Keycloak.

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

Ersetzen Sie YOUR_CLIENT_SECRET durch den Clientschlüssel, der vom Tab Anmeldedaten in Keycloak abgerufen wurde.

Führen Sie folgenden Befehl aus, um OIDC zu konfigurieren:

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

Warten Sie eine Minute, bis die verschiedenen Systemkomponenten neu konfiguriert wurden.
Folgen Sie der Anleitung unter Autorisierungsrollen konfigurieren, um ein anfängliches Plattformadministratorkonto einzurichten.
Rufen Sie in einem Inkognitofenster https://ANTHOS_MANAGEMENT_CENTER auf. Sie werden auf eine Keycloak-Anmeldeseite weitergeleitet und können sich als anthos-platform-admin anmelden, wenn Sie ein permanentes Passwort festgelegt haben.

Keycloak löschen

Wenn Sie die Keycloak-Demo nicht mehr benötigen, löschen Sie die Keycloak-Installation.

kubectl delete ns keycloak

Mit Google SSO authentifizieren

Google SSO ist im privaten Anthos-Modus nicht verfügbar. Wenn Sie die Google SSO verwenden möchten, müssen der Cluster und die Browser in der Lage sein, die SSO-Server von Google zu kontaktieren. Die SSO-Server von Google müssen nicht die Nutzercluster kontaktieren können.

Melden Sie sich bei der Google Cloud Console an und wählen Sie ein gültiges Projekt aus.
Auf den Abschnitt "API & Dienste > OAuth-Zustimmungsbildschirm" zugreifen
Erstellen Sie einen neuen OAuth-Zustimmungsbildschirm. Diese Informationen werden Nutzern angezeigt.
1. Legen Sie für die Anwendungsstartseite die Administrator-URL fest.
Führen Sie im Bereich API und Dienste > Anmeldedaten Folgendes aus:
1. Klicken Sie auf Anmeldedaten erstellen.
2. Erstellen Sie eine neue OAuth-Client-ID.
3. Legen Sie für den Anwendungstyp Webanwendung fest.
4. Relevanten Namen auswählen
5. Legen Sie für die JavaScript-Quellen https://anthos.example.com fest. Dafür ist https://anthos.example.com der Domainname für das Management Center.
6. Legen Sie für die autorisierten Weiterleitungs-URIs Folgendes fest:
  - https://anthos.example.com/_gcp_anthos_oidc_callback
  - http://localhost:9879/callback
Client-ID und Client-Schlüssel in die AdminUI-Konfiguration kopieren
Legen Sie die URL des OIDC-Anbieters auf https://accounts.google.com fest.
Setzen Sie Username Claim auf email und Scopes auf openid email.
Setzen Sie die zusätzlichen Parameter auf prompt=consent,access_type=offline. Andernfalls können Sie sich nicht mit dem Kubernetes API-Server anmelden.
Fügen Sie die erste Liste der Nutzer-E-Mail-Adressen durch Kommas getrennt hinzu, um Plattformadministrator-Berechtigungen zu erhalten.
Klicken Sie auf Save.

Google-SSO

Nächste Schritte

Identität und Sicherheit in Nutzerclustern konfigurieren