Crie uma extensão de autenticação personalizada para eventos de início e envio de coleção de atributos (versão prévia)

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

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

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

  Dica

  

  Para testar 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.

  Dica

  

  Para testar 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 "Impedir 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 iniciar e enviar uma 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 forma rápida de começar a usar uma função do Azure em C#. Com o Azure Functions você pode executar seu código em um ambiente sem servidor sem que seja preciso primeiro criar uma VM (máquina virtual) ou publicar um aplicativo Web.

Pré-requisitos

• Para usar os serviços do Azure, incluindo o Azure Functions, você precisa ter uma assinatura do Azure. Caso não tenha uma conta do Azure, você pode se inscrever em uma avaliação gratuita ou usar seus benefícios da Assinatura do Visual Studio ao criar uma conta.
• Um fluxo de usuário de inscrição e de entrada.

Etapa 1: criar uma API REST de extensões de autenticação personalizada (aplicativo de funções do Azure)

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

• OnAttributeCollectionStart
• OnAttributeCollectionSubmit

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

2. No menu do portal do Azure ou na Página inicial, selecione Criar um recurso.

3. Pesquise e selecione Aplicativo de funções e selecione Criar.

4. Na página Informações básicas, use as configurações do aplicativo de funções conforme especificado na seguinte tabela:

   Configuração	Valor sugerido	Descrição
   Assinatura	Sua assinatura	A assinatura na qual o novo aplicativo de funções será criado.
   Grupo de Recursos	myResourceGroup	Selecione um grupo de recursos existente ou nomeie um novo no qual você criará seu aplicativo de funções.
   Nome do aplicativo de funções	Nome globalmente exclusivo	Um nome que identifique o novo aplicativo de funções. Os caracteres válidos são a-z (não diferencia maiúsculas de minúsculas), 0-9 e -.
   Publicar	Código	Opção para publicar arquivos de código ou um contêiner do Docker. Para este tutorial, selecione Código.
   Pilha de runtime	.NET	Sua linguagem de programação preferida. Para este tutorial, selecione .NET.
   Versão	6 (LTS) em processo	Versão do runtime 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 preferencial	Selecione uma região perto de você ou perto de outros serviços que suas funções podem acessar.
   Sistema operacional	Windows	O sistema operacional é pré-selecionado para você com base na seleção da pilha de runtime.
   Tipo de plano	Consumo (Sem servidor)	Plano de hospedagem que define como os recursos são alocados para seu aplicativo de funções.

5. Selecione Examinar + criar para examinar as seleções de configuração do aplicativo e, em seguida, selecione Criar. A implantação leva alguns minutos.

6. Depois de implantado, selecione Ir para o recurso para visualizar seu novo aplicativo de funções.

1.1 Criar funções de gatilho HTTP

Agora que você criou o aplicativo de funções do Azure, crie 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 extensão de autenticação personalizada do Microsoft Entra.

1. Na página Visão geral do seu aplicativo de funções, 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 Nova Função.
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: Continuar, Bloquear ou SetPrefillValues. Substitua o código pelo(s) snippet(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 esse 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) snippet(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 esse 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ê registrará uma extensão de autenticação personalizada usada pelo Microsoft Entra ID para chamar sua função do Azure. A extensão de autenticação personalizada contém informações sobre o ponto de extremidade da API REST, as ações de início e envio da coleção de atributos que analisa desde a API REST e de como autenticar em sua API REST.

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

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

3. Selecione Criar uma extensão personalizada.

4. Em Básico, selecione o evento AttributeCollectionStart ou o evento AttributeCollectionSubmit e selecione Avançar. Certifique-se de que isso corresponda à configuração na etapa anterior.

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

   • Nome – um nome para sua extensão de autenticação personalizada. Por exemplo, Evento On Attribute Collection.
   • URL de destino – o {Function_Url} do URL da função do Azure.
   • Descrição – uma descrição para suas extensões de autenticação personalizadas.

6. Selecione Avançar.

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

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

9. Selecione Avançar.

10. Selecione Criar; para criar a extensão de autenticação personalizada e o registro de aplicativo associado.

2.2 Fornecer o consentimento do administrador

Depois que sua extensão de autenticação personalizada for criada, dê o consentimento ao aplicativo registrado, o que permitirá que a extensão de autenticação personalizada se autentique em sua API.

1. Navegue até Identidade>Identidades Externas>Extensões de autenticação personalizadas (versão prévia).
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 do administrador ao aplicativo registrado. A extensão de autenticação personalizada usa client_credentials para autenticar no Aplicativo de Funções do Azure usando a permissão Receive custom authentication extension HTTP requests. 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 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 Administrador de Aplicativo e Administrador de Autenticação no mínimo

2. Se você tiver acesso a vários locatários, use o ícone Configurações no menu superior para alternar para o locatário externo.

3. Navegue atéIdentidade>Identidades Externas>Fluxos do Usuário.

4. Selecione o fluxo de usuário 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 do 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 configurado para o evento de início da coleta de atributos e escolha Selecionar.
   • Quando um usuário envia suas informações, elas são associadas ao evento OnAttributeCollectionSubmit. somente as extensões personalizadas configuradas para o evento OnAttributeCollectionSubmit serão exibidas. Selecione o aplicativo configurado para o evento de envio da coleta de atributos e escolha Selecionar.

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

8. Selecione o ícone Salvar.

Etapa 4: testar o aplicativo

Para obter um token e testar a extensão de autenticação personalizada, você pode usar o aplicativo https://jwt.ms. É um aplicativo da 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 Registrar o aplicativo Web jwt.ms

1. Iniciar sessão no centro de administração do Microsoft Entra como, no mínimo, Administrador de Aplicativos.
2. Navegue até Identidade>Aplicativos>Registros de aplicativos.
3. Selecione Novo registro.
4. Insira um Nome para o aplicativo. Por exemplo, Meu aplicativo de teste.
5. Em Tipos de contas com suporte, selecione Contas somente neste diretório organizacional.
6. Na lista suspensa Selecionar uma plataforma no URI de redirecionamento, selecione Web e, em seguida, insira https://jwt.ms na caixa de texto URL.
7. Selecione Registrar para concluir o registro do aplicativo.

4.2 Obter a ID do aplicativo

No registro do aplicativo, em Visão geral, copie a ID do aplicativo (cliente). A ID do aplicativo é referenciada como o <client_id> nas etapas posteriores. No Microsoft Graph, ela é referenciada pela propriedade appId.

4.3 Habilitar o fluxo implícito

O aplicativo de teste jwt.ms usa o fluxo implícito. Habilite o fluxo implícito no registro do Meu aplicativo de teste com as seguintes etapas.

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

Etapa 5: proteger sua Função do Azure

A extensão de autenticação personalizada do Microsoft Entra utiliza o fluxo de servidor a 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 o registro de aplicativos API de eventos de autenticação do Azure Functions.

5.1 Adicione um provedor de identidade à sua Função Azure

1. Entre no portal do Azure.

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

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

4. Selecione Adicionar provedor de identidade.

5. Selecione Microsoft como provedor de identidade.

6. Selecione Cliente como tipo de locatário.

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

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 locatário externo.
   • {tenantId} é a ID de locatário do locatário 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 provedor de identidade.

10. Desmarque a opção Repositório de tokens.

11. Selecione Adicionar para adicionar autenticação à 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 daquele 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ções que você publicou anteriormente.

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

3. Selecione Adicionar provedor de identidade.

4. Selecione OpenID Connect como provedor de identidade.

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

6. Na Entrada de metadados, insira o URL a seguir para o URL do Documento. Substitua o {tenantId} por seu locatário do Microsoft Entra ID.

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

7. Em Registro de aplicativo, insira a ID do aplicativo (ID do cliente) do registro de aplicativo 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 de aplicativo API de eventos de autenticação do Azure Functions que você criou anteriormente.
   2. Selecione Certificados e segredos>Segredos do cliente>Novo segredo do cliente.
   3. Adicione uma descrição para o segredo do cliente.
   4. Selecione uma data de 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. Esse valor secreto nunca será exibido novamente depois que você sair dessa página.

9. De volta à função do Azure, no Registro do aplicativo, insira o Segredo do cliente.

10. Desmarque a opção Repositório de tokens.

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

Etapa 6: testar o aplicativo

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

1. Abra uma janela de 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> pela ID do locatário externo.
   • Substitua <client_id> pela ID do aplicativo que você adicionou ao fluxo de usuário.

2. Depois de entrar, você receberá o token decodificado em https://jwt.ms.

Próximas etapas

• Referência OnAttributeCollectionStart
• Referência OnAttributeCollectionSubmit