API Web che chiama le API Web: Acquisire un token per l'app

Microsoft.Identity.Web aggiunge metodi di estensione che forniscono servizi pratici per chiamare Microsoft Graph o un'API Web downstream. Questi metodi sono illustrati in dettaglio in Un'app Web che chiama LE API Web: Chiamare un'API. Con questi metodi helper non è necessario acquisire manualmente un token.

Se, tuttavia, si vuole acquisire manualmente un token, il codice seguente mostra un esempio di utilizzo di Microsoft.Identity.Web per farlo in un controller home. Chiama Microsoft Graph usando l'API REST (anziché Microsoft Graph SDK). In genere, non è necessario ottenere un token, è necessario compilare un'intestazione di autorizzazione aggiunta alla richiesta. Per ottenere un'intestazione di autorizzazione, inserire il IAuthorizationHeaderProvider servizio tramite l'inserimento delle dipendenze nel costruttore del controller (o il costruttore di pagina se si usa Blazor) e lo si usa nelle azioni del controller. Questa interfaccia include metodi che producono una stringa contenente il protocollo (Bearer, Pop, ...) e un token. Per ottenere un'intestazione di autorizzazione per chiamare un'API per conto dell'utente, usare (CreateAuthorizationHeaderForUserAsync). Per ottenere un'intestazione di autorizzazione per chiamare un'API downstream per conto dell'applicazione stessa, usare (CreateAuthorizationHeaderForAppAsyncin uno scenario daemon).

I metodi controller sono protetti da un [Authorize] attributo che garantisce che solo le chiamate autenticate possano usare l'API Web.

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

Per informazioni dettagliate sul callTodoListService metodo, vedere UN'API Web che chiama LE API Web: Chiamare un'API.

Il codice per ASP.NET è simile al codice illustrato per ASP.NET Core:

• Un'azione del controller protetta da un attributo [Authorize] estrae l'ID tenant e l'ID utente del ClaimsPrincipal membro del controller. (ASP.NET usa HttpContext.User.) Microsoft.Identity.Web.OWIN aggiunge metodi di estensione al controller che forniscono servizi pratici per chiamare Microsoft Graph o un'API Web downstream o per ottenere un'intestazione di autorizzazione o anche un token. I metodi usati per chiamare direttamente un'API sono illustrati in dettaglio in Un'app Web che chiama le API Web: Chiamare un'API. Con questi metodi helper non è necessario acquisire manualmente un token.

Se, tuttavia, si vuole acquisire manualmente un token o compilare un'intestazione di autorizzazione, il codice seguente illustra come usare Microsoft.Identity.Web per farlo in un controller. Chiama un'API (Microsoft Graph) usando l'API REST anziché Microsoft Graph SDK.

Per ottenere un'intestazione di autorizzazione, si ottiene un IAuthorizationHeaderProvider servizio dal controller usando un metodo GetAuthorizationHeaderProviderdi estensione . Per ottenere un'intestazione di autorizzazione per chiamare un'API per conto dell'utente, usare (CreateAuthorizationHeaderForUserAsync). Per ottenere un'intestazione di autorizzazione per chiamare un'API downstream per conto dell'applicazione stessa, usare (CreateAuthorizationHeaderForAppAsyncin uno scenario daemon).

I metodi controller sono protetti da un [Authorize] attributo che garantisce che solo gli utenti autenticati possano usare l'app Web.

Il frammento di codice seguente illustra l'azione di , che ottiene un'intestazione di HomeControllerautorizzazione per chiamare Microsoft Graph come API REST:

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

Il frammento di codice seguente illustra l'azione di MyApiController, che ottiene un token di accesso per chiamare Microsoft Graph come API REST:

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

Ecco un esempio di codice chiamato nelle azioni dei controller API. Chiama l'API downstream - 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);
    }

}

Un'API Web Python richiede l'uso del middleware per convalidare il token di connessione ricevuto dal client. L'API Web può quindi ottenere il token di accesso per un'API downstream usando la libreria PYTHON MSAL chiamando il acquire_token_on_behalf_of metodo .

Ecco un esempio di codice che acquisisce un token di accesso usando il acquire_token_on_behalf_of metodo e il framework Flask. Chiama l'API downstream, ovvero l'endpoint delle sottoscrizioni di gestione di Azure.

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)

(Avanzate) Accesso alla cache dei token dell'utente connesso da app, API e servizi in background

È possibile usare l'implementazione della cache dei token di MSAL per consentire alle app, alle API e ai servizi in background di usare la cache dei token di accesso per continuare a eseguire operazioni per conto degli utenti in loro assenza. Questa opzione è particolarmente utile se le app e i servizi in background devono continuare a funzionare per conto dell'utente dopo che questi è uscito dall'app Web front-end.

Attualmente, la maggior parte dei processi in background usa le autorizzazioni per le applicazioni quando deve operare con i dati di un utente senza che questi sia presente per autenticare o ripetere l'autenticazione. Poiché le autorizzazioni per le applicazioni richiedono spesso il consenso dell'amministratore, il che presuppone l'elevazione dei privilegi, ne derivano conflitti non necessari nella misura in cui lo sviluppatore non intendeva ottenere un'autorizzazione diversa da quella per cui l'utente aveva inizialmente dato il proprio consenso per l'app.

Questo codice di esempio in GitHub illustra come evitare questi conflitti non necessari accedendo alla cache dei token di MSAL dalle app in background:

Accesso alla cache dei token dell'utente connesso da app, API e servizi in background