Aplikacja desktopowa, która wywołuje internetowe interfejsy API: uzyskaj token

Dotyczy: Dzierżawcy usługi Workforce Zewnętrzni dzierżawcy (dowiedz się więcej)

Po utworzeniu wystąpienia publicznej aplikacji klienckiej użyjesz go do uzyskania tokenu, którego następnie użyjesz do wywołania internetowego interfejsu API.

Zalecany wzorzec

Internetowy interfejs API jest definiowany przez jego zakresy. Niezależnie od doświadczenia, jakie zapewniasz w swojej aplikacji, wzorzec do użycia to:

• Systematyczne próby pobierania tokenu z pamięci podręcznej przez wywołanie metody AcquireTokenSilent.
• Jeśli to wywołanie zakończy się niepowodzeniem, użyj przepływu AcquireToken, który jest tutaj reprezentowany przez AcquireTokenXX.

.NET

W MSAL.NET

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

Java

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;

macOS

W usłudze MSAL dla systemów iOS i macOS

Objective-C:

MSALAccount *account = [application accountForIdentifier:accountIdentifier error:nil];

MSALSilentTokenParameters *silentParams = [[MSALSilentTokenParameters alloc] initWithScopes:scopes account:account];
[application acquireTokenSilentWithParameters:silentParams completionBlock:^(MSALResult *result, NSError *error) {

    // Check the error
    if (error && [error.domain isEqual:MSALErrorDomain] && error.code == MSALErrorInteractionRequired)
    {
        // Interactive auth will be required, call acquireTokenWithParameters:error:
    }
}];

Szybki

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
    }
}

Node.js

W MSAL Node uzyskujesz tokeny za pośrednictwem przepływu kodu autoryzacji z użyciem PKCE (Proof Key for Code Exchange). MSAL Node używa pamięci podręcznej tokenu, aby sprawdzić, czy w pamięci podręcznej znajdują się konta użytkowników. Jeśli obiekt konta istnieje, można go przekazać do metody acquireTokenSilent() w celu pobrania buforowanego tokenu dostępu.

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

Python

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"])

Istnieją różne sposoby uzyskiwania tokenów w aplikacji klasycznej.

• Interaktywnie
• Zintegrowane uwierzytelnianie systemu Windows
• WAM
• Hasło nazwy użytkownika
• Przepływ kodu urządzenia

---

Ważne

Użytkownicy zostaną zablokowani, jeśli będą musieli logować się w aplikacji przy użyciu uwierzytelniania wieloskładnikowego (MFA).

Następne kroki

Przejdź do następnego artykułu w tym scenariuszu, wywołaj interfejs API z aplikacji komputerowej.