Ett webb-API som anropar webb-API:er: Hämta en token för appen

När du har skapat ett klientprogramobjekt använder du det för att hämta en token som du kan använda för att anropa ett webb-API.

Kod i kontrollanten

ASP.NET Core

Microsoft.Identity.Web lägger till tilläggsmetoder som tillhandahåller bekvämlighetstjänster för att anropa Microsoft Graph eller ett underordnat webb-API. Dessa metoder beskrivs i detalj i En webbapp som anropar webb-API:er: Anropa ett API. Med de här hjälpmetoderna behöver du inte skaffa en token manuellt.

Om du däremot vill hämta en token manuellt visar följande kod ett exempel på hur du använder Microsoft.Identity.Web för att göra det i en hemstyrenhet. Den anropar Microsoft Graph med hjälp av REST-API:et (i stället för Microsoft Graph SDK). Vanligtvis behöver du inte hämta en token. Du måste skapa ett auktoriseringshuvud som du lägger till i din begäran. För att få ett auktoriseringshuvud matar du in IAuthorizationHeaderProvider tjänsten genom beroendeinmatning i styrenhetens konstruktor (eller sidkonstruktorn om du använder Blazor) och använder den i dina kontrollantåtgärder. Det här gränssnittet har metoder som skapar en sträng som innehåller protokollet (Bearer, Pop, ...) och en token. Om du vill hämta ett auktoriseringshuvud för att anropa ett API för användarens räkning använder du (CreateAuthorizationHeaderForUserAsync). Om du vill hämta ett auktoriseringshuvud för att anropa ett underordnat API för själva programmet använder du (CreateAuthorizationHeaderForAppAsync) i ett daemonscenario.

Kontrollantmetoderna skyddas av ett [Authorize] attribut som säkerställer att endast autentiserade anrop kan använda webb-API:et.

[Authorize]
public class MyApiController : Controller
{
    /// <summary>
    /// The web API will accept only tokens 1) for users, 2) that have the `access_as_user` scope for
    /// this API.
    /// </summary>
    static readonly string[] scopeRequiredByApi = new string[] { "access_as_user" };

     static readonly string[] scopesToAccessDownstreamApi = new string[] { "api://MyTodolistService/access_as_user" };

     readonly IAuthorizationHeaderProvider authorizationHeaderProvider;

    public MyApiController(IAuthorizationHeaderProvider authorizationHeaderProvider)
    {
      this.authorizationHeaderProvider = authorizationHeaderProvider;
    }

    [RequiredScopes(Scopes = scopesToAccessDownstreamApi)]
    public IActionResult Index()
    {
        // Get an authorization header.
        IAuthorizationHeaderProvider authorizationHeaderProvider = this.GetAuthorizationHeaderProvider();
        string[] scopes = new string[]{"user.read"};
        string authorizationHeader = await authorizationHeaderProvider.CreateAuthorizationHeaderForUserAsync(scopes);

        return await callTodoListService(authorizationHeader);
    }
}

Mer information om metoden finns i callTodoListService Ett webb-API som anropar webb-API:er: Anropa ett API.

ASP.NET

Koden för ASP.NET liknar koden som visas för ASP.NET Core:

• En kontrollantåtgärd som skyddas av attributet [Auktorisera] extraherar klientorganisations-ID:t och användar-ID:t för kontrollantens ClaimsPrincipal medlem. (ASP.NET använder HttpContext.User.) Microsoft.Identity.Web.OWIN lägger till tilläggsmetoder till kontrollanten som tillhandahåller bekvämlighetstjänster för att anropa Microsoft Graph eller ett underordnat webb-API, eller för att hämta ett auktoriseringshuvud eller till och med en token. De metoder som används för att anropa ett API direkt förklaras i detalj i En webbapp som anropar webb-API:er: Anropa ett API. Med de här hjälpmetoderna behöver du inte skaffa en token manuellt.

Om du däremot vill hämta en token manuellt eller skapa en auktoriseringsrubrik visar följande kod hur du använder Microsoft.Identity.Web för att göra det i en kontrollant. Den anropar ett API (Microsoft Graph) med hjälp av REST-API:et i stället för Microsoft Graph SDK.

Om du vill hämta ett auktoriseringshuvud får du en IAuthorizationHeaderProvider tjänst från kontrollanten med hjälp av en tilläggsmetod GetAuthorizationHeaderProvider. Om du vill hämta ett auktoriseringshuvud för att anropa ett API för användarens räkning använder du (CreateAuthorizationHeaderForUserAsync). Om du vill hämta ett auktoriseringshuvud för att anropa ett underordnat API för själva programmet använder du (CreateAuthorizationHeaderForAppAsync) i ett daemonscenario.

Kontrollantmetoderna skyddas av ett [Authorize] attribut som säkerställer att endast autentiserade användare kan använda webbappen.

Följande kodfragment visar åtgärden HomeControllerför , som hämtar ett auktoriseringshuvud för att anropa Microsoft Graph som ett REST-API:

[Authorize]
public class MyApiController : Controller
{
 [AuthorizeForScopes(Scopes = new[] { "user.read" })]
 public async Task<IActionResult> Profile()
 {
  // Get an authorization header.
  IAuthorizationHeaderProvider authorizationHeaderProvider = this.GetAuthorizationHeaderProvider();
  string[] scopes = new string[]{"user.read"};
  string authorizationHeader = await authorizationHeaderProvider.CreateAuthorizationHeaderForUserAsync(scopes);

  // Use the access token to call a protected web API.
  HttpClient client = new HttpClient();
  client.DefaultRequestHeaders.Add("Authorization", authorizationHeader);
  string json = await client.GetStringAsync(url);
 }
}

Följande kodfragment visar åtgärden MyApiControllerför , som hämtar en åtkomsttoken för att anropa Microsoft Graph som ett REST-API:

[Authorize]
public class HomeController : Controller
{
 [AuthorizeForScopes(Scopes = new[] { "user.read" })]
 public async Task<IActionResult> Profile()
 {
  // Get an authorization header.
  ITokenAcquirer tokenAcquirer = TokenAcquirerFactory.GetDefaultInstance().GetTokenAcquirer();
  string[] scopes = new string[]{"user.read"};
  string token = await await tokenAcquirer.GetTokenForUserAsync(scopes);

  // Use the access token to call a protected web API.
  HttpClient client = new HttpClient();
  client.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}");
  string json = await client.GetStringAsync(url);
 }
}

Java

Här är ett exempel på kod som anropas i API-kontrollanternas åtgärder. Den anropar det underordnade API:et – Microsoft Graph.

@RestController
public class ApiController {

    @Autowired
    MsalAuthHelper msalAuthHelper;

    @RequestMapping("/graphMeApi")
    public String graphMeApi() throws MalformedURLException {

        String oboAccessToken = msalAuthHelper.getOboToken("https://graph.microsoft.com/.default");

        return callMicrosoftGraphMeEndpoint(oboAccessToken);
    }

}

Python

Ett Python-webb-API kräver att mellanprogram används för att verifiera den ägartoken som tas emot från klienten. Webb-API:et kan sedan hämta åtkomsttoken för ett underordnat API med hjälp av MSAL Python-biblioteket genom att anropa acquire_token_on_behalf_of metoden.

Här är ett exempel på kod som hämtar en åtkomsttoken med hjälp av acquire_token_on_behalf_of metoden och Flask-ramverket. Den anropar det underordnade API:et – slutpunkten för Azure Management-prenumerationer.

def get(self):
 
        _scopes = ["https://management.azure.com/user_impersonation"]
        _azure_management_subscriptions_uri = "https://management.azure.com/subscriptions?api-version=2020-01-01"
 
        current_access_token = request.headers.get("Authorization", None)
        
        #This example only uses the default memory token cache and should not be used for production
        msal_client = msal.ConfidentialClientApplication(
                client_id=os.environ.get("CLIENT_ID"),
                authority=os.environ.get("AUTHORITY"),
                client_credential=os.environ.get("CLIENT_SECRET"))
 
        #acquire token on behalf of the user that called this API
        arm_resource_access_token = msal_client.acquire_token_on_behalf_of(
            user_assertion=current_access_token.split(' ')[1],
            scopes=_scopes
        )
 
        headers = {'Authorization': arm_resource_access_token['token_type'] + ' ' + arm_resource_access_token['access_token']}
 
        subscriptions_list = req.get(_azure_management_subscriptions_uri), headers=headers).json()
 
        return jsonify(subscriptions_list)

(Avancerat) Åtkomst till den inloggade användarens tokencache från bakgrundsappar, API:er och tjänster

Du kan använda MSAL:s tokencacheimplementering för att tillåta att bakgrundsappar, API:er och tjänster använder cacheminnet för åtkomsttoken för att fortsätta att agera åt användare i deras frånvaro. Detta är särskilt användbart om bakgrundsappar och tjänster måste fortsätta att fungera för användarens räkning när användaren har avslutat klientwebbappen.

I dag använder de flesta bakgrundsprocesser programbehörigheter när de behöver arbeta med en användares data utan att de finns för att autentisera eller autentisera igen. Eftersom programbehörigheter ofta kräver administratörsmedgivande, vilket kräver utökade privilegier, uppstår onödig friktion eftersom utvecklaren inte hade för avsikt att få behörighet utöver det som användaren ursprungligen samtyckt till för sin app.

Det här kodexemplet på GitHub visar hur du undviker den här onödiga friktionen genom att komma åt MSAL:s tokencache från bakgrundsappar:

Komma åt den inloggade användarens tokencache från bakgrundsappar, API:er och tjänster

Nästa steg

Gå vidare till nästa artikel i det här scenariot, Anropa ett API.