Tutorial: chamar uma API Web protegida do aplicativo daemon .NET

Artigo
02/02/2024

Este tutorial é a parte final de uma série que demonstra como chamar uma API Web protegida de um aplicativo daemon .NET. Na parte 1 desta série, você preparou seu locatário externo para autorizar um aplicativo daemon .NET. Neste tutorial, você cria seu aplicativo daemon cliente e chama uma API Web protegida. Você habilita o aplicativo daemon cliente para adquirir um token de acesso usando sua própria identidade e, em seguida, chamar a API Web.

Neste tutorial;

Configure um aplicativo daemon para usar seus detalhes de registro do aplicativo.
Crie um aplicativo daemon que adquira um token em seu próprio nome e chame uma API Web protegida.

Pré-requisitos

Tutorial: prepare seu locatário externo para autorizar um aplicativo daemon do .NET

Criar um aplicativo daemon .NET

Abra o terminal e navegue até a pasta em que você deseja que seu projeto resida.
Inicialize um aplicativo de console .NET e navegue até a sua pasta raiz.
```
dotnet new console -n ToDoListClient
cd ToDoListClient
```

Instalar Pacotes

Instale os pacotes Microsoft.Identity.Web e Microsoft.Identity.Web.DownstreamApi:

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

O Microsoft.Identity.Web fornece a união entre o ASP.NET Core, o middleware de autenticação e a MSAL (Biblioteca de Autenticação da Microsoft) para .NET, facilitando a adição de recursos de autenticação e autorização ao seu aplicativo. O Microsoft.Identity.Web.DownstreamApi fornece uma interface usada para chamar uma API downstream.

Criar o arquivo appsettings.json para adicionar configurações de registro

Crie o arquivo appsettings.json na pasta raiz do aplicativo.

Adicione detalhes de registro de aplicativo ao arquivo 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"
        ]
    }
}

Substitua os seguintes valores pelos seus próprios valores:

Valor	Descrição
Enter_the_Application_Id_Here	A ID do Aplicativo (cliente) do aplicativo daemon cliente que você registrou.
Insira_o_subdomínio_do_locatário_aqui	O subdomínio do Diretório (locatário).
Insira_o_segredo_do_cliente_aqui	O valor do segredo do aplicativo daemon que você criou.
Insira_a_ID_do_aplicativo_da_API_Web_aqui	A ID do Aplicativo (cliente) do aplicativo de API Web que você registrou.
URL_base_da_API_Web	A URL base da API Web. Por exemplo, `https://localhost:44351/` em que 44351 é o número da porta em que sua API está sendo executada. Sua API já deve estar em execução e aguardando solicitações por esse estágio para que você obtenha esse valor.

Adicionar modelos

Navegue até a raiz da pasta do projeto e crie uma pasta de modelos. Na pasta modelos, crie um arquivo ToDo.cs e adicione o seguinte código:

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

Adquirir o token de acesso

Agora você configurou os itens obrigatórios para seu aplicativo daemon. Nesta etapa, você escreverá o código que permite que o aplicativo daemon adquira um token de acesso.

Abra o arquivo program.cs no editor de código e exclua seu conteúdo.

Adicione seus pacotes ao arquivo.

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

Crie a instância de aquisição de token. Use o método GetDefaultInstance da classe TokenAcquirerFactory do pacote Microsoft.Identity.Web para criar a instância de aquisição do token. Por padrão, a instância lerá um arquivo appsettings.json se ele existir na mesma pasta que o aplicativo. A GetDefaultInstance também nos permite adicionar serviços à coleção de serviços.

Adicione essa linha de código ao arquivo program.cs:
```
var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();
```
Configure as opções de aplicativo a serem lidas na configuração e adicione o serviço de DownstreamApi. O serviço de DownstreamApi fornece uma interface usada para chamar uma API downstream. Chamamos esse serviço de DownstreamAPI no objeto de configuração. O aplicativo daemon lê as configurações de API downstream da seção DownstreamApi de appsettings.json. Por padrão, você obtém um cache de token na memória.

Adicione o seguinte trecho de código ao arquivo program.cs:
```
const string ServiceName = "DownstreamApi";

tokenAcquirerFactory.Services.AddDownstreamApi(ServiceName,
    tokenAcquirerFactory.Configuration.GetSection("DownstreamApi"));
```
Crie o adquirente de token. Isso compõe todos os serviços que você adicionou aos Serviços e retorna um provedor de serviços. Use esse provedor de serviços para obter acesso ao recurso de API que você adicionou. Nesse caso, você adicionou apenas um recurso de API como um serviço downstream ao qual deseja acessar.

Adicione o seguinte trecho de código ao arquivo program.cs:
```
var serviceProvider = tokenAcquirerFactory.Build();
```

Chamar a API Web

Adicione código para chamar sua API Web protegida usando a interface IDownstreamApi. Neste tutorial, você só implementa uma chamada para Postar um ToDo e outra para Obter todos os ToDos. Consulte as outras implementações, como Excluir e Colocar no código de exemplo.

Adicione essa linha de código ao arquivo 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}");
}

Executar o aplicativo daemon cliente

Navegue até a pasta raiz do aplicativo daemon e execute o seguinte comando:

dotnet run

Se estiver tudo certo, você deverá ver a saída a seguir em seu 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

Solucionar problemas

Caso ocorra erros,

Confirme os detalhes de registro adicionados ao arquivo appsettings.json.
Confirme se você está chamando a API Web por meio da porta correta e por https.
Confirme se as permissões de aplicativo estão configuradas corretamente.

O código de exemplo completo está disponível no GitHub.

Limpar os recursos

Se você não pretende usar os aplicativos registrados e criados neste tutorial, exclua-os para evitar incorrer em custos.

Confira também

Chamar uma API em um aplicativo daemon do Node.js de exemplo

Compartilhar via