Konfigurieren von Daemon-Apps, die Web-APIs aufrufen

Hier ist ein Beispiel für die Definition der Konfiguration in einer appsettings.json Beispielkonfigurationsdatei. Dieses Beispiel stammt aus dem Codebeispiel .NET-Konsolen-Daemon auf GitHub.

{
    "AzureAd": {
        "Instance": "https://login.microsoftonline.com/",
        "TenantId": "[Enter here the tenantID or domain name for your Azure AD tenant]",
        "ClientId": "[Enter here the ClientId for your application]",
        "ClientCredentials": [
            {
                "SourceType": "ClientSecret",
                "ClientSecret": "[Enter here a client secret for your application]"
            }
        ]
    }
}

Sie stellen ein Zertifikat anstelle des geheimen Clientschlüssels oder der Anmeldeinformationen des Workloadidentitätsverbunds bereit.

Das folgende Beispiel zeigt die Java Konfigurationskonstanten für eine Daemon-App:

 private final static String CLIENT_ID = "";
 private final static String AUTHORITY = "https://login.microsoftonline.com/<tenant>/";
 private final static String CLIENT_SECRET = "";
 private final static Set<String> SCOPE = Collections.singleton("https://graph.microsoft.com/.default");

Konfigurationsparameter für das Node.js-Daemon-Beispiel sind in einer ENV-Datei enthalten:

# Credentials
TENANT_ID=Enter_the_Tenant_Info_Here
CLIENT_ID=Enter_the_Application_Id_Here

// You provide either a ClientSecret or a CertificateConfiguration, or a ClientAssertion. These settings are exclusive
CLIENT_SECRET=Enter_the_Client_Secret_Here
CERTIFICATE_THUMBPRINT=Enter_the_certificate_thumbprint_Here
CERTIFICATE_PRIVATE_KEY=Enter_the_certificate_private_key_Here
CLIENT_ASSERTION=Enter_the_Assertion_String_Here

# Endpoints
// the Azure AD endpoint is the authority endpoint for token issuance
AAD_ENDPOINT=Enter_the_Cloud_Instance_Id_Here // https://login.microsoftonline.com/
// the graph endpoint is the application ID URI of Microsoft Graph
GRAPH_ENDPOINT=Enter_the_Graph_Endpoint_Here // https://graph.microsoft.com/

Wenn Sie einen vertraulichen Client mit Clientgeheimnissen erstellen, sieht die Beispieldatei parameters.json für den Client-Secret-Flow im Python-Daemon-Beispiel wie folgt aus:

{
  "authority": "https://login.microsoftonline.com/<your_tenant_id>",
  "client_id": "your_client_id",
  "scope": [ "https://graph.microsoft.com/.default" ],
  "secret": "The secret generated by Azure AD during your confidential app registration",
  "endpoint": "https://graph.microsoft.com/v1.0/users"
}

Wenn Sie einen vertraulichen Client mit Zertifikaten erstellen, lautet das parameters.json Beispiel für die Zertifikatflusskonfigurationsdatei im Python Daemon-Beispiel wie folgt:

{
  "authority": "https://login.microsoftonline.com/<your_tenant_id>",
  "client_id": "your_client_id",
  "scope": [ "https://graph.microsoft.com/.default" ],
  "thumbprint": "790E... The thumbprint generated by Azure AD when you upload your public cert",
  "private_key_file": "server.pem",
  "endpoint": "https://graph.microsoft.com/v1.0/users"
}

Hier ist ein Beispiel für die Definition der Konfiguration in einer appsettings.json Daemon-Konsolenkonfigurationsdatei. Dieses Beispiel stammt aus dem Codebeispiel .NET-Konsolen-Daemon auf GitHub.

{
  "Instance": "https://login.microsoftonline.com/{0}",
  "Tenant": "[Enter here the tenantID or domain name for your Azure AD tenant]",
  "ClientId": "[Enter here the ClientId for your application]",
  "ClientSecret": "[Enter here a client secret for your application]",
  "CertificateName": "[Or instead of client secret: Enter here the name of a certificate (from the user cert store) as registered with your application]"
}

Sie geben entweder ClientSecret oder CertificateName an. Diese Einstellungen sind exklusiv.

Fügen Sie Ihrer Anwendung das NuGet-Paket Microsoft.Identity.Web.TokenAcquisition hinzu. Wenn Sie Microsoft Graph aufrufen möchten, fügen Sie alternativ das Paket Microsoft.Identity.Web.GraphServiceClient hinzu. Ihr Projekt könnte wie folgt aussehen. Die Datei appsettings.json muss in das Ausgabeverzeichnis kopiert werden.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net7.0</TargetFramework>
    <RootNamespace>daemon_console</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Identity.Web.GraphServiceClient" Version="2.12.2" />
  </ItemGroup>

  <ItemGroup>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>
</Project>

Fügen Sie in der Datei „Program.cs“ in Ihrem Code eine using-Anweisung hinzu, um auf „Microsoft.Identity.Web“ zu verweisen.

using Microsoft.Identity.Abstractions;
using Microsoft.Identity.Web;

import com.microsoft.aad.msal4j.ClientCredentialFactory;
import com.microsoft.aad.msal4j.ClientCredentialParameters;
import com.microsoft.aad.msal4j.ConfidentialClientApplication;
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.IClientCredential;
import com.microsoft.aad.msal4j.MsalException;
import com.microsoft.aad.msal4j.SilentParameters;

Installieren Sie die Pakete durch Ausführen von npm install in dem Ordner, in dem sich die Datei package.json befindet. Importieren Sie dann das Paket msal-node:

const msal = require('@azure/msal-node');

Importieren Sie die erforderlichen MSAL- und Hilfsmodule in Ihre Python Anwendung:

import msal
import json
import sys
import logging

Fügen Sie Ihrer Anwendung das NuGet-Paket Microsoft.Identity.Client hinzu, und fügen Sie dann im Code eine using-Direktive hinzu, um darauf zu verweisen.

In MSAL.NET wird die vertrauliche Clientanwendung durch die IConfidentialClientApplication-Schnittstelle dargestellt.

using Microsoft.Identity.Client;
IConfidentialClientApplication app;

Im folgenden Beispiel wird die vertrauliche Clientanwendung mithilfe eines geheimen Clientschlüssels mit Microsoft erstellt. Identity.Web:

   class Program
    {
        static async Task Main(string[] _)
        {
            // Get the Token acquirer factory instance. By default it reads an appsettings.json
            // file if it exists in the same folder as the app (make sure that the 
            // "Copy to Output Directory" property of the appsettings.json file is "Copy if newer").
            TokenAcquirerFactory tokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance();

            // Configure the application options to be read from the configuration
            // and add the services you need (Graph, token cache)
            IServiceCollection services = tokenAcquirerFactory.Services;
            services.AddMicrosoftGraph();
            // By default, you get an in-memory token cache.
            // For more token cache serialization options, see https://aka.ms/msal-net-token-cache-serialization

            // Resolve the dependency injection.
            var serviceProvider = tokenAcquirerFactory.Build();

            // ...
        }
    }

Die Konfiguration wird aus appsettings.json gelesen:

Verwenden Sie den folgenden Java Code, um eine vertrauliche Clientanwendung mit einem geheimen Clientschlüssel zu erstellen:

IClientCredential credential = ClientCredentialFactory.createFromSecret(CLIENT_SECRET);

ConfidentialClientApplication cca =
        ConfidentialClientApplication
                .builder(CLIENT_ID, credential)
                .authority(AUTHORITY)
                .build();

Verwenden Sie die folgende Node.js Konfiguration, um eine vertrauliche Clientanwendung mit einem geheimen Clientschlüssel zu instanziieren:

const msalConfig = {
  auth: {
    clientId: process.env.CLIENT_ID,
    authority: process.env.AAD_ENDPOINT + process.env.TENANT_ID,
    clientSecret: process.env.CLIENT_SECRET,
  }
};

const apiConfig = {
  uri: process.env.GRAPH_ENDPOINT + 'v1.0/users',
};

const tokenRequest = {
  scopes: [process.env.GRAPH_ENDPOINT + '.default'],
};

const cca = new msal.ConfidentialClientApplication(msalConfig);

# Pass the parameters.json file as an argument to this Python script. E.g.: python your_py_file.py parameters.json
config = json.load(open(sys.argv[1]))

# Create a preferably long-lived app instance that maintains a token cache.
app = msal.ConfidentialClientApplication(
    config["client_id"], authority=config["authority"],
    client_credential=config["secret"],
    # 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
    )

Im folgenden MSAL.NET Beispiel wird mithilfe des konfigurierten geheimen Clientschlüssels eine vertrauliche Clientanwendung erstellt:

app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
           .WithClientSecret(config.ClientSecret)
           .WithAuthority(new Uri(config.Authority))
           .Build();

Die Authority ist eine Verkettung der Cloudinstanz und der Mandanten-ID, z. B. https://login.microsoftonline.com/contoso.onmicrosoft.com oder https://login.microsoftonline.com/aaaabbbb-0000-cccc-1111-dddd2222eeee. In der im Abschnitt Konfigurationsdatei abgebildeten Datei appsettings.json werden die Instanz und der Mandant durch die Werte Instance und Tenant dargestellt.

In dem Codebeispiel, aus dem der vorherige Ausschnitt stammt, ist Authority eine Eigenschaft für die AuthenticationConfig-Klasse und als solche definiert:

/// <summary>
/// URL of the authority
/// </summary>
public string Authority
{
    get
    {
        return String.Format(CultureInfo.InvariantCulture, Instance, Tenant);
    }
}

Der Anwendungskonstruktionscode ist identisch mit dem Clientschlüsselbeispiel. Der einzige Unterschied besteht darin, dass das Zertifikat in der Konfiguration anstelle eines geheimen Schlüssels beschrieben wird. Es gibt viele Möglichkeiten, das Zertifikat abzurufen. Weitere Informationen finden Sie unter Verwenden Sie Zertifikate mit Microsoft Identity Web. Das folgende Konfigurationsbeispiel zeigt, wie Sie Ihr Zertifikat aus Azure Key Vault abrufen. Die Microsoft-Identität delegiert an „DefaultAzureCredential“ der Azure-Identität und verwendet eine verwaltete Identität, sofern verfügbar, um über KeyVault auf das Zertifikat zuzugreifen. Sie können Ihre Anwendung lokal debuggen, da DefaultAzureCredential dann Ihre Entwickleranmeldeinformationen verwendet.

  "ClientCredentials": [
      {
        "SourceType": "KeyVault",
        "KeyVaultUrl": "https://yourKeyVaultUrl.vault.azure.net",
        "KeyVaultCertificateName": "NameOfYourCertificate"
      }

In MSAL.Java gibt es zwei Generatoren zum Instanziieren der vertraulichen Clientanwendung mit Zertifikaten:

InputStream pkcs12Certificate = ... ; /* Containing PCKS12-formatted certificate*/
string certificatePassword = ... ;    /* Contains the password to access the certificate */

IClientCredential credential = ClientCredentialFactory.createFromCertificate(pkcs12Certificate, certificatePassword);

ConfidentialClientApplication cca =
        ConfidentialClientApplication
                .builder(CLIENT_ID, credential)
                .authority(AUTHORITY)
                .build();

oder

PrivateKey key = getPrivateKey(); /* RSA private key to sign the assertion */
X509Certificate publicCertificate = getPublicCertificate(); /* x509 public certificate used as a thumbprint */

IClientCredential credential = ClientCredentialFactory.createFromCertificate(key, publicCertificate);

ConfidentialClientApplication cca =
        ConfidentialClientApplication
                .builder(CLIENT_ID, credential)
                .authority(AUTHORITY)
                .build();

Im folgenden Node.js Beispiel wird eine vertrauliche Clientanwendung für die Verwendung eines Zertifikats konfiguriert:

const config = {
    auth: {
        clientId: process.env.CLIENT_ID,
        authority: process.env.AAD_ENDPOINT + process.env.TENANT_ID,
        clientCertificate: {
            thumbprint:  process.env.CERTIFICATE_THUMBPRINT, // a 40-digit hexadecimal string
            privateKey:  process.env.CERTIFICATE_PRIVATE_KEY,
        }
    }
};

// Create an MSAL application object
const cca = new msal.ConfidentialClientApplication(config);

Genauere Informationen finden Sie unter Verwenden von Zertifikatanmeldeinformationen mit MSAL Node.

# Pass the parameters.json file as an argument to this Python script. E.g.: python your_py_file.py parameters.json
config = json.load(open(sys.argv[1]))

# Create a preferably long-lived app instance that maintains a token cache.
app = msal.ConfidentialClientApplication(
    config["client_id"], authority=config["authority"],
    client_credential={"thumbprint": config["thumbprint"], "private_key": open(config['private_key_file']).read()},
    # 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
    )

Verwenden Sie den folgenden MSAL.NET Code, um ein Zertifikat zu laden und die vertrauliche Clientanwendung zu erstellen:

X509Certificate2 certificate = ReadCertificate(config.CertificateName);
app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
    .WithCertificate(certificate)
    .WithAuthority(new Uri(config.Authority))
    .Build();

Zusätzlich zur Verwendung eines geheimen Clientschlüssels oder Zertifikats können vertrauliche Clientanwendungen ihre Identität auch mithilfe von Client-Assertionen nachweisen. Ausführliche Informationen finden Sie unter CredentialDescription.

Im folgenden Java Beispiel wird eine vertrauliche Clientanwendung mithilfe einer Client assertion erstellt:

IClientCredential credential = ClientCredentialFactory.createFromClientAssertion(assertion);

ConfidentialClientApplication cca =
        ConfidentialClientApplication
                .builder(CLIENT_ID, credential)
                .authority(AUTHORITY)
                .build();

Verwenden Sie die folgende Node.js Konfiguration, um eine vertrauliche Clientanwendung mit einer Client assertion zu initialisieren:

const clientConfig = {
    auth: {
        clientId: process.env.CLIENT_ID,
        authority: process.env.AAD_ENDPOINT + process.env.TENANT_ID,
        clientAssertion:  process.env.CLIENT_ASSERTION
    }
};
const cca = new msal.ConfidentialClientApplication(clientConfig);

Genauere Informationen finden Sie unter Initialisieren des ConfidentialClientApplication-Objekts.

In MSAL Python können Sie Client-Claims bereitstellen, indem Sie die Claims verwenden, die mit dem privaten Schlüssel von ConfidentialClientApplication signiert werden.

# Pass the parameters.json file as an argument to this Python script. E.g.: python your_py_file.py parameters.json
config = json.load(open(sys.argv[1]))

# Create a preferably long-lived app instance that maintains a token cache.
app = msal.ConfidentialClientApplication(
    config["client_id"], authority=config["authority"],
    client_credential={"thumbprint": config["thumbprint"], "private_key": open(config['private_key_file']).read()},
    client_claims = {"client_ip": "x.x.x.x"}
    # 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
    )

Weitere Informationen finden Sie in der MSAL-Python-Referenzdokumentation für ConfidentialClientApplication.

Die vertrauliche Clientanwendung kann ihre Identität statt mit einem geheimen Clientschlüssel oder einem Zertifikat auch mithilfe von Clientassertionen nachweisen.

MSAL.NET verfügt über zwei Methoden, um für die vertrauliche Client-App signierte Assertionen bereitzustellen:

• .WithClientAssertion()
• .WithClientClaims()

Wenn Sie WithClientAssertion verwenden, geben Sie ein signiertes JWT an. Dieses erweiterte Szenario wird unter Clientassertionen ausführlich erläutert.

string signedClientAssertion = ComputeAssertion();
app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
                                          .WithClientAssertion(signedClientAssertion)
                                          .Build();

Bei Verwendung von WithClientClaims erstellt MSAL.NET eine signierte Assertion, die die von Microsoft Entra ID erwarteten Ansprüche sowie zusätzliche Clientansprüche enthält, die Sie senden möchten. Dies wird im folgenden Code veranschaulicht:

string ipAddress = "192.168.1.2";
var claims = new Dictionary<string, string> { { "client_ip", ipAddress } };
X509Certificate2 certificate = ReadCertificate(config.CertificateName);
app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
                                          .WithAuthority(new Uri(config.Authority))
                                          .WithClientClaims(certificate, claims)
                                          .Build();

Ausführliche Informationen finden Sie unter Clientassertionen.

Fahren Sie mit dem nächsten Artikel in diesem Szenario fort: Abrufen eines Tokens für die App.

Fahren Sie mit dem nächsten Artikel in diesem Szenario fort: Abrufen eines Tokens für die App.

Fahren Sie mit dem nächsten Artikel in diesem Szenario fort: Abrufen eines Tokens für die App.

Fahren Sie mit dem nächsten Artikel in diesem Szenario fort: Abrufen eines Tokens für die App.

Fahren Sie mit dem nächsten Artikel in diesem Szenario fort: Abrufen eines Tokens für die App.