Een web-API die web-API's aanroept: een API aanroepen

Wanneer u Microsoft.Identity.Web gebruikt, hebt u drie gebruiksscenario's:

• Optie 1: Microsoft Graph aanroepen met de SDK
• Optie 2: een downstream-web-API aanroepen met de helperklasse
• Optie 3: een downstream-web-API aanroepen zonder de helperklasse

Optie 1: Microsoft Graph aanroepen met de SDK

In dit scenario hebt u het NuGet-pakket Microsoft.Identity.Web.GraphServiceClient toegevoegd en hebt u .AddMicrosoftGraph() in Startup.cs toegevoegd zoals gespecificeerd in de configuratie van de code, en u kunt direct de GraphServiceClient in uw controller of paginaconstructeur injecteren voor gebruik in de acties. Op de volgende voorbeeldpagina van Razor wordt de foto van de aangemelde gebruiker weergegeven.

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

Optie 2: een downstream-web-API aanroepen met de helperklasse

In dit scenario heb je .AddDownstreamApi() toegevoegd in Startup.cs zoals opgegeven in de codeconfiguratie, en kun je rechtstreeks een IDownstreamWebApi-service in je controller- of paginaconstructor injecteren en deze gebruiken in de acties:

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

De CallApiForUserAsync-methode heeft ook sterk getypte generieke overschrijfmethoden waarmee u direct een object kunt ontvangen. De volgende methode heeft bijvoorbeeld een Todo exemplaar ontvangen. Dit is een sterk getypte weergave van de JSON die wordt geretourneerd door de web-API.

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

Optie 3: een downstream-web-API aanroepen zonder de helperklasse

Als u hebt besloten een autorisatieheader op te halen met behulp van de IAuthorizationHeaderProvider interface, gaat de volgende code verder met de voorbeeldcode die wordt weergegeven in een web-API die web-API's aanroept: Een token voor de app verkrijgen. De code wordt aangeroepen in de acties van de API-controllers. Er wordt een downstream-API aangeroepen met de naam todolist.

Nadat u het token hebt opgehaald, gebruikt u het als bearer-token om de downstream-API aan te roepen.

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

Wanneer u Microsoft.Identity.Web gebruikt, hebt u drie gebruiksopties voor het aanroepen van een API:

• Optie 1: Microsoft Graph aanroepen met de Microsoft Graph SDK
• Optie 2: een downstream-web-API aanroepen met de helperklasse
• Optie 3: een downstream-web-API aanroepen zonder de helperklasse

Optie 1: Microsoft Graph aanroepen met de SDK vanuit de OWIN-app

U roept Microsoft Graph aan door AddMicrosoftGraph toe te voegen in Startup.cs zoals opgegeven in codeconfiguratie. Gebruik de GetGraphServiceClient()-extensiemethode op de controller om GraphServiceClient in je controller of paginaconstructor te verkrijgen, zodat deze kan worden gebruikt in de acties. In het volgende voorbeeld wordt de foto van de aangemelde gebruiker weergegeven.

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

Optie 2: Een downstream-web-API aanroepen met de helperklasse van de OWIN-app

U wilt een andere web-API dan Microsoft Graph aanroepen. Voeg in dat geval AddDownstreamApi toe aan Startup.cs zoals opgegeven in codeconfiguratie. Gebruik de GetDownstreamApi-extensiemethode op de controller om de IDownstreamApi-service op te halen:

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

De CallApiForUserAsync heeft ook sterk getypeerde algemene overschrijvingen waarmee u een object rechtstreeks kunt ontvangen. Met de volgende methode wordt bijvoorbeeld een Todo-exemplaar ontvangen. Dat is een sterk getypte weergave van de JSON die wordt geretourneerd door de web-API.

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

Optie 3: Een downstream-web-API aanroepen zonder de helperklasse van de OWIN-app

U hebt besloten om een autorisatieheader te verkrijgen met behulp van de IAuthorizationHeaderProvider service en u moet deze nu gebruiken in uw HttpClient of HttpRequest. In dat geval gaat de volgende code verder met de voorbeeldcode die wordt weergegeven in een web-API die web-API's aanroept: Een token voor de app verkrijgen. De code wordt aangeroepen in de acties van de web-API-controllers.

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

Met de volgende code wordt de voorbeeldcode voortgezet die wordt weergegeven in een web-API die web-API's aanroept: Een token voor de app verkrijgen. De code wordt aangeroepen in de acties van de API-controllers. Hiermee wordt de downstream-API MS Graph aangeroepen.

Nadat u het token hebt verkregen, gebruikt u het als bearer-token om de downstream-API aan te roepen.

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

Een voorbeeld van deze stroom met MSAL Python is beschikbaar op ms-identity-python-on-behalf-of.