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.

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.

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
    
  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 : anthos-platform-admin@example.com
    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.
    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}"
    
  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.
  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 anthos-platform-admin@example.com, saisissez keycloak-anthos-platform-admin@example.com.

  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.

SSO Google

Étapes suivantes