Partage via

Utiliser Azure Active Directory B2C pour accorder l’accès au service FHIR

  • Article

Les organisations de santé peuvent utiliser Azure Active Directory B2C (Azure AD B2C) avec le service FHIR® dans Services de données de santé Azure pour accorder l’accès à leurs applications et utilisateurs.

Créer un locataire Azure AD B2C pour le service FHIR

La création d’un locataire Azure AD B2C pour le service FHIR configure une infrastructure sécurisée pour la gestion des identités utilisateur dans vos applications de santé.

Si vous avez déjà créé un locataire Azure AD B2C, vous pouvez passer à Déployer le service FHIR avec Azure AD B2C.

Déployer un locataire Azure AD B2C à l’aide d’un modèle ARM

Utilisez PowerShell ou Azure CLI pour déployer le modèle ARM par programmation sur un abonnement Azure. Pour plus d’informations sur la syntaxe, les propriétés et l’utilisation du modèle, consultez Déployer une instance d’Azure Active Directory B2C.

Exécutez le code dans Azure Cloud Shell ou PowerShell localement dans Visual Studio Code pour déployer le service FHIR sur le locataire Azure AD B2C.

  1. Utilisez Connect-AzAccount pour vous connecter à Azure. Une fois connecté, utilisez Get-AzContext pour vérifier l’abonnement et le locataire que vous souhaitez utiliser. Changez l’abonnement et le locataire si nécessaire.

  2. Créez un groupe de ressources (ou utilisez-en un existant) en ignorant l’étape « Créer un groupe de ressources » ou en commentant la ligne commençant par New-AzResourceGroup.

### variables
$tenantid="your tenant id"
$subscriptionid="your subscription id"
$resourcegroupname="your resource group name"
$b2cName="your b2c tenant name"

### login to azure
Connect-AzAccount -Tenant $tenantid -SubscriptionId $subscriptionid 

### create resource group
New-AzResourceGroup -Name $resourcegroupname -Location $region

### deploy the resource
New-AzResourceGroupDeployment -ResourceGroupName $resourcegroupname -TemplateUri https://raw.githubusercontent.com/Azure-Samples/azure-health-data-and-ai-samples/main/samples/fhir-aad-b2c/b2c-arm-template.json -b2cName $b2cNa

Ajouter un utilisateur de test B2C au locataire Azure AD B2C

Vous avez besoin d’un utilisateur de test B2C à associer à une ressource de patient spécifique dans le service FHIR, et afin de vérifier que le flux d’authentification fonctionne comme prévu.

  1. Dans le portail Azure, accédez à la ressource B2C. Choisissez Ouvrir le locataire B2C.

    Capture d’écran présentant une ressource B2C.

  2. Dans le volet gauche, choisissez Utilisateurs.

    Capture d’écran présentant l’utilisateur d’accueil.

  3. Choisissez + Nouvel utilisateur.

    Capture d’écran présentant l’ajout d’un nouvel utilisateur.

L’attribut utilisateur personnalisé fhirUser est utilisé pour lier un utilisateur B2C à une ressource utilisateur dans le service FHIR. Dans cet exemple, un utilisateur nommé Test Patient1 est créé dans le locataire B2C. Dans une étape ultérieure, une ressource patient est créée dans le service FHIR. L’utilisateur Test Patient1 est lié à la ressource patient en définissant la valeur d’attribut fhirUser sur l’identificateur de ressource du patient. Pour plus d’informations sur les attributs utilisateur personnalisés, consultez Attributs personnalisés de flux d’utilisateur dans Azure Active Directory B2C.

  1. Dans la page Azure AD B2C dans le volet gauche, choisissez Attributs utilisateur.

  2. Choisissez + Ajouter.

  3. Dans le champ Nom, entrez fhirUser (en respectant la casse).

  4. Dans la liste déroulante Type de données, sélectionnez Chaîne.

  5. Cliquez sur Créer.

    Capture d’écran présentant l’attribut B2C.

Créer un flux d’utilisateur B2C

Les flux d’utilisateur définissent la séquence d’étapes que les utilisateurs doivent suivre pour se connecter. Dans cet exemple, un flux utilisateur est défini lorsqu’un utilisateur se connecte et le jeton d’accès fourni inclut la revendication fhirUser. Pour plus d’informations, consultez Créer des flux d’utilisateurs et des stratégies personnalisées dans Azure Active Directory B2C.

  1. Dans la page Azure AD B2C dans le volet gauche, choisissez Flux d’utilisateurs.

  2. Choisissez + Nouveau flux d’utilisateur.

    Capture d’écran présentant le flux utilisateur B2C.

  3. Donnez au flux d’utilisateur un nom unique au locataire B2C. Le nom n’a pas besoin d’être globalement unique. Dans cet exemple, le nom du flux d’utilisateur est USER_FLOW_1. Prenez note du nom.

  4. Vérifiez que l’option Connexion par e-mail est activée pour les comptes locaux afin, que l’utilisateur de test puisse se connecter et obtenir un jeton d’accès pour le service FHIR.

    Capture d’écran présentant la configuration du flux utilisateur B2C.

  5. Dans la page Créer un flux d’utilisateur, faites défiler jusqu’à la section 5. Revendications d’application, puis sélectionnez Afficher plus pour afficher la liste de toutes les revendications disponibles.

  6. Sélectionnez la revendication fhirUser.

  7. Choisissez Ok.

  8. Cliquez sur Créer.

    Capture d’écran présentant la configuration du flux utilisateur B2C avec la revendication utilisateur FHIR.

Créer une ressource d’application B2C

La ressource d’application B2C gère les requêtes d’authentification de votre application de santé vers Azure Active Directory B2C.

  1. Dans la page Azure AD B2C dans le volet gauche, choisissez Inscriptions d’applications.

  2. Choisissez + Nouvelle inscription.

    Capture d’écran présentant la nouvelle application B2C.

  3. Saisir un nom complet. Cet exemple utilise Service FHIR.

  4. Dans la liste Types de comptes pris en charge, choisissez Comptes dans un fournisseur d’identité ou annuaire organisationnel (pour authentifier les utilisateurs avec des flux d’utilisateurs).

  5. Dans la liste déroulante URI de redirection (recommandé), sélectionnez Client public/natif (mobile & bureau). Renseignez la valeur avec l’URI de rappel Postman https://oauth.pstmn.io/v1/callback. Cet URI de rappel est à des fins de test.

  6. Dans la section Autorisations, sélectionnez Accorder le consentement administrateur aux autorisations openid et offline_access.

  7. Choisissez Inscrire. Attendez que l’inscription de l’application se termine. Le navigateur accède automatiquement à la page Vue d’ensemble de l’application.

    Capture d’écran présentant le registre de l’application B2C.

Configurer des autorisations d’API pour l’application

  1. Dans la page Inscriptions d’applications dans le volet gauche, choisissez Manifeste.

  2. Faites défiler jusqu’à ce que vous trouviez le tableau oauth2Permissions. Remplacez le tableau par une ou plusieurs valeurs dans le fichier oauth2Permissions.json. Copiez l’ensemble du tableau ou des autorisations spécifiques.

    Si vous ajoutez une autorisation à la liste, n’importe quel utilisateur du locataire B2C peut obtenir un jeton d’accès avec l’autorisation d’API. Si un niveau d’accès n’est pas approprié pour un utilisateur du locataire B2C, ne l’ajoutez pas au tableau parce qu’il n’existe aucun moyen de limiter les autorisations à une partie des utilisateurs.

  3. Une fois le tableau oauth2Permissions rempli, choisissez Enregistrer.

    Capture d’écran présentant le manifeste de l’application B2C.

Exposer l’API web et affecter un URI d’ID d’application

  1. Dans la page Inscriptions d’applications dans le volet gauche, choisissez Exposer une API.

  2. Choisissez Ajouter.

  3. Par défaut, le champ URI d’ID d’application est renseigné avec l’ID d’application (client). Modifiez la valeur si vous le souhaitez. Dans cet exemple, la valeur est fhir.

  4. Choisissez Enregistrer.

    Capture d’écran présentant l’API de l’application B2C.

  5. Dans la page Inscriptions d’applications dans le volet gauche, choisissez API autorisées.

  6. Choisissez + Ajouter une autorisation.

    Capture d’écran présentant l’autorisation de l’API B2C.

  7. Dans le volet Demander des autorisations d’API, sélectionnez API utilisées par mon organisation.

  8. Sélectionnez la ressource d’application dans la liste.

    Capture d’écran présentant les autorisations d’API B2C avec les API utilisées.

  9. Dans le volet Demander des autorisations d’API, dans la section Patient, sélectionnez au moins une autorisation. Dans cet exemple, l’autorisation patient.all.read est sélectionnée, ce qui signifie qu’un utilisateur qui demande un jeton d’accès avec l’étendue patient.all.read dispose de privilèges de lecture (patient.all.read) pour toutes les ressources FHIR (patient.all.read) dans le compartiment Patient (patient.all.read). Pour plus d’informations, consultez Compartment Patient.

  10. Choisissez Ajouter des autorisations.

    Capture d’écran présentant les autorisations d’API B2C avec des autorisations ajoutées.

  11. Dans la page API autorisées, dans la section Autorisations configurées, choisissez Accorder un consentement d’administrateur.

    Capture d’écran présentant les autorisations d’API B2C pour le consentement administrateur.

Déployer le service FHIR avec Azure Active Directory B2C en tant que fournisseur d’identité

Le déploiement du service FHIR avec Azure Active Directory B2C en tant que fournisseur d’identité permet au service FHIR d’authentifier les utilisateurs en fonction de leurs informations d’identification Azure AD B2C, ce qui garantit que seuls les utilisateurs autorisés peuvent accéder aux informations sensibles sur les patients

Obtenir l’autorité B2C et l’ID client

Utilisez les paramètres autorité et ID client (ou ID d’application) pour configurer le service FHIR de façon à utiliser un locataire Azure AD B2C en tant que fournisseur d’identité.

  1. Créez la chaîne d’autorité en utilisant le nom du locataire B2C et le nom du flux d’utilisateur.

    https://<YOUR_B2C_TENANT_NAME>.b2clogin.com/<YOUR_B2C_TENANT_NAME>.onmicrosoft.com/<YOUR_USER_FLOW_NAME>/v2.0

  2. Testez la chaîne d’autorité en effectuant une requête au point de terminaison .well-known/openid-configuration. Entrez la chaîne dans un navigateur pour confirmer qu’elle mène au fichier JSON de configuration OpenId. Si le chargement du fichier JSON de configuration OpenId échoue, vérifiez que le nom du locataire B2C et le nom du flux d’utilisateur sont corrects.

    https://<YOUR_B2C_TENANT_NAME>.b2clogin.com/<YOUR_B2C_TENANT_NAME>.onmicrosoft.com/<YOUR_USER_FLOW_NAME>/v2.0/.well-known/openid-configuration

  3. Récupérez l’ID client à partir de la page de vue d’ensemble de la ressource d’application.

    Capture d’écran présentant la page de présentation de l’application B2C.

Déployer le service FHIR à l’aide d’un modèle ARM

Utilisez un modèle ARM pour simplifier le déploiement du service FHIR. Utilisez PowerShell ou Azure CLI pour déployer le modèle ARM sur un abonnement Azure.

Exécutez le code dans Azure Cloud Shell ou PowerShell localement dans Visual Studio Code pour déployer le service FHIR sur le locataire Azure AD B2C.

  1. Utilisez Connect-AzAccount pour vous connecter à Azure. Utilisez Get-AzContext pour vérifier l’abonnement et le locataire que vous souhaitez utiliser. Changez l’abonnement et le locataire si nécessaire.

  2. Créez un groupe de ressources (ou utilisez-en un existant) en ignorant l’étape « Créer un groupe de ressources » ou en commentant la ligne commençant par New-AzResourceGroup.

### variables
$tenantid="your tenant id"
$subscriptionid="your subscription id"
$resourcegroupname="your resource group name"
$region="your desired region"
$workspacename="your workspace name"
$fhirServiceName="your fhir service name"
$smartAuthorityUrl="your authority (from previous step)"
$smartClientId="your client id (from previous step)"

### login to azure
Connect-AzAccount 
#Connect-AzAccount SubscriptionId $subscriptionid
Set-AzContext -Subscription $subscriptionid
Connect-AzAccount -Tenant $tenantid -SubscriptionId $subscriptionid
#Get-AzContext 

### create resource group
New-AzResourceGroup -Name $resourcegroupname -Location $region

### deploy the resource
New-AzResourceGroupDeployment -ResourceGroupName $resourcegroupname -TemplateUri https://raw.githubusercontent.com/Azure-Samples/azure-health-data-and-ai-samples/main/samples/fhir-aad-b2c/fhir-service-arm-template.json -tenantid $tenantid -region $region -workspaceName $workspacename -fhirServiceName $fhirservicename -smartAuthorityUrl $smartAuthorityUrl -smartClientId $smartClientId

Vérifier que les utilisateurs Azure AD B2C sont en mesure d’accéder aux ressources FHIR

Le processus de validation implique la création d’une ressource patient dans le service FHIR, la liaison de la ressource patient à l’utilisateur Azure AD B2C, et la configuration de Postman afin d’obtenir un jeton d’accès pour les utilisateurs B2C. Une fois le processus de validation terminé, vous pouvez récupérer la ressource patient à l’aide de l’utilisateur de test B2C.

Exécuter Postman pour obtenir un jeton d’accès

Exécutez l’application Postman localement ou dans un navigateur web. Pour connaître les étapes d’obtention de l’accès approprié au service FHIR, consultez Accéder au service FHIR à l’aide de Postman.

Lorsque vous suivez les étapes de la section Obtenir la ressource FHIR, la requête retourne une réponse vide parce que le service FHIR est nouveau et n’a aucune ressource patient.

Créer une ressource patient dans le service FHIR

Il est important de noter que les utilisateurs du locataire B2C ne peuvent lire aucune ressource tant que l’utilisateur (tel que le patient ou le praticien) est lié à une ressource FHIR. Un utilisateur disposant du rôle FhirDataWriter ou FhirDataContributor dans Microsoft Entra ID où le service FHIR est locataire doit effectuer cette étape.

  1. Créez un patient avec un identificateur spécifique en remplaçant la méthode par PUT et en exécutant une requête à {{fhirurl}}/Patient/1 avec ce corps :
{
    "resourceType": "Patient",
    "id": "1",
    "name": [
        {
            "family": "Patient1",
            "given": [
                "Test"
            ]
        }
    ]
}
  1. Vérifiez que le patient est créé en remplaçant de nouveau la méthode par GET et en vérifiant qu’une requête à {{fhirurl}}/Patient retourne le nouveau patient.

Créez un lien explicite entre l’utilisateur test du locataire B2C et la ressource du service FHIR. Créez le lien à l’aide d’attributs d’extension dans Microsoft Graph. Pour plus d’informations, consultez Définir des attributs personnalisés dans Azure Active Directory B2C.

  1. Accédez au locataire B2C. Dans le volet gauche, sélectionnez Inscriptions d’applications.

  2. Sélectionnez Toutes les applications.

  3. Sélectionnez l’application avec le préfixe b2c-extensions-app.

    Capture d’écran présentant la liste des applications B2C.

  4. Notez la valeur ID d’application (client).

    Capture d’écran présentant l’application extensions B2C.

  5. Revenez à la page d’accueil du locataire B2C et, dans le volet gauche, sélectionnez Utilisateurs.

    Capture d’écran présentant l’utilisateur d’accueil B2C.

  6. Sélectionnez Test Patient1.

    Capture d’écran présentant la liste des utilisateurs B2C.

  7. Notez la valeur ID de l’objet.

    Capture d’écran présentant l’identifiant utilisateur B2C.

  8. Ouvrez l’afficheur Microsoft Graph. Connectez-vous avec un utilisateur disposant du rôle Administrateur général pour le locataire B2C. (Il est judicieux de créer un utilisateur administrateur dans le locataire B2C pour gérer les utilisateurs dans le locataire.)

    Capture d’écran présentant la connexion Graph.

  9. Sélectionnez l’avatar de l’utilisateur, puis choisissez Consentement aux autorisations.

    Capture d’écran présentant le consentement Graph pour l’utilisateur de test.

  10. Faites défiler jusqu’à Utilisateur. Consentez à User.ReadWrite.All. Cette autorisation vous permet de mettre à jour l’utilisateur Test Patient1 avec la valeur de revendication fhirUser.

    Capture d’écran présentant le consentement Graph pour la revendication fhirUser.

  11. Une fois le processus de consentement terminé, mettez à jour l’utilisateur. Vous avez besoin de l’ID d’application (client) b2c-extensions-app et de l’ID de l’objet utilisateur.

    • Remplacez la méthode par PATCH.

    • Changez l’URL en https://graph.microsoft.com/v1.0/users/{USER_OBJECT_ID}.

    • Créez le corps PATCH. Un corps PATCH est une paire clé-valeur unique, où le format de clé est extension_{B2C_EXTENSION_APP_ID_NO_HYPHENS}_fhirUser et la valeur est l’ID de ressource FHIR complet pour le patient https://{YOUR_FHIR_SERVICE}.azurehealthcareapis.com/Patient/1".

    Pour plus d’informations, consultez Gérer les attributs d’extension via Microsoft Graph.

  12. Une fois la requête mise en forme, choisissez Exécuter la requête. Attendez une réponse de réussite qui confirme que l’utilisateur dans le locataire B2C est lié à la ressource patient dans le service FHIR.

    Capture d’écran présentant le patch Graph.

Configurer Postman de façon à obtenir un jeton d’accès pour les utilisateurs B2C

Obtenez un jeton d’accès pour tester le flux d’authentification.

  1. Lancez l’application Postman, puis créez une collection vide. Dans cet exemple, la collection se nomme FHIR Patient.

    Capture d’écran présentant la nouvelle collection Postman.

  2. Sélectionnez l’onglet Autorisation dans la vue d’ensemble de la collection.

  3. Dans la liste déroulante Type, sélectionnez OAuth 2.0.

    Capture d’écran présentant l’authentification Postman.

  4. Faites défiler jusqu’à la section Configurer un nouveau jeton et entrez les valeurs suivantes.

    • URL de rappel. Cette valeur est configurée lorsque la ressource d’application B2C est créée.

      https://oauth.pstmn.io/v1/callback

    • URL d’authentification. Cette valeur peut être créée à l’aide du nom du locataire B2C et du nom du flux d’utilisateur.

      https://{YOUR_B2C_TENANT_NAME}.b2clogin.com/{YOUR_B2C_TENANT_NAME}.onmicrosoft.com/{YOUR_USER_FLOW_NAME}/oauth2/v2.0/authorize

    • URL du jeton d’accès. Cette valeur peut être créée à l’aide du nom du locataire B2C et du nom du flux d’utilisateur.

      https://{YOUR_B2C_TENANT_NAME}.b2clogin.com/{YOUR_B2C_TENANT_NAME}.onmicrosoft.com/{YOUR_USER_FLOW_NAME}/oauth2/v2.0/token

    • ID client. Cette valeur est l’ID d’application (client) de la ressource d’application B2C.

      {YOUR_APPLICATION_ID}

    • Portée. Cette valeur est définie dans la ressource d’application B2C dans la section Exposer une API. L’autorisation délimitée accordée est patient.all.read. La requête d’étendue doit être une URL complète, par exemple https://testb2c.onmicrosoft.com/fhir/patient.all.read.

  5. Copiez l’étendue complète à partir de la section Exposer une API de la ressource d’application B2C.

    {YOUR_APPLICATION_ID_URI}/patient.all.read

    Capture d’écran présentant les URL de Postman.

Récupérer la ressource patient à l’aide de l’utilisateur B2C

Vérifiez que les utilisateurs Azure AD B2C peuvent accéder aux ressources FHIR.

  1. Lorsque la configuration d’autorisation dans Postman est effectuée de façon à lancer le flux d’utilisateur B2C, choisissez Obtenir un nouveau jeton d’accès pour obtenir un jeton d’accès.

    Capture d'écran présentant l'obtention du jeton d'accès par Postman.

  2. Utilisez les informations d’identification du patient de test pour vous connecter.

    Capture d'écran présentant l'obtention d'un jeton par Postman.

  3. Choisissez Utiliser le jeton afin d’utiliser le jeton d’accès pour toutes les requêtes dans la collection.

    Capture d’écran présentant le jeton d’utilisation de Postman.

  4. Créez une requête pour effectuer une recherche dans les ressources de patients dans le service FHIR. Sélectionnez le bouton de sélection (...) en regard du nom de la collection, puis choisissez Ajouter une requête.

    Capture d’écran présentant la requête Postman ajoutée.

  5. Définissez la méthode sur GET, entrez l’URL complète du service FHIR, puis ajoutez le chemin d’accès /Patient.

  6. Choisissez Envoyer.

  7. Vérifiez que la réponse contient la ressource patient unique.

    Capture d’écran présentant la réponse de la requête Postman.

Étapes suivantes

Configurer plusieurs fournisseurs d’identité

Résoudre les problèmes de configuration des fournisseurs d’identité

Remarque

FHIR® est une marque déposée de HL7 utilisé avec l’autorisation de HL7.