Criar uma extensão de autenticação personalizada para iniciar e enviar eventos de coleta de atributos (visualização)

Aplica-se a: Locatários da força de trabalho Locatários externos (saiba mais)

Este artigo descreve como estender a experiência de inscrição do usuário no Microsoft Entra External ID para clientes. Nos fluxos de usuário de inscrição de clientes, os ouvintes de eventos podem ser usados para estender o processo de coleta de atributos antes da coleta de atributos e no momento do envio de atributos:

• O evento OnAttributeCollectionStart ocorre no início da etapa de coleta de atributos, antes da renderização da página de coleção de atributos. Você pode adicionar ações como pré-preencher valores e exibir um erro de bloqueio.

  Gorjeta

  

  Para experimentar esse recurso, vá para a demonstração do Woodgrove Groceries e inicie o caso de uso "Pré-preencher atributos de inscrição".

• O evento OnAttributeCollectionSubmit ocorre depois que o usuário insere e envia atributos. Você pode adicionar ações como validar ou modificar as entradas do usuário.

  Gorjeta

  

  Para experimentar esse recurso, vá para a demonstração do Woodgrove Groceries e inicie o caso de uso "Validar atributos de inscrição" ou o caso de uso "Bloquear um usuário de continuar o processo de inscrição".

Além de criar uma extensão de autenticação personalizada para os eventos de início e envio da coleção de atributos, você precisa criar uma API REST que defina as ações de fluxo de trabalho a serem executadas para cada evento. Você pode usar qualquer linguagem de programação, estrutura e ambiente de hospedagem para criar e hospedar sua API REST. Este artigo demonstra uma maneira rápida de começar a usar uma Função do Azure em C#. Com o Azure Functions, você executa seu código em um ambiente sem servidor sem precisar primeiro criar uma máquina virtual (VM) ou publicar um aplicativo Web.

Pré-requisitos

• Para usar os serviços do Azure, incluindo o Azure Functions, você precisa de uma assinatura do Azure. Se você não tiver uma conta existente do Azure, poderá se inscrever para uma avaliação gratuita ou usar os benefícios da Assinatura do Visual Studio ao criar uma conta.
• Um fluxo de usuário de inscrição e login.

Etapa 1: Criar uma API REST de extensões de autenticação personalizadas (aplicativo Azure Function)

Nesta etapa, você cria uma API de função de gatilho HTTP usando o Azure Functions. A função API é a fonte da lógica de negócios para seus fluxos de usuários. Depois de criar sua função de gatilho, você pode configurá-la para um dos seguintes eventos:

• OnAttributeCollectionStart
• OnAttributeCollectionSubmit

1. Entre no portal do Azure com sua conta de administrador.

2. A partir do menu do portal do Azure ou a partir da Home page, selecione Criar um recurso.

3. Procure e selecione Função App e selecione Criar.

4. Na página Noções básicas, use as configurações do aplicativo de função conforme especificado na tabela a seguir:

   Definição	Valor sugerido	Description
   Subscrição	a sua subscrição	A assinatura na qual o novo aplicativo de função será criado.
   Grupo de Recursos	myResourceGroup	Selecione o grupo de recursos existente ou o nome do novo no qual você criará seu aplicativo de função.
   Nome da Aplicação de Funções	Nome globalmente exclusivo	Um nome que identifica o novo aplicativo de função. Os carateres válidos são a-z (não sensível a maiúsculas e minúsculas), 0-9 e -.
   Publicar	Código	Opção para publicar ficheiros de código ou um contentor de Docker. Para este tutorial, selecione Código.
   Pilha de runtime	.NET	A sua linguagem de programação preferida. Para este tutorial, selecione .NET.
   Versão	6 (LTS) Em processo	Versão do tempo de execução do .NET. Em processo significa que você pode criar e modificar funções no portal, o que é recomendado para este guia
   Região	Região preferida	Selecione uma região perto de você ou perto de outros serviços que suas funções possam acessar.
   Sistema operativo	Windows	O sistema operacional é pré-selecionado para você com base na seleção da pilha de tempo de execução.
   Tipo de plano	Consumo (Sem servidor)	O plano de alojamento que define a forma como os recursos são alocados à sua aplicação de funções.

5. Selecione Rever + criar para rever as seleções de configuração da aplicação e, em seguida, selecione Criar. A implantação leva alguns minutos.

6. Depois de implantado, selecione Ir para o recurso para exibir seu novo aplicativo de função.

1.1 Criar funções de gatilho HTTP

Agora que você criou o aplicativo Azure Function, você cria funções de gatilho HTTP para as ações que deseja invocar com uma solicitação HTTP. Os gatilhos HTTP são referenciados e chamados pela sua extensão de autenticação personalizada do Microsoft Entra.

1. Na página Visão geral do seu aplicativo de função, selecione o painel Funções e selecione Criar função em Criar no portal do Azure.
2. Na janela Criar função, deixe a propriedade Ambiente de desenvolvimento como Desenvolver no portal. Em Modelo, selecione Gatilho HTTP.
3. Em Detalhes do modelo, insira CustomAuthenticationExtensionsAPI para a propriedade New Function .
4. Para o nível de autorização, selecione Função.
5. Selecione Criar.

1.2 Configurar o gatilho HTTP para OnAttributeCollectionStart

1. No menu, selecione Código + Teste.
2. Selecione a guia abaixo para o cenário que você deseja implementar: Continue, Block ou SetPrefillValues. Substitua o código pelo(s) trecho(s) de código fornecido(s).
3. Depois de substituir o código, no menu superior, selecione Obter URL da função e copie o URL. Use essa URL na Etapa 2: criar e registrar uma extensão de autenticação personalizada para a URL de destino.

#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 Configurar o gatilho HTTP para OnAttributeCollectionSubmit

1. No menu, selecione Código + Teste.
2. Selecione a guia abaixo para o cenário que você deseja implementar: Continuar, Bloquear, Modificar valores ou Erro de validação. Substitua o código pelo(s) trecho(s) de código fornecido(s).
3. Depois de substituir o código, no menu superior, selecione Obter URL da função e copie o URL. Use essa URL na Etapa 2: criar e registrar uma extensão de autenticação personalizada para a URL de destino.

#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; }
}

Etapa 2: Criar e registrar uma extensão de autenticação personalizada

Nesta etapa, você registra uma extensão de autenticação personalizada que é usada pelo Microsoft Entra ID para chamar sua função do Azure. A extensão de autenticação personalizada contém informações sobre seu ponto de extremidade da API REST, o início e o envio da coleção de atributos que ele analisa da sua API REST e como autenticar na sua API REST.

1. Entre no centro de administração do Microsoft Entra como pelo menos um Administrador de Aplicativo e Administrador de Autenticação.

2. Navegue até Identidades>>Externas Extensões de autenticação personalizadas.

3. Selecione Criar uma extensão personalizada.

4. Em Basics, selecione o evento AttributeCollectionStart ou o evento AttributeCollectionSubmit e selecione Next. Certifique-se de que isso corresponde à configuração na etapa anterior.

5. Em Configuração do ponto final, preencha as seguintes propriedades:

   • Nome - Um nome para sua extensão de autenticação personalizada. Por exemplo, On Attribute Collection Event.
   • URL de destino - A {Function_Url} URL da sua função do Azure.
   • Descrição - Uma descrição para suas extensões de autenticação personalizadas.

6. Selecione Seguinte.

7. Em Autenticação de API, selecione a opção Criar novo registro de aplicativo para criar um registro de aplicativo que represente seu aplicativo de função.

8. Dê um nome ao aplicativo, por exemplo , API de eventos de autenticação do Azure Functions.

9. Selecione Seguinte.

10. Selecione Criar, que cria a extensão de autenticação personalizada e o registro do aplicativo associado.

2.2 Conceder consentimento de administrador

Depois que sua extensão de autenticação personalizada for criada, conceda o consentimento do aplicativo para o aplicativo registrado, o que permite que a extensão de autenticação personalizada se autentique em sua API.

1. Navegue até Identidades>Externas Extensões>de autenticação personalizadas (Pré-visualização).
2. Selecione sua extensão de autenticação personalizada na lista.
3. Na guia Visão geral, selecione o botão Conceder permissão para dar consentimento de administrador ao aplicativo registrado. A extensão de autenticação personalizada usa client_credentials para autenticar no Aplicativo de Função do Azure usando a Receive custom authentication extension HTTP requests permissão. Selecione Aceitar.

Etapa 3: Adicionar a extensão de autenticação personalizada a um fluxo de usuário

Agora você pode associar a extensão de autenticação personalizada a um ou mais de seus fluxos de usuário.

3.1 Adicionar a extensão de autenticação personalizada a um fluxo de usuário existente

1. Entre no centro de administração do Microsoft Entra como pelo menos um Administrador de Aplicativo e Administrador de Autenticação

2. Se tiver acesso a vários inquilinos, utilize o ícone Definições no menu superior para mudar para o inquilino externo.

3. Navegue até Identidades> externas Fluxos>de usuário.

4. Selecione o fluxo de utilizador na lista.

5. Selecione Extensões de autenticação personalizadas.

6. Na página Extensões de autenticação personalizadas, você pode associar sua extensão de autenticação personalizada a duas etapas diferentes no fluxo de usuário:

   • Antes de coletar informações do usuário é associado ao evento OnAttributeCollectionStart . Selecione o lápis de edição. Somente as extensões personalizadas configuradas para o evento OnAttributeCollectionStart serão exibidas. Selecione o aplicativo que você configurou para o evento de início da coleção de atributos e escolha Selecionar.
   • Quando um usuário envia suas informações são associadas ao evento OnAttributeCollectionSubmit . somente as extensões personalizadas configuradas para o evento OnAttributeCollectionSubmit serão exibidas. Selecione o aplicativo que você configurou para o evento de envio da coleção de atributos e escolha Selecionar.

7. Verifique se os aplicativos listados ao lado de ambas as etapas de coleta de atributos estão corretos.

8. Selecione o ícone Guardar.

Passo 4: Testar a aplicação

Para obter um token e testar a extensão de autenticação personalizada, você pode usar o https://jwt.ms aplicativo. É um aplicativo Web de propriedade da Microsoft que exibe o conteúdo decodificado de um token (o conteúdo do token nunca sai do seu navegador).

Siga estas etapas para registrar o aplicativo Web jwt.ms :

4.1 Registar a aplicação Web jwt.ms

1. Entre no centro de administração do Microsoft Entra como pelo menos um Administrador de Aplicativos.
2. Navegue até Registros de aplicativos de identidade>>.
3. Selecione Novo registo.
4. Insira um Nome para o aplicativo. Por exemplo, Meu aplicativo de teste.
5. Em Tipos de conta suportados, selecione Contas somente neste diretório organizacional.
6. Na lista suspensa Selecione uma plataforma no URI de redirecionamento, selecione Web e digite https://jwt.ms a caixa de texto URL.
7. Selecione Registrar para concluir o registro do aplicativo.

4.2 Obter o ID do aplicativo

No registro do aplicativo, em Visão geral, copie a ID do aplicativo (cliente). O ID do aplicativo é chamado de <client_id> nas etapas posteriores. No Microsoft Graph, ele é referenciado pela propriedade appId .

4.3 Ativar fluxo implícito

O aplicativo de teste jwt.ms usa o fluxo implícito. Habilite o fluxo implícito em seu registro de aplicativo My Test com as etapas a seguir.

1. Em Gerir, selecione Autenticação.
2. Em Concessão implícita e fluxos híbridos, marque a caixa de seleção Tokens de ID (usados para fluxos implícitos e híbridos).
3. Selecione Guardar.

Etapa 5: Proteger sua função do Azure

A extensão de autenticação personalizada do Microsoft Entra usa o fluxo de servidor para servidor para obter um token de acesso que é enviado no cabeçalho HTTP Authorization para sua função do Azure. Ao publicar sua função no Azure, especialmente em um ambiente de produção, você precisa validar o token enviado no cabeçalho de autorização.

Para proteger sua função do Azure, siga estas etapas para integrar a autenticação do Microsoft Entra, para validar tokens de entrada com seu registro de aplicativo de API de eventos de autenticação do Azure Functions.

5.1 Adicionar um provedor de identidade à sua função do Azure

1. Inicie sessão no portal do Azure.

2. Navegue e selecione o aplicativo de função que você publicou anteriormente.

3. Selecione Autenticação no menu à esquerda.

4. Selecione Adicionar provedor de identidade.

5. Selecione Microsoft como o provedor de identidade.

6. Selecione Cliente como o tipo de locatário.

7. Em Registro de aplicativo, insira o client_id registro do aplicativo de API de eventos de autenticação do Azure Functions que você criou anteriormente ao registrar o provedor de declarações personalizado.

8. Para o URL do emissor, insira o seguinte URL https://{domainName}.ciamlogin.com/{tenant_id}/v2.0, onde

   • {domainName} é o nome de domínio do seu inquilino externo.
   • {tenantId} é o ID do inquilino do seu inquilino externo. Sua extensão de autenticação personalizada deve ser registrada aqui.

9. Em Solicitações não autenticadas, selecione HTTP 401 Não autorizado como o provedor de identidade.

10. Desmarque a opção Loja de tokens.

11. Selecione Adicionar para adicionar autenticação à sua Função do Azure.

    

5.2 Usando o provedor de identidade OpenID Connect

Se você configurou a Etapa 5: Proteger sua Função do Azure, ignore esta etapa. Caso contrário, se a Função do Azure estiver hospedada em um locatário diferente do locatário no qual sua extensão de autenticação personalizada está registrada, siga estas etapas para proteger sua função:

1. Entre no portal do Azure e, em seguida, navegue e selecione o aplicativo de função que você publicou anteriormente.

2. Selecione Autenticação no menu à esquerda.

3. Selecione Adicionar provedor de identidade.

4. Selecione OpenID Connect como o provedor de identidade.

5. Forneça um nome, como Contoso Microsoft Entra ID.

6. Na entrada Metadados, insira a seguinte URL para a URL do documento. Substitua o pelo seu ID de locatário do {tenantId} Microsoft Entra.

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

7. Em Registro do aplicativo, insira a ID do aplicativo (ID do cliente) do registro do aplicativo da API de eventos de autenticação do Azure Functions que você criou anteriormente.

8. No centro de administração do Microsoft Entra:

   1. Selecione o registro do aplicativo de API de eventos de autenticação do Azure Functions que você criou anteriormente.
   2. Selecione Certificados & segredos Segredos do>cliente Novo segredo do>cliente.
   3. Adicione uma descrição do segredo do cliente.
   4. Selecione uma expiração para o segredo ou especifique um tempo de vida personalizado.
   5. Selecione Adicionar.
   6. Registre o valor do segredo para uso no código do aplicativo cliente. Este valor secreto nunca mais é apresentado depois de sair desta página.

9. De volta à Função do Azure, sob o registro do aplicativo, insira o segredo do cliente.

10. Desmarque a opção Loja de tokens.

11. Selecione Adicionar para adicionar o provedor de identidade OpenID Connect.

Etapa 6: Testar o aplicativo

Para testar sua extensão de autenticação personalizada, siga estas etapas:

1. Abra um novo navegador privado e navegue até o seguinte URL:

   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
   

   • Substitua <domainName> pelo nome do locatário externo e substitua <tenant-id> pelo ID do locatário externo.
   • Substitua <client_id> pela ID do aplicativo que você adicionou ao fluxo de usuário.

2. Depois de iniciar sessão, ser-lhe-á apresentado o seu token descodificado em https://jwt.ms.

Próximos passos

• Referência OnAttributeCollectionStart
• Referência OnAttributeCollectionSubmit