En webbapp som anropar webb-API:er: Anropa ett webb-API

Nu när du har en token kan du anropa ett skyddat webb-API. Du anropar vanligtvis ett underordnat API från kontrollanten eller sidorna i webbappen.

Anropa ett skyddat webb-API

Att anropa ett skyddat webb-API beror på ditt språk och valfritt ramverk:

ASP.NET Core

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

I det här scenariot anropar du Microsoft Graph genom att lägga till NuGet-paketet Microsoft.Identity.Web.GraphServiceClient och i .AddMicrosoftGraph() Startup.cs som anges i Kodkonfiguration. Du kan sedan mata in GraphServiceClient styrenheten eller sidkonstruktorn direkt för att använda den 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;
  }
 }
}

Ett fullständigt exempel finns i ASP.NET Core-webbapp som anropar Microsoft Graph.

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

Du vill anropa ett annat webb-API än Microsoft Graph. I så fall lägger du till AddDownstreamApi Startup.cs som anges i Kodkonfiguration, och du kan direkt mata in en IDownstreamApi tjänst i kontrollanten eller sidkonstruktorn och använda den i åtgärderna:

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

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

Ett fullständigt exempel finns i ASP.NET Core-webbapp som anropar ett API

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

Du har bestämt dig för att hämta en token manuellt med hjälp av IAuthorizationHeaderProvider tjänsten och du måste nu använda token. I så fall fortsätter följande kod exempelkoden som visas i En webbapp som anropar webb-API:er: Hämta en token för appen. Koden anropas i webbappkontrollanternas åtgärder.

När du har hämtat token använder du den som en ägartoken för att anropa det underordnade API:et, i det här fallet 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();
}

Kommentar

Du kan använda samma princip för att anropa alla webb-API:er.

De flesta Azure-webb-API:er tillhandahåller ett SDK som förenklar anropet av API:et, vilket är fallet för Microsoft Graph.

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 som anges i Kodkonfiguration, och du kan hämta i kontrollanten GraphServiceClient eller sidkonstruktorn för användning i åtgärderna med hjälp GetGraphServiceClient() av tilläggsmetoden på kontrollanten. I följande exempel visas bilden på den inloggade användaren.

[Authorize]
[AuthorizeForScopes(Scopes = new[] { "user.read" })]
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;
  }
 }
}

Ett fullständigt exempel finns i ASP.NET OWIN-webbapp som anropar Microsoft Graph

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.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 från OWIN-appen

Du har bestämt dig för att hämta 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 En webbapp som anropar webb-API:er: Hämta en token för appen. Koden anropas i webbappkontrollanternas åtgärder.

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

private String getUserInfoFromGraph(String accessToken) throws Exception {
    // Microsoft Graph user endpoint
    URL url = new URL("https://graph.microsoft.com/v1.0/me");

    HttpURLConnection conn = (HttpURLConnection) url.openConnection();

    // Set the appropriate header fields in the request header.
    conn.setRequestProperty("Authorization", "Bearer " + accessToken);
    conn.setRequestProperty("Accept", "application/json");

    String response = HttpClientHelper.getResponseStringFromConn(conn);

    int responseCode = conn.getResponseCode();
    if(responseCode != HttpURLConnection.HTTP_OK) {
        throw new IOException(response);
    }

    JSONObject responseObject = HttpClientHelper.processResponse(responseCode, response);
    return responseObject.toString();
}

Node.js

När en token har hämtats använder koden axios-paketet för att fråga API-slutpunkten och hämta ett JSON-resultat.

/**
 * Attaches a given access token to a MS Graph API call
 * @param endpoint: REST API endpoint to call
 * @param accessToken: raw access token string
 */
async function fetch(endpoint, accessToken) {
    const options = {
        headers: {
            Authorization: `Bearer ${accessToken}`
        }
    };

    console.log(`request made to ${endpoint} at: ` + new Date().toString());

    try {
        const response = await axios.get(endpoint, options);
        return await response.data;
    } catch (error) {
        throw new Error(error);
    }
}

Python

När en token har hämtats använder koden begärandepaketet för att fråga API-slutpunkten och hämta ett JSON-resultat.

@app.route("/call_downstream_api")
def call_downstream_api():
    token = auth.get_token_for_user(app_config.SCOPE)
    if "error" in token:
        return redirect(url_for("login"))
    # Use access token to call downstream api
    api_result = requests.get(
        app_config.ENDPOINT,
        headers={'Authorization': 'Bearer ' + token['access_token']},
        timeout=30,
    ).json()
    return render_template('display.html', result=api_result)

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 webbappexempel