Acquérir des jetons pour appeler une API web à l’aide d’une application démon

Voici un exemple de définition des étendues de l’API web dans le cadre de la configuration dans un fichier appsettings.json. Cet exemple est extrait de l’exemple de code démon de console .NET sur GitHub.

{
    "AzureAd": {
        // Same AzureAd section as before.
    },

    "MyWebApi": {
        "BaseUrl": "https://localhost:44372/",
        "RelativePath": "api/TodoList",
        "RequestAppToken": true,
        "Scopes": [ "[Enter here the scopes for your web API]" ]
    }
}

Dans Java, définissez l’étendue de Microsoft Graph par défaut en tant que constante :

final static String GRAPH_DEFAULT_SCOPE = "https://graph.microsoft.com/.default";

Dans Node.js, spécifiez l’étendue dans l’objet de demande de jeton :

const tokenRequest = {
    scopes: [process.env.GRAPH_ENDPOINT + '.default'], // e.g. 'https://graph.microsoft.com/.default'
};

Dans MSAL Python, le fichier de configuration ressemble à l’extrait de code suivant :

{
    "scope": ["https://graph.microsoft.com/.default"],
}

Dans le code .NET de bas niveau, générez l’étendue en ajoutant /.default à l’ID de ressource :

ResourceId = "someAppIDURI";
var scopes = new [] {  ResourceId+"/.default"};

Avec Microsoft. Identity.Web, vous n'avez pas besoin d'acquérir un jeton directement. Vous pouvez utiliser des API de niveau supérieur, comme vous le voyez dans Appel d’une API web à partir d’une application démon. Toutefois, si vous utilisez un Kit de développement logiciel (SDK) qui nécessite un jeton, vous pouvez obtenir un jeton d’application par le biais de l’abstraction ITokenAcquirer , comme illustré dans l’exemple suivant :

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Identity.Abstractions;
using Microsoft.Identity.Web;

// In the Program.cs, acquire a token for your downstream API

var tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();
ITokenAcquirer acquirer = tokenAcquirerFactory.GetTokenAcquirer();
AcquireTokenResult tokenResult = await acquirer.GetTokenForUserAsync(new[] { "https://graph.microsoft.com/.default" });
string accessToken = tokenResult.AccessToken;

L’exemple d’acquisition de jetons Java suivant est extrait des exemples de développement MSAL Java.

private static IAuthenticationResult acquireToken() throws Exception {

     // Load token cache from file and initialize token cache aspect. The token cache will have
     // dummy data, so the acquireTokenSilently call will fail.
     TokenCacheAspect tokenCacheAspect = new TokenCacheAspect("sample_cache.json");

     IClientCredential credential = ClientCredentialFactory.createFromSecret(CLIENT_SECRET);
     ConfidentialClientApplication cca =
             ConfidentialClientApplication
                     .builder(CLIENT_ID, credential)
                     .authority(AUTHORITY)
                     .setTokenCacheAccessAspect(tokenCacheAspect)
                     .build();

     IAuthenticationResult result;
     try {
         SilentParameters silentParameters =
                 SilentParameters
                         .builder(SCOPE)
                         .build();

         // try to acquire token silently. This call will fail since the token cache does not
         // have a token for the application you are requesting an access token for
         result = cca.acquireTokenSilently(silentParameters).join();
     } catch (Exception ex) {
         if (ex.getCause() instanceof MsalException) {

             ClientCredentialParameters parameters =
                     ClientCredentialParameters
                             .builder(SCOPE)
                             .build();

             // Try to acquire a token. If successful, you should see
             // the token information printed out to console
             result = cca.acquireToken(parameters).join();
         } else {
             // Handle other exceptions accordingly
             throw ex;
         }
     }
     return result;
 }

L’extrait de code suivant illustre une acquisition de jeton dans une application cliente confidentielle MSAL Node :

try {
    const authResponse = await cca.acquireTokenByClientCredential(tokenRequest);
    console.log(authResponse.accessToken) // display access token
} catch (error) {
    console.log(error);
}

L’exemple suivant montre le modèle de Python MSAL pour acquérir un jeton d’accès d’application uniquement avec les informations d’identification du client :

result = None

# First, the code looks up a token from the cache.
# Because we're looking for a token for the current app, not for a user,
# use None for the account parameter.
result = app.acquire_token_silent(config["scope"], account=None)

if not result:
    logging.info("No suitable token exists in cache. Let's get a new one from Azure AD.")
    result = app.acquire_token_for_client(scopes=config["scope"])

if "access_token" in result:
    # Call a protected API with the access token.
    print(result["token_type"])
else:
    print(result.get("error"))
    print(result.get("error_description"))
    print(result.get("correlation_id"))  # You might need this when reporting a bug.

using Microsoft.Identity.Client;

// With client credentials flows, the scope is always of the shape "resource/.default" because the
// application permissions need to be set statically (in the portal or by PowerShell), and then granted by
// a tenant administrator.
string[] scopes = new string[] { "https://graph.microsoft.com/.default" };

AuthenticationResult result = null;
try
{
 result = await app.AcquireTokenForClient(scopes)
                  .ExecuteAsync();
}
catch (MsalUiRequiredException ex)
{
    // The application doesn't have sufficient permissions.
    // - Did you declare enough app permissions during app creation?
    // - Did the tenant admin grant permissions to the application?
}
catch (MsalServiceException ex) when (ex.Message.Contains("AADSTS70011"))
{
    // Invalid scope. The scope has to be in the form "https://resourceurl/.default"
    // Mitigation: Change the scope to be as expected.
}

AcquireTokenForClient utilise le cache de jetons d’application

Dans MSAL.NET, AcquireTokenForClient utilise le cache de jetons de l’application (toutes les autres méthodes AcquireTokenXX utilisent le cache de jetons de l’utilisateur). N’appelez pas AcquireTokenSilent avant d’appeler AcquireTokenForClient, car AcquireTokenSilent utilise le cache de jetons de l’utilisateur. AcquireTokenForClient vérifie lui-même le cache de jetons d'application et le met à jour.

Passez à l’article suivant de ce scénario, Appeler une API web.

Passez à l’article suivant de ce scénario, Appeler une API web.

Passez à l’article suivant de ce scénario, Appeler une API web.

Passez à l’article suivant de ce scénario, Appeler une API web.

Passez à l’article suivant de ce scénario, Appeler une API web.