Didacticiel : appeler une API web protégée à partir de votre application démon .NET

Article
02/02/2024

Ce tutoriel est la dernière partie d’une série qui montre comment appeler une API web protégée à partir d’une application démon .NET. Dans la partie 1 de cette série, vous avez préparé votre locataire externe pour autoriser une application démon .NET. Dans ce tutoriel, vous allez créer votre application démon cliente et appeler une API web protégée. Vous activez l’application démon cliente pour acquérir un jeton d’accès à l’aide de sa propre identité, puis appelez l’API web.

Dans ce tutoriel,

Configurez une application démon pour utiliser ses détails d’inscription de l’application.
Créez une application démon qui acquiert un jeton pour son propre compte et appelle une API web protégée.

Prérequis

Tutoriel : Préparer votre locataire externe à autoriser une application démon .NET

Créer une application démon .NET

Ouvrez votre terminal et accédez au dossier où vous voulez que votre projet soit actif.
Initialisez une application console .NET et accédez à son dossier racine.
```
dotnet new console -n ToDoListClient
cd ToDoListClient
```

Installer des packages

Installez les packages Microsoft.Identity.Web et Microsoft.Identity.Web.DownstreamApi :

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

Microsoft.Identity.Web fournit le lien entre ASP.NET Core, l’intergiciel d’authentification et la bibliothèque d’authentification Microsoft (MSAL) pour .NET, ce qui vous permet d’ajouter plus facilement des fonctionnalités d’authentification et d’autorisation à votre application. Microsoft.Identity.Web.DownstreamApi fournit une interface servant à appeler une API en aval.

Créer un fichier appsettings.json et ajouter des configurations d’inscription

Créez un fichier appsettings.json dans le dossier racine de l’application.

Ajoutez les détails de l’inscription de l’application au fichier appsettings.json.

{
    "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"
        ]
    }
}

Remplacez les valeurs suivantes par les vôtres :

Valeur	Description
Enter_the_Application_Id_Here	L’ID d’application (client) de l’application démon cliente que vous avez inscrite.
Enter_the_Tenant_Subdomain_Here	Sous-domaine de répertoire (locataire).
Enter_the_Client_Secret_Here	Valeur secrète d’application démon que vous avez créée.
Enter_the_Web_Api_Application_Id_Here	L’ID d’application (client) de l’application API web que vous avez inscrite.
Web_API_base_url	URL de base de l’API web. Par exemple, `https://localhost:44351/` où 44351 est le numéro de port du port sur lequel votre API s’exécute. Votre API doit déjà être en cours d’exécution et attendre des requêtes à ce stade pour que vous obteniez cette valeur.

Ajouter des modèles

Accédez à la racine de votre dossier de projet et créez un dossier modèles. Dans le dossier modèles, créez un fichier ToDo.cs et ajoutez le code suivant :

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;
}

Acquérir un jeton d’accès

Vous avez maintenant configuré les éléments requis pour votre application démon. Dans cette étape, vous écrivez le code qui permet à l’application démon d’acquérir un jeton d’accès.

Ouvrez le fichier program.cs dans votre éditeur de code et supprimez son contenu.

Ajoutez vos packages au fichier.

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

Créez l’instance d’acquisition de jetons. Utilisez la méthode GetDefaultInstance de la classe TokenAcquirerFactory de package Microsoft.Identity.Web pour générer l’instance d’acquisition de jetons. Par défaut, l’instance lit un fichier appsettings.json s’il existe dans le même dossier que l’application. GetDefaultInstance nous permet également d’ajouter des services à la collection de services.

Ajoutez cette ligne de code au fichier program.cs :
```
var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();
```
Configurez les options d’application à lire à partir de la configuration et ajoutez le service DownstreamApi. Le service DownstreamApi fournit une interface servant à appeler une API en aval. Nous appelons ce service DownstreamAPI dans l’objet de configuration. L’application démon lit les configurations d’API en aval à partir de la section DownstreamApi de appsettings.json. Par défaut, vous obtenez un cache de jetons en mémoire.

Ajoutez l’extrait de code suivant au fichier program.cs :
```
const string ServiceName = "DownstreamApi";

tokenAcquirerFactory.Services.AddDownstreamApi(ServiceName,
    tokenAcquirerFactory.Configuration.GetSection("DownstreamApi"));
```
Générez l’acquéreur de jetons. Cela compose tous les services que vous avez ajoutés aux services et renvoie un fournisseur de services. Utilisez ce fournisseur de services pour accéder à la ressource d’API que vous avez ajoutée. Dans ce cas, vous avez ajouté une seule ressource d’API en tant que service en aval auquel vous souhaitez accéder.

Ajoutez l’extrait de code suivant au fichier program.cs :
```
var serviceProvider = tokenAcquirerFactory.Build();
```

Appel de l’API web

Ajoutez du code pour appeler votre API web protégée à l’aide de l’interface IDownstreamApi. Dans ce didacticiel, vous implémentez uniquement un appel à Publier un élément TODO et un autre pour Obtenir tous les éléments TODO. Consultez les autres implémentations telles que Supprimer et Placer dans l’exemple de code.

Ajoutez cette ligne de code au fichier 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}");
}

Exécuter l’application démon cliente

Accédez au dossier racine de l’application démon et exécutez la commande suivante :

dotnet run

Si tout va bien, vous devriez voir la sortie suivante dans votre terminal.

Posting a to-do...
Retrieving to-do's from server...
To-do data:
ID: 1
User ID: 00aa00aa-bb11-cc22-dd33-44ee44ee44ee

Message: Bake bread

Dépanner

Si vous rencontrez des erreurs,

Confirmez les détails d’inscription que vous avez ajoutés au fichier appsettings.json.
Vérifiez que vous appelez l’API web via le bon port et via https.
Vérifiez que vos autorisations d’application sont correctement configurées.

L’exemple de code complet est disponible sur GitHub.

Nettoyer les ressources

Si vous n’avez pas l’intention d’utiliser les applications que vous avez inscrites et créées dans ce didacticiel, supprimez-les pour éviter d’entraîner des frais.

Voir aussi

Appeler une API dans votre application démon Node.js

Partager via