Authentifier les utilisateurs avec Cloud Identity-Aware Proxy pour Python

Vous pouvez éviter de gérer l'authentification des utilisateurs et les sessions pour les applications qui s'exécutent sur des plates-formes gérées par Google Cloud, telles qu'App Engine, en contrôlant les accès à l'aide d'Identity-Aware Proxy (IAP). IAP permet non seulement de contrôler l'accès à l'application, mais fournit également des informations sur les utilisateurs authentifiés, comme l'adresse e-mail et un identifiant persistant sous forme de nouveaux en-têtes HTTP.

Objectifs

Obliger les utilisateurs de votre application App Engine à s'authentifier à l'aide de IAP
Accéder aux identités des utilisateurs dans l'application pour afficher l'adresse e-mail authentifiée de l'utilisateur actuel

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Contexte

Dans ce tutoriel, les utilisateurs sont authentifiés à l'aide d'IAP. Il ne s'agit là que d'une approche parmi d'autres. Pour en savoir plus sur les différentes méthodes d'authentification des utilisateurs, consultez la section Concepts d'authentification.

Application Hello `user-email-address`

L'application utilisée dans le cadre de ce tutoriel est une application Hello World App Engine minimale, comprenant une fonctionnalité inhabituelle : elle affiche non pas "Hello World", mais "Hello user-email-address", où user-email-address est l'adresse e-mail de l'utilisateur authentifié.

L'application examine pour cela les informations authentifiées qu'IAP ajoute à chaque requête Web transmise. Trois nouveaux en-têtes de requête sont ajoutés à chaque requête Web atteignant l'application. Les deux premiers en-têtes sont des chaînes de texte brut qui permettent d'identifier l'utilisateur. Le troisième en-tête est un objet avec signature cryptographique qui contient les mêmes informations.

X-Goog-Authenticated-User-Email : l'adresse e-mail permettant d'identifier un utilisateur. Évitez de stocker des informations personnelles. Cette application ne stocke aucune donnée : elle ne fait que renvoyer les données à l'utilisateur.
X-Goog-Authenticated-User-Id : cet ID utilisateur attribué par Google ne fournit aucune information sur l'utilisateur, mais permet à une application de savoir si un utilisateur connecté est déjà apparu auparavant.
X-Goog-Iap-Jwt-Assertion : vous pouvez configurer des applications Google Cloud afin qu'elles acceptent des requêtes Web provenant d'autres applications cloud en plus des requêtes Web Internet, contournant ainsi IAP. Dans ce cas, il est possible que les en-têtes de ces requêtes soient falsifiés. Plutôt que d'utiliser l'un des en-têtes en texte brut précédemment mentionnés, vous pouvez employer et valider cet en-tête avec signature cryptographique afin de confirmer que les informations ont bien été fournies par Google. L'adresse e-mail de l'utilisateur et un ID utilisateur persistant sont disponibles dans cet en-tête signé.

Si vous êtes certain que l'application est configurée pour ne recevoir que des requêtes Web Internet et si personne ne peut désactiver le service IAP pour l'application, vous récupérez l'ID utilisateur unique à l'aide d'une simple ligne de code :

user_id = request.headers.get('X-Goog-Authenticated-User-ID')

Toutefois, une application résiliente doit pouvoir faire face à diverses complications, telles que des problèmes de configuration ou d'environnement inattendus. Nous vous recommandons donc de créer une fonction qui utilise et valide l'en-tête avec signature cryptographique. La signature de l'en-tête ne peut pas être falsifiée et, une fois validé, celui-ci peut être utilisé pour renvoyer l'identification.

Créer le code source

Utilisez un éditeur de texte pour créer un fichier nommé main.py et collez-y le code suivant :

authentication-users/main.py

Afficher sur GitHub

import sys

from flask import Flask
app = Flask(__name__)

CERTS = None
AUDIENCE = None

def certs():
    """Returns a dictionary of current Google public key certificates for
    validating Google-signed JWTs. Since these change rarely, the result
    is cached on first request for faster subsequent responses.
    """
    import requests

    global CERTS
    if CERTS is None:
        response = requests.get(
            'https://www.gstatic.com/iap/verify/public_key'
        )
        CERTS = response.json()
    return CERTS

def get_metadata(item_name):
    """Returns a string with the project metadata value for the item_name.
    See https://cloud.google.com/compute/docs/storing-retrieving-metadata for
    possible item_name values.
    """
    import requests

    endpoint = 'http://metadata.google.internal'
    path = '/computeMetadata/v1/project/'
    path += item_name
    response = requests.get(
        '{}{}'.format(endpoint, path),
        headers={'Metadata-Flavor': 'Google'}
    )
    metadata = response.text
    return metadata

def audience():
    """Returns the audience value (the JWT 'aud' property) for the current
    running instance. Since this involves a metadata lookup, the result is
    cached when first requested for faster future responses.
    """
    global AUDIENCE
    if AUDIENCE is None:
        project_number = get_metadata('numeric-project-id')
        project_id = get_metadata('project-id')
        AUDIENCE = '/projects/{}/apps/{}'.format(
            project_number, project_id
        )
    return AUDIENCE

def validate_assertion(assertion):
    """Checks that the JWT assertion is valid (properly signed, for the
    correct audience) and if so, returns strings for the requesting user's
    email and a persistent user ID. If not valid, returns None for each field.
    """
    from jose import jwt

    try:
        info = jwt.decode(
            assertion,
            certs(),
            algorithms=['ES256'],
            audience=audience()
            )
        return info['email'], info['sub']
    except Exception as e:
        print('Failed to validate assertion: {}'.format(e), file=sys.stderr)
        return None, None

@app.route('/', methods=['GET'])
def say_hello():
    from flask import request

    assertion = request.headers.get('X-Goog-IAP-JWT-Assertion')
    email, id = validate_assertion(assertion)
    page = "<h1>Hello {}</h1>".format(email)
    return page

Le fichier main.py est expliqué en détail dans la section Comprendre le code de ce tutoriel.

Créez un autre fichier nommé requirements.txt et collez-y le code suivant :

authentication-users/requirements.txt

Afficher sur GitHub
```
Flask==2.1.2
cryptography==37.0.2
python-jose[cryptography]==3.3.0
requests==2.27.1
```
Le fichier requirements.txt répertorie toutes les bibliothèques Python non standards qu'App Engine doit charger pour votre application :
- Flask est le framework Web Python utilisé pour l'application.
- cryptography est un module qui fournit des fonctions de chiffrement performantes.
- python-jose[cryptography] fournit la fonction de vérification et de décodage JWT.
- requests récupère les données des sites Web.
Créez un fichier nommé app.yaml et collez-y le code suivant :

authentication-users/app.yaml

Afficher sur GitHub
```
runtime: python37
```
Le fichier app.yaml indique à App Engine l'environnement de langage requis par votre code.

Comprendre le code

Cette section explique le fonctionnement du code présent dans le fichier main.py. Si vous souhaitez simplement exécuter l'application, vous pouvez passer directement à la section Déployer l'application.

Le code ci-dessous se trouve dans le fichier main.py. Lorsqu'une requête HTTP GET est reçue par l'application sur la page d'accueil, le framework Flask appelle la fonction say_hello :

authentication-users/main.py

Afficher sur GitHub

@app.route('/', methods=['GET'])
def say_hello():
    from flask import request

    assertion = request.headers.get('X-Goog-IAP-JWT-Assertion')
    email, id = validate_assertion(assertion)
    page = "<h1>Hello {}</h1>".format(email)
    return page

La fonction say_hello obtient la valeur de l'en-tête d'assertion JWT qu'IAP ajoute à la requête entrante, puis appelle une fonction pour valider cette valeur avec signature cryptographique. La première valeur renvoyée (adresse e-mail) est ensuite utilisée dans une page Web minimale, créée et renvoyée par la fonction.

authentication-users/main.py

Afficher sur GitHub

def validate_assertion(assertion):
    """Checks that the JWT assertion is valid (properly signed, for the
    correct audience) and if so, returns strings for the requesting user's
    email and a persistent user ID. If not valid, returns None for each field.
    """
    from jose import jwt

    try:
        info = jwt.decode(
            assertion,
            certs(),
            algorithms=['ES256'],
            audience=audience()
            )
        return info['email'], info['sub']
    except Exception as e:
        print('Failed to validate assertion: {}'.format(e), file=sys.stderr)
        return None, None

La fonction validate_assertion utilise la fonction jwt.decode de la bibliothèque tierce jose pour confirmer que l'assertion est correctement signée et extraire les informations de charge utile de l'assertion. Ces informations correspondent à l'adresse e-mail de l'utilisateur authentifié et à un ID unique persistant pour l'utilisateur. Si l'assertion ne peut pas être décodée, la fonction renvoie None pour chacune de ces valeurs et affiche un message pour consigner l'erreur.

Une assertion JWT ne peut être validée que si les certificats de clés publiques de l'entité qui a signé l'assertion (dans le cas présent, Google) et l'audience à laquelle l'assertion est destinée sont connus. Pour une application App Engine, l'audience est une chaîne contenant des informations d'identification de projet Google Cloud. La fonction récupère ces certificats et la chaîne d'audience à partir des fonctions qui la précèdent.

authentication-users/main.py

Afficher sur GitHub

def audience():
    """Returns the audience value (the JWT 'aud' property) for the current
    running instance. Since this involves a metadata lookup, the result is
    cached when first requested for faster future responses.
    """
    global AUDIENCE
    if AUDIENCE is None:
        project_number = get_metadata('numeric-project-id')
        project_id = get_metadata('project-id')
        AUDIENCE = '/projects/{}/apps/{}'.format(
            project_number, project_id
        )
    return AUDIENCE

Vous pouvez rechercher l'identifiant numérique et le nom du projet Google Cloud pour les ajouter manuellement dans le code source, mais la fonction audience le fait pour vous en interrogeant le service de métadonnées standard disponible pour chaque application App Engine. Étant donné que le service de métadonnées est externe au code de l'application, ce résultat est enregistré dans une variable globale renvoyée sans avoir à examiner les métadonnées lors des appels suivants.

authentication-users/main.py

Afficher sur GitHub

def get_metadata(item_name):
    """Returns a string with the project metadata value for the item_name.
    See https://cloud.google.com/compute/docs/storing-retrieving-metadata for
    possible item_name values.
    """
    import requests

    endpoint = 'http://metadata.google.internal'
    path = '/computeMetadata/v1/project/'
    path += item_name
    response = requests.get(
        '{}{}'.format(endpoint, path),
        headers={'Metadata-Flavor': 'Google'}
    )
    metadata = response.text
    return metadata

Le service de métadonnées App Engine (et les services de métadonnées semblables des autres services Google Cloud) ressemble à un site Web et est interrogé par des requêtes Web standards. Il ne s'agit toutefois pas d'un site externe, mais d'une fonctionnalité interne qui renvoie les informations demandées sur l'application en cours d'exécution. Vous pouvez donc utiliser des requêtes http en toute sécurité plutôt que des requêtes https. Le service de métadonnées permet d'obtenir les identifiants Google Cloud actuels nécessaires à la définition de l'audience visée par l'assertion JWT.

authentication-users/main.py

Afficher sur GitHub

def certs():
    """Returns a dictionary of current Google public key certificates for
    validating Google-signed JWTs. Since these change rarely, the result
    is cached on first request for faster subsequent responses.
    """
    import requests

    global CERTS
    if CERTS is None:
        response = requests.get(
            'https://www.gstatic.com/iap/verify/public_key'
        )
        CERTS = response.json()
    return CERTS

La validation d'une signature numérique nécessite le certificat de clé publique du signataire. Google fournit un site Web qui renvoie l'ensemble des certificats de clés publiques actuellement utilisés. Ces résultats sont mis en cache au cas où vous en auriez encore besoin dans la même instance d'application.

Déployer l'application

Vous pouvez à présent déployer l'application, puis activer IAP pour exiger que les utilisateurs s'authentifient avant qu'ils puissent accéder à l'application.

Dans votre fenêtre de terminal, accédez au répertoire contenant le fichier app.yaml, puis déployez l'application dans App Engine :
```
gcloud app deploy
```
Lorsque vous y êtes invité, sélectionnez une région proche de votre emplacement géographique.
Lorsqu'un message vous demandant si vous souhaitez poursuivre l'opération de déploiement s'affiche, saisissez Y.

Votre application devient disponible sur Internet au bout de quelques minutes.
Affichez l'application :
```
gcloud app browse
```
Dans le résultat, copiez web-site-url, l'adresse Web de l'application.
Dans une fenêtre de navigateur, collez web-site-url pour ouvrir l'application.

Aucune adresse e-mail n'est affichée, car vous n'utilisez pas encore IAP. Par conséquent, aucune information utilisateur n'est envoyée à l'application.

Activer IAP

Maintenant que vous disposez d'une instance App Engine, vous pouvez la protéger à l'aide d'IAP :

Dans Google Cloud Console, accédez à la page Identity-Aware Proxy.

Accéder à la page "Identity-Aware Proxy"
Comme c'est la première fois que vous activez une option d'authentification pour ce projet, un message vous indique que vous devez configurer votre écran d'autorisation OAuth pour pouvoir utiliser IAP.

Cliquez sur Configurer l'écran d'autorisation.
Dans l'onglet Écran d'autorisation OAuth de la page Identifiants, renseignez les champs suivants :
- Si votre compte se trouve dans une organisation Google Workspace, sélectionnez Externe, puis cliquez sur Créer. Pour commencer, l'application ne sera disponible que pour les utilisateurs que vous autorisez explicitement.
- Dans le champ Nom de l'application, saisissez IAP Example.
- Dans le champ Adresse e-mail d'assistance, saisissez votre adresse e-mail.
- Dans le champ Domaine autorisé, saisissez la partie nom d'hôte de l'URL de l'application. Par exemple, iap-example-999999.uc.r.appspot.com. Après avoir saisi le nom d'hôte, appuyez sur la touche Enter.
- Dans le champ Lien vers la page d'accueil de l'application , saisissez l'URL de votre application. Par exemple, https://iap-example-999999.uc.r.appspot.com/.
- Dans le champ Lien vers les règles de confidentialité de l'application, utilisez la même URL que le lien vers la page d'accueil à des fins de test.
Cliquez sur Enregistrer. Lorsque vous êtes invité à créer des identifiants, vous pouvez fermer la fenêtre.
Dans Cloud Console accédez à la page Identity-Aware Proxy.

Accéder à la page "Identity-Aware Proxy"
Pour actualiser la page, cliquez sur Actualiser . La page affiche la liste de ressources que vous pouvez protéger.
Dans la colonne IAP, cliquez pour activer IAP pour l'application.
Dans votre navigateur, accédez de nouveau à web-site-url.
Au lieu de la page Web, un écran de connexion s'affiche pour vous authentifier. Lorsque vous vous connectez, l'accès est refusé, car IAP ne dispose d'aucune liste d'utilisateurs autorisés à accéder à l'application.

Ajouter des utilisateurs autorisés à l'application

Dans Cloud Console, accédez à la page Identity-Aware Proxy.

Accéder à la page "Identity-Aware Proxy"
Cochez la case correspondant à l'application App Engine, puis cliquez sur Ajouter un compte principal.
Saisissez allAuthenticatedUsers, puis sélectionnez le rôle Utilisateur de l'application Web sécurisée par Cloud IAP/IAP.
Cliquez sur Enregistrer.

Les utilisateurs que Google peut authentifier ont désormais accès à l'application. Si vous le souhaitez, vous pouvez restreindre davantage l'accès en n'ajoutant qu'un ou que quelques autres utilisateurs ou groupes en tant que comptes principaux :

Toute adresse e-mail Gmail ou Google Workspace
Une adresse e-mail de groupe Google
Un nom de domaine Google Workspace

Accéder à l'application

Dans votre navigateur, accédez à web-site-url.
Pour actualiser la page, cliquez sur Actualiser.
Sur l'écran de connexion, connectez-vous avec vos identifiants Google.

La page "Hello user-email-address" s'affiche et indique votre adresse e-mail.

Si vous voyez la même page que précédemment, il est possible que le navigateur ne mette pas complètement à jour les nouvelles requêtes maintenant que vous avez activé IAP. Fermez toutes les fenêtres du navigateur, rouvrez-les, puis réessayez.

Concepts d'authentification

Une application peut authentifier ses utilisateurs et limiter l'accès aux utilisateurs autorisés de plusieurs façons. Les sections suivantes répertorient les méthodes courantes d'authentification, de la plus complexe à la plus simple du point de vue de l'application.

Option	Avantages	Inconvénients
Authentification par l'application	L'application peut s'exécuter sur n'importe quelle plate-forme, avec ou sans connexion Internet Les utilisateurs n'ont pas besoin d'utiliser un autre service pour gérer l'authentification	L'application doit gérer les identifiants de l'utilisateur de manière sécurisée et éviter toute divulgation L'application doit conserver les données de session des utilisateurs connectés L'appli doit proposer l'inscription des utilisateurs, les modifications de mot de passe, et la récupération des mots de passe
OAuth2	L'application peut s'exécuter sur n'importe quelle plate-forme connectée à Internet, y compris un poste de travail de développeur L'appli n'a pas besoin d'enregistrer d'utilisateurs, de modifier de mot de passe ni de fonctions de récupération de mot de passe. La gestion des risques de divulgation des informations utilisateur est déléguée à un autre service Nouvelles mesures de sécurité de connexion gérées en dehors de l'application	Les utilisateurs doivent s'inscrire auprès du service de gestion des identités L'application doit conserver les données de session des utilisateurs connectés
IAP	L'application n'a pas besoin de code pour gérer les utilisateurs, l'authentification ni l'état des sessions L'application ne contient pas d'identifiants utilisateur pouvant être compromis	L'application ne peut s'exécuter que sur les plates-formes compatibles avec le service. Plus précisément, certains services Google Cloud compatibles avec IAP, tels qu'App Engine.

Authentification gérée par l'application

Avec cette méthode, l'application gère tous les aspects de l'authentification des utilisateurs. L'application doit tenir à jour la base de données de ses propres comptes utilisateur et gérer les sessions utilisateur. Elle doit également fournir des fonctionnalités permettant de gérer les comptes utilisateur et mots de passe, de vérifier les identifiants utilisateur, ainsi que d'émettre, de vérifier et de mettre à jour des sessions utilisateur à chaque connexion authentifiée. Le schéma suivant illustre la méthode d'authentification gérée par l'application.

Schéma de principe de l'authentification gérée par l'application

Comme le montre le diagramme, une fois que l'utilisateur s'est connecté, l'application crée et conserve des informations sur la session de l'utilisateur. Lorsque l'utilisateur envoie une requête à l'application, celle-ci doit inclure les informations de session que l'application est chargée de vérifier.

Le principal avantage de cette approche est qu'elle est autonome et placée sous le contrôle de l'application. L'application n'a même pas besoin d'être disponible sur Internet. Le principal inconvénient est que l'application doit fournir toutes les fonctionnalités de gestion des comptes et protéger toutes les données d'identification sensibles.

Authentification externe OAuth2

Plutôt que de tout gérer au sein de l'application, une bonne alternative consiste à utiliser un service d'identité externe, comme Google, qui gère toutes les fonctionnalités et informations liées aux comptes utilisateur, et protège les identifiants sensibles. Lorsqu'un utilisateur tente de se connecter à l'application, la requête est redirigée vers le service de gestion des identités, qui authentifie l'utilisateur, puis renvoie la requête à l'application avec les informations d'authentification nécessaires. Pour en savoir plus, consultez la section S'authentifier en tant qu'utilisateur final.

Le schéma suivant illustre l'authentification externe avec la méthode OAuth2.

Schéma de principe de l'authentification OAuth 2.0

Dans ce schéma, le processus commence lorsque l'utilisateur envoie une requête d'accès à l'application. Au lieu de répondre directement, l'application redirige l'utilisateur vers la plate-forme d'identité de Google, qui affiche une page permettant de se connecter à Google. Une fois connecté, l'utilisateur est redirigé vers l'application. Cette requête inclut des informations permettant à l'application d'obtenir des données sur l'utilisateur désormais authentifié. L'application répond ensuite à l'utilisateur.

Cette méthode présente de nombreux avantages pour l'application. Elle permet de déléguer l'ensemble des fonctionnalités et des risques liés à la gestion des comptes au service externe, renforçant ainsi la sécurité des comptes et des connexions sans exiger de modifications au niveau de l'application. Toutefois, comme décrit dans le schéma précédent, l'application doit avoir accès à Internet pour employer cette méthode. Elle est également responsable de la gestion des sessions une fois l'utilisateur authentifié.

Cloud IAP

La troisième approche, qui est l'objet de ce tutoriel, consiste à gérer l'authentification et la gestion des sessions à l'aide d'IAP, sans avoir à modifier l'application. IAP intercepte toutes les requêtes Web envoyées à l'application, bloque celles qui n'ont pas été authentifiées et laisse passer les autres en y incluant les données d'identité de l'utilisateur.

Le traitement des requêtes est décrit dans le schéma suivant :

Schéma de principe de l'authentification Cloud IAP

IAP intercepte les requêtes envoyées par les utilisateurs et bloque les requêtes non authentifiées. Les requêtes authentifiées sont transmises à l'application, à condition que l'utilisateur authentifié figure dans la liste des utilisateurs autorisés. Les requêtes transmises par IAP incluent des en-têtes qui identifient l'utilisateur à l'origine de la requête.

L'application n'a plus besoin de gérer les données de session ni les informations des comptes utilisateur. Les opérations nécessitant un identifiant unique pour l'utilisateur peuvent l'obtenir directement à partir de chaque requête Web entrante. Toutefois, cette fonctionnalité ne peut être utilisée que pour les services compatibles avec IAP, tels qu'App Engine et les équilibreurs de charge. Vous ne pouvez pas employer IAP sur un ordinateur de développement local.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et les ressources individuelles.

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Authentifier les utilisateurs avec Cloud Identity-Aware Proxy pour Python

Objectifs

Coûts

Avant de commencer

Contexte

Application Hello user-email-address

Créer le code source

Comprendre le code

Déployer l'application

Activer IAP

Ajouter des utilisateurs autorisés à l'application

Accéder à l'application

Concepts d'authentification

Authentification gérée par l'application

Authentification externe OAuth2

Cloud IAP

Effectuer un nettoyage

Application Hello `user-email-address`