Ett webb-API som anropar webb-API:er: Anropa ett API

När du har en token kan du anropa ett skyddat webb-API. Du anropar vanligtvis underordnade API:er från kontrollanten eller sidorna i webb-API:et.

Styrenhetskod

ASP.NET Core

När du använder Microsoft.Identity.Web har du tre användningsscenarier:

• Alternativ 1: Anropa Microsoft Graph med SDK:n
• Alternativ 2: Anropa ett underordnat webb-API med hjälpklassen
• Alternativ 3: Anropa ett underordnat webb-API utan hjälpklassen

Alternativ 1: Anropa Microsoft Graph med programvaru-utvecklingspaketet (SDK)

I det här scenariot har du lagt till NuGet-paketet Microsoft.Identity.Web.GraphServiceClient och lagt till .AddMicrosoftGraph() i Startup.cs som anges i Kodkonfiguration, och du kan direkt mata in i kontrollanten GraphServiceClient eller sidkonstruktorn för användning i åtgärderna. Följande exempel på Razor-sidan visar bilden på den inloggade användaren.

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

Alternativ 2: Anropa ett underordnat webb-API med hjälpklassen

I det här scenariot har du lagt till .AddDownstreamApi() i Startup.cs som anges i Kodkonfiguration, och du kan mata in en IDownstreamWebApi tjänst direkt i kontrollanten eller sidkonstruktorn och använda den i åtgärderna:

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

Metoden CallApiForUserAsync har också starkt inskrivna allmänna åsidosättningar som gör att du kan ta emot ett objekt direkt. Följande metod tog till exempel emot en Todo instans, som är en starkt skriven representation av JSON som returneras av webb-API:et.

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

Alternativ 3: Anropa ett underordnat webb-API utan hjälpklassen

Om du har valt att hämta ett auktoriseringshuvud med hjälp av IAuthorizationHeaderProvider gränssnittet fortsätter följande kod exempelkoden som visas i ett webb-API som anropar webb-API:er: Hämta en token för appen. Koden anropas i api-kontrollanternas åtgärder. Det anropar ett underordnat API med namnet todolist.

När du har hämtat token använder du den som en ägartoken för att anropa det underordnade API:et.

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

När du använder Microsoft.Identity.Web har du tre användningsalternativ för att anropa ett API:

• Alternativ 1: Anropa Microsoft Graph med Microsoft Graph SDK
• Alternativ 2: Anropa ett underordnat webb-API med hjälpklassen
• Alternativ 3: Anropa ett underordnat webb-API utan hjälpklassen

Alternativ 1: Anropa Microsoft Graph med SDK från OWIN-appen

Du vill anropa Microsoft Graph. I det här scenariot har du lagt till AddMicrosoftGraph i Startup.cs enligt specifikationen i Kodkonfiguration, och du kan hämta GraphServiceClient i kontrollanten eller sidkonstruktorn för att använda i åtgärderna med hjälp av GetGraphServiceClient()-tilläggsmetoden på kontrollanten. I följande exempel visas bilden på den inloggade användaren.

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

Alternativ 2: Anropa ett underordnat webb-API med hjälpklassen från OWIN-appen

Du vill anropa ett annat webb-API än Microsoft Graph. I så fall har du lagt till AddDownstreamApi i Startup.cs som anges i Kodkonfiguration, och du kan hämta IDownstreamApi tjänsten i kontrollanten GetDownstreamApi genom att anropa tilläggsmetoden på kontrollanten:

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

Har CallApiForUserAsync också starkt inskrivna allmänna åsidosättningar som gör att du kan ta emot ett objekt direkt. Följande metod tar till exempel emot en Todo instans, som är en starkt skriven representation av den JSON som returneras av webb-API:et.

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

Alternativ 3: Anropa ett underordnat webb-API utan hjälpklassen från OWIN-appen

Du har bestämt dig för att skaffa en auktoriseringsrubrik med hjälp av IAuthorizationHeaderProvider tjänsten och du måste nu använda den i din HttpClient eller HttpRequest. I så fall fortsätter följande kod exempelkoden som visas i Ett webb-API som anropar webb-API:er: Hämta en token för appen. Koden anropas i åtgärderna för webb-API-kontrollanterna.

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

Följande kod fortsätter med exempelkoden som visas i Ett webb-API som anropar webb-API:er: Hämta en token för appen. Koden anropas i api-kontrollanternas åtgärder. Den anropar det underordnade API:et MS Graph.

När du har hämtat token använder du den som en ägartoken för att anropa det underordnade API:et.

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

Ett exempel som visar det här flödet med MSAL Python finns på ms-identity-python-on-behalf-of.

Nästa steg

• Läs mer genom att skapa en ASP.NET Core-webbapp som loggar in användare i följande självstudieserie i flera delar

• Utforska Microsofts identitetsplattform webb-API-exempel