Desktop-App, die Web-APIs aufruft: Abrufen eines Token
Artikel
Wenn Sie eine Instanz der öffentlichen Clientanwendung erstellt haben, rufen Sie damit ein Token ab, mit dem Sie anschließend eine Web-API aufrufen.
Empfohlenes Muster
Die Web-API wird durch ihre Bereiche definiert. Verwenden Sie ungeachtet der Benutzeroberfläche, die Sie in Ihrer Anwendung bereitstellen, folgendes Muster:
Versuchen Sie systematisch, ein Token aus dem Tokencache abzurufen, indem Sie AcquireTokenSilent aufrufen.
Schlägt dieser Aufruf fehl, verwenden Sie den gewünschten AcquireToken-Flow, der hier durch AcquireTokenXX dargestellt wird.
AuthenticationResult result;
var accounts = await app.GetAccountsAsync();
IAccount account = ChooseAccount(accounts); // for instance accounts.FirstOrDefault
// if the app manages is at most one account
try
{
result = await app.AcquireTokenSilent(scopes, account)
.ExecuteAsync();
}
catch(MsalUiRequiredException ex)
{
result = await app.AcquireTokenXX(scopes, account)
.WithOptionalParameterXXX(parameter)
.ExecuteAsync();
}
Set<IAccount> accountsInCache = pca.getAccounts().join();
// Take first account in the cache. In a production application, you would filter
// accountsInCache to get the right account for the user authenticating.
IAccount account = accountsInCache.iterator().next();
IAuthenticationResult result;
try {
SilentParameters silentParameters =
SilentParameters
.builder(SCOPE, account)
.build();
// try to acquire token silently. This call will fail since the token cache
// does not have any data for the user you are trying to acquire a token for
result = pca.acquireTokenSilently(silentParameters).join();
} catch (Exception ex) {
if (ex.getCause() instanceof MsalException) {
InteractiveRequestParameters parameters = InteractiveRequestParameters
.builder(new URI("http://localhost"))
.scopes(SCOPE)
.build();
// Try to acquire a token interactively with system browser. If successful, you should see
// the token and account information printed out to console
result = pca.acquireToken(parameters).join();
} else {
// Handle other exceptions accordingly
throw ex;
}
}
return result;
guard let account = try? application.account(forIdentifier: accountIdentifier) else { return }
let silentParameters = MSALSilentTokenParameters(scopes: scopes, account: account)
application.acquireTokenSilent(with: silentParameters) { (result, error) in
guard let authResult = result, error == nil else {
let nsError = error! as NSError
if (nsError.domain == MSALErrorDomain &&
nsError.code == MSALError.interactionRequired.rawValue) {
// Interactive auth will be required, call acquireToken()
return
}
return
}
}
Im MSAL Node rufen Sie Token über den Autorisierungscodefluss mit einem Prüfschlüssel für den Codeaustausch (Proof Key for Code Exchange, PKCE) ab. Der MSAL Node verwendet einen In-Memory-Tokencache, um festzustellen, ob Benutzerkonten im Cache vorhanden sind. Wenn dies der Fall ist, kann das Kontoobjekt zum Abrufen eines zwischengespeicherten Zugriffstokens der acquireTokenSilent()-Methode übergeben werden.
const msal = require("@azure/msal-node");
const msalConfig = {
auth: {
clientId: "your_client_id_here",
authority: "your_authority_here",
}
};
const pca = new msal.PublicClientApplication(msalConfig);
const msalTokenCache = pca.getTokenCache();
let accounts = await msalTokenCache.getAllAccounts();
if (accounts.length > 0) {
const silentRequest = {
account: accounts[0], // Index must match the account that is trying to acquire token silently
scopes: ["user.read"],
};
pca.acquireTokenSilent(silentRequest).then((response) => {
console.log("\nSuccessful silent token acquisition");
console.log("\nResponse: \n:", response);
res.sendStatus(200);
}).catch((error) => console.log(error));
} else {
const {verifier, challenge} = await msal.cryptoProvider.generatePkceCodes();
const authCodeUrlParameters = {
scopes: ["User.Read"],
redirectUri: "your_redirect_uri",
codeChallenge: challenge, // PKCE Code Challenge
codeChallengeMethod: "S256" // PKCE Code Challenge Method
};
// get url to sign user in and consent to scopes needed for application
pca.getAuthCodeUrl(authCodeUrlParameters).then((response) => {
console.log(response);
const tokenRequest = {
code: response["authorization_code"],
codeVerifier: verifier, // PKCE Code Verifier
redirectUri: "your_redirect_uri",
scopes: ["User.Read"],
};
// acquire a token by exchanging the code
pca.acquireTokenByCode(tokenRequest).then((response) => {
console.log("\nResponse: \n:", response);
}).catch((error) => {
console.log(error);
});
}).catch((error) => console.log(JSON.stringify(error)));
}
result = None
# Firstly, check the cache to see if this end user has signed in before
accounts = app.get_accounts(username=config["username"])
if accounts:
result = app.acquire_token_silent(config["scope"], account=accounts[0])
if not result:
result = app.acquire_token_by_xxx(scopes=config["scope"])
Es gibt verschiedene Möglichkeiten zum Abrufen von Token in einer Desktopanwendung.