Partager via

Application web appelant des API web : Appeler une API web

  • Article

Maintenant que vous avez un jeton, vous pouvez appeler une API web protégée. Vous appelez généralement une API située en aval à partir du contrôleur ou des pages de votre application web.

Appeler une API web protégée

L’appel d’une API web protégée dépend du langage et de l’infrastructure de votre choix :

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

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

Dans ce scénario, vous appelez Microsoft Graph en ajoutant le package NuGet Microsoft.Identity.Web.GraphServiceClient et en incluant .AddMicrosoftGraph() dans le fichier Startup.cs, tel que spécifié dans la Configuration du code. Ensuite, vous pouvez injecter directement le 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;
  }
 }
}

Pour obtenir un exemple complet, consultez Application web ASP.NET Core qui appelle Microsoft Graph.

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

Vous souhaitez appeler une API web autre que Microsoft Graph. Dans ce cas, vous ajoutez AddDownstreamApi dans le fichier Startup.cs, tel que spécifié dans la Configuration du code, et vous pouvez injecter directement un service IDownstreamApi dans votre contrôleur ou constructeur de page pour l’utiliser dans les actions :

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

  public TodoListController(IDownstreamApi downstreamApi)
  {
    _downstreamApi = downstreamApi;
  }

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

CallWebApiForUserAsync 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 value = await _downstreamApi.CallApiForUserAsync<object, Todo>(
            ServiceName,
            null,
            options =>
            {
                options.HttpMethod = HttpMethod.Get;
                options.RelativePath = $"api/todolist/{id}";
            });
        return View(value);
    }

Pour obtenir un exemple complet, consultez l’application web ASP.NET Core qui appelle une API

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

Vous avez décidé d'acquérir un jeton manuellement à l'aide du service IAuthorizationHeaderProvider, et vous devez maintenant utiliser le jeton. Le code suivant est la suite de l'exemple de code illustré dans Une application web qui appelle des API web : Acquérir un jeton pour l’application. Le code est appelé dans les actions des contrôleurs d'applications web.

Une fois que vous avez acquis le jeton, utilisez-le comme un jeton de porteur pour appeler l'API située en aval, dans ce cas Microsoft Graph.

public async Task<IActionResult> Profile()
{
  // Acquire the access token.
  string[] scopes = new string[]{"user.read"};
  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();
}

Notes

Vous pouvez utiliser le même principe pour appeler une API web.

La plupart des API web Azure fournissent un kit de développement logiciel (SDK) qui simplifie l'appel de l'API, comme c'est le cas pour Microsoft Graph.

Étapes suivantes