Aplikacja komputerowa, która wywołuje interfejsy API sieciowe: konfiguracja kodu

Dotyczy: Najemcy Workforce Zewnętrzni najemcy (dowiedz się więcej)

Po utworzeniu aplikacji dowiesz się, jak skonfigurować kod ze współrzędnymi aplikacji.

Biblioteki firmy Microsoft obsługujące aplikacje desktopowe

Następujące biblioteki firmy Microsoft obsługują aplikacje klasyczne:

Język/struktura	Projekt dotyczący GitHub	Pakiet	Uzyskiwanie rozpoczęto	Logowanie użytkowników	Dostęp do interfejsów API sieci Web	Ogólnie dostępne (ogólna dostępność) lub Publiczna wersja zapoznawcza1
Electron	MSAL Node.js	msal-node	—			Publiczna wersja zapoznawcza
Java	MSAL4J	msal4j	—			Ogólna dostępność
macOS (Swift/Obj-C)	MSAL dla iOS i macOS	MSAL	Samouczek			Ogólna dostępność
Platforma UWP	MSAL.NET	Microsoft.Identity.Client	Samouczek			Ogólna dostępność
WPF	MSAL.NET	Microsoft.Identity.Client	Samouczek			Ogólna dostępność

¹Uniwersalne postanowienia licencyjne dotyczące usług online mają zastosowanie do bibliotek w publicznej wersji zapoznawczej.

Publiczna aplikacja kliencka

Z punktu widzenia kodu aplikacje desktopowe to publiczne aplikacje klienckie. Konfiguracja będzie nieco inna w zależności od tego, czy używasz uwierzytelniania interakcyjnego, czy nie.

.NET

Musisz skompilować i manipulować MSAL.NET IPublicClientApplication.

Wyłącznie według kodu

Poniższy kod tworzy wystąpienie publicznej aplikacji klienckiej i loguje użytkowników w chmurze publicznej platformy Microsoft Azure przy użyciu konta służbowego lub osobistego konta Microsoft.

IPublicClientApplication app = PublicClientApplicationBuilder.Create(clientId)
    .Build();

Jeśli zamierzasz używać uwierzytelniania interakcyjnego lub przepływu kodu urządzenia, jak pokazano wcześniej, użyj .WithRedirectUri modyfikatora.

IPublicClientApplication app;
app = PublicClientApplicationBuilder.Create(clientId)
        .WithDefaultRedirectUri()
        .Build();

Korzystanie z plików konfiguracji

Poniższy kod tworzy wystąpienie publicznej aplikacji klienckiej z obiektu konfiguracji, który można wypełnić za pomocą programu lub odczytać z pliku konfiguracji.

PublicClientApplicationOptions options = GetOptions(); // your own method
IPublicClientApplication app = PublicClientApplicationBuilder.CreateWithApplicationOptions(options)
        .WithDefaultRedirectUri()
        .Build();

Bardziej rozbudowana konfiguracja

Można rozbudować proces tworzenia aplikacji, dodając szereg modyfikatorów. Jeśli na przykład aplikacja ma być aplikacją wielodostępną w chmurze krajowej, taką jak pokazano tutaj dla instytucji rządowych USA, możesz napisać:

IPublicClientApplication app;
app = PublicClientApplicationBuilder.Create(clientId)
        .WithDefaultRedirectUri()
        .WithAadAuthority(AzureCloudInstance.AzureUsGovernment,
                         AadAuthorityAudience.AzureAdMultipleOrgs)
        .Build();

MSAL.NET zawiera również modyfikator usług Active Directory Federation Services 2019:

IPublicClientApplication app;
app = PublicClientApplicationBuilder.Create(clientId)
        .WithAdfsAuthority("https://consoso.com/adfs")
        .Build();

Jeśli na koniec chcesz uzyskać tokeny dla dzierżawy usługi Azure Active Directory (Azure AD) B2C, określ dzierżawę, jak pokazano w poniższym fragmencie kodu:

IPublicClientApplication app;
app = PublicClientApplicationBuilder.Create(clientId)
        .WithB2CAuthority("https://fabrikamb2c.b2clogin.com/tfp/{tenant}/{PolicySignInSignUp}")
        .Build();

Dowiedz się więcej

Aby dowiedzieć się więcej na temat konfigurowania aplikacji klasycznej MSAL.NET:

• Aby uzyskać listę wszystkich modyfikatorów dostępnych w PublicClientApplicationBuilder, zobacz dokumentację referencyjną PublicClientApplicationBuilder.
• Opis wszystkich opcji uwidocznionych w PublicClientApplicationOptions znajdziesz w temacie PublicClientApplicationOptions w dokumentacji referencyjnej.

Kompletny przykład z opcjami konfiguracji

Wyobraź sobie aplikację konsolową platformy .NET, która ma następujący appsettings.json plik konfiguracji:

{
  "Authentication": {
    "AzureCloudInstance": "AzurePublic",
    "AadAuthorityAudience": "AzureAdMultipleOrgs",
    "ClientId": "00001111-aaaa-2222-bbbb-3333cccc4444"
  },

  "WebAPI": {
    "MicrosoftGraphBaseEndpoint": "https://graph.microsoft.com"
  }
}

W tym pliku jest mało kodu do odczytania, korzystając z dostarczonego przez .NET frameworka konfiguracyjnego.

public class SampleConfiguration
{
 /// <summary>
 /// Authentication options
 /// </summary>
 public PublicClientApplicationOptions PublicClientApplicationOptions { get; set; }

 /// <summary>
 /// Base URL for Microsoft Graph (it varies depending on whether the application runs
 /// in Microsoft Azure public clouds or national or sovereign clouds)
 /// </summary>
 public string MicrosoftGraphBaseEndpoint { get; set; }

 /// <summary>
 /// Reads the configuration from a JSON file
 /// </summary>
 /// <param name="path">Path to the configuration json file</param>
 /// <returns>SampleConfiguration as read from the json file</returns>
 public static SampleConfiguration ReadFromJsonFile(string path)
 {
  // .NET configuration
  IConfigurationRoot Configuration;
  var builder = new ConfigurationBuilder()
                    .SetBasePath(Directory.GetCurrentDirectory())
                    .AddJsonFile(path);
  Configuration = builder.Build();

  // Read the auth and graph endpoint configuration
  SampleConfiguration config = new SampleConfiguration()
  {
   PublicClientApplicationOptions = new PublicClientApplicationOptions()
  };
  Configuration.Bind("Authentication", config.PublicClientApplicationOptions);
  config.MicrosoftGraphBaseEndpoint =
  Configuration.GetValue<string>("WebAPI:MicrosoftGraphBaseEndpoint");
  return config;
 }
}

Teraz, aby utworzyć aplikację, napisz następujący kod:

SampleConfiguration config = SampleConfiguration.ReadFromJsonFile("appsettings.json");
var app = PublicClientApplicationBuilder.CreateWithApplicationOptions(config.PublicClientApplicationOptions)
           .WithDefaultRedirectUri()
           .Build();

Przed wywołaniem .Build() metody można zastąpić konfigurację wywołaniami .WithXXX metod, jak pokazano wcześniej.

Java

Oto klasa używana w przykładach programowania w języku Java biblioteki MSAL do konfigurowania przykładów: TestData.

PublicClientApplication pca = PublicClientApplication.builder(CLIENT_ID)
        .authority(AUTHORITY)
        .build();

MacOS

Poniższy kod tworzy wystąpienie publicznej aplikacji klienckiej i umożliwia logowanie użytkownikom do publicznej chmury Microsoft Azure przy użyciu konta służbowego lub osobistego konta Microsoft.

Szybka konfiguracja

Objective-C:

NSError *msalError = nil;

MSALPublicClientApplicationConfig *config = [[MSALPublicClientApplicationConfig alloc] initWithClientId:@"<your-client-id-here>"];
MSALPublicClientApplication *application = [[MSALPublicClientApplication alloc] initWithConfiguration:config error:&msalError];

Szybki

let config = MSALPublicClientApplicationConfig(clientId: "<your-client-id-here>")
if let application = try? MSALPublicClientApplication(configuration: config){ /* Use application */}

Bardziej rozbudowana konfiguracja

Można wzbogacić tworzenie aplikacji, dodając szereg modyfikatorów. Jeśli na przykład aplikacja ma być aplikacją wielodostępną w chmurze krajowej, taką jak pokazano tutaj dla instytucji rządowych USA, możesz napisać:

Objective-C:

MSALAADAuthority *aadAuthority =
                [[MSALAADAuthority alloc] initWithCloudInstance:MSALAzureUsGovernmentCloudInstance
                                                   audienceType:MSALAzureADMultipleOrgsAudience
                                                      rawTenant:nil
                                                          error:nil];

MSALPublicClientApplicationConfig *config =
                [[MSALPublicClientApplicationConfig alloc] initWithClientId:@"<your-client-id-here>"
                                                                redirectUri:@"<your-redirect-uri-here>"
                                                                  authority:aadAuthority];

NSError *applicationError = nil;
MSALPublicClientApplication *application =
                [[MSALPublicClientApplication alloc] initWithConfiguration:config error:&applicationError];

Szybki

let authority = try? MSALAADAuthority(cloudInstance: .usGovernmentCloudInstance, audienceType: .azureADMultipleOrgsAudience, rawTenant: nil)

let config = MSALPublicClientApplicationConfig(clientId: "<your-client-id-here>", redirectUri: "<your-redirect-uri-here>", authority: authority)
if let application = try? MSALPublicClientApplication(configuration: config) { /* Use application */}

Node.js

Parametry konfiguracji można załadować z wielu źródeł, takich jak plik JavaScript lub zmienne środowiskowe. Poniżej jest używany plik authConfig.js.

/*
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */

const { LogLevel } = require("@azure/msal-node");

/**
 * Configuration object to be passed to MSAL instance on creation.
 * For a full list of MSAL.js configuration parameters, visit:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/configuration.md
 */
const AAD_ENDPOINT_HOST = "Enter_the_Cloud_Instance_Id_Here"; // include the trailing slash

const msalConfig = {
    auth: {
        clientId: "Enter_the_Application_Id_Here",
        authority: `${AAD_ENDPOINT_HOST}Enter_the_Tenant_Info_Here`,
    },
    system: {
        loggerOptions: {
            loggerCallback(loglevel, message, containsPii) {
                console.log(message);
            },
            piiLoggingEnabled: false,
            logLevel: LogLevel.Verbose,
        },
    },
};

/**
 * Add here the endpoints and scopes when obtaining an access token for protected web APIs. For more information, see:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-browser/docs/resources-and-scopes.md
 */
const GRAPH_ENDPOINT_HOST = "Enter_the_Graph_Endpoint_Here"; // include the trailing slash

const protectedResources = {
    graphMe: {
        endpoint: `${GRAPH_ENDPOINT_HOST}v1.0/me`,
        scopes: ["User.Read"],
    }
};


module.exports = {
    msalConfig: msalConfig,
    protectedResources: protectedResources,
};

Zaimportuj obiekt konfiguracji z pliku authConfig.js . MSAL Node można zainicjować minimalnie, jak pokazano poniżej. Zobacz dostępne opcje konfiguracji.

const { PublicClientApplication } = require('@azure/msal-node');
const { msalConfig } = require('./authConfig')

/**
* Initialize a public client application. For more information, visit:
* https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/initialize-public-client-application.md
*/
clientApplication = new PublicClientApplication(msalConfig);

Python

config = json.load(open(sys.argv[1]))

app = msal.PublicClientApplication(
    config["client_id"], authority=config["authority"],
    # token_cache=...  # Default cache is in memory only.
                       # You can learn how to use SerializableTokenCache from
                       # https://msal-python.rtfd.io/en/latest/#msal.SerializableTokenCache
    )

Następne kroki

Przejdź do następnego artykułu w tym scenariuszu, Uzyskaj token dla aplikacji desktopowej.