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

Artigo
06/29/2024

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

Tutorial: Prepare seu locatário externo para criar um aplicativo Web ASP.NET Core.
Embora qualquer ambiente de desenvolvimento integrado (IDE) que ofereça suporte a aplicativos ASP.NET Core possa ser usado, este tutorial usa o Visual Studio Code. Você pode baixá-lo aqui.
SDK do .NET 7.0.

Criar um projeto Web ASP.NET Core

Abra o Visual Studio Code, selecione File>Open Folder.... Navegue até o local para criar seu projeto e selecione-o.
Abra um novo terminal selecionando Terminal>New Terminal.
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.

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

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.
Salve as alterações no arquivo.
Abra o arquivo Propriedades/launchSettings.json .
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.
Salve as alterações no arquivo.

Usar domínio de URL 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:

Use as etapas em Habilitar domínios de URL personalizados para aplicativos em locatários externos para habilitar o domínio de URL personalizado para seu locatário externo.
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 seu domínio de URL personalizado e Enter_the_Tenant_ID_Here pelo seu ID de inquilino. 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 o domínio de URL personalizado estiver login.contoso.com e o 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.

No editor de códigos, abra o arquivo Controllers\HomeController.cs .
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;
```
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.

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;

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

Etapa 3: Adicionar entrada e saída a um aplicativo Web ASP.NET Core para um locatário externo

Partilhar via