Partager via

Activer l’authentification dans votre propre API web à l’aide d’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.

Pour autoriser l’accès à une API web, vous ne pouvez servir que les requêtes qui incluent un jeton d’accès valide délivré par Azure Active Directory B2C (Azure AD B2C). Cet article vous montre comment activer l’autorisation Azure AD B2C sur votre API web. Une fois que vous avez effectué les étapes décrites dans cet article, seuls les utilisateurs qui obtiennent un jeton d’accès valide sont autorisés à appeler vos points de terminaison d’API web.

Conditions préalables

Avant de commencer, lisez l’un des articles suivants, qui expliquent comment configurer l’authentification pour les applications qui appellent des API web. Suivez ensuite les étapes décrites dans cet article pour remplacer l’exemple d’API web par votre propre API web.

Aperçu

L’authentification par jeton garantit que les requêtes adressées à une API web incluent un jeton d’accès valide.

L’application effectue les étapes suivantes :

  1. Il authentifie les utilisateurs avec Azure AD B2C.

  2. Elle obtient un jeton d’accès doté des autorisations requises (étendues) pour le point de terminaison de l’API web.

  3. Il transmet le jeton d’accès en tant que jeton du porteur dans l’en-tête d’authentification de la requête HTTP à l’aide de ce format :

    Authorization: Bearer <access token>

L’API web effectue les étapes suivantes :

  1. Elle lit le jeton du porteur à partir de l’en-tête d’authentification dans la requête HTTP.

  2. Il valide le jeton.

  3. Elle valide les autorisations (étendues) dans le jeton.

  4. Il lit les revendications encodées dans le jeton (facultatif).

  5. Elle répond à la requête HTTP.

Vue d’ensemble de l’inscription de l’application

Pour permettre à votre application de se connecter avec Azure AD B2C et d’appeler une API web, vous devez inscrire deux applications dans le répertoire Azure AD B2C.

  • L’inscription d’application web, mobile ou SPA permet à votre application de se connecter avec Azure AD B2C. Le processus d’inscription d’application génère un ID d’application, également appelé ID client, qui identifie de manière unique votre application (par exemple, ID d’application : 1).

  • L’enregistrement de l’API Web permet à votre application d’appeler une API Web protégée. L’inscription expose les autorisations de l’API web (étendues). Le processus d’inscription d’application génère un ID d’application, qui identifie de manière unique votre API web (par exemple, ID d’application : 2). Accordez à votre application (ID d’application : 1) des autorisations sur les étendues de l’API web (ID d’application : 2).

Les inscriptions d’applications et l’architecture d’application sont décrites dans le diagramme suivant :

Diagramme des inscriptions d’applications et de l’architecture d’application pour une application avec l’API web.

Préparer votre environnement de développement

Dans les sections suivantes, vous créez un projet d’API web. Sélectionnez votre langage de programmation, ASP.NET Core ou Node.js. Vérifiez que vous disposez d’un ordinateur exécutant l’un des logiciels suivants :

Étape 1 : Créer une API web protégée

Créez un projet d’API web. Tout d’abord, sélectionnez le langage de programmation que vous souhaitez utiliser, ASP.NET Core ou Node.js.

Utilisez la commande dotnet new. La dotnet new commande crée un dossier nommé TodoList avec les ressources du projet d’API web. Ouvrez le répertoire, puis ouvrez Visual Studio Code.

dotnet new webapi -o TodoList
cd TodoList
code .

Lorsque vous êtes invité à « ajouter des ressources requises au projet », sélectionnez Oui.

Étape 2 : Installer les dépendances

Ajoutez la bibliothèque d’authentification à votre projet d’API web. La bibliothèque d’authentification analyse l’en-tête d’authentification HTTP, valide le jeton et extrait les revendications. Pour plus d’informations, consultez la documentation de la bibliothèque.

Pour ajouter la bibliothèque d’authentification, installez le package en exécutant la commande suivante :

dotnet add package Microsoft.Identity.Web

Étape 3 : Lancer la bibliothèque d’authentification

Ajoutez le code nécessaire pour lancer la bibliothèque d’authentification.

Ouvrez Startup.cs puis, au début de la classe, ajoutez les déclarations suivantes using :

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Identity.Web;

Recherchez la fonction ConfigureServices(IServiceCollection services). Ensuite, avant la services.AddControllers(); ligne de code, ajoutez l’extrait de code suivant :

public void ConfigureServices(IServiceCollection services)
{
    // Adds Microsoft Identity platform (Azure AD B2C) support to protect this Api
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddMicrosoftIdentityWebApi(options =>
    {
        Configuration.Bind("AzureAdB2C", options);

        options.TokenValidationParameters.NameClaimType = "name";
    },
    options => { Configuration.Bind("AzureAdB2C", options); });
    // End of the Microsoft Identity platform block    

    services.AddControllers();
}

Recherchez la fonction Configure. Ensuite, immédiatement après la app.UseRouting(); ligne de code, ajoutez l’extrait de code suivant :

app.UseAuthentication();

Après la modification, votre code doit ressembler à l’extrait de code suivant :

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();

    app.UseRouting();
    
    // Add the following line 
    app.UseAuthentication();
    // End of the block you add
    
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Étape 4 : Ajouter les points de terminaison

Ajoutez deux points de terminaison à votre API web :

  • Point de terminaison /public anonyme. Ce point de terminaison retourne la date et l’heure actuelles. Utilisez-le pour déboguer votre API web avec des appels anonymes.
  • Point de terminaison /hello protégé. il retourne la valeur de la revendication name dans le jeton d’accès.

Pour ajouter le point de terminaison anonyme :

Sous le dossier /Controllers , ajoutez un fichier PublicController.cs , puis ajoutez-le à l’extrait de code suivant :

using System;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

namespace TodoList.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class PublicController : ControllerBase
    {
        private readonly ILogger<PublicController> _logger;

        public PublicController(ILogger<PublicController> logger)
        {
            _logger = logger;
        }

        [HttpGet]
        public ActionResult Get()
        {
            return Ok( new {date = DateTime.UtcNow.ToString()});
        }
    }
}

Pour ajouter le point de terminaison protégé :

Sous le dossier /Controllers , ajoutez un fichier HelloController.cs , puis ajoutez-le au code suivant :

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Identity.Web.Resource;

namespace TodoList.Controllers
{
    [Authorize]
    [RequiredScope("tasks.read")]
    [ApiController]
    [Route("[controller]")]
    public class HelloController : ControllerBase
    {

        private readonly ILogger<HelloController> _logger;
        private readonly IHttpContextAccessor _contextAccessor;

        public HelloController(ILogger<HelloController> logger, IHttpContextAccessor contextAccessor)
        {
            _logger = logger;
            _contextAccessor = contextAccessor;
        }

        [HttpGet]
        public ActionResult Get()
        {
            return Ok( new { name = User.Identity.Name});
        }
    }
}

Le HelloController contrôleur est pourvu de l'attribut AuthorizeAttribute, qui limite l’accès aux utilisateurs authentifiés.

Le contrôleur est également décoré avec le [RequiredScope("tasks.read")]. RequiredScopeAttribute vérifie que l’API web est appelée avec les étendues appropriées. tasks.read

Étape 5 : Configurer le serveur web

Dans un environnement de développement, définissez l’API web pour écouter le numéro de port des requêtes HTTP ou HTTPS entrantes. Dans cet exemple, utilisez le port HTTP 6000 et le port HTTPS 6001. L’URI de base de l’API web sera http://localhost:6000 pour HTTP et https://localhost:6001 https.

Ajoutez l’extrait de code JSON suivant au fichier appsettings.json .

"Kestrel": {
    "EndPoints": {
      "Http": {
        "Url": "http://localhost:6000"
      },
      "Https": {
         "Url": "https://localhost:6001"   
        }
    }
  }

Étape 6 : Configurer l’API web

Ajoutez des configurations à un fichier de configuration. Le fichier contient des informations sur votre fournisseur d’identité Azure AD B2C. L'application API web utilise ces informations pour valider le jeton d'accès que l'application web transmet comme jeton porteur.

Sous le dossier racine du projet, ouvrez le fichier appsettings.json , puis ajoutez les paramètres suivants :

{
  "AzureAdB2C": {
    "Instance": "https://contoso.b2clogin.com",
    "Domain": "contoso.onmicrosoft.com",
    "ClientId": "<web-api-app-application-id>",
    "SignedOutCallbackPath": "/signout/<your-sign-up-in-policy>",
    "SignUpSignInPolicyId": "<your-sign-up-in-policy>"
  },
  // More settings here
}

Dans le fichier appsettings.json , mettez à jour les propriétés suivantes :

Section Clé Valeur
AzureAdB2C Cas Première partie de votre nom de client Azure AD B2C (par exemple, https://contoso.b2clogin.com).
AzureAdB2C Domaine Le nom du locataire complet de votre locataire Azure AD B2C (par exemple contoso.onmicrosoft.com).
AzureAdB2C ClientId ID d’application de l’API web. Dans le diagramme précédent, il s’agit de l’application avec l’ID d’application : 2. Pour savoir comment obtenir votre ID d’inscription d’application d’API web, consultez Conditions préalables.
AzureAdB2C SignUpSignInPolicyId Les parcours utilisateur ou une stratégie personnalisée. Pour savoir comment obtenir votre flux d’utilisateur ou votre stratégie, consultez Conditions préalables.

Étape 7 : Exécuter et tester l’API web

Enfin, exécutez l’API web avec vos paramètres d’environnement Azure AD B2C.

Dans l’interpréteur de commandes, démarrez l’application web en exécutant la commande suivante :

 dotnet run

Vous devez voir la sortie suivante, ce qui signifie que votre application est opérationnelle et prête à recevoir des demandes.

Now listening on: http://localhost:6000

Pour arrêter le programme, dans l’interpréteur de commandes, sélectionnez Ctrl+C. Vous pouvez réexécuter l’application à l’aide de la node app.js commande.

Conseil / Astuce

Vous pouvez également utiliser le dotnet run pour exécuter la commande. Le débogueur intégré de Visual Studio Code permet d’accélérer votre boucle de modification, de compilation et de débogage.

Ouvrez un navigateur et accédez à http://localhost:6000/public. Dans la fenêtre du navigateur, vous devez voir le texte suivant affiché, ainsi que la date et l’heure actuelles.

Étape 8 : Appeler l’API web à partir de votre application

Essayez d’appeler le point de terminaison d’API web protégé sans jeton d’accès. Ouvrez un navigateur et accédez à http://localhost:6000/hello. L’API retourne un message d’erreur HTTP non autorisé, confirmant que l’API web est protégée par un jeton du porteur.

Continuez à configurer votre application pour appeler l’API web. Pour obtenir des conseils, consultez la section Conditions préalables .

Regardez cette vidéo pour en savoir plus sur certaines bonnes pratiques quand vous intégrez Azure AD B2C à une API.

Contenu connexe

Obtenez l’exemple complet dans GitHub :