Esercitazione: Chiamare un'API protetta da un'app di servizio .NET

Articolo
03/05/2025

si applica a: indicatore verde con un segno di spunta bianco. dipendenti utenti esterni (scopri di più)

Questa esercitazione illustra come chiamare un'API Web protetta da un'app daemon .NET. Si abilita l'app daemon client per acquisire un token di accesso usando la propria identità, quindi chiamare l'API Web. Nel nostro caso, chiamiamo un endpoint Microsoft Graph protetto.

In questa esercitazione;

Configurare un'app daemon per utilizzare i suoi dettagli di registrazione. Assicurarsi di concedere all'app l'autorizzazione User.Read.All per l'API Microsoft Graph.
Creare un'app daemon che acquisisce un token per proprio conto e chiama un'API Web protetta.

Prerequisiti

.NET. In questa esercitazione si usa .NET 9.0.
Visual Studio Code o un altro editor di codice.
Un di registrazione dell'app nel tenant. Assicurarsi di avere le informazioni seguenti nei dettagli di registrazione dell'app:
- L'ID dell'applicazione (client) dell'app client web che hai registrato.
- L'ID Directory (tenant) in cui è stata registrata l'applicazione web.
- Il valore del segreto del client per l'applicazione web che hai creato.

Creare un'app daemon .NET

Aprire il terminale e passare alla cartella in cui si vuole che il progetto sia attivo.
Inizializzare un'app console .NET e passare alla relativa cartella radice.
```
dotnet new console -n DotnetDaemon
cd DotnetDaemon
```

Installare i pacchetti

Installare pacchetti Microsoft.Identity.Web e Microsoft.Identity.Web.DownstreamApi:

dotnet add package Microsoft.Identity.Web
dotnet add package Microsoft.Identity.Web.DownstreamApi

Microsoft.Identity.Web fornisce l'associazione tra ASP.NET Core, il middleware di autenticazione e Microsoft Authentication Library (MSAL) per .NET semplificando l'aggiunta di funzionalità di autenticazione e autorizzazione all'app. Microsoft.Identity.Web.DownstreamApi fornisce un'interfaccia usata per chiamare un'API downstream.

Creare il file appsettings.json e aggiungere le configurazioni di registrazione

Creare appsettings.json file nella cartella radice dell'app.

Aggiungere i dettagli di registrazione dell'app al file appsettings.json.

{
    "AzureAd": {
        // "Authority": "", you can use this for customer tenants in place of Instance and TenantId values
        "Instance": "https://login.microsoftonline.com/",
        "TenantId": "Enter_the_Tenant_ID_Here",
        "ClientId": "Enter_the_Application_ID_Here",
        "ClientCredentials": [
            {
                "SourceType": "ClientSecret",
                "ClientSecret": "Enter_the_Client_Secret_Here"
            }
        ]
    },
    "DownstreamApi": {
        "BaseUrl": "https://graph.microsoft.com",
        "RelativePath": "/v1.0/users/",
        "RequestAppToken": true,
        "Scopes": [
            "https://graph.microsoft.com/.default"
        ]
    }
}

Sostituire i valori seguenti con i valori personalizzati:

Valore	Descrizione
Inserisci_l'ID_dell'Applicazione_qui	ID applicazione (client) dell'app daemon client registrata.
Inserisci_il_Client_Secret_qui	Valore segreto dell'app daemon che hai creato.
Inserisci_l'Identificativo_del_Locatario_Qui	L'ID del tenant della directory in cui è registrata l'app.

Nota

Per le app registrate nel tenant esterno, è possibile usare Authority e rimuovere sia 'istanza che TenantId.

"Authority": "https://<Enter_the_Tenant_Subdomain_Here>.ciamlogin.com/". Dove Enter_the_Tenant_Subdomain_Here è il sottodominio del locatario.

Aggiungere il file appsettings.json al file di progetto. Il file di progetto è un file .csproj nel tuo progetto. Ciò è dovuto al fatto che il file deve essere copiato nella directory di output.
```
<ItemGroup>
    <None Update="appsettings.json">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>
```

Acquisire il token di accesso

Aprire il file program.cs nell'editor di codice ed eliminarlo.

Aggiungere i pacchetti al file.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Identity.Abstractions;
using Microsoft.Identity.Web;

Creare l'istanza di acquisizione del token. Usare il metodo GetDefaultInstance della classe TokenAcquirerFactory del pacchetto di Microsoft.Identity.Web per compilare l'istanza di acquisizione del token. Per impostazione predefinita, l'istanza legge un file appsettings.json se presente nella stessa cartella dell'app. GetDefaultInstance consente anche di aggiungere servizi alla raccolta di servizi.

Aggiungere questa riga di codice al file program.cs:
```
var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();
```
Configurare le opzioni dell'applicazione da leggere dalla configurazione e aggiungere il servizio DownstreamApi. Il servizio DownstreamApi fornisce un'interfaccia usata per chiamare un'API downstream. Questo servizio viene chiamato DownstreamAPI nell'oggetto config. L'app daemon legge le configurazioni dell'API Downstream dalla sezione DownstreamApi di appsettings.json. Per impostazione predefinita, si ottiene una cache dei token in memoria.

Aggiungere il frammento di codice seguente al file program.cs:
```
const string ServiceName = "DownstreamApi";

tokenAcquirerFactory.Services.AddDownstreamApi(ServiceName,
    tokenAcquirerFactory.Configuration.GetSection("DownstreamApi"));
```
L'API downstream chiamata è Microsoft Graph. In questa esercitazione viene usato il servizio DownstreamApi. È anche possibile usare Microsoft Graph SDK.
Costruire l'acquirer del token. Questo comando compone tutti i servizi aggiunti e restituisce un provider di servizi. Usare questo provider di servizi per ottenere l'accesso alla risorsa API aggiunta. In questo caso, si aggiunge una sola risorsa API come servizio downstream a cui si vuole accedere.

Aggiungere il frammento di codice seguente al file program.cs:
```
var serviceProvider = tokenAcquirerFactory.Build();
```

Chiamare l'API Web

Aggiungere codice per chiamare l'API Web protetta usando l'interfaccia IDownstreamApi. In questa esercitazione, chiamiamo un endpoint dell'API Microsoft Graph.

Aggiungere questo codice al file program.cs:

try
{
    IDownstreamApi downstreamApi = serviceProvider.GetRequiredService<IDownstreamApi>();

    var response = await downstreamApi.GetForAppAsync<HttpResponseMessage>("DownstreamApi");
    var content = await response.Content.ReadAsStringAsync();
    var statusCode = response.StatusCode;

    Console.WriteLine($"Response status code: {statusCode}");

    if (!content.Any())
    {
        Console.WriteLine("There are no users to display.");
        return;
    }

    Console.WriteLine(content);
}
catch (Exception ex) { Console.WriteLine("We could not retrieve the user's list: " + $"{ex}"); }

Il codice chiama l'endpoint definito nel file appsettings.json. Il metodo GetForAppAsync dell'interfaccia IDownstreamApi viene usato per chiamare l'endpoint. L'app effettua una chiamata per proprio conto. Il metodo restituisce un oggetto HttpResponseMessage. La risposta viene quindi letta come stringa e visualizzata nella console.

Avviare l'applicazione daemon client

Passare alla cartella radice dell'app daemon ed eseguire il comando seguente:

dotnet run

Se tutto va bene, dovresti vedere il codice di stato della risposta: OK, nel terminale. Se sono presenti utenti, gli utenti vengono elencati nel terminale; in caso contrario, viene visualizzato il messaggio Non sono presenti utenti da visualizzare.

Se si verificano errori, viene visualizzato un messaggio di errore nel terminale.

Risoluzione dei problemi

In caso di errori,

Conferma i dettagli di registrazione aggiunti al file di appsettings.json.
Verificare di aver aggiunto il file appsettings.json al file di progetto.
Verificare che le autorizzazioni dell'app siano configurate correttamente.

Condividi tramite