Créer une extension d’authentification personnalisée pour le démarrage et l’envoi d’événements de collecte d’attributs

S’applique à : Locataires externes (en savoir plus)

Cet article explique comment étendre l’expérience d’inscription de l’utilisateur dans l’ID externe Microsoft Entra pour les clients. Dans les flux d’utilisateurs d’inscription du client, les écouteurs d’événements peuvent être utilisés pour étendre le processus de collection d’attributs avant celle-ci et au moment de l’envoi d’attributs :

• L’événement OnAttributeCollectionStart se produit au début de l’étape de collection d’attributs, avant le rendu de la page de collection d’attributs. Vous pouvez ajouter des actions telles que Préremplir des valeurs et Afficher une erreur bloquante.
• L’événement OnAttributeCollectionSubmit se produit une fois que l’utilisateur entre et envoie des attributs. Vous pouvez ajouter des actions telles que la validation ou la modification des entrées de l’utilisateur.

Outre la création d’une extension d’authentification personnalisée pour le démarrage et l’envoi d’événements de collection d’attributs, vous devez créer une API REST qui définit les actions de flux de travail à entreprendre pour chaque événement. Vous pouvez utiliser n’importe quel langage de programmation, infrastructure et environnement d’hébergement pour créer et héberger votre API REST. Cet article illustre un moyen rapide de commencer à utiliser une fonction Azure C#. Azure Functions vous permet d’exécuter votre code dans un environnement serverless, sans avoir à créer une machine virtuelle ou à publier une application web au préalable.

Prérequis

• Pour utiliser les services Azure, y Azure Functions, vous avez besoin d’un abonnement Azure. Si vous n’avez pas de compte Azure existant, vous pouvez vous inscrire à une version d’évaluation gratuite ou utiliser vos avantages d’abonnement Visual Studio lorsque vous créez un compte.
• Flux d’utilisateur d’inscription et de connexion.

Étape 1 : Créer une API REST d’extensions d’authentification personnalisées (application de fonction Azure)

Dans cette étape, vous créez une API de fonction de déclencheur HTTP à l’aide d’Azure Functions. L’API de fonction est la source de la logique métier pour vos flux d’utilisateurs. Après avoir créé votre fonction de déclencheur, vous pouvez la configurer pour un des événements suivants :

• AuDébutDeCollectionD'Attributs
• OnAttributeCollectionSubmit

1. Connectez-vous au portail Azure avec votre compte d’administrateur.

2. Dans le menu du portail Azure ou dans la page d’accueil , sélectionnez Créer une ressource.

3. Recherchez et sélectionnez Application de fonction , puis sélectionnez Créer.

4. Dans la page Informations de base , utilisez les paramètres de l’application de fonction comme spécifié dans le tableau suivant :

   Paramètre	Valeur suggérée	Descriptif
   Abonnement	Votre abonnement	Abonnement dans lequel la nouvelle application de fonction sera créée.
   Groupe de ressources	myResourceGroup	Sélectionnez le groupe de ressources existant ou le nom du nouveau dans lequel vous allez créer votre application de fonction.
   Nom de l’application de fonction	Nom globalement unique	Nom qui identifie la nouvelle application de fonction. Les caractères valides sont a-z (insensible à la casse), 0-9et -.
   Publier	Code	Option permettant de publier des fichiers de code ou un conteneur Docker. Pour ce tutoriel, sélectionnez Code.
   Pile d’exécution	.FILET	Votre langage de programmation préféré. Pour ce tutoriel, sélectionnez .NET.
   Version	6 (LTS) in-process	Version du runtime .NET. In-process signifie que vous pouvez créer et modifier des fonctions dans le portail, ce qui est recommandé pour ce guide
   Région	Région recommandée	Sélectionnez une région proche de vous ou près d’autres services auxquels vos fonctions peuvent accéder.
   Système d’exploitation	Fenêtres	Le système d’exploitation est présélectionné pour vous en fonction de la pile d’exécution que vous avez sélectionnée.
   Type de plan	Consommation (serverless)	Plan d’hébergement qui définit la façon dont les ressources sont allouées à votre Function App.

5. Sélectionnez Vérifier + créer pour passer en revue les sélections de configuration d’application, puis sélectionnez Créer. Le déploiement prend quelques minutes.

6. Une fois déployé, sélectionnez Accéder à la ressource pour afficher votre nouvelle application de fonction.

1.1 Créer des fonctions de déclencheur HTTP

Maintenant que vous avez créé l’application de fonction Azure, vous créez des fonctions de déclencheur HTTP pour les actions que vous souhaitez appeler avec une requête HTTP. Ces déclencheurs HTTP sont référencés et appelés par votre extension d’authentification personnalisée Microsoft Entra.

1. Dans la page Vue d’ensemble de votre application de fonction, sélectionnez le volet Fonctions et sélectionnez Créer une fonctionsous Créer dans le portail Azure.
2. Dans la fenêtre Créer une fonction, laissez la propriété Environnement de développement sur Développer dans le portail. Sous Modèle, sélectionnez déclencheur HTTP.
3. Sous Détails du modèle, entrez CustomAuthenticationExtensionsAPI pour la propriété New Function .
4. Pour le niveau d’autorisation, sélectionnez Fonction.
5. Sélectionnez Créer.

1.2 Configurer le déclencheur HTTP pour OnAttributeCollectionStart

1. Dans le menu, sélectionnez Code + Test.
2. Sélectionnez l’onglet ci-dessous pour le scénario que vous souhaitez implémenter : Continuer, Bloquer ou SetPrefillValues. Remplacez le code par le ou les extraits de code fournis.
3. Après avoir remplacé le code, dans le menu supérieur, sélectionnez Obtenir l’URL de la fonction, puis copiez l’URL. Vous utilisez cette URL à l’étape 2 : créez et inscrivez une extension d’authentification personnalisée pour l’URL cible.

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic request = JsonConvert.DeserializeObject(requestBody);


    var actions = new List<ContinueWithDefaultBehavior>{
        new ContinueWithDefaultBehavior { type = "microsoft.graph.attributeCollectionStart.continueWithDefaultBehavior"}
    };

    var dataObject = new Data {
        type = "microsoft.graph.onAttributeCollectionStartResponseData",
        actions= actions
    };

    dynamic response = new ResponseObject {
        data = dataObject
    };

    // Send the response
    return response;
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<ContinueWithDefaultBehavior> actions { get; set; }
}

[JsonObject]
public class ContinueWithDefaultBehavior {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
}

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    
    dynamic request = JsonConvert.DeserializeObject(requestBody);       

    var actions = new List<BlockedActions>{
        new BlockedActions { 
            type = "microsoft.graph.attributeCollectionStart.showBlockPage", 
            message = "AttributeCollectionStart Custom Extension message: Sorry, your access request has been blocked. Try reaching an admin at admin@contoso.com."
        }
    };

    var dataObject = new Data {
        type = "microsoft.graph.onAttributeCollectionStartResponseData",
        actions= actions
    };

    dynamic response = new ResponseObject {
        data = dataObject
    };

    // Send the response
    return response;
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<BlockedActions> actions { get; set; }
}

[JsonObject]
public class BlockedActions {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public string message { get; set; }
}

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic request = JsonConvert.DeserializeObject(requestBody);

    // The form fields will load with these default values
    var inputs = new Dictionary<string, object>()
    {
        { "postalCode", "<your-prefill-value>" },
        { "streetAddress", "<your-prefill-value>" },
        { "city", "<your-prefill-value>" },
        { "extension_appId_mailingList", false },
        { "extension_appId_memberSince", 2023 }      
    };

    var actions = new List<SetPrefillValuesAction>{
        new SetPrefillValuesAction { 
            type = "microsoft.graph.attributeCollectionStart.setPrefillValues", 
            inputs = inputs }
    };

    var dataObject = new Data {
        type = "microsoft.graph.onAttributeCollectionStartResponseData",
        actions= actions
    };

    dynamic response = new ResponseObject {
        data = dataObject
    };

    // Send the response
    return response;
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<SetPrefillValuesAction> actions { get; set; }
}

[JsonObject]
public class SetPrefillValuesAction {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public Dictionary<string, object> inputs { get; set; }
}

1.3 Configurer le déclencheur HTTP pour OnAttributeCollectionSubmit

1. Dans le menu, sélectionnez Code + Test.
2. Sélectionnez l’onglet ci-dessous pour le scénario que vous souhaitez implémenter : Continuer, Bloquer, Modifier des valeurs ou Erreur de validation. Remplacez le code par le ou les extraits de code fournis.
3. Après avoir remplacé le code, dans le menu supérieur, sélectionnez Obtenir l’URL de la fonction, puis copiez l’URL. Vous utilisez cette URL à l’étape 2 : créez et inscrivez une extension d’authentification personnalisée pour l’URL cible.

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic request = JsonConvert.DeserializeObject(requestBody);
    
    var actions = new List<ContinueWithDefaultBehavior>{
        new ContinueWithDefaultBehavior { type = "microsoft.graph.attributeCollectionSubmit.continueWithDefaultBehavior"}
    };
						
    var dataObject = new Data {
        type = "microsoft.graph.onAttributeCollectionSubmitResponseData",
        actions= actions
    };
	    
	dynamic response = new ResponseObject {
        data = dataObject
    };

    // Send the response
    return response;
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    
    public List<ContinueWithDefaultBehavior> actions { get; set; }
}

[JsonObject]
public class ContinueWithDefaultBehavior {
    [JsonProperty("@odata.type")]
	public string type { get; set; }
}

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic request = JsonConvert.DeserializeObject(requestBody);
    
    var actions = new List<BlockedActions>{
        new BlockedActions { 
            type = "microsoft.graph.attributeCollectionSubmit.showBlockPage", 
            message = "AttributeCollectionSubmit Custom Extension Message: Thank you for your response. Your access request is processing. You'll be notified when your request has been approved."
        }
    };

    var dataObject = new Data {
        type = "microsoft.graph.onAttributeCollectionSubmitResponseData",
        actions= actions
    };

    dynamic response = new ResponseObject {
        data = dataObject
    };

    // Send the response
    return response;
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<BlockedActions> actions { get; set; }
}

[JsonObject]
public class BlockedActions {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public string message { get; set; }
}

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    // User attributes will be saved with these override values
    var attributes = new Dictionary<string, object>()
    {
        { "postalCode", "<your-override-value>" },
        { "streetAddress", "<your-override-value>" },
        { "city", "<your-override-value>" },
        { "extension_appId_mailingList", false }
        { "extension_appId_memberSince", 2010 }
    };

    var actions = new List<ModifiedAttributesAction>{
        new ModifiedAttributesAction { 
            type = "microsoft.graph.attributeCollectionSubmit.modifyAttributeValues", 
            attributes = attributes 
        }
    };

    log.LogInformation("actions: " + actions);

    var dataObject = new Data {
        type = "microsoft.graph.onAttributeCollectionSubmitResponseData",
        actions= actions
    };


    dynamic response = new ResponseObject {
        data = dataObject
    };

    // Send the response
    return response;
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<ModifiedAttributesAction> actions { get; set; }
}

[JsonObject]
public class ModifiedAttributesAction {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public Dictionary<string, object> attributes { get; set; }
}

#r "Newtonsoft.Json"

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Text;

public static async Task<object> Run(HttpRequest req, ILogger log)
{
    log.LogInformation($"C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    dynamic request = JsonConvert.DeserializeObject(requestBody);

    // Parse specified attributes
    string cityValue = (JsonConvert.SerializeObject(request?.data?.userSignUpInfo?.attributes?.city?.value)).ToString();

    string postalCodeValue = (JsonConvert.SerializeObject(request?.data?.userSignUpInfo?.attributes?.postalCode?.value)).ToString();

    string streetAddressValue = (JsonConvert.SerializeObject(request?.data?.userSignUpInfo?.attributes?.streetAddress?.value)).ToString();

    // JSON convert makes the length different, so we put 7 here
    if(cityValue.Length < 7 || postalCodeValue.Length < 7 || streetAddressValue.Length < 7){
        var inputs = new Dictionary<string, string>();

        if(cityValue.Length < 7){
            inputs.Add("city", "Length of city string should be of at 5 characters at least");
        }

        if(postalCodeValue.Length < 7){
            inputs.Add("postalCode", "Length of postalCodeValue string should be of at 5 characters at least");
        }

        if(streetAddressValue.Length < 7){
            inputs.Add("streetAddress", "Length of streetAddress string should be of at 5 characters at least");
        }

        string pageMessage = "Please fix below errors to proceed";

        var actions = new List<ValidationErrorActions>{
            new ValidationErrorActions { type = "microsoft.graph.attributeCollectionSubmit.ShowValidationError", message = pageMessage, attributeErrors = inputs }
        };

        
        var dataObject = new Data {
            type = "microsoft.graph.onAttributeCollectionSubmitResponseData",
            actions= actions
        };

        dynamic response = new ResponseObject {
            data = dataObject
        };

        log.LogInformation($"Returning validation error");

        // Send the validation error response
        return response;

    }else{
        var actions = new List<ContinueWithDefaultBehavior>{
            new ContinueWithDefaultBehavior { type = "microsoft.graph.attributeCollectionSubmit.ContinueWithDefaultBehavior"}
            };

        
        var dataObject = new DataContinue {
            type = "microsoft.graph.onAttributeCollectionSubmitResponseData",
            actions= actions
            };

        dynamic response = new ResponseObjectContinue {
            data = dataObject
        };

        log.LogInformation($"Returning continue");
        
        // Send the continue response
        return response;
    }
}

public class ResponseObject
{
    public Data data { get; set; }
}

[JsonObject]
public class Data {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<ValidationErrorActions> actions { get; set; }
}

[JsonObject]
public class ValidationErrorActions {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public string message { get; set; }
    public Dictionary<string, string> attributeErrors {get; set;}
}


public class ResponseObjectContinue
{
    public DataContinue data { get; set; }
}

[JsonObject]
public class DataContinue {
    [JsonProperty("@odata.type")]
    public string type { get; set; }
    public List<ContinueWithDefaultBehavior> actions { get; set; }
}

[JsonObject]
public class ContinueWithDefaultBehavior {
    [JsonProperty("@odata.type")]
	public string type { get; set; }
}

Étape 2 : Créer et inscrire une extension d’authentification personnalisée

Dans cette étape, vous inscrivez une extension d’authentification personnalisée utilisée par Microsoft Entra ID pour appeler votre fonction Azure. L’extension d’authentification personnalisée contient des informations sur votre point de terminaison d’API REST, sur les actions de démarrage et d’envoi de la collection d’attributs qu’elle analyse à partir de votre API REST et sur la façon de s’authentifier auprès de votre API REST.

1. Connectez-vous au Centre d’administration Microsoft Entra en tant qu’administrateur d’application et administrateur d’authentification.

2. Accédez à Entra ID>, Identités externes> et extensions d’authentification personnalisées.

3. Sélectionnez Créer une extension personnalisée.

4. Dans Basics, sélectionnez l’événement AttributeCollectionStart ou l’événement AttributeCollectionSubmit , puis sélectionnez Suivant. Assurez-vous que cela correspond à la configuration de l’étape précédente.

5. Dans Endpoint Configuration, renseignez les propriétés suivantes :

   • Nom : nom de votre extension d’authentification personnalisée. Par exemple, Lors de l'événement de collecte d'attributs.
   • URL cible : URL {Function_Url} de votre fonction Azure.
   • Description : description de vos extensions d’authentification personnalisées.

6. Sélectionnez Suivant.

7. Dans l’authentification API, sélectionnez l’option Créer une inscription d’application pour créer une inscription d’application qui représente votre application de fonction.

8. Donnez un nom à l’application, par exemple l’API d’événements d’authentification Azure Functions.

9. Sélectionnez Suivant.

10. Sélectionnez Créer, qui crée l’extension d’authentification personnalisée et l’inscription d’application associée.

2.2 Accorder un consentement administrateur

Une fois votre extension d’authentification personnalisée créée, accordez le consentement à l’application inscrite ; cela permet à l’extension d’authentification personnalisée de s’authentifier auprès de votre API.

1. Accédez à Entra ID>, Identités externes> et extensions d’authentification personnalisées.
2. Sélectionnez votre extension d’authentification personnalisée dans la liste.
3. Sous l’onglet Vue d’ensemble , sélectionnez le bouton Accorder l’autorisation pour donner le consentement administrateur à l’application inscrite. L’extension d’authentification personnalisée utilise client_credentials pour s’authentifier auprès de l’application de fonction Azure à l’aide de l’autorisation Receive custom authentication extension HTTP requests. Sélectionnez Accepter.

Étape 3 : Ajouter l’extension d’authentification personnalisée à un flux d’utilisateur

Vous pouvez maintenant associer l’extension d’authentification personnalisée à un ou plusieurs de vos flux d’utilisateurs.

3.1 Ajouter l’extension d’authentification personnalisée à un flux d’utilisateur existant

1. Connectez-vous au Centre d’administration Microsoft Entra en tant qu’administrateur d’application et administrateur d’authentification au moins

2. Si vous avez accès à plusieurs locataires, utilisez l’icône Paramètres dans le menu supérieur pour basculer vers votre locataire externe.

3. Accédez à Entra ID>Identités externes>flux utilisateur.

4. Sélectionnez le flux d’utilisateur dans la liste.

5. Sélectionnez extensions d’authentification personnalisées.

6. Dans la page Extensions d’authentification personnalisées , vous pouvez associer votre extension d’authentification personnalisée à deux étapes différentes dans votre flux d’utilisateur :

   • Avant de collecter des informations auprès de l’utilisateur , il est associé à l’événement OnAttributeCollectionStart . Sélectionnez le crayon de modification. Seules les extensions personnalisées configurées pour l’événement OnAttributeCollectionStart sont affichées. Sélectionnez l’application que vous avez configurée pour l’événement de démarrage de la collection d’attributs, puis sélectionnez Sélectionner.
   • Lorsqu’un utilisateur envoie ses informations est associée à l’événement OnAttributeCollectionSubmit . seules les extensions personnalisées configurées pour l’événement OnAttributeCollectionSubmit sont affichées. Sélectionnez l’application que vous avez configurée pour l’événement d’envoi de la collection d’attributs, puis sélectionnez Sélectionner.

7. Vérifiez que les applications répertoriées en regard des deux étapes de collection d’attributs sont correctes.

8. Sélectionnez l’icône Enregistrer .

Étape 4 : test de l’application

Pour obtenir un jeton et tester l’extension d’authentification personnalisée, vous pouvez utiliser l’application https://jwt.ms. Il s’agit d’une application Web Microsoft qui affiche le contenu décodé d’un jeton (le contenu du jeton ne quitte jamais votre navigateur).

Procédez comme suit pour inscrire l’application web jwt.ms :

4.1 Inscrire l’application web jwt.ms

1. Connectez-vous au Centre d’administration Microsoft Entra en tant qu’administrateur d’application au moins.
2. Accédez auxinscriptions d’application>.
3. Sélectionnez Nouvelle inscription.
4. Entrez un nom pour l’application. Par exemple, mon application test.
5. Sous Types de comptes pris en charge, sélectionnez Comptes dans cet annuaire organisationnel uniquement.
6. Dans la liste déroulante Sélectionner une plateforme dans l’URI de redirection, sélectionnez Web , puis entrez https://jwt.ms dans la zone de texte URL.
7. Sélectionnez Inscrire pour terminer l’inscription de l’application.

4.2 Récupérer l’ID de l’application

Dans l'enregistrement de votre application, sous Vue d’ensemble, copiez l'ID de l'application (client) . L’ID d’application est appelé <client_id> dans les étapes ultérieures. Dans Microsoft Graph, il est référencé par la propriété appId .

4.3 Activer le flux implicite

L’application de test jwt.ms utilise le flux implicite. Activez le flux implicite dans l'inscription de l'application My Test en suivant les étapes suivantes.

1. Sous Gérer, sélectionnez Authentification.
2. Sous Octroi implicite et flux hybrides, cochez la case des jetons d’ID (utilisés pour les flux implicites et hybrides).
3. Sélectionnez Enregistrer.

Étape 5 : protéger votre fonction Azure

L’extension d’authentification personnalisée Microsoft Entra utilise le flux de serveur à serveur pour obtenir un jeton d’accès envoyé dans l’en-tête HTTP Authorization à votre fonction Azure. Lorsque vous publiez votre fonction sur Azure, en particulier dans un environnement de production, vous devez valider le jeton envoyé dans l’en-tête d’autorisation.

Pour protéger votre fonction Azure, procédez comme suit pour intégrer l’authentification Microsoft Entra, pour valider les jetons entrants avec votre inscription d’application d’API d’événements d’authentification Azure Functions .

5.1 Ajouter un fournisseur d’identité à votre fonction Azure

1. Connectez-vous au portail Azure.

2. Naviguez et sélectionnez l’application de fonction que vous avez publiée précédemment.

3. Sélectionnez Authentification dans le menu de gauche.

4. Sélectionnez Ajouter un fournisseur d’identité.

5. Sélectionnez Microsoft comme fournisseur d’identité.

6. Sélectionnez Customer comme type de locataire.

7. Sous Inscription d’application, entrez l’identifiant client_id de l’application API d’événements d’authentification Azure Functions que vous avez créée précédemment lors de l’inscription du fournisseur de revendications personnalisées.

8. Pour l’URL de l’émetteur, entrez l’URL https://{domainName}.ciamlogin.com/{tenant_id}/v2.0suivante, où

   • {domainName} est le nom de domaine de votre tenant externe.
   • {tenantId} est l’ID de tenant de votre tenant externe. Votre extension d’authentification personnalisée doit être inscrite ici.

9. Sous Demandes non authentifiées, sélectionnez HTTP 401 Non autorisé comme fournisseur d’identité.

10. Désélectionnez l’option magasin de jetons .

11. Sélectionnez Ajouter pour ajouter l’authentification à votre fonction Azure.

    

5.2 Utilisation d’un fournisseur d’identité OpenID Connect

Si vous avez configuré l’étape 5 : Protéger votre fonction Azure, ignorez cette étape. Sinon, si la fonction Azure est hébergée sous un locataire différent du locataire dans lequel votre extension d’authentification personnalisée est inscrite, procédez comme suit pour protéger votre fonction :

1. Connectez-vous au portail Azure, puis naviguez et sélectionnez l’application de fonction que vous avez publiée précédemment.

2. Sélectionnez Authentification dans le menu de gauche.

3. Sélectionnez Ajouter un fournisseur d’identité.

4. Sélectionnez OpenID Connect en tant que fournisseur d’identité.

5. Fournissez un nom, tel que Contoso Microsoft Entra ID.

6. Sous l’entrée Métadonnées, entrez l’URL suivante vers l’URL du document. Remplacez {tenantId} par votre ID de locataire Microsoft Entra.

   https://login.microsoftonline.com/{tenantId}/v2.0/.well-known/openid-configuration
   

7. Sous l’inscription de l’application, entrez l’ID d’application (ID client) de l’inscription d’application API d’événements d’authentification Azure Functionsque vous avez créée précédemment.

8. Dans le centre d’administration Microsoft Entra :

   1. Sélectionnez l'enregistrement de l'application API d'événements d'authentification Azure Functions que vous avez créé précédemment.
   2. Sélectionnez Certificats et secrets>Secrets client>Nouveau secret client.
   3. Ajoutez une description pour votre clé secrète client.
   4. Sélectionnez un délai d’expiration pour le secret ou spécifiez une durée de vie personnalisée.
   5. Sélectionnez Ajouter.
   6. Enregistrez la valeur du secret à utiliser dans le code de votre application cliente. Cette valeur secrète ne sera plus jamais affichée lorsque vous aurez quitté cette page.

9. Revenez à la fonction Azure, sous l’enregistrement de l'application, entrez le secret client.

10. Désélectionnez l’option magasin de jetons .

11. Sélectionnez Ajouter pour ajouter le fournisseur d’identité OpenID Connect.

Étape 6 : Tester l’application

Pour tester votre extension d’authentification personnalisée, procédez comme suit :

1. Ouvrez un nouveau navigateur privé et accédez à l’URL suivante :

   https://<domainName>.ciamlogin.com/<tenant_id>/oauth2/v2.0/authorize?client_id=<client_id>&response_type=code+id_token&redirect_uri=https://jwt.ms&scope=openid&state=12345&nonce=12345
   

   • Remplacez <domainName> par le nom de votre tenant externe, puis remplacez <tenant-id> par l’ID de votre tenant externe.
   • Remplacez <client_id> par l’ID de l’application que vous avez ajoutée au flux d’utilisateur.

2. Une fois connecté, vous et votre jeton décodé serez dirigés vers https://jwt.ms.

Étapes suivantes

• Informations de référence sur OnAttributeCollectionStart
• Référence OnAttributeCollectionSubmit