Självstudie: Anropa ett skyddat webb-API från din .NET-daemonapp

Artikel
04/10/2024

Den här självstudien är den sista delen i en serie som visar hur du anropar ett skyddat webb-API från en .NET-daemonapp. I del 1 av den här serien förberedde du din externa klientorganisation för att auktorisera en .NET-daemonapp. I den här självstudien skapar du din klientdaemonapp och anropar ett skyddat webb-API. Du gör det möjligt för klientdaemonappen att hämta en åtkomsttoken med sin egen identitet och anropa sedan webb-API:et.

I den här självstudien;

Konfigurera en daemonapp så att den använder appregistreringsinformation.
Skapa en daemonapp som hämtar en token för egen räkning och anropar ett skyddat webb-API.

Förutsättningar

Självstudie: Förbereda din externa klientorganisation för att auktorisera ett .NET-daemonprogram

Skapa en .NET-daemonapp

Öppna terminalen och gå till mappen där du vill att projektet ska finnas.

Initiera en .NET-konsolapp och navigera till rotmappen.

dotnet new console -n ToDoListClient
cd ToDoListClient

Installera paket

Installera Microsoft.Identity.Web och Microsoft.Identity.Web.DownstreamApi paket:

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

Microsoft.Identity.Web innehåller limmet mellan ASP.NET Core, mellanprogrammet för autentisering och Microsoft Authentication Library (MSAL) för .NET, vilket gör det enklare för dig att lägga till funktioner för autentisering och auktorisering i din app. Microsoft.Identity.Web.DownstreamApi tillhandahåller ett gränssnitt som används för att anropa ett underordnat API.

Skapa appsettings.json fil och lägg till registreringskonfigurationer

Skapa appsettings.json fil i appens rotmapp.

Lägg till appregistreringsinformation i appsettings.json-filen.

{
    "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>"
            }
        ]
    },
    "DownstreamApi": {
        "BaseUrl": "<Web_API_base_url>",
        "RelativePath": "api/todolist",
        "RequestAppToken": true,
        "Scopes": [
            "api://<Enter_the_Web_Api_Application_Id_Here>/.default"
        ]
    }
}

Ersätt följande värden med dina egna:

Värde	beskrivning
Enter_the_Application_Id_Here	Program-ID:t (klient) för klientdaemonappen som du registrerade.
Enter_the_Tenant_Subdomain_Here	Underdomänen Katalog (klientorganisation).
Enter_the_Client_Secret_Here	Det hemliga värdet för daemonappen som du skapade.
Enter_the_Web_Api_Application_Id_Here	Program-ID :t (klient) för webb-API-appen som du registrerade.
Web_API_base_url	Webb-API:ets bas-URL. Till exempel där `https://localhost:44351/` 44351 är portnumret för den port som ditt API körs på. Api:et bör redan köras och vänta på begäranden i det här steget så att du kan hämta det här värdet.

Lägg till modeller

Navigera till roten i projektmappen och skapa en modellmapp . I mappen models skapar du en ToDo.cs-fil och lägger till följande kod:

using System;

namespace ToDoListClient.Models;

public class ToDo
{
    public int Id { get; set; }
    public Guid Owner { get; set; }
    public string Description { get; set; } = string.Empty;
}

Hämta åtkomsttoken

Nu har du konfigurerat de nödvändiga objekten i för ditt daemon-program. I det här steget skriver du koden som gör att daemon-appen kan hämta en åtkomsttoken.

Öppna filen program.cs i kodredigeraren och ta bort dess innehåll.

Lägg till paketen i filen.

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

Skapa tokeninsamlingsinstansen. GetDefaultInstance Använd metoden för paketklassen TokenAcquirerFactoryMicrosoft.Identity.Web för att skapa tokeninsamlingsinstansen. Som standard läser instansen en appsettings.json fil om den finns i samma mapp som appen. GetDefaultInstance gör det också möjligt för oss att lägga till tjänster i tjänstsamlingen.

Lägg till den här kodraden i filen program.cs :
```
var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();
```
Konfigurera programalternativen som ska läsas från konfigurationen och lägga till DownstreamApi tjänsten. Tjänsten DownstreamApi tillhandahåller ett gränssnitt som används för att anropa ett underordnat API. Vi anropar den här tjänsten DownstreamAPI i konfigurationsobjektet. Daemon-appen läser de underordnade API-konfigurationerna från avsnittet DownstreamApi i appsettings.json. Som standard får du en minnesintern tokencache.

Lägg till följande kodfragment i filen program.cs :
```
const string ServiceName = "DownstreamApi";

tokenAcquirerFactory.Services.AddDownstreamApi(ServiceName,
    tokenAcquirerFactory.Configuration.GetSection("DownstreamApi"));
```
Skapa token-förvärvaren. Detta består av alla tjänster som du har lagt till i Tjänster och returnerar en tjänstleverantör. Använd den här tjänstleverantören för att få åtkomst till den API-resurs som du har lagt till. I det här fallet har du bara lagt till en API-resurs som en underordnad tjänst som du vill ha åtkomst till.

Lägg till följande kodfragment i filen program.cs :
```
var serviceProvider = tokenAcquirerFactory.Build();
```

Anropa webb-API:et

Lägg till kod för att anropa ditt skyddade webb-API med hjälp av IDownstreamApi gränssnittet. I den här självstudien implementerar du bara ett anrop till Post a todo och en annan för att hämta alla todos. Se de andra implementeringarna, till exempel Ta bort och Placera i exempelkoden.

Lägg till den här kodraden i filen program.cs :

var toDoApiClient = serviceProvider.GetRequiredService<IDownstreamApi>();

Console.WriteLine("Posting a to-do...");

var firstNewToDo = await toDoApiClient.PostForAppAsync<ToDo, ToDo>(
    ServiceName,
    new ToDo()
    {
        Owner = Guid.NewGuid(),
        Description = "Bake bread"
    });

await DisplayToDosFromServer();
    
async Task DisplayToDosFromServer()
{
    Console.WriteLine("Retrieving to-do's from server...");
    var toDos = await toDoApiClient!.GetForAppAsync<IEnumerable<ToDo>>(
        ServiceName,
        options => options.RelativePath = "/api/todolist"
    );
    
    if (!toDos!.Any())
    {
        Console.WriteLine("There are no to-do's in server");
        return;
    }
    
    Console.WriteLine("To-do data:");
    
    foreach (var toDo in toDos!) {
        DisplayToDo(toDo);
    }
}

void DisplayToDo(ToDo toDo) {
    Console.WriteLine($"ID: {toDo.Id}");
    Console.WriteLine($"User ID: {toDo.Owner}");
    Console.WriteLine($"Message: {toDo.Description}");
}

Kör klientdaemonappen

Gå till rotmappen för daemonappen och kör följande kommando:

dotnet run

Om allt är okej bör du se följande utdata i terminalen.

Posting a to-do...
Retrieving to-do's from server...
To-do data:
ID: 1
User ID: 00001111-aaaa-2222-bbbb-3333cccc4444

Message: Bake bread

Felsöka

Om du stöter på fel

Bekräfta registreringsinformationen som du lade till i filen appsettings.json.
Bekräfta att du anropar webb-API:et via rätt port och via https.
Kontrollera att appbehörigheterna är korrekt konfigurerade.

Den fullständiga exempelkoden är tillgänglig på GitHub.

Rensa resurser

Om du inte tänker använda de appar som du har registrerat och skapat i den här självstudien tar du bort dem för att undvika kostnader.

Se även

Anropa ett API i ett exempel på Node.js daemon-program

Dela via