Démonstration : S'authentifier avec Keycloak ou Google SSO

Cette page s'adresse aux administrateurs de plates-formes.

Vous pouvez essayer de vous authentifier avec Keycloak ou l'authentification unique Google (SSO) à des fins de démonstration ou de test uniquement.

S'authentifier avec Keycloak

Keycloak est un logiciel Open Source de gestion de l'authentification et des accès. Vous pouvez le configurer en tant que fournisseur OIDC pour une démonstration rapide.

Remarque : Keycloak n'est pas une fonctionnalité compatible avec Anthos en mode déconnecté. Elle n'est fournie qu'à des fins de démonstration et n'est pas recommandée pour une utilisation en production.

Avertissement : Les données de Keycloak seront supprimées à la fin d'opérations telles que les redémarrages de nœuds ou les mises à niveau système. Si la suppression des données se produit, vous perdrez l'accès au cluster si vous utilisez Keycloak en tant que fournisseur d'identité. Il est donc vivement recommandé de ne pas utiliser cette configuration de démonstration Keycloak en production, ni de l'utiliser pour tester les mises à niveau.

Avant de commencer

Pour installer et activer Keycloak, vous devez disposer d'un cluster Kubernetes avec une adresse Ingress accessible à partir du déploiement d'Anthos en mode déconnecté. Un cluster d'administrateur Anthos en mode déconnecté est utilisé comme exemple sur cette page.

Remarque : Les utilisateurs peuvent déployer l'instance Keycloak dans n'importe quel cluster Kubernetes tant que l'instance Anthos en mode déconnecté peut y accéder.

Vous devez également avoir créé un nom de domaine personnalisé pour le centre de gestion d'Anthos en mode déconnecté. Consultez la section Configurer le nom de domaine pour accéder au centre de gestion.

1. Exportez le nom de domaine du centre de gestion en tant que variable, par exemple :

   export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
   

2. Exportez un registre privé en tant que variable, par exemple :

   export PRIVATE_REGISTRY=10.200.0.2/library
   

Télécharger l'image Keycloak et la transférer vers le registre privé

1. Téléchargez l'image Keycloak depuis dockerhub :

   actl images save \
     --output keycloak-image \
     jboss/keycloak:12.0.2
   

   Remarque : keycloak:12.0.2 est la seule version que nous avons testée pour cette démonstration en tant que fournisseur OIDC pour Anthos en mode déconnecté.

2. Transférez l'image Keycloak vers le registre privé :

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

Déployer Keycloak

Mettez à jour votre configuration DNS et générez un certificat pour déployer Keycloak.

1. Créez le service Keycloak pour exposer l'adresse IP de 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. Une fois qu'une adresse IP est allouée par LoadBalancer, exportez l'adresse IP dans une variable, par exemple :

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

3. Ajoutez un "enregistrement A" à la configuration de votre domaine DNS et définissez-le sur ${KEYCLOAK_SVC_IP} :

   export KEYCLOAK_SVC=keycloak.example.com
   

4. Générez un certificat autosigné pour Keycloak à utiliser pour 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. Importez le certificat et la clé privée dans le cluster :

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

6. Exécutez la commande suivante pour déployer 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
   

Configurer l'utilisateur et le client Keycloak

Ouvrez la console Keycloak sur le poste de travail administrateur et connectez-vous avec KEYCLOAK_USER et KEYCLOAK_PASSWORD dans le fichier keycloak.yaml. Par défaut, ces valeurs sont KEYCLOAK_USER=admin et KEYCLOAK_PASSWORD=admin. Si nécessaire, acceptez le certificat autosigné dans votre navigateur. Si vous y êtes invité dans Chrome avec un avertissement concernant un certificat non approuvé, saisissez thisisunsafe dans la boîte de dialogue.

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

Créer un domaine

1. Passez la souris sur Master en haut à gauche, puis cliquez sur Add Realm (Ajouter un domaine).
2. Saisissez anthos comme nom de domaine, puis cliquez sur Créer.
3. Dans Realm settings > Tokens (Paramètres du domaine > Jetons), remplacez la valeur Access Token Lifespan (Durée de vie du jeton d'accès) par 1 Hour pour éviter que le jeton n'expire trop tôt, puis cliquez sur Save (Enregistrer).

Créer un compte utilisateur

1. Dans la barre de navigation de gauche, cliquez sur Users (Utilisateurs), puis sur Add user (Ajouter un utilisateur).
2. Configurez les paramètres suivants pour l'utilisateur, puis cliquez sur Enregistrer.
   1. Nom d'utilisateur : anthos-platform-admin
   2. Adresse e-mail : [e-mail]
   3. Utilisateur activé : ACTIVÉ
   4. Adresse e-mail validée : ACTIVÉ
3. Dans l'onglet Credentials (Identifiants), renseignez les champs Password (Mot de passe) et Password Confirmation (Confirmation du mot de passe). Cliquez sur Définir un mot de passe, puis validez lorsque vous y êtes invité.

Créer un client

1. Dans la barre de navigation de gauche, cliquez sur Clients, puis sur Créer.
2. Configurez les paramètres suivants pour le client, puis cliquez sur Enregistrer. ANTHOS_MANAGEMENT_CENTER est le nom de domaine personnalisé que vous utilisez pour le centre de gestion.
   1. ID client : anthos
   2. Protocole client : openid-connect
   3. URL racine : https://ANTHOS_MANAGEMENT_CENTER
3. Accédez à la page de gestion du client nouvellement créé.
4. Dans l'onglet Paramètres de la page de gestion du client, procédez comme suit :
   1. Définissez le type d'accès sur confidential.
   2. Ajoutez les URI suivants aux URI de redirection valides.
      • http://localhost:9879/callback
      • https://ANTHOS_MANAGEMENT_CENTER/_gcp_anthos_oidc_callback
   3. Cliquez sur Enregistrer.
5. Dans l'onglet Identifiants de la page de gestion des clients, sélectionnez ID client et secret comme authentificateur client.
6. Notez le secret quelque part.

7. (Recommandé) Configurer l'appartenance à un groupe dans Keycloak

   1. Dans la barre de navigation de gauche, cliquez sur Groupes, puis sur Nouveau.
   2. Saisissez le nom de votre groupe : anthos-platform-admin-group.
   3. Revenez à l'onglet User (Utilisateur) sur la gauche et cliquez sur View all users (Afficher tous les utilisateurs).
   4. Cliquez sur l'utilisateur que vous venez de créer (anthos-platform-admin), puis sur l'onglet Groupes.
   5. Sous Groupes disponibles, sélectionnez le groupe que vous avez créé (anthos-platform-admin-group) puis cliquez sur Rejoindre.
   6. Revenez à la page de gestion des clients anthos.
   7. Cliquez sur l'onglet Mappers, puis sur Créer :
      1. Saisissez le nom de ce mappeur : anthos-platform-admin-group-mapper.
      2. Dans la liste déroulante Type de mappeur, sélectionnez Appartenance à un groupe.
      3. Token Claim Name est la valeur d'attribut affichée dans le jeton d'authentification. La valeur par défaut dans d'Anthos en mode déconnecté est "groups". Vous pouvez donc utiliser groups dans ce champ. N'oubliez pas que vous devez modifier le champ GroupsClaim de la configuration OIDC avec cette valeur si le nom de Token Claim Name n'est pas groups.
      4. Vérifiez que l'option Chemin d'accès complet au groupe est désactivée.
      5. Assurez-vous que les options Ajouter au jeton d'identification, Ajouter au jeton d'accès et Ajouter à l'info-utilisateur sont toutes activées.
      6. Cliquez sur Enregistrer.

Activer l'authentification OIDC

Obtenez l'URL du fournisseur OIDC à utiliser dans les étapes suivantes.

1. Exécutez la commande suivante :

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

2. À l'aide du fichier tls.crt évoqué précédemment, générez le certificat encodé en 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}"
   

Approche recommandée (en utilisant la console du centre de gestion)

1. Dans la console du centre de gestion, ouvrez le menu Identité et accès.
2. Dans l'onglet Identité, cliquez sur Configurer Anthos Identity Service (OIDC).

3. Créez le profil pour Keycloak en complétant les champs suivants, puis cliquez sur Envoyer :

   1. Nom du profil : keycloak
   2. URL du fournisseur OIDC : URL de l'émetteur provenant de la section Activer l'authentification OIDC.
   3. ID client OIDC : anthos
   4. Code secret du client OIDC : code secret du client provenant de la section Créer un client
   5. Revendication du nom d'utilisateur : email
   6. Préfixe du nom d'utilisateur : keycloak-
   7. Revendication des groupes : revendication des groupes provenant de la section Configurer l'appartenance à un groupe. Si vous laissez ce champ vide, la valeur est groups.
   8. Préfixe du groupe : keycloak-
   9. Niveaux d'accès : email openid
   10. Paramètres supplémentaires : access_type=offline
   11. Données de l'autorité de certification : utilisez le certificat encodé en base64 provenant de la section Activer l'authentification OIDC.
   Remarque : Le préfixe du nom d'utilisateur et le préfixe du groupe peuvent être définis comme des valeurs différentes. N'oubliez pas d'ajouter ces préfixes lorsque vous associez des comptes à des rôles.

4. Cliquez sur Appliquer des profils aux clusters, puis sur l'onglet Admin Cluster (Cluster d'administration).

5. Pour Profils, choisissez le profil "keycloak" que vous venez de créer.

6. Dans le champ Nom de domaine, saisissez ANTHOS_MANAGEMENT_CENTER.

7. Pour Administrateur initial de la plate-forme, ajoutez toujours le préfixe utilisateur avant votre nom d'utilisateur. Par exemple, si vous ajoutez [e-mail], saisissez [e-mail].

8. Cliquez sur Envoyer et attendez que les différents composants du système soient reconfigurés.

9. Dans une fenêtre de navigation privée, accédez à l'adresse https://ANTHOS_MANAGEMENT_CENTER. Vous êtes redirigé vers une page de connexion Keycloak où vous pouvez vous connecter en tant que anthos-platform-admin (après avoir défini un mot de passe permanent).

Deuxième approche (en appliquant un fichier YAML)

1. Définissez le fournisseur d'identité pour le domaine. Si l'objet DomainConfig est déjà créé pour le domaine, appliquez un correctif à l'objet pour définir le nom de la méthode d'authentification à utiliser pour le domaine à l'aide de la commande suivante :

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

   Si DomainConfig n'est pas créé pour le domaine, créez-le avec la commande suivante :

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

2. Créez clientconfig-patch.yaml avec le contenu suivant :

   # 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
   

3. Modifiez clientconfig-patch.yaml avec les paramètres de 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. Remplacez YOUR_CLIENT_SECRET par le code secret du client obtenu à partir de l'onglet Identifiants de Keycloak.

5. Exécutez la commande suivante pour configurer OIDC :

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

6. Attendez une minute pour que les différents composants du système soient reconfigurés.

7. Suivez les instructions de la section Configurer les rôles d'autorisation pour configurer le compte administrateur d'origine de la plate-forme.

8. Dans une fenêtre de navigation privée, accédez à l'adresse https://ANTHOS_MANAGEMENT_CENTER. Vous êtes redirigé vers une page de connexion Keycloak où vous pouvez vous connecter en tant que anthos-platform-admin (après avoir défini un mot de passe permanent).

Supprimer Keycloak

Une fois que vous avez fini d'utiliser la démonstration de Keycloak, supprimez l'installation de Keycloak.

kubectl delete ns keycloak

S'authentifier avec l'authentification unique de Google

L'authentification unique de Google n'est pas disponible en mode privé d'Anthos. Si vous souhaitez utiliser l'authentification unique de Google, le cluster et les navigateurs doivent pouvoir contacter les serveurs d'authentification unique de Google. Les serveurs SSO de Google n'ont pas besoin de pouvoir contacter les clusters d'utilisateurs.

1. Connectez-vous à la console Google Cloud et sélectionnez un projet valide.
2. Accédez à la section "API et services" > Écran d'autorisation OAuth".
3. Créez un écran d'autorisation OAuth. Ces informations sont visibles par les utilisateurs.
   1. Définissez la page d'accueil de l'application sur l'URL de l'administrateur.
4. Dans la section API & Services > Credentials (API et services > Identifiants) :
   1. Cliquez sur Créer des identifiants.
   2. Créez un ID client OAuth.
   3. Définissez le type d'application sur Web Application (Application Web).
   4. Choisissez un nom pertinent.
   5. Pour les origines JavaScript, définissez https://anthos.example.com (en supposant que https://anthos.example.com est votre nom de domaine pour le Centre de gestion).
   6. Pour les URI de redirection autorisés, définissez ce qui suit :
      • https://anthos.example.com/_gcp_anthos_oidc_callback
      • http://localhost:9879/callback
5. Copiez l'ID client et le code secret du client dans la configuration AdminUI.
6. Définissez l'URL du fournisseur OIDC sur https://accounts.google.com.
7. Définissez Username Claim sur email et Scopes sur openid email.
8. Définissez des paramètres supplémentaires sur prompt=consent,access_type=offline. Dans le cas contraire, vous ne pourrez pas vous connecter avec le serveur d'API Kubernetes.
9. Ajoutez la liste initiale des adresses e-mail d'utilisateurs (en les séparant par une virgule) qui recevront les autorisations "Administrateur de la plate-forme".
10. Cliquez sur Save.

Étapes suivantes

• Configurez l'identité et la sécurité sur les clusters d'utilisateur.