Autenticazione e autorizzazione per le ZPSAuthentication and authorization for SPAs

ASP.NET Core 3,0 o versione successiva offre l'autenticazione in app a pagina singola (Spa) usando il supporto per l'autorizzazione dell'API.ASP.NET Core 3.0 or later offers authentication in Single Page Apps (SPAs) using the support for API authorization. ASP.NET Core identità per l'autenticazione e l'archiviazione degli utenti viene combinata con IdentityServer per l'implementazione di Open ID Connect.ASP.NET Core Identity for authenticating and storing users is combined with IdentityServer for implementing Open ID Connect.

Un parametro di autenticazione è stato aggiunto ai modelli di progetto angolari e React che è simile al parametro di autenticazione nell' applicazione Web ( MVC) e nell' applicazione Web (Razor Pages) modelli di progetto.An authentication parameter was added to the Angular and React project templates that is similar to the authentication parameter in the Web Application (Model-View-Controller) (MVC) and Web Application (Razor Pages) project templates. I valori dei parametri consentiti sono None e individual.The allowed parameter values are None and Individual. Il modello di progetto React. js e Redux non supporta il parametro Authentication al momento.The React.js and Redux project template doesn't support the authentication parameter at this time.

Creare un'app con supporto per l'autorizzazione APICreate an app with API authorization support

L'autenticazione e l'autorizzazione degli utenti possono essere usate sia con le ZPS angolari che React.User authentication and authorization can be used with both Angular and React SPAs. Aprire una shell dei comandi ed eseguire il comando seguente:Open a command shell, and run the following command:

Angolare:Angular:

dotnet new angular -o <output_directory_name> -au Individual

Reagire:React:

dotnet new react -o <output_directory_name> -au Individual

Il comando precedente crea un'app ASP.NET Core con una directory ClientApp contenente la Spa.The preceding command creates an ASP.NET Core app with a ClientApp directory containing the SPA.

Descrizione generale dei componenti ASP.NET Core dell'appGeneral description of the ASP.NET Core components of the app

Le sezioni seguenti descrivono le aggiunte al progetto quando è incluso il supporto per l'autenticazione:The following sections describe additions to the project when authentication support is included:

Classe StartupStartup class

La classe Startup presenta le aggiunte seguenti:The Startup class has the following additions:

  • All'interno del metodo Startup.ConfigureServices:Inside the Startup.ConfigureServices method:

    • Identità con l'interfaccia utente predefinita:Identity with the default UI:

      services.AddDbContext<ApplicationDbContext>(options =>
          options.UseSqlite(Configuration.GetConnectionString("DefaultConnection")));
      
      services.AddDefaultIdentity<ApplicationUser>()
          .AddDefaultUI(UIFramework.Bootstrap4)
          .AddEntityFrameworkStores<ApplicationDbContext>();
      
    • IdentityServer con un metodo helper AddApiAuthorization aggiuntivo che configura alcune convenzioni di ASP.NET Core predefinite in IdentityServer:IdentityServer with an additional AddApiAuthorization helper method that setups some default ASP.NET Core conventions on top of IdentityServer:

      services.AddIdentityServer()
          .AddApiAuthorization<ApplicationUser, ApplicationDbContext>();
      
    • Autenticazione con un metodo helper AddIdentityServerJwt aggiuntivo che configura l'app per convalidare i token JWT prodotti da IdentityServer:Authentication with an additional AddIdentityServerJwt helper method that configures the app to validate JWT tokens produced by IdentityServer:

      services.AddAuthentication()
          .AddIdentityServerJwt();
      
  • All'interno del metodo Startup.Configure:Inside the Startup.Configure method:

    • Il middleware di autenticazione responsabile della convalida delle credenziali della richiesta e dell'impostazione dell'utente nel contesto della richiesta:The authentication middleware that is responsible for validating the request credentials and setting the user on the request context:

      app.UseAuthentication();
      
    • Il middleware IdentityServer che espone gli endpoint di connessione Open ID:The IdentityServer middleware that exposes the Open ID Connect endpoints:

      app.UseIdentityServer();
      

AddApiAuthorizationAddApiAuthorization

Questo metodo helper configura IdentityServer in modo da usare la configurazione supportata.This helper method configures IdentityServer to use our supported configuration. IdentityServer è un Framework potente ed estendibile per la gestione dei problemi di sicurezza delle app.IdentityServer is a powerful and extensible framework for handling app security concerns. Allo stesso tempo, che espone complessità superflua per gli scenari più comuni.At the same time, that exposes unnecessary complexity for the most common scenarios. Di conseguenza, viene fornito un set di convenzioni e opzioni di configurazione che sono considerati un valido punto di partenza.Consequently, a set of conventions and configuration options is provided to you that are considered a good starting point. Una volta modificate le esigenze di autenticazione, è ancora disponibile la potenza completa di IdentityServer per personalizzare l'autenticazione in base alle esigenze.Once your authentication needs change, the full power of IdentityServer is still available to customize authentication to suit your needs.

AddIdentityServerJwtAddIdentityServerJwt

Questo metodo helper configura uno schema di criteri per l'app come gestore di autenticazione predefinito.This helper method configures a policy scheme for the app as the default authentication handler. Il criterio è configurato in modo da consentire all'identità di gestire tutte le richieste indirizzate a qualsiasi sottopercorso nello spazio URL identità "/Identity".The policy is configured to let Identity handle all requests routed to any subpath in the Identity URL space "/Identity". Il JwtBearerHandler gestisce tutte le altre richieste.The JwtBearerHandler handles all other requests. Questo metodo registra inoltre una risorsa API <<ApplicationName>>API con IdentityServer con un ambito predefinito di <<ApplicationName>>API e configura il middleware del token di porta JWT per convalidare i token emessi da IdentityServer per l'app.Additionally, this method registers an <<ApplicationName>>API API resource with IdentityServer with a default scope of <<ApplicationName>>API and configures the JWT Bearer token middleware to validate tokens issued by IdentityServer for the app.

WeatherForecastControllerWeatherForecastController

Nel file Controllers\WeatherForecastController.cs , si noti l'attributo [Authorize] applicato alla classe che indica che l'utente deve essere autorizzato in base ai criteri predefiniti per accedere alla risorsa.In the Controllers\WeatherForecastController.cs file, notice the [Authorize] attribute applied to the class that indicates that the user needs to be authorized based on the default policy to access the resource. I criteri di autorizzazione predefiniti vengono configurati per l'utilizzo dello schema di autenticazione predefinito, configurato dal AddIdentityServerJwt allo schema dei criteri menzionato in precedenza, rendendo il JwtBearerHandler configurato da tale metodo helper il gestore predefinito per le richieste a app.The default authorization policy happens to be configured to use the default authentication scheme, which is set up by AddIdentityServerJwt to the policy scheme that was mentioned above, making the JwtBearerHandler configured by such helper method the default handler for requests to the app.

ApplicationDbContextApplicationDbContext

Nel file Data\ApplicationDbContext.cs si noti che lo stesso DbContext viene usato nell'identità con l'eccezione che estende ApiAuthorizationDbContext (una classe più derivata da IdentityDbContext) per includere lo schema per IdentityServer.In the Data\ApplicationDbContext.cs file, notice the same DbContext is used in Identity with the exception that it extends ApiAuthorizationDbContext (a more derived class from IdentityDbContext) to include the schema for IdentityServer.

Per ottenere il controllo completo dello schema del database, ereditare da una delle classi Identity DbContext disponibili e configurare il contesto per includere lo schema di identità chiamando builder.ConfigurePersistedGrantContext(_operationalStoreOptions.Value) sul metodo OnModelCreating.To gain full control of the database schema, inherit from one of the available Identity DbContext classes and configure the context to include the Identity schema by calling builder.ConfigurePersistedGrantContext(_operationalStoreOptions.Value) on the OnModelCreating method.

OidcConfigurationControllerOidcConfigurationController

Nel file Controllers\OidcConfigurationController.cs , si noti l'endpoint di cui è stato effettuato il provisioning per gestire i parametri di OIDC che il client deve usare.In the Controllers\OidcConfigurationController.cs file, notice the endpoint that's provisioned to serve the OIDC parameters that the client needs to use.

appsettings.jsonappsettings.json

Nel file appSettings. JSON della radice del progetto è presente una nuova sezione IdentityServer che descrive l'elenco dei client configurati.In the appsettings.json file of the project root, there's a new IdentityServer section that describes the list of configured clients. Nell'esempio seguente è presente un singolo client.In the following example, there's a single client. Il nome del client corrisponde al nome dell'app e viene mappato per convenzione al parametro OAuth ClientId.The client name corresponds to the app name and is mapped by convention to the OAuth ClientId parameter. Il profilo indica il tipo di app da configurare.The profile indicates the app type being configured. Viene usato internamente per guidare le convenzioni che semplificano il processo di configurazione per il server.It's used internally to drive conventions that simplify the configuration process for the server. Sono disponibili diversi profili, come illustrato nella sezione profili applicazione .There are several profiles available, as explained in the Application profiles section.

"IdentityServer": {
  "Clients": {
    "angularindividualpreview3final": {
      "Profile": "IdentityServerSPA"
    }
  }
}

appSettings. Development. JSONappsettings.Development.json

In appSettings. File Development. JSON della radice del progetto, è presente una sezione IdentityServer che descrive la chiave usata per firmare i token.In the appsettings.Development.json file of the project root, there's an IdentityServer section that describes the key used to sign tokens. Quando si esegue la distribuzione nell'ambiente di produzione, è necessario eseguire il provisioning di una chiave e distribuirla insieme all'app, come illustrato nella sezione Deploy to Production .When deploying to production, a key needs to be provisioned and deployed alongside the app, as explained in the Deploy to production section.

"IdentityServer": {
  "Key": {
    "Type": "Development"
  }
}

Descrizione generale dell'app angolareGeneral description of the Angular app

Il supporto per l'autenticazione e l'autorizzazione API nel modello angolare si trova nel proprio modulo angolare nella directory ClientApp\src\api-AuthorizationThe authentication and API authorization support in the Angular template resides in its own Angular module in the ClientApp\src\api-authorization directory. Il modulo è costituito dagli elementi seguenti:The module is composed of the following elements:

  • 3 componenti:3 components:
    • login. Component. TS: gestisce il flusso di accesso dell'app.login.component.ts: Handles the app's login flow.
    • Logout. Component. TS: gestisce il flusso di disconnessione dell'app.logout.component.ts: Handles the app's logout flow.
    • login-menu. Component. TS: widget che visualizza uno dei seguenti set di collegamenti:login-menu.component.ts: A widget that displays one of the following sets of links:
      • Collegamenti di gestione dei profili utente e disconnessione quando l'utente viene autenticato.User profile management and log out links when the user is authenticated.
      • Collegamenti per la registrazione e l'accesso quando l'utente non è autenticato.Registration and log in links when the user isn't authenticated.
  • Un AuthorizeGuard di route Guard che può essere aggiunto alle route e richiede che un utente venga autenticato prima di visitare la route.A route guard AuthorizeGuard that can be added to routes and requires a user to be authenticated before visiting the route.
  • Un intercettore HTTP AuthorizeInterceptor che connette il token di accesso alle richieste HTTP in uscita destinate all'API quando l'utente viene autenticato.An HTTP interceptor AuthorizeInterceptor that attaches the access token to outgoing HTTP requests targeting the API when the user is authenticated.
  • AuthorizeService del servizio che gestisce i dettagli di basso livello del processo di autenticazione ed espone le informazioni relative all'utente autenticato al resto dell'app per l'utilizzo.A service AuthorizeService that handles the lower-level details of the authentication process and exposes information about the authenticated user to the rest of the app for consumption.
  • Un modulo angolare che definisce le route associate alle parti di autenticazione dell'app.An Angular module that defines routes associated with the authentication parts of the app. Espone il componente del menu di accesso, l'intercettore, il Guard e il servizio per l'utilizzo dal resto dell'app.It exposes the login menu component, the interceptor, the guard, and the service for consumption from the rest of the app.

Descrizione generale dell'app ReactGeneral description of the React app

Il supporto per l'autenticazione e l'autorizzazione API nel modello React risiede nella directory ClientApp\src\components\api-AuthorizationThe support for authentication and API authorization in the React template resides in the ClientApp\src\components\api-authorization directory. È costituito dagli elementi seguenti:It's composed of the following elements:

  • 4 componenti:4 components:
    • Login. js: gestisce il flusso di accesso dell'app.Login.js: Handles the app's login flow.
    • Logout. js: gestisce il flusso di disconnessione dell'app.Logout.js: Handles the app's logout flow.
    • LoginMenu. js: widget che visualizza uno dei seguenti set di collegamenti:LoginMenu.js: A widget that displays one of the following sets of links:
      • Collegamenti di gestione dei profili utente e disconnessione quando l'utente viene autenticato.User profile management and log out links when the user is authenticated.
      • Collegamenti per la registrazione e l'accesso quando l'utente non è autenticato.Registration and log in links when the user isn't authenticated.
    • AuthorizeRoute. js: componente di route che richiede l'autenticazione di un utente prima di eseguire il rendering del componente indicato nel parametro Component.AuthorizeRoute.js: A route component that requires a user to be authenticated before rendering the component indicated in the Component parameter.
  • Istanza di authService esportata della classe AuthorizeService che gestisce i dettagli di basso livello del processo di autenticazione ed espone le informazioni relative all'utente autenticato al resto dell'app per l'utilizzo.An exported authService instance of class AuthorizeService that handles the lower-level details of the authentication process and exposes information about the authenticated user to the rest of the app for consumption.

Ora che sono stati esaminati i componenti principali della soluzione, è possibile approfondire i singoli scenari per l'app.Now that you've seen the main components of the solution, you can take a deeper look at individual scenarios for the app.

Richiedi autorizzazione per una nuova APIRequire authorization on a new API

Per impostazione predefinita, il sistema è configurato in modo da richiedere facilmente l'autorizzazione per le nuove API.By default, the system is configured to easily require authorization for new APIs. A tale scopo, creare un nuovo controller e aggiungere l'attributo [Authorize] alla classe controller o a qualsiasi azione all'interno del controller.To do so, create a new controller and add the [Authorize] attribute to the controller class or to any action within the controller.

Personalizzare il gestore di autenticazione APICustomize the API authentication handler

Per personalizzare la configurazione del gestore JWT dell'API, configurare la relativa istanza di JwtBearerOptions:To customize the configuration of the API's JWT handler, configure its JwtBearerOptions instance:

services.AddAuthentication()
    .AddIdentityServerJwt();

services.Configure<JwtBearerOptions>(
    IdentityServerJwtConstants.IdentityServerJwtBearerScheme,
    options =>
    {
        ...
    });

Il gestore JWT dell'API genera eventi che consentono di controllare il processo di autenticazione usando JwtBearerEvents.The API's JWT handler raises events that enable control over the authentication process using JwtBearerEvents. Per fornire supporto per l'autorizzazione API, AddIdentityServerJwt registra i propri gestori eventi.To provide support for API authorization, AddIdentityServerJwt registers its own event handlers.

Per personalizzare la gestione di un evento, eseguire il wrapping del gestore eventi esistente con logica aggiuntiva, se necessario.To customize the handling of an event, wrap the existing event handler with additional logic as required. Esempio:For example:

services.Configure<JwtBearerOptions>(
    IdentityServerJwtConstants.IdentityServerJwtBearerScheme,
    options =>
    {
        var onTokenValidated = options.Events.OnTokenValidated;       
        
        options.Events.OnTokenValidated = async context =>
        {
            await onTokenValidated(context);
            ...
        }
    });

Nel codice precedente, il gestore dell'evento OnTokenValidated viene sostituito con un'implementazione personalizzata.In the preceding code, the OnTokenValidated event handler is replaced with a custom implementation. Questa implementazione:This implementation:

  1. Chiama l'implementazione originale fornita dal supporto dell'autorizzazione dell'API.Calls the original implementation provided by the API authorization support.
  2. Eseguire la propria logica personalizzata.Run its own custom logic.

Proteggere una route lato client (angolare)Protect a client-side route (Angular)

Per la protezione di una route sul lato client, è necessario aggiungere l'autorizzazione Guard all'elenco delle protezioni da eseguire durante la configurazione di una route.Protecting a client-side route is done by adding the authorize guard to the list of guards to run when configuring a route. Come esempio, è possibile vedere come viene configurata la route fetch-data all'interno del modulo principale dell'app angolare:As an example, you can see how the fetch-data route is configured within the main app Angular module:

RouterModule.forRoot([
  // ...
  { path: 'fetch-data', component: FetchDataComponent, canActivate: [AuthorizeGuard] },
])

È importante ricordare che la protezione di una route non protegge l'endpoint effettivo (che richiede ancora un attributo [Authorize] applicato), ma che impedisce all'utente di passare alla route specificata sul lato client quando non è autenticato.It's important to mention that protecting a route doesn't protect the actual endpoint (which still requires an [Authorize] attribute applied to it) but that it only prevents the user from navigating to the given client-side route when it isn't authenticated.

Autenticare le richieste API (angolare)Authenticate API requests (Angular)

L'autenticazione delle richieste alle API ospitate insieme all'app viene eseguita automaticamente tramite l'uso dell'intercettore client HTTP definito dall'app.Authenticating requests to APIs hosted alongside the app is done automatically through the use of the HTTP client interceptor defined by the app.

Proteggere una route lato client (React)Protect a client-side route (React)

Proteggere una route sul lato client usando il componente AuthorizeRoute anziché il componente Route normale.Protect a client-side route by using the AuthorizeRoute component instead of the plain Route component. Si noti, ad esempio, il modo in cui la route fetch-data viene configurata all'interno del componente App:For example, notice how the fetch-data route is configured within the App component:

<AuthorizeRoute path='/fetch-data' component={FetchData} />

Protezione di una route:Protecting a route:

  • Non protegge l'endpoint effettivo (che richiede ancora un attributo [Authorize] applicato).Doesn't protect the actual endpoint (which still requires an [Authorize] attribute applied to it).
  • Impedisce solo all'utente di passare alla route specificata sul lato client quando non viene autenticata.Only prevents the user from navigating to the given client-side route when it isn't authenticated.

Autenticare le richieste API (React)Authenticate API requests (React)

L'autenticazione delle richieste con React viene eseguita importando innanzitutto l'istanza authService dalla AuthorizeService.Authenticating requests with React is done by first importing the authService instance from the AuthorizeService. Il token di accesso viene recuperato dalla authService ed è associato alla richiesta, come illustrato di seguito.The access token is retrieved from the authService and is attached to the request as shown below. Nei componenti React questa operazione viene in genere eseguita nel metodo componentDidMount Lifecycle o come risultato di un'interazione dell'utente.In React components, this work is typically done in the componentDidMount lifecycle method or as the result from some user interaction.

Importare authService nel componenteImport the authService into your component

import authService from './api-authorization/AuthorizeService'

Recupera e alleghi il token di accesso alla rispostaRetrieve and attach the access token to the response

async populateWeatherData() {
  const token = await authService.getAccessToken();
  const response = await fetch('api/SampleData/WeatherForecasts', {
    headers: !token ? {} : { 'Authorization': `Bearer ${token}` }
  });
  const data = await response.json();
  this.setState({ forecasts: data, loading: false });
}

Distribuisci in produzioneDeploy to production

Per distribuire l'app nell'ambiente di produzione, è necessario eseguire il provisioning delle risorse seguenti:To deploy the app to production, the following resources need to be provisioned:

  • Un database per archiviare gli account utente di identità e le concessioni IdentityServer.A database to store the Identity user accounts and the IdentityServer grants.
  • Un certificato di produzione da usare per firmare i token.A production certificate to use for signing tokens.
    • Non sono previsti requisiti specifici per il certificato. può essere un certificato autofirmato o un certificato sottoposti a provisioning tramite un'autorità di certificazione.There are no specific requirements for this certificate; it can be a self-signed certificate or a certificate provisioned through a CA authority.
    • Può essere generato tramite strumenti standard come PowerShell o OpenSSL.It can be generated through standard tools like PowerShell or OpenSSL.
    • Può essere installata nell'archivio certificati nei computer di destinazione o distribuita come file con estensione pfx con una password complessa.It can be installed into the certificate store on the target machines or deployed as a .pfx file with a strong password.

Esempio: distribuire in siti Web di AzureExample: Deploy to Azure Websites

Questa sezione descrive la distribuzione dell'app in siti Web di Azure usando un certificato archiviato nell'archivio certificati.This section describes deploying the app to Azure websites using a certificate stored in the certificate store. Per modificare l'app per caricare un certificato dall'archivio certificati, il piano di servizio app deve trovarsi almeno nel livello standard quando si configura in un passaggio successivo.To modify the app to load a certificate from the certificate store, the App Service plan needs to be on at least the Standard tier when you configure in a later step. Nel file appSettings. JSON dell'app modificare la sezione IdentityServer per includere i dettagli della chiave:In the app's appsettings.json file, modify the IdentityServer section to include the key details:

"IdentityServer": {
  "Key": {
    "Type": "Store",
    "StoreName": "My",
    "StoreLocation": "CurrentUser",
    "Name": "CN=MyApplication"
  }
}
  • La proprietà Name del certificato corrisponde all'oggetto distinto per il certificato.The name property on certificate corresponds with the distinguished subject for the certificate.
  • Il percorso dell'archivio indica dove caricare il certificato (CurrentUser o LocalMachine).The store location represents where to load the certificate from (CurrentUser or LocalMachine).
  • Il nome dell'archivio rappresenta il nome dell'archivio certificati in cui è archiviato il certificato.The store name represents the name of the certificate store where the certificate is stored. In questo caso, fa riferimento all'archivio utenti personali.In this case, it points to the personal user store.

Per eseguire la distribuzione in siti Web di Azure, distribuire l'app seguendo la procedura descritta in distribuire l'app in Azure per creare le risorse di Azure necessarie e distribuire l'app nell'ambiente di produzione.To deploy to Azure Websites, deploy the app following the steps in Deploy the app to Azure to create the necessary Azure resources and deploy the app to production.

Dopo aver seguito le istruzioni precedenti, l'app viene distribuita in Azure, ma non è ancora funzionante.After following the preceding instructions, the app is deployed to Azure but isn't yet functional. È ancora necessario configurare il certificato usato dall'app.The certificate used by the app still needs to be set up. Individuare l'identificazione personale per il certificato da usare e seguire i passaggi descritti in caricare i certificati.Locate the thumbprint for the certificate to be used, and follow the steps described in Load your certificates.

Sebbene questi passaggi menzionino SSL, nel portale è presente una sezione relativa ai certificati privati in cui è possibile caricare il certificato di cui è stato effettuato il provisioning da usare con l'app.While these steps mention SSL, there's a Private certificates section on the portal where you can upload the provisioned certificate to use with the app.

Dopo questo passaggio, riavviare l'app e dovrebbe essere funzionante.After this step, restart the app and it should be functional.

Altre opzioni di configurazioneOther configuration options

Il supporto per l'autorizzazione API si basa su IdentityServer con un set di convenzioni, valori predefiniti e miglioramenti per semplificare l'esperienza per le Spa.The support for API authorization builds on top of IdentityServer with a set of conventions, default values, and enhancements to simplify the experience for SPAs. Inutile dire che la potenza completa di IdentityServer è disponibile dietro le quinte se le integrazioni ASP.NET Core non coprono lo scenario.Needless to say, the full power of IdentityServer is available behind the scenes if the ASP.NET Core integrations don't cover your scenario. Il supporto ASP.NET Core si concentra sulle app "First-Party", in cui tutte le app vengono create e distribuite dall'organizzazione.The ASP.NET Core support is focused on "first-party" apps, where all the apps are created and deployed by our organization. Di conseguenza, il supporto non viene offerto per elementi come il consenso o la Federazione.As such, support isn't offered for things like consent or federation. Per questi scenari, usare IdentityServer e seguire la relativa documentazione.For those scenarios, use IdentityServer and follow their documentation.

Profili applicazioneApplication profiles

I profili dell'applicazione sono configurazioni predefinite per le app che definiscono ulteriormente i parametri.Application profiles are predefined configurations for apps that further define their parameters. A questo punto sono supportati i profili seguenti:At this time, the following profiles are supported:

  • IdentityServerSPA: rappresenta una SPA ospitata insieme a IdentityServer come singola unità.IdentityServerSPA: Represents a SPA hosted alongside IdentityServer as a single unit.
    • Per impostazione predefinita, il redirect_uri viene /authentication/login-callback.The redirect_uri defaults to /authentication/login-callback.
    • Per impostazione predefinita, il post_logout_redirect_uri viene /authentication/logout-callback.The post_logout_redirect_uri defaults to /authentication/logout-callback.
    • Il set di ambiti include la openid, profilee ogni ambito definito per le API nell'app.The set of scopes includes the openid, profile, and every scope defined for the APIs in the app.
    • Il set di tipi di risposta OIDC consentiti è id_token token o singolarmente (id_token, token).The set of allowed OIDC response types is id_token token or each of them individually (id_token, token).
    • La modalità di risposta consentita è fragment.The allowed response mode is fragment.
  • SPA: rappresenta una SPA non ospitata con IdentityServer.SPA: Represents a SPA that isn't hosted with IdentityServer.
    • Il set di ambiti include la openid, profilee ogni ambito definito per le API nell'app.The set of scopes includes the openid, profile, and every scope defined for the APIs in the app.
    • Il set di tipi di risposta OIDC consentiti è id_token token o singolarmente (id_token, token).The set of allowed OIDC response types is id_token token or each of them individually (id_token, token).
    • La modalità di risposta consentita è fragment.The allowed response mode is fragment.
  • IdentityServerJwt: rappresenta un'API ospitata insieme a IdentityServer.IdentityServerJwt: Represents an API that is hosted alongside with IdentityServer.
    • L'app è configurata in modo da avere un singolo ambito per impostazione predefinita sul nome dell'app.The app is configured to have a single scope that defaults to the app name.
  • API: rappresenta un'API non ospitata con IdentityServer.API: Represents an API that isn't hosted with IdentityServer.
    • L'app è configurata in modo da avere un singolo ambito per impostazione predefinita sul nome dell'app.The app is configured to have a single scope that defaults to the app name.

Configurazione tramite AppSettingsConfiguration through AppSettings

Configurare le app tramite il sistema di configurazione aggiungendole all'elenco di Clients o Resources.Configure the apps through the configuration system by adding them to the list of Clients or Resources.

Configurare la proprietà redirect_uri e post_logout_redirect_uri di ogni client, come illustrato nell'esempio seguente:Configure each client's redirect_uri and post_logout_redirect_uri property, as shown in the following example:

"IdentityServer": {
  "Clients": {
    "MySPA": {
      "Profile": "SPA",
      "RedirectUri": "https://www.example.com/authentication/login-callback",
      "LogoutUri": "https://www.example.com/authentication/logout-callback"
    }
  }
}

Quando si configurano le risorse, è possibile configurare gli ambiti per la risorsa come illustrato di seguito:When configuring resources, you can configure the scopes for the resource as shown below:

"IdentityServer": {
  "Resources": {
    "MyExternalApi": {
      "Profile": "API",
      "Scopes": "a b c"
    }
  }
}

Configurazione tramite codiceConfiguration through code

È anche possibile configurare i client e le risorse tramite il codice usando un overload di AddApiAuthorization che esegue un'azione per configurare le opzioni.You can also configure the clients and resources through code using an overload of AddApiAuthorization that takes an action to configure options.

AddApiAuthorization<ApplicationUser, ApplicationDbContext>(options =>
{
    options.Clients.AddSPA(
        "My SPA", spa =>
        spa.WithRedirectUri("http://www.example.com/authentication/login-callback")
           .WithLogoutRedirectUri(
               "http://www.example.com/authentication/logout-callback"));

    options.ApiResources.AddApiResource("MyExternalApi", resource =>
        resource.WithScopes("a", "b", "c"));
});

Risorse aggiuntiveAdditional resources