Web API'lerini çağıran masaüstü uygulaması: Belirteç alma

Şunlar için geçerlidir: İş gücü kiracıları (daha fazla bilgi edinin)

Genel istemci uygulamasının bir örneğini inşa ettikten sonra, bir web API'sini çağırmak için kullanacağınız jetonu almak adına bunu kullanacaksınız.

Önerilen desen

Web API'si kapsamları tarafından tanımlanır. Uygulamanızda sağladığınız deneyim ne olursa olsun, kullanılacak desen şu şekildedir:

• AcquireTokenSilent çağrısı yaparak belirteç önbelleğinden sistematik bir şekilde belirteç almaya çalışın.
• Bu çağrı başarısız olursa, burada AcquireToken ile temsil edilen ve kullanmak istediğiniz AcquireTokenXX akışını kullanın.

.NET

In 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

iOS ve macOS için MSAL'de

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:
    }
}];

Çabuk:

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

MSAL Node'da, PKCE (Kod Değişimi için Kanıt Anahtarı) ile yetkilendirme kodu akışı kullanarak belirteçler alırsınız. MSAL Düğümü, önbellekte herhangi bir kullanıcı hesabı olup olmadığını görmek için bellek içi belirteç önbelleği kullanır. Eğer varsa, hesap nesnesi, önbelleğe alınmış bir erişim belirtecini almak için acquireTokenSilent() yöntemine geçirilebilir.

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

Piton

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

Bir masaüstü uygulamasında belirteç almanın çeşitli yolları vardır.

• Etkileşimli
• Tümleşik Windows kimlik doğrulaması
• WAM
• Kullanıcı Adı Parolası
• Cihaz kodu akışı

---

Önemli

Kullanıcıların uygulamada oturum açmak için çok faktörlü kimlik doğrulaması (MFA) kullanması gerekirse, bu kullanıcılar engellenir.

Sonraki adımlar

Bu senaryoda masaüstü uygulamasından web API'sini çağırma adlı sonraki makaleye geçin.