Partilhar via


Tutorial: Preparar um aplicativo Web ASP.NET Core para autenticação em um locatário externo

Este tutorial é parte 2 de uma série que demonstra como criar um aplicativo Web ASP.NET Core e prepará-lo para autenticação usando o centro de administração do Microsoft Entra. Na Parte 1 desta série, você registrou um aplicativo e configurou fluxos de usuário em seu locatário externo. Este tutorial demonstra como criar um aplicativo Web ASP.NET Core e configurá-lo para autenticação.

Neste tutorial você vai;

  • Criar um projeto ASP.NET Core no Visual Studio Code
  • Adicionar os pacotes NuGet necessários
  • Definir as configurações para o aplicativo
  • Adicionar código para implementar a autenticação

Pré-requisitos

Criar um projeto Web ASP.NET Core

  1. Abra o Visual Studio Code, selecione File>Open Folder.... Navegue até o local para criar seu projeto e selecione-o.

  2. Abra um novo terminal selecionando Terminal>New Terminal.

  3. Insira o comando a seguir para criar um MVC (Model View Controller) ASP.NET projeto principal.

    dotnet new mvc -n dotnetcore_webapp
    

Instalar pacotes de identidade

Os pacotes NuGet relacionados à identidade devem ser instalados no projeto para autenticar os usuários.

  1. Insira os seguintes comandos para mudar para a pasta dotnetcore_webapp e instalar o pacote NuGet relevante:

    cd dotnetcore_webapp
    dotnet add package Microsoft.Identity.Web.UI
    

Configurar o aplicativo para autenticação

  1. Abra o arquivo appsettings.json e substitua o código existente pelo trecho a seguir.

    {
      "AzureAd": {
        "Authority": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/",
        "ClientId": "Enter_the_Application_Id_Here",
        "ClientCredentials": [
          {
            "SourceType": "ClientSecret",
            "ClientSecret": "Enter_the_Client_Secret_Here"
          }
        ],
        "CallbackPath": "/signin-oidc",
        "SignedOutCallbackPath": "/signout-callback-oidc"
      },
      "Logging": {
        "LogLevel": {
          "Default": "Information",
          "Microsoft.AspNetCore": "Warning"
        }
      },
      "AllowedHosts": "*"
    }
    
    • Authority - A instância do provedor de identidade e o público de entrada para o aplicativo. Substitua Enter_the_Tenant_Subdomain_Here pelo subdomínio do seu locatário externo. Para encontrar isso, selecione Visão geral no menu da barra lateral e alterne para a guia Visão geral. Encontre o domínio Principal, no formato caseyjensen.onmicrosoft.com. O subdomínio é caseyjensen.
    • ClientId - O identificador da aplicação, também referido como o cliente. Substitua o texto entre aspas pelo valor de ID do aplicativo (cliente) que foi registrado anteriormente na página de visão geral do aplicativo registrado.
    • ClientSecret - O valor do segredo do cliente que você criou em Prepare seu inquilino. Substitua o texto entre aspas pelo valor secreto do cliente no centro de administração do Microsoft Entra.
    • CallbackPath - É um identificador para ajudar o servidor a redirecionar uma resposta para o aplicativo apropriado.
  2. Salve as alterações no arquivo.

  3. Abra o arquivo Propriedades/launchSettings.json .

  4. https Na seção de profiles, altere o https URL para applicationUrl que ele leia https://localhost:7274. Você usou essa URL para definir o URI de redirecionamento.

  5. Salve as alterações no arquivo.

Usar URL de domínio personalizado (opcional)

Use um domínio personalizado para marcar totalmente a URL de autenticação. Do ponto de vista do usuário, os usuários permanecem no seu domínio durante o processo de autenticação, em vez de serem redirecionados para ciamlogin.com nome de domínio.

Siga estas etapas para usar um domínio personalizado:

  1. Use as etapas em Habilitar domínios de URL personalizados para aplicativos em locatários externos para habilitar a URL de domínio personalizada para seu locatário externo.

  2. Abra appsettings.json arquivo:

    1. Atualize o Authority valor da propriedade para https://Enter_the_Custom_Domain_Here/Enter_the_Tenant_ID_Here. Substitua Enter_the_Custom_Domain_Here pelo URL do domínio personalizado e Enter_the_Tenant_ID_Here pelo ID do locatário. Se não tiver o ID do inquilino, saiba como ler os detalhes do inquilino.
    2. Adicionar knownAuthorities propriedade com um valor [Enter_the_Custom_Domain_Here].

Depois de fazer as alterações no arquivo appsettings.json, se a URL do domínio personalizado estiver login.contoso.com e a ID do locatário for aaaabbbb-0000-cccc-1111-dddd2222eeee, o arquivo deverá ser semelhante ao seguinte trecho:

{
  "AzureAd": {
    "Authority": "https://login.contoso.com/aaaabbbb-0000-cccc-1111-dddd2222eeee",
    "ClientId": "Enter_the_Application_Id_Here",
    "ClientCredentials": [
      {
        "SourceType": "ClientSecret",
        "ClientSecret": "Enter_the_Client_Secret_Here"
      }
    ],
    "CallbackPath": "/signin-oidc",
    "SignedOutCallbackPath": "/signout-callback-oidc",
    "KnownAuthorities": ["login.contoso.com"]
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Adicionar autorização a HomeController.cs

O arquivo HomeController.cs contém o código para a página inicial do aplicativo e precisa ter a capacidade de autorizar o usuário. O Microsoft.AspNetCore.Authorization namespace fornece as classes e interfaces para implementar a autorização para o aplicativo Web, e o [Authorize] atributo é usado para especificar que apenas usuários autenticados podem usar o aplicativo Web.

  1. No editor de códigos, abra o arquivo Controllers\HomeController.cs .

  2. A autorização precisa ser adicionada ao controlador, adicione Microsoft.AspNetCore.Authorization para que a parte superior do arquivo seja idêntica ao seguinte trecho:

    using System.Diagnostics;
    using Microsoft.AspNetCore.Authorization;
    using Microsoft.AspNetCore.Mvc;
    using dotnetcore_webapp.Models;
    
  3. Além disso, adicione o [Authorize] atributo diretamente acima da definição de HomeController classe.

    [Authorize]
    

Adicionar autenticação e autorização ao Program.cs

O Program.cs precisa ser modificado para adicionar autenticação e autorização ao aplicativo Web. Isso inclui adicionar namespaces para autenticação e autorização e ser capaz de entrar usuários com a plataforma de identidade da Microsoft.

  1. Para adicionar os namespaces necessários, abra Program.cs e adicione o seguinte trecho à parte superior do arquivo:

    using Microsoft.AspNetCore.Authentication.OpenIdConnect;
    using Microsoft.AspNetCore.Authorization;
    using Microsoft.AspNetCore.Mvc.Authorization;
    using Microsoft.Identity.Web;
    using Microsoft.Identity.Web.UI;
    using System.IdentityModel.Tokens.Jwt;
    
  2. Em seguida, adicione os serviços de autenticação ao aplicativo, o que permitirá que o aplicativo Web entre usuários com a plataforma de identidade da Microsoft. Você pode substituir o restante do código no Program.cs pelo seguinte trecho:

    var builder = WebApplication.CreateBuilder(args);
    
    // Add services to the container.
    builder.Services.AddControllersWithViews();
    
    // This is required to be instantiated before the OpenIdConnectOptions starts getting configured.
    // By default, the claims mapping will map claim names in the old format to accommodate older SAML applications.
    // For instance, 'http://schemas.microsoft.com/ws/2008/06/identity/claims/role' instead of 'roles' claim.
    // This flag ensures that the ClaimsIdentity claims collection will be built from the claims in the token
    JwtSecurityTokenHandler.DefaultMapInboundClaims = false;
    
    // Sign-in users with the Microsoft identity platform
    builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
        .AddMicrosoftIdentityWebApp(builder.Configuration)
        .EnableTokenAcquisitionToCallDownstreamApi()
        .AddInMemoryTokenCaches();
    
    builder.Services.AddControllersWithViews(options =>
    {
        var policy = new AuthorizationPolicyBuilder()
            .RequireAuthenticatedUser()
            .Build();
        options.Filters.Add(new AuthorizeFilter(policy));
    }).AddMicrosoftIdentityUI();
    
    var app = builder.Build();
    
    // Configure the HTTP request pipeline.
    if (!app.Environment.IsDevelopment())
    {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    
    app.UseRouting();
    app.UseAuthorization();
    
    app.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
    
    app.Run();
    
    

Próximo passo