API sécurisées utilisées pour les connecteurs d’API dans Azure AD B2C

Important

À compter du 1er mai 2025, Azure AD B2C ne sera plus disponible pour les nouveaux clients. Pour plus d’informations, consultez notre FAQ.

Lors de l’intégration d’une API REST dans un flux d’utilisateurs Azure AD B2C, vous devez protéger votre point de terminaison d’API REST avec l’authentification. L’authentification de l’API REST garantit que seuls les services disposant d’informations d’identification appropriées, tels qu’Azure AD B2C, peuvent effectuer des appels à votre point de terminaison. Cet article explique comment sécuriser une API REST.

Conditions préalables

Suivez les étapes du guide Ajouter un connecteur d’API à un flux d'inscription utilisateur.

Vous pouvez protéger votre point de terminaison d’API à l’aide de l’authentification de base HTTP ou de l’authentification par certificat client HTTPS. Dans les deux cas, vous fournissez les informations d’identification qu’Azure AD B2C utilise lorsqu’il appelle votre point de terminaison d’API. Votre point de terminaison d'API vérifie ensuite les informations d'identification et prend les décisions relatives aux autorisations.

Authentification HTTP de base

L’authentification de base HTTP est définie dans RFC 2617. L’authentification de base fonctionne comme suit :

• Azure AD B2C envoie une requête HTTP avec les informations d’identification du client (username et password) dans l’en-tête Authorization .

• Les informations d'identification sont mises en forme en tant que chaîne username:password codée en base64.

• Votre API est ensuite chargée de vérifier ces valeurs pour prendre d’autres décisions d’autorisation.

Pour configurer un connecteur d'API avec l'authentification de base HTTP, procédez comme suit :

1. Connectez-vous au portail Azure.
2. Sous Services Azure, sélectionnez Azure AD B2C ou recherchez et sélectionnez Azure AD B2C.
3. Sélectionnez Connecteurs API, puis sélectionnez le connecteur API que vous souhaitez configurer.
4. Pour le type d’authentification, sélectionnez De base.
5. Indiquez le nom d’utilisateur et le mot de passe de votre point de terminaison d’API REST.
6. Cliquez sur Enregistrer.

Ajouter un nom d’utilisateur et des clés de politique de mot de passe de l’API REST

Pour configurer un profil technique d’API REST avec l’authentification HTTP de base, créez les clés de chiffrement suivantes pour stocker le nom d’utilisateur et le mot de passe :

1. Connectez-vous au portail Azure.
2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
3. Choisissez tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
4. Dans la page Vue d’ensemble, sélectionnez Identity Experience Framework.
5. Sélectionnez Clés de stratégie, puis sélectionnez Ajouter.
6. Pour options, sélectionnez Manuel.
7. Pour Nom, tapez RestApiUsername. Le préfixe B2C_1A_ peut être ajouté automatiquement.
8. Dans la zone Secret , entrez le nom d’utilisateur de l’API REST.
9. Pour l’utilisation de la clé, sélectionnez Chiffrement.
10. Cliquez sur Créer.
11. Sélectionnez à nouveau Clés de stratégie .
12. Sélectionnez Ajouter.
13. Pour options, sélectionnez Manuel.
14. Pour Nom, tapez RestApiPassword. Le préfixe B2C_1A_ peut être ajouté automatiquement.
15. Dans la zone Secret , entrez le mot de passe de l’API REST.
16. Pour l’utilisation de la clé, sélectionnez Chiffrement.
17. Cliquez sur Créer.

Configurer votre profil technique d’API REST pour utiliser l’authentification HTTP de base

Après avoir créé les clés nécessaires, configurez les métadonnées de votre profil technique d’API REST pour référencer les informations d’identification.

1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
2. Recherchez le profil technique de l’API REST. Par exemple REST-ValidateProfile, ou REST-GetProfile.
3. Recherchez l’élément <Metadata>.
4. Remplacez AuthenticationType par Basic.
5. Remplacez AllowInsecureAuthInProduction par false.
6. Immédiatement après l’élément de fermeture </Metadata> , ajoutez l’extrait de code XML suivant :

   <CryptographicKeys>
       <Key Id="BasicAuthenticationUsername" StorageReferenceId="B2C_1A_RestApiUsername" />
       <Key Id="BasicAuthenticationPassword" StorageReferenceId="B2C_1A_RestApiPassword" />
   </CryptographicKeys>
   

L’extrait de code XML suivant est un exemple de profil technique RESTful configuré avec l’authentification HTTP de base :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">Basic</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="BasicAuthenticationUsername" StorageReferenceId="B2C_1A_RestApiUsername" />
        <Key Id="BasicAuthenticationPassword" StorageReferenceId="B2C_1A_RestApiPassword" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Authentification par certificat client HTTPS

L’authentification par certificat client est une authentification mutuelle basée sur un certificat, dans laquelle le client, Azure AD B2C, fournit son certificat client au serveur pour prouver son identité. Cela se produit dans le cadre de la négociation SSL. Votre API est chargée de valider l’appartenance des certificats à un client valide, tel qu’Azure AD B2C, et d’effectuer les décisions d’autorisation. Le certificat client est un certificat numérique X.509.

Important

Dans les environnements de production, le certificat doit être signé par une autorité de certification.

Créer un certificat

Option 1 : utiliser Azure Key Vault (recommandé)

Pour créer un certificat, vous pouvez utiliser Azure Key Vault, qui propose des options pour les certificats auto-signés et les intégrations avec les fournisseurs d’émetteurs de certificats pour les certificats signés. Paramètres recommandés :

• Objet : CN=<yourapiname>.<tenantname>.onmicrosoft.com
• Type de contenu : PKCS #12
• Type Acton à vie : Email all contacts at a given percentage lifetime ou Email all contacts a given number of days before expiry
• Type de clé : RSA
• Taille de clé : 2048
• Clé privée exportable : Yes (pour pouvoir exporter .pfx le fichier)

Vous pouvez ensuite exporter le certificat.

Option 2 : préparer un certificat auto-signé à l’aide du module PowerShell

Si vous n’avez pas encore de certificat, vous pouvez utiliser un certificat auto-signé. Un certificat auto-signé est un certificat de sécurité qui n’est pas signé par une autorité de certification et qui n’offre pas les garanties de sécurité d’un certificat signé par une autorité de certification.

Windows

Sur Windows, utilisez l’applet de commande New-SelfSignedCertificate dans PowerShell pour générer un certificat.

1. Exécutez la commande PowerShell suivante pour générer un certificat auto-signé. Modifiez l’argument -Subject comme il convient pour votre application et le nom de locataire Azure AD B2C, comme contosowebapp.contoso.onmicrosoft.com. Vous pouvez également ajuster la date de -NotAfter pour spécifier un délai d’expiration différent pour le certificat.

   New-SelfSignedCertificate `
       -KeyExportPolicy Exportable `
       -Subject "CN=yourappname.yourtenant.onmicrosoft.com" `
       -KeyAlgorithm RSA `
       -KeyLength 2048 `
       -KeyUsage DigitalSignature `
       -NotAfter (Get-Date).AddMonths(12) `
       -CertStoreLocation "Cert:\CurrentUser\My"
   

2. Sur l’ordinateur Windows, recherchez et sélectionnez Gérer les certificats utilisateur

3. Sous Certificats - Utilisateur actuel, sélectionnez Personnels>Certificats>yourappname.yourtenant.onmicrosoft.com.

4. Sélectionnez le certificat, puis Action>All Tasks>Export.

5. Sélectionnez Suivant>Oui, exportez la clé> privéeSuivant.

6. Acceptez les valeurs par défaut pour Exporter le format de fichier, puis sélectionnez Suivant.

7. Activez l’option Mot de passe , entrez un mot de passe pour le certificat, puis sélectionnez Suivant.

8. Pour spécifier un emplacement pour enregistrer votre certificat, sélectionnez Parcourir et accédez à un répertoire de votre choix.

9. Dans la fenêtre Enregistrer sous , entrez un nom de fichier, puis sélectionnez Enregistrer.

10. Sélectionnez Suivant>Terminer.

Pour qu’Azure AD B2C accepte le mot de passe du fichier .pfx, celui-ci doit être chiffré à l’aide de l’option TripleDES-SHA1 de l’utilitaire d’exportation du magasin de certificats Windows, par opposition à AES256-SHA256.

macOS

Sur macOS, utilisez l’Assistant Certificat dans Keychain Access pour générer un certificat.

1. Suivez les instructions pour créer des certificats auto-signés dans Keychain Access sur un Mac.
2. Dans l’application d’Accès au Trousseau de votre Mac, sélectionnez le certificat que vous avez créé.
3. Sélectionnez Fichier>Exporter les éléments.
4. Sélectionnez un nom de fichier pour enregistrer votre certificat. Par exemple : certificat-auto-signé.p12.
5. Pour le format de fichier, sélectionnez Échange d’informations personnelles (.p12).
6. Cliquez sur Enregistrer.
7. Entrez un mot de passe dans les zones Mot de passe et Vérification .
8. Remplacez l’extension du fichier par pfx. Par exemple : certificat-auto-signé.pfx.

Configurer votre connecteur d'API

Pour configurer un connecteur d'API avec l'authentification par certificat client, procédez comme suit :

1. Connectez-vous au portail Azure.
2. Sous Services Azure, sélectionnez Azure AD B2C.
3. Sélectionnez Connecteurs API, puis sélectionnez le connecteur API que vous souhaitez configurer.
4. Pour le type d’authentification, sélectionnez Certificat.
5. Dans la zone Charger un certificat , sélectionnez le fichier .pfx de votre certificat avec une clé privée.
6. Dans la zone Entrer le mot de passe , tapez le mot de passe du certificat.
7. Cliquez sur Enregistrer.

Prendre des décisions d’autorisation

Votre API doit implémenter l'autorisation basée sur les certificats clients envoyés afin de protéger les points de terminaison d'API. Pour Azure App Service et Azure Functions, consultez configurer l’authentification mutuelle TLS pour savoir comment activer et valider le certificat à partir de votre code API. Vous pouvez également utiliser Gestion des API Azure comme couche devant n’importe quel service d’API pour vérifier les propriétés de certificat client par rapport aux valeurs souhaitées.

Renouvellement des certificats

Il est recommandé de définir des alertes de rappel pour savoir quand votre certificat expirera. Vous devez générer un nouveau certificat et répéter les étapes ci-dessus lorsque les certificats utilisés sont sur le point d’expirer. Pour « roder » l’utilisation d’un nouveau certificat, votre service d’API peut continuer à accepter les anciens et nouveaux certificats pendant un laps de temps limité pendant le déploiement du nouveau certificat.

Pour télécharger un nouveau certificat sur un connecteur d’API existant, sélectionnez le connecteur d’API sous Connecteurs d’API et cliquez sur Télécharger un nouveau certificat. Le dernier certificat chargé, qui n’a pas expiré et dont la date de début est dépassée, sera automatiquement utilisé par Azure AD B2C.

Ajoutez une clé de stratégie de certificat client

1. Connectez-vous au portail Azure.
2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
3. Choisissez tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
4. Dans la page Vue d’ensemble, sélectionnez Identity Experience Framework.
5. Sélectionnez Clés de stratégie, puis sélectionnez Ajouter.
6. Dans la zone Options , sélectionnez Télécharger.
7. Dans la zone Nom , tapez RestApiClientCertificate. Le préfixe B2C_1A_ est ajouté automatiquement.
8. Dans la zone Téléchargement de fichier , sélectionnez le fichier .pfx de votre certificat avec une clé privée.
9. Dans la zone Mot de passe , tapez le mot de passe du certificat.
10. Cliquez sur Créer.

Configurer votre profil technique d’API REST pour utiliser l’authentification par certificat client

Après avoir créé la clé nécessaire, configurez les métadonnées de votre profil technique d’API REST pour référencer le certificat client.

1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
2. Recherchez le profil technique de l’API REST. Par exemple REST-ValidateProfile, ou REST-GetProfile.
3. Recherchez l’élément <Metadata>.
4. Remplacez AuthenticationType par ClientCertificate.
5. Remplacez AllowInsecureAuthInProduction par false.
6. Immédiatement après l’élément de fermeture </Metadata> , ajoutez l’extrait de code XML suivant :

   <CryptographicKeys>
      <Key Id="ClientCertificate" StorageReferenceId="B2C_1A_RestApiClientCertificate" />
   </CryptographicKeys>
   

L’extrait de code XML suivant est un exemple de profil technique RESTful configuré avec un certificat client HTTP :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">ClientCertificate</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="ClientCertificate" StorageReferenceId="B2C_1A_RestApiClientCertificate" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Authentification du porteur OAuth2

L’authentification par jeton du porteur est définie dans le cadre d’autorisation OAuth2.0 : Utilisation du jeton du porteur (RFC 6750). Dans l’authentification par jeton du porteur, Azure AD B2C envoie une requête HTTP avec un jeton dans l’en-tête d’autorisation.

Authorization: Bearer <token>

Un jeton de porteur est une chaîne opaque. Il peut s’agir d’un jeton d’accès JWT ou de n’importe quelle chaîne que l’API REST attend d’Azure AD B2C qu’il envoie dans l’en-tête d’autorisation. Azure AD B2C prend en charge les types suivants :

• Jeton du porteur. Pour pouvoir envoyer le jeton au porteur dans le profil technique RESTful, votre politique doit d’abord acquérir le jeton au porteur, puis l’utiliser dans le profil technique RESTful.
• Jeton du porteur statique. Utilisez cette approche lorsque votre API REST émet un jeton d’accès à long terme. Pour utiliser un jeton de porteur statique, créez une clé de stratégie et faites référence à partir du profil technique RESTful à votre clé de stratégie.

Utilisation du porteur OAuth2

Les étapes suivantes montrent comment utiliser les informations d’identification du client pour obtenir un jeton de porteur et le transmettre dans l’en-tête Authorization des appels d’API REST.

Définir une revendication pour stocker le jeton du porteur

Une revendication fournit un stockage temporaire de données lors d’une exécution de stratégie Azure AD B2C. Le schéma de revendications est l’endroit où vous déclarez vos revendications. Le jeton d’accès doit être stocké dans une revendication pour être utilisé ultérieurement.

1. Ouvrez le fichier d’extensions de votre stratégie. Par exemple : SocialAndLocalAccounts/TrustFrameworkExtensions.xml.
2. Recherchez l’élément BuildingBlocks . Si l’élément n’existe pas, ajoutez-le.
3. Recherchez l’élément ClaimsSchema . Si l’élément n’existe pas, ajoutez-le.
4. Ajoutez les revendications suivantes à l’élément ClaimsSchema .

<ClaimType Id="bearerToken">
  <DisplayName>Bearer token</DisplayName>
  <DataType>string</DataType>
</ClaimType>
<ClaimType Id="grant_type">
  <DisplayName>Grant type</DisplayName>
  <DataType>string</DataType>
</ClaimType>
<ClaimType Id="scope">
  <DisplayName>scope</DisplayName>
  <DataType>string</DataType>
</ClaimType>

Acquisition d’un jeton d’accès

Vous pouvez obtenir un jeton d'accès de plusieurs manières : à partir d'un fournisseur d'identité fédéré, en appelant une API REST qui renvoie un jeton d'accès, en utilisant un flux de processus d'identification du mot de passe propriétaire (ROPC), ou en utilisant le flux des informations d'identification du client. Le flux d’informations d’identification du client est couramment utilisé pour les interactions de serveur à serveur qui doivent s’exécuter en arrière-plan, sans interaction immédiate avec un utilisateur.

Avertissement

Microsoft vous recommande de ne pas utiliser le flux ROPC. Ce flux demande un degré de confiance très élevé dans l’application et comporte des risques qui ne sont pas présents dans d’autres flux. Utilisez ce flux uniquement lorsqu’aucun autre flux plus sécurisé n’est viable.

Acquisition d’un jeton d’accès Microsoft Entra

L’exemple suivant utilise un profil technique d’API REST pour envoyer une requête au point de terminaison de jeton Microsoft Entra à l’aide des informations d’identification du client transmises en tant qu’authentification HTTP de base. Pour plus d’informations, voir Plateforme d’identités Microsoft et flux d’informations d’identification du client OAuth 2.0.

Avant que le profil technique puisse interagir avec Microsoft Entra ID pour obtenir un jeton d’accès, vous devez inscrire une application. Azure AD B2C s’appuie sur la plateforme Microsoft Entra. Vous pouvez créer l’application dans votre locataire Azure AD B2C ou dans n’importe quel locataire Microsoft Entra que vous gérez. Pour enregistrer une demande :

1. Connectez-vous au portail Azure.
2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
3. Dans le menu de gauche, sélectionnez Microsoft Entra ID. Vous pouvez également sélectionner tous les services et rechercher et sélectionner l’ID Microsoft Entra.
4. Sélectionnez Inscriptions d'applications, puis sélectionnez Nouvelle inscription.
5. Entrez un nom pour l’application. Par exemple, Client_Credentials_Auth_app.
6. Sous Types de comptes pris en charge, sélectionnez Comptes dans cet annuaire organisationnel uniquement.
7. Sélectionnez Inscrire.
8. Enregistrez l’ID de l’application (client).

Pour un flux d’informations d’identification client, vous devez créer un secret d’application. La clé secrète client est également connue sous le nom de mot de passe d’application. Votre application utilise le secret pour acquérir un jeton d’accès.

1. Dans la page Microsoft Entra ID - Inscriptions d’applications , sélectionnez l’application que vous avez créée, par exemple Client_Credentials_Auth_app.
2. Dans le menu de gauche, sous Gérer, sélectionnez Certificats et secrets.
3. Sélectionnez Nouveau secret client.
4. Entrez une description pour la clé secrète client dans la zone Description. Par exemple, clientsecret1.
5. Sous Expire, sélectionnez une durée pendant laquelle le secret est valide, puis sélectionnez Ajouter.
6. Enregistrez la valeur du secret en prévision d’une utilisation dans le code de votre application cliente. Cette valeur secrète ne sera plus jamais affichée lorsque vous aurez quitté cette page. Vous utiliserez cette valeur comme secret d’application dans le code de votre application.

Créer des clés de stratégie Azure AD B2C

Vous devez stocker l’ID de client et la valeur de clé secrète client que vous avez enregistrée dans votre locataire Azure AD B2C.

1. Connectez-vous au portail Azure.
2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
3. Choisissez tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
4. Dans la page Vue d’ensemble, sélectionnez Identity Experience Framework.
5. Sélectionnez Clés de stratégie , puis sélectionnez Ajouter.
6. Pour options, choisissez Manual.
7. Entrez un nom pour la clé de stratégie, SecureRESTClientId. Le préfixe B2C_1A_ est ajouté automatiquement au nom de votre clé.
8. Dans Secret, entrez votre ID client que vous avez précédemment enregistré.
9. Pour l’utilisation de la clé, sélectionnez Signature.
10. Cliquez sur Créer.
11. Créez une autre clé de stratégie avec les paramètres suivants :
    • Nom : SecureRESTClientSecret.
    • Secret : entrez le secret client que vous avez précédemment enregistré

Pour ServiceUrl, remplacez your-tenant-name par le nom de votre locataire Microsoft Entra. Consultez la référence du profil technique RESTful pour connaître toutes les options disponibles.

<TechnicalProfile Id="REST-AcquireAccessToken">
  <DisplayName></DisplayName>
  <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
  <Metadata>
    <Item Key="ServiceUrl">https://login.microsoftonline.com/your-tenant-name.onmicrosoft.com/oauth2/v2.0/token</Item>
    <Item Key="AuthenticationType">Basic</Item>
     <Item Key="SendClaimsIn">Form</Item>
  </Metadata>
  <CryptographicKeys>
    <Key Id="BasicAuthenticationUsername" StorageReferenceId="B2C_1A_SecureRESTClientId" />
    <Key Id="BasicAuthenticationPassword" StorageReferenceId="B2C_1A_SecureRESTClientSecret" />
  </CryptographicKeys>
  <InputClaims>
    <InputClaim ClaimTypeReferenceId="grant_type" DefaultValue="client_credentials" AlwaysUseDefaultValue="true" />
    <InputClaim ClaimTypeReferenceId="scope" DefaultValue="https://graph.microsoft.com/.default" AlwaysUseDefaultValue="true" />
  </InputClaims>
  <OutputClaims>
    <OutputClaim ClaimTypeReferenceId="bearerToken" PartnerClaimType="access_token" />
  </OutputClaims>
  <UseTechnicalProfileForSessionManagement ReferenceId="SM-Noop" />
</TechnicalProfile>

Remarque

Si vous utilisez les revendications grant_type ou scope dans d’autres profils techniques, nous vous recommandons de spécifier également DefaultValue et d’utiliser AlwaysUseDefaultValue="true" pour éviter les conflits potentiels lors de l'association avec la valeur incorrecte.

Modifier le profil technique REST pour utiliser l’authentification par jeton de porteur

Pour prendre en charge l’authentification par jeton de porteur dans votre stratégie personnalisée, modifiez le profil technique de l’API REST à l’aide des étapes suivantes :

1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension TrustFrameworkExtensions.xml.

2. Recherchez le <TechnicalProfile> nœud qui inclut Id="REST-API-SignUp".

3. Recherchez l’élément <Metadata>.

4. Remplacez AuthenticationType par Bearer, comme suit :

   <Item Key="AuthenticationType">Bearer</Item>
   

5. Modifiez ou ajoutez le UseClaimAsBearerToken à bearerToken, comme suit. Le bearerToken est le nom de la revendication à partir de laquelle le jeton du porteur est récupéré (la revendication de sortie de REST-AcquireAccessToken).

   <Item Key="UseClaimAsBearerToken">bearerToken</Item>
   

6. Ajoutez la revendication de l’étape précédente en tant que revendication d’entrée :

   <InputClaim ClaimTypeReferenceId="bearerToken"/>
   

Une fois que vous avez mis à jour votre stratégie, votre profil technique doit ressembler au code XML suivant :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">Bearer</Item>
        <Item Key="UseClaimAsBearerToken">bearerToken</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <InputClaims>
        <InputClaim ClaimTypeReferenceId="bearerToken"/>
      </InputClaims>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Appelez le profil technique REST

Pour appeler le profil technique REST-GetProfile, vous devez d’abord acquérir un jeton d’accès Microsoft Entra en utilisant le profil technique REST-AcquireAccessToken. L’exemple suivant montre comment appeler le REST-GetProfile profil technique à partir d’un profil technique de validation :

<ValidationTechnicalProfiles>
  <ValidationTechnicalProfile ReferenceId="REST-AcquireAccessToken" />
  <ValidationTechnicalProfile ReferenceId="REST-GetProfile" />
</ValidationTechnicalProfiles>

L’exemple suivant montre comment appeler le REST-GetProfile profil technique à partir d’un parcours utilisateur ou d’un sous-parcours :

<OrchestrationSteps>
  <OrchestrationStep Order="2" Type="ClaimsExchange">
    <ClaimsExchanges>
      <ClaimsExchange Id="REST-AcquireAccessTokens" TechnicalProfileReferenceId="REST-AcquireAccessToken" />
    </ClaimsExchanges>
  </OrchestrationStep>

  <OrchestrationStep Order="3" Type="ClaimsExchange">
    <ClaimsExchanges>
      <ClaimsExchange Id="REST-GetProfile" TechnicalProfileReferenceId="REST-GetProfile" />
    </ClaimsExchanges>
  </OrchestrationStep>
</OrchestrationSteps>

Utilisation d'un jeton OAuth2 statique

Ajouter la clé de stratégie de jeton du porteur OAuth2

Pour configurer un profil technique d’API REST avec un jeton de porteur OAuth2, obtenez un jeton d’accès auprès du propriétaire de l’API REST. Créez ensuite la clé cryptographique suivante pour stocker le jeton du porteur.

1. Connectez-vous au portail Azure.
2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
3. Choisissez tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
4. Dans la page Vue d’ensemble, sélectionnez Identity Experience Framework.
5. Sélectionnez Clés de stratégie, puis sélectionnez Ajouter.
6. Pour options, choisissez Manual.
7. Entrez un nom pour la clé de stratégie. Par exemple : RestApiBearerToken. Le préfixe B2C_1A_ est ajouté automatiquement au nom de votre clé.
8. Dans Secret, entrez votre clé secrète client que vous avez enregistrée précédemment.
9. Pour l’utilisation de la clé, sélectionnez Encryption.
10. Cliquez sur Créer.

Configurer votre profil technique de l’API REST pour utiliser la clé de stratégie de jeton du porteur

Après avoir créé la clé nécessaire, configurez les métadonnées de votre profil technique d’API REST pour référencer le jeton porteur.

1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
2. Recherchez le profil technique de l’API REST. Par exemple REST-ValidateProfile, ou REST-GetProfile.
3. Recherchez l’élément <Metadata>.
4. Remplacez AuthenticationType par Bearer.
5. Remplacez AllowInsecureAuthInProduction par false.
6. Immédiatement après l’élément de fermeture </Metadata> , ajoutez l’extrait de code XML suivant :

   <CryptographicKeys>
      <Key Id="BearerAuthenticationToken" StorageReferenceId="B2C_1A_RestApiBearerToken" />
   </CryptographicKeys>
   

L’extrait de code XML suivant est un exemple de profil technique RESTful configuré avec l’authentification par jeton de porteur :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">Bearer</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="BearerAuthenticationToken" StorageReferenceId="B2C_1A_RestApiBearerToken" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Ajoutez la référence du profil technique de validation au profil technique d’inscription, qui appelle le REST-AcquireAccessToken. Ce comportement signifie qu’Azure AD B2C ne passe à la création du compte dans l’annuaire qu’après une validation réussie.

Par exemple:

```XML
<ValidationTechnicalProfiles>
   ....
   <ValidationTechnicalProfile ReferenceId="REST-AcquireAccessToken" />
   ....
</ValidationTechnicalProfiles>

Authentification par clé API

Certains services utilisent un mécanisme de « clé API » pour obfusquer l’accès à vos points de terminaison HTTP pendant le développement en obligeant l’appelant à inclure une clé unique comme un en-tête HTTP ou un paramètre de requête HTTP. Pour Azure Functions, vous pouvez effectuer cette opération en incluant code comme paramètre de requête dans l’URL du point de terminaison de votre connecteur d’API. Par exemple, https://contoso.azurewebsites.net/api/endpoint?code=0123456789).

Ce n’est pas un mécanisme qui doit être utilisé seul dans la production. Par conséquent, la configuration de l'authentification de base ou par certificat est toujours requise. Si vous ne souhaitez pas implémenter de méthode d’authentification (non recommandée) à des fins de développement, vous pouvez sélectionner l’authentification « de base » dans la configuration du connecteur d’API et utiliser des valeurs temporaires pour username et password que votre API peut ignorer pendant que vous implémentez l’autorisation appropriée.

La clé API est un identificateur unique utilisé pour authentifier un utilisateur afin qu’il puisse accéder à un point de terminaison d’API REST. La clé est envoyée dans un en-tête HTTP personnalisé. Par exemple, le déclencheur HTTP Azure Functions utilise l’en-tête x-functions-key HTTP pour identifier le demandeur.

Ajouter des clés de stratégie de clé API

Pour configurer un profil technique d’API REST avec l’authentification par clé API, créez la clé de chiffrement suivante pour stocker la clé d’API :

1. Connectez-vous au portail Azure.
2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
3. Choisissez tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
4. Dans la page Vue d’ensemble, sélectionnez Identity Experience Framework.
5. Sélectionnez Clés de stratégie, puis sélectionnez Ajouter.
6. Pour options, sélectionnez Manuel.
7. Pour Nom, tapez RestApiKey. Le préfixe B2C_1A_ peut être ajouté automatiquement.
8. Dans la zone Secret , entrez la clé API REST.
9. Pour l’utilisation de la clé, sélectionnez Chiffrement.
10. Cliquez sur Créer.

Configurer votre profil technique d’API REST pour utiliser l’authentification par clé API

Après avoir créé la clé nécessaire, configurez les métadonnées de votre profil technique d’API REST pour référencer les informations d’identification.

1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
2. Recherchez le profil technique de l’API REST. Par exemple REST-ValidateProfile, ou REST-GetProfile.
3. Recherchez l’élément <Metadata>.
4. Remplacez AuthenticationType par ApiKeyHeader.
5. Remplacez AllowInsecureAuthInProduction par false.
6. Immédiatement après l’élément de fermeture </Metadata> , ajoutez l’extrait de code XML suivant :

   <CryptographicKeys>
       <Key Id="x-functions-key" StorageReferenceId="B2C_1A_RestApiKey" />
   </CryptographicKeys>
   

L’Id de la clé cryptographique définit l’en-tête HTTP. Dans cet exemple, la clé API est envoyée sous la forme x-functions-key.

L’extrait de code XML suivant est un exemple de profil technique RESTful configuré pour appeler une fonction Azure avec l’authentification par clé API :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">ApiKeyHeader</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="x-functions-key" StorageReferenceId="B2C_1A_RestApiKey" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Contenu connexe

• Commencez avec nos échantillons.

• Pour en savoir plus sur l’élément de profil technique RESTful, consultez la référence de stratégie personnalisée.