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

Artigo
07/25/2024

Este tutorial é a 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 primeira parte dessa série, você registrou um aplicativo e configurou os fluxos de usuário no seu locatário externo. Este tutorial demonstra como criar um aplicativo Web ASP.NET Core e configurá-lo para autenticação.

Neste tutorial você irá;

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

Pré-requisitos

Tutorial: Preparar o locatário externo para a criação de um aplicativo Web ASP.NET Core.
Embora qualquer ambiente de desenvolvimento integrado (IDE) que dê suporte a aplicativos ASP.NET Core possa ser utilizado, esse tutorial usa o Visual Studio Code. Você pode baixá-lo aqui.
SDK do .NET 7.0.

Criar um projeto ASP.NET Core

Abra o Visual Studio Code, selecione Arquivo>Abrir Pasta.... Navegue e selecione o local no qual criar seu projeto.
Abra um novo terminal selecione Terminal>Novo Terminal.
Insira o seguinte comando para criar um projeto ASP.NET Core Model View Controller (MVC).
```
dotnet new mvc -n dotnetcore_webapp
```

Instalar os pacotes de identidades

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

Digite 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 snippet 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-alvo de conexão do aplicativo. Substitua Enter_the_Tenant_Subdomain_Here pelo subdomínio do seu locatário externo. Para encontrar essa informação, selecione Visão geral no menu da barra lateral e alterne para a guia Visão geral. Localize o domínio Primário, no formulário caseyjensen.onmicrosoft.com. O subdomínio é caseyjensen.
- ClientId – O identificador do aplicativo, também conhecido como cliente. Substitua o texto entre aspas pelo valor da ID do Aplicativo (locatário) 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 Preparar seu locatário. Substitua o texto entre aspas pelo valor do segredo 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 Properties/launchSettings.json.
Na seção https de profiles, altere a URL https em applicationUrl para que ela 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 o nome de domínio ciamlogin.com.

Siga essas 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 uma URL de domínio personalizado para o seu locatário externo.
Abra o arquivo appsettings.json:
1. Atualize o valor da propriedade Authority para https://Enter_the_Custom_Domain_Here/Enter_the_Tenant_ID_Here. Substitua Enter_the_Custom_Domain_Here pelo domínio de URL personalizado e Enter_the_Tenant_ID_Here pela ID do locatário. Se você não tiver o nome do locatário, saiba como ler os detalhes do locatário.
2. Adicione a propriedade knownAuthorities com um valor [Insira_o_Domínio_Personalizado_Aqui].

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

{
  "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 da página inicial do aplicativo e precisa ter a capacidade de autorizar o usuário. O namespace Microsoft.AspNetCore.Authorization fornece as classes e interfaces para implementar a autorização para o aplicativo Web e o atributo [Authorize] é usado para especificar que apenas usuários autenticados podem usar o aplicativo Web.

No editor de código, 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 snippet:
```
using System.Diagnostics;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using dotnetcore_webapp.Models;
```
Além disso, adicione o atributo [Authorize] diretamente acima da definição da classe HomeController.
```
[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 poder conectar usuários com a plataforma de identidade da Microsoft.

Para adicionar os namespaces necessários, abra Program.cs e adicione o seguinte trecho de código ao início 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 que permitirão que o aplicativo Web conecte usuários com a plataforma de identidade da Microsoft. Você pode substituir o restante do código em Program.cs pelo seguinte trecho de código:

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óxima etapa

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

Compartilhar via