Une API web qui appelle des API web : Appeler une API

Après avoir obtenu un jeton, vous pouvez appeler une API web protégée. Vous appelez généralement les API située en aval à partir du contrôleur ou de pages de votre API web.

Code de contrôle

ASP.NET Core

Lorsque vous utilisez Microsoft.Identity.Web, vous avez trois scénarios d’utilisation :

• Option 1 : Appeler Microsoft Graph à l’aide du SDK
• Option n°2 : Appeler une API web située en aval avec la classe d’assistance
• Option 3 : Appeler une API web située en aval sans la classe d’assistance

Option 1 : Appeler Microsoft Graph à l'aide du SDK

Dans ce scénario, vous avez ajouté le package NuGet Microsoft.Identity.Web.GraphServiceClient et ajouté .AddMicrosoftGraph() dans Startup.cs comme spécifié dans la configuration du code, et vous pouvez directement injecter GraphServiceClient dans votre contrôleur ou constructeur de page pour l’utiliser dans les actions. L’exemple de page Razor suivant affiche la photo de l’utilisateur connecté.

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

Option n°2 : Appeler une API web située en aval avec la classe d’assistance

Vous avez ici ajouté .AddDownstreamApi() dans le fichier Startup.cs comme spécifié dans Configuration de code, et vous pouvez injecter directement un service IDownstreamWebApi dans votre contrôleur ou constructeur de page pour l’utiliser dans les actions :

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

La méthode CallApiForUserAsync possède également des remplacements génériques fortement typés qui vous permettent de recevoir directement un objet. Par exemple, la méthode suivante a reçu une instance Todo, qui est une représentation fortement typée du code JSON renvoyé par l’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);
 }

Option 3 : Appeler une API web située en aval sans la classe d’assistance

Si vous avez décidé d’obtenir un en-tête d’autorisation en tirant parti de l’interface IAuthorizationHeaderProvider, le code suivant poursuit l’exemple de code présenté dans Une API web qui appelle des API web : Acquérir un jeton pour l’application. Le code est appelé dans les actions des contrôleurs d’API. Il appelle une API en aval nommée todolist.

Une fois que vous avez acquis le jeton, utilisez-le comme un jeton du porteur pour appeler l’API en aval.

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

Lorsque vous utilisez Microsoft.Identity.Web, vous disposez de trois options pour appeler une API :

• Option n°1 : Appeler Microsoft Graph à l'aide du kit de développement logiciel (SDK) Microsoft Graph
• Option n°2 : Appeler une API web située en aval avec la classe d’assistance
• Option 3 : Appeler une API web située en aval sans la classe d’assistance

Option 1 : appeler Microsoft Graph à l’aide du Kit de développement logiciel (SDK) de l’application OWIN

Vous souhaitez appeler Microsoft Graph. Dans ce scénario, vous avez ajouté AddMicrosoftGraph dans le fichier Startup.cs comme spécifié dans Configuration de code, et vous pouvez obtenir le GraphServiceClient dans votre contrôleur ou constructeur de page pour l’utiliser dans les actions en utilisant la méthode d’extension GetGraphServiceClient() sur le contrôleur. L’exemple suivant affiche la photo de l’utilisateur connecté.

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

Option 2 : appeler une API web située en aval à l’aide de la classe d’assistance de l’application OWIN

Vous souhaitez appeler une API web autre que Microsoft Graph. Dans ce cas, vous avez ajouté AddDownstreamApi dans le fichier Startup.cs comme spécifié dans Configuration du code, et vous pouvez obtenir le service IDownstreamApi dans votre contrôleur en appelant la méthode d’extension GetDownstreamApi sur le contrôleur :

[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 possède également des remplacements génériques fortement typés qui vous permettent de recevoir directement un objet. Par exemple, la méthode suivante reçoit une instance Todo, qui est une représentation fortement typée du code JSON renvoyé par l'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);
    }

Option 3 : appeler une API web située en aval sans la classe d’assistance de l’application OWIN

Vous avez décidé d’acquérir un en-tête d’autorisation à l’aide du service IAuthorizationHeaderProvider et vous devez maintenant l’utiliser dans votre HttpClient ou HttpRequest. Dans ce cas, le code suivant est la suite de l’exemple de code illustré dans Une API web qui appelle des API web : Acquérir un jeton pour l’application. Le code est appelé dans les actions des contrôleurs d’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

Le code suivant poursuit l’exemple de code illustré dans Une API web qui appelle des API web : Acquérir un jeton pour l’application. Le code est appelé dans les actions des contrôleurs d’API. Il appelle l’API MS Graph en aval.

Une fois que vous avez acquis le jeton, utilisez-le comme un jeton du porteur pour appeler l’API en aval.

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 exemple illustrant ce flux avec MSAL Python est disponible dans ms-identity-python-on-behalf-of.

Étapes suivantes

• Découvrez comment générer une application web ASP.NET Core qui permet de connecter des utilisateurs, en consultant une série de tutoriels en plusieurs parties

• Explorer les exemples d’API web de la plateforme d’identités Microsoft