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.
Exportez le nom de domaine du centre de gestion en tant que variable, par exemple :
export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
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é
Téléchargez l'image Keycloak depuis dockerhub :
actl images save \ --output keycloak-image \ jboss/keycloak:12.0.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.
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
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}')
Ajoutez un "enregistrement A" à la configuration de votre domaine DNS et définissez-le sur
${KEYCLOAK_SVC_IP}
:export KEYCLOAK_SVC=keycloak.example.com
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"
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
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
- Passez la souris sur Master en haut à gauche, puis cliquez sur Add Realm (Ajouter un domaine).
- Saisissez
anthos
comme nom de domaine, puis cliquez sur Créer. - 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
- Dans la barre de navigation de gauche, cliquez sur Users (Utilisateurs), puis sur Add user (Ajouter un utilisateur).
- Configurez les paramètres suivants pour l'utilisateur, puis cliquez sur Enregistrer.
- Nom d'utilisateur :
anthos-platform-admin
- Adresse e-mail :
anthos-platform-admin@example.com
- Utilisateur activé : ACTIVÉ
- Adresse e-mail validée : ACTIVÉ
- Nom d'utilisateur :
- 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
- Dans la barre de navigation de gauche, cliquez sur Clients, puis sur Créer.
- 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.- ID client : anthos
- Protocole client : openid-connect
- URL racine : https://
ANTHOS_MANAGEMENT_CENTER
- Accédez à la page de gestion du client nouvellement créé.
- Dans l'onglet Paramètres de la page de gestion du client, procédez comme suit :
- Définissez le type d'accès sur
confidential
. - Ajoutez les URI suivants aux URI de redirection valides.
- http://localhost:9879/callback
- https://
ANTHOS_MANAGEMENT_CENTER
/_gcp_anthos_oidc_callback
- Cliquez sur Enregistrer.
- Définissez le type d'accès sur
- Dans l'onglet Identifiants de la page de gestion des clients, sélectionnez ID client et secret comme authentificateur client.
- Notez le secret quelque part.
(Recommandé) Configurer l'appartenance à un groupe dans Keycloak
- Dans la barre de navigation de gauche, cliquez sur Groupes, puis sur Nouveau.
- Saisissez le nom de votre groupe :
anthos-platform-admin-group
. - Revenez à l'onglet User (Utilisateur) sur la gauche et cliquez sur View all users (Afficher tous les utilisateurs).
- Cliquez sur l'utilisateur que vous venez de créer (anthos-platform-admin), puis sur l'onglet Groupes.
- Sous Groupes disponibles, sélectionnez le groupe que vous avez créé (
anthos-platform-admin-group
) puis cliquez sur Rejoindre. - Revenez à la page de gestion des clients anthos.
- Cliquez sur l'onglet Mappers, puis sur Créer :
- Saisissez le nom de ce mappeur :
anthos-platform-admin-group-mapper
. - Dans la liste déroulante Type de mappeur, sélectionnez Appartenance à un groupe.
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 utilisergroups
dans ce champ. N'oubliez pas que vous devez modifier le champGroupsClaim
de la configuration OIDC avec cette valeur si le nom deToken Claim Name
n'est pasgroups
.- Vérifiez que l'option Chemin d'accès complet au groupe est désactivée.
- 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.
- Cliquez sur Enregistrer.
- Saisissez le nom de ce mappeur :
Activer l'authentification OIDC
Obtenez l'URL du fournisseur OIDC à utiliser dans les étapes suivantes.
Exécutez la commande suivante :
export ISSUER_URL=https://${KEYCLOAK_SVC}/auth/realms/anthos echo "Issuer URL: ${ISSUER_URL}"
À 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)
- Dans la console du centre de gestion, ouvrez le menu Identité et accès.
- Dans l'onglet Identité, cliquez sur Configurer Anthos Identity Service (OIDC).
Créez le profil pour Keycloak en complétant les champs suivants, puis cliquez sur Envoyer :
- Nom du profil :
keycloak
- URL du fournisseur OIDC : URL de l'émetteur provenant de la section Activer l'authentification OIDC.
- ID client OIDC :
anthos
- Code secret du client OIDC : code secret du client provenant de la section Créer un client
- Revendication du nom d'utilisateur :
email
- Préfixe du nom d'utilisateur :
keycloak-
- 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
. - Préfixe du groupe :
keycloak-
- Niveaux d'accès :
email openid
- Paramètres supplémentaires :
access_type=offline
- Données de l'autorité de certification : utilisez le certificat encodé en base64 provenant de la section Activer l'authentification OIDC.
- Nom du profil :
Cliquez sur Appliquer des profils aux clusters, puis sur l'onglet Admin Cluster (Cluster d'administration).
Pour Profils, choisissez le profil "keycloak" que vous venez de créer.
Dans le champ Nom de domaine, saisissez
ANTHOS_MANAGEMENT_CENTER
.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
, saisissezkeycloak-anthos-platform-admin@example.com
.Cliquez sur Envoyer et attendez que les différents composants du système soient reconfigurés.
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 queanthos-platform-admin
(après avoir défini un mot de passe permanent).
Deuxième approche (en appliquant un fichier YAML)
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
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
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
Remplacez
YOUR_CLIENT_SECRET
par le code secret du client obtenu à partir de l'onglet Identifiants de Keycloak.Exécutez la commande suivante pour configurer OIDC :
kubectl patch ClientConfig default -n kube-public --type=merge \ --patch "$(cat clientconfig-patch.yaml)"
Attendez une minute pour que les différents composants du système soient reconfigurés.
Suivez les instructions de la section Configurer les rôles d'autorisation pour configurer le compte administrateur d'origine de la plate-forme.
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 queanthos-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.
- Connectez-vous à la console Google Cloud et sélectionnez un projet valide.
- Accédez à la section "API et services" > Écran d'autorisation OAuth".
- Créez un écran d'autorisation OAuth. Ces informations sont visibles par les utilisateurs.
- Définissez la page d'accueil de l'application sur l'URL de l'administrateur.
- Dans la section API & Services > Credentials (API et services > Identifiants) :
- Cliquez sur Créer des identifiants.
- Créez un ID client OAuth.
- Définissez le type d'application sur Web Application (Application Web).
- Choisissez un nom pertinent.
- Pour les origines JavaScript, définissez
https://anthos.example.com
(en supposant quehttps://anthos.example.com
est votre nom de domaine pour le Centre de gestion). - Pour les URI de redirection autorisés, définissez ce qui suit :
https://anthos.example.com/_gcp_anthos_oidc_callback
http://localhost:9879/callback
- Copiez l'ID client et le code secret du client dans la configuration AdminUI.
- Définissez l'URL du fournisseur OIDC sur
https://accounts.google.com
. - Définissez
Username Claim
suremail
etScopes
suropenid email
. - 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. - 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".
- Cliquez sur
Save
.