API Web che chiama le API Web: Chiamare un'API

Dopo aver ottenuto un token, è possibile chiamare un'API Web protetta. Di solito chiami le API downstream dall'interno del controller o delle pagine della tua API Web.

Codice del controller

ASP.NET Core

Quando si usa Microsoft.Identity.Web, sono disponibili tre scenari di utilizzo:

• Opzione 1: Chiamare Microsoft Graph con l'SDK
• Opzione 2: Chiamare un'API Web downstream con la classe helper
• Opzione 3: Chiamare un'API Web downstream senza la classe helper

Opzione 1: Chiamare Microsoft Graph con l'SDK

In questo scenario è stato aggiunto il pacchetto NuGet Microsoft.Identity.Web.GraphServiceClient e aggiunto .AddMicrosoftGraph() in Startup.cs come specificato nella configurazione del codice ed è possibile inserire GraphServiceClient direttamente nel controller o nel costruttore di pagina per l'uso nelle azioni. Nella pagina Razor di esempio seguente viene visualizzata la foto dell'utente connesso.

 [Authorize]
 [AuthorizeForScopes(Scopes = new[] { "user.read" })]
 public class IndexModel : PageModel
 {
     private readonly GraphServiceClient _graphServiceClient;

     public IndexModel(GraphServiceClient graphServiceClient)
     {
         _graphServiceClient = graphServiceClient;
     }

     public async Task OnGet()
     {
         var user = await _graphServiceClient.Me.GetAsync();
         try
         {
             using (var photoStream = await _graphServiceClient.Me.Photo.Content.GetAsync())
             {
                 byte[] photoByte = ((MemoryStream)photoStream).ToArray();
                 ViewData["photo"] = Convert.ToBase64String(photoByte);
             }
             ViewData["name"] = user.DisplayName;
         }
         catch (Exception)
         {
             ViewData["photo"] = null;
         }
     }
 }

Opzione 2: Chiamare un'API Web downstream con la classe helper

In questo scenario, è stato aggiunto .AddDownstreamApi() in Startup.cs come specificato in Configurazione del codice ed è possibile inserire direttamente un IDownstreamWebApi servizio nel controller o nel costruttore della pagina e usarlo nelle azioni:

 [Authorize]
 [AuthorizeForScopes(ScopeKeySection = "TodoList:Scopes")]
 public class TodoListController : Controller
 {
     private IDownstreamWebApi _downstreamWebApi;
     private const string ServiceName = "TodoList";

     public TodoListController(IDownstreamWebApi downstreamWebApi)
     {
         _downstreamWebApi = downstreamWebApi;
     }

     public async Task<ActionResult> Details(int id)
     {
         var value = await _downstreamWebApi.CallApiForUserAsync(
             ServiceName,
             options =>
             {
                 options.RelativePath = $"me";
             });
         return View(value);
     }

Il metodo CallApiForUserAsync dispone anche di ridefinizioni generiche fortemente tipate che consentono di ricevere direttamente un oggetto. Ad esempio, il metodo seguente ha ricevuto un'istanza Todo , ovvero una rappresentazione fortemente tipizzata del codice JSON restituito dall'API Web.

 // GET: TodoList/Details/5
 public async Task<ActionResult> Details(int id)
 {
     var value = await _downstreamWebApi.CallApiForUserAsync<object, Todo>(
         ServiceName,
         null,
         options =>
         {
             options.HttpMethod = HttpMethod.Get;
             options.RelativePath = $"api/todolist/{id}";
         });
     return View(value);
 }

Opzione 3: Chiamare un'API Web downstream senza la classe helper

Se si è deciso di ottenere un'intestazione di autorizzazione usando l'interfaccia IAuthorizationHeaderProvider , il codice seguente continua il codice di esempio illustrato in Un'API Web che chiama le API Web: Acquisire un token per l'app. Il codice viene chiamato nelle azioni dei controller API. Chiama un'API downstream denominata todolist.

Dopo aver acquisito il token, utilizzarlo come token portatore per chiamare l'API a valle.

private async Task CallTodoListService(string accessToken)
{
  // After the token has been returned by Microsoft.Identity.Web, add it to the HTTP authorization header before making the call to access the todolist service.
  authorizationHeader = await authorizationHeaderProvider.GetAuthorizationHeaderForUserAsync(scopes);
  _httpClient.DefaultRequestHeaders["Authorization"] = authorizationHeader;

  // Call the todolist service.
  HttpResponseMessage response = await _httpClient.GetAsync(TodoListBaseAddress + "/api/todolist");
  // ...
}

ASP.NET

Quando si usa Microsoft.Identity.Web, sono disponibili tre opzioni di utilizzo per chiamare un'API:

• Opzione 1: Chiamare Microsoft Graph con Microsoft Graph SDK
• Opzione 2: Chiamare un'API Web downstream con la classe helper
• Opzione 3: Chiamare un'API Web downstream senza la classe helper

Opzione 1: Chiamare Microsoft Graph con l'SDK dall'app OWIN

Vuoi chiamare Microsoft Graph. In questo scenario, hai aggiunto AddMicrosoftGraph in Startup.cs come specificato nella Configurazione del codice, ed è possibile ottenere GraphServiceClient nel controller o nel costruttore di pagina per l'uso nelle azioni utilizzando il GetGraphServiceClient() metodo di estensione nel controller. Nell'esempio seguente viene visualizzata la foto dell'utente connesso.

[Authorize]
public class HomeController : Controller
{

 public async Task GetIndex()
 {
  var graphServiceClient = this.GetGraphServiceClient();
  var user = await graphServiceClient.Me.GetAsync();
  try
  {
   using (var photoStream = await graphServiceClient.Me.Photo.Content.GetAsync())
   {
    byte[] photoByte = ((MemoryStream)photoStream).ToArray();
    ViewData["photo"] = Convert.ToBase64String(photoByte);
   }
   ViewData["name"] = user.DisplayName;
  }
  catch (Exception)
  {
   ViewData["photo"] = null;
  }
 }
}

Opzione 2: Chiamare un'API Web downstream con la classe helper dall'app OWIN

Si vuole chiamare un'API Web diversa da Microsoft Graph. In tal caso, hai aggiunto AddDownstreamApi in Startup.cs come specificato in Code configuration, e puoi ottenere il IDownstreamApi servizio nel tuo controller chiamando il metodo di estensione GetDownstreamApi sul controller.

[Authorize]
public class TodoListController : Controller
{ 
  public async Task<ActionResult> Details(int id)
  {
    var downstreamApi = this.GetDownstreamApi();
    var value = await downstreamApi.CallApiForUserAsync(
      ServiceName,
      options =>
      {
        options.RelativePath = $"me";
      });
      return View(value);
  }
}

CallApiForUserAsync ha anche override generici fortemente tipati che consentono di ricevere direttamente un oggetto. Ad esempio, il metodo seguente riceve un'istanza Todo , ovvero una rappresentazione fortemente tipizzata del codice JSON restituito dall'API Web.

    // GET: TodoList/Details/5
    public async Task<ActionResult> Details(int id)
    {
        var downstreamApi = this.GetDownstreamApi();
        var value = await downstreamApi.GetForUserAsync<object, Todo>(
            ServiceName,
            null,
            options =>
            {
                options.RelativePath = $"api/todolist/{id}";
            });
        return View(value);
    }

Opzione 3: Chiamare un'API Web downstream senza la classe helper dall'app OWIN

Hai deciso di acquisire un'intestazione di autorizzazione usando il servizio IAuthorizationHeaderProvider e ora devi usarla nel tuo HttpClient o HttpRequest. In tal caso, il codice seguente continua il codice di esempio illustrato in Un'API Web che chiama le API Web: Acquisire un token per l'app. Il codice viene chiamato nelle azioni dei controller API Web.

public async Task<IActionResult> Profile()
{
  // Acquire the access token.
  string[] scopes = new string[]{"user.read"};
  var IAuthorizationHeaderProvider = this.GetAuthorizationHeaderProvider();
  string authorizationHeader = await IAuthorizationHeaderProvider.GetAuthorizationHeaderForUserAsync(scopes);

  // Use the access token to call a protected web API.
  HttpClient httpClient = new HttpClient();
  client.DefaultRequestHeaders.Add("Authorization", authorizationHeader);

  var response = await httpClient.GetAsync($"{webOptions.GraphApiUrl}/beta/me");

  if (response.StatusCode == HttpStatusCode.OK)
  {
    var content = await response.Content.ReadAsStringAsync();

    dynamic me = JsonConvert.DeserializeObject(content);
    ViewData["Me"] = me;
  }

  return View();
}

Java

Il codice seguente continua il codice di esempio illustrato in Un'API Web che chiama le API Web: Acquisire un token per l'app. Il codice viene chiamato nelle azioni dei controller API. Chiama l'API downstream MS Graph.

Dopo aver acquisito il token, usalo come token di autorizzazione per chiamare l'API downstream.

private String callMicrosoftGraphMeEndpoint(String accessToken){
    RestTemplate restTemplate = new RestTemplate();

    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);

    headers.set("Authorization", "Bearer " + accessToken);

    HttpEntity<String> entity = new HttpEntity<>(null, headers);

    String result = restTemplate.exchange("https://graph.microsoft.com/v1.0/me", HttpMethod.GET,
            entity, String.class).getBody();

    return result;
}

Python

Un esempio che illustra questo flusso con MSAL Python è disponibile in ms-identity-python-on-behalf-of.

Passaggi successivi

• Per saperne di più, costruisci un'app Web ASP.NET Core che effettua l'accesso degli utenti nella seguente serie di esercitazioni in più parti.

• Esplorare gli esempi di API Web di Microsoft Identity Platform