Vergleich: Microsoft Entra SDK für Agent-ID und In-Process Microsoft. Identity.Web

Dieses Handbuch hilft Ihnen, die Unterschiede zwischen dem Microsoft Entra SDK für Agent-ID und der prozessinternen Microsoft.Identity.Web-Bibliothek zur Authentifizierung Ihrer Anwendungen zu ermitteln. Die Microsoft. Identity.Web library ist direkt in .NET Anwendungen integriert, um maximale Leistung zu erzielen. Das Microsoft Entra SDK für Agent-ID wird als separater Container ausgeführt und unterstützt jede Programmiersprache über HTTP-APIs. Die Auswahl des richtigen Ansatzes hängt von der Architektur, Sprache und Bereitstellungsumgebung Ihrer Anwendung ab.

Architekturunterschiede

Der grundlegende Unterschied liegt darin , wo die Authentifizierungslogik ausgeführt wird. Microsoft. Identity.Web wird innerhalb Ihres Anwendungsprozesses ausgeführt. Das Microsoft Entra SDK für Agent-ID arbeitet neben Ihrer Anwendung als eigenständiger Dienst. Diese Architekturauswahl wirkt sich auf Faktoren wie Entwicklungsworkflow und betriebstechnische Komplexität aus.

Microsoft.Identity.Web (in-process)

Dieser Codeausschnitt zeigt, wie Microsoft. Identity.Web integriert sich direkt in eine ASP.NET Core Anwendung:

// Startup configuration
services.AddMicrosoftIdentityWebApiAuthentication(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("Graph", Configuration.GetSection("DownstreamApis:Graph"))
    .AddInMemoryTokenCaches();

// Usage in controller
public class MyController : ControllerBase
{
    private readonly IDownstreamApi _downstreamApi;
    
    public MyController(IDownstreamApi downstreamApi)
    {
        _downstreamApi = downstreamApi;
    }
    
    public async Task<ActionResult> GetUserData()
    {
        var user = await _downstreamApi.GetForUserAsync<User>("Graph", 
            options => options.RelativePath = "me");
        return Ok(user);
    }
}

Microsoft Entra SDK für Agent-ID (außerhalb des Prozesses)

Dieser Codeausschnitt veranschaulicht, wie das Microsoft Entra SDK für Agent-ID aus einer Node.js Anwendung mithilfe von HTTP aufgerufen wird. Der Aufruf des /DownstreamApi Endpunkts des SDK übernimmt die Verarbeitung der Tokenakquisition und der aufeinanderfolgenden API-Aufrufe. Hierbei wird das eingehende Token für OBO-Flows im Authorization Header übergeben.

// Configuration
const SidecarUrl = process.env.SIDECAR_URL || "http://localhost:5000";

// Usage in application
async function getUserData(incomingToken: string) {
  const response = await fetch(
    `${SidecarUrl}/DownstreamApi/Graph?optionsOverride.RelativePath=me`,
    {
      headers: {
        'Authorization': `Bearer ${incomingToken}`
      }
    }
  );
  
  const result = await response.json();
  return JSON.parse(result.content);
}

Funktionsvergleich

Wann jeder Ansatz verwendet werden soll

Die Entscheidung zwischen Microsoft.Identity.Web und dem Microsoft Entra SDK für Agent-ID hängt von den Anforderungen, der Architektur und der Bereitstellungsstrategie Ihrer Anwendung ab. Je nach Ihren Anforderungen ist ein Ansatz möglicherweise besser geeignet als der andere. Die folgenden Richtlinien können Ihnen dabei helfen, eine fundierte Entscheidung zu treffen.

Migrationsleitfaden

Migrieren von Microsoft. Identity.Web zum Microsoft Entra SDK für AgentID

In bestimmten Szenarien möchten Sie möglicherweise eine vorhandene .NET-Anwendung migrieren, die Microsoft.Identity.Web verwendet, um das Microsoft Entra SDK für die Agent-ID-Authentifizierung zu nutzen. Gründe für die Migration können die Einführung einer mehrsprachigen Architektur, die Standardisierung der Authentifizierung über Dienste hinweg oder das Verschieben in ein containerisiertes Bereitstellungsmodell umfassen.

Bevor Sie diese Änderung vornehmen, sind sorgfältige Überlegungen und Planung erforderlich. Dieser Abschnitt enthält einen allgemeinen Migrationspfad mit Codebeispielen, die Ihnen beim Übergang Ihrer Anwendung helfen.

Schritt 1: Bereitstellen des SDK-Containers

Fügen Sie zuerst den SDK-Container zu Ihrem Pod hinzu:

# Before: Single ASP.NET Core container
containers:
- name: app
  image: myregistry/myapp:latest

# After: App + Microsoft Entra SDK for AgentID
containers:
- name: app
  image: myregistry/myapp:latest
  env:
  - name: SIDECAR_URL
    value: "http://localhost:5000"

- name: sidecar
  image: mcr.microsoft.com/entra-sdk/auth-sidecar:1.0.0
  env:
  - name: AzureAd__TenantId
    value: "your-tenant-id"
  - name: AzureAd__ClientId
    value: "your-client-id"

Schritt 2: Migrieren der Konfiguration

Übertragen Sie als Nächstes Ihre Konfiguration von appsettings.json in Umgebungsvariablen.

Vorher (appsettings.json)

{
  "AzureAd": {
    "Instance": "https://login.microsoftonline.com/",
    "TenantId": "your-tenant-id",
    "ClientId": "your-client-id"
  },
  "DownstreamApis": {
    "Graph": {
      "BaseUrl": "https://graph.microsoft.com/v1.0",
      "Scopes": "User.Read Mail.Read", 
      "RelativePath": "/me"
    }
  }
}

After (Kubernetes ConfigMap / Umgebungsvariablen)

apiVersion: v1
kind: ConfigMap
metadata:
  name: sidecar-config
data:
  AzureAd__Instance: "https://login.microsoftonline.com/"
  AzureAd__TenantId: "your-tenant-id"
  AzureAd__ClientId: "your-client-id"
  DownstreamApis__Graph__BaseUrl: "https://graph.microsoft.com/v1.0"
  DownstreamApis__Graph__Scopes: "User.Read Mail.Read"
  DownstreamApis__Graph__RelativePath: "/me"

Schritt 3: Aktualisieren des Anwendungscodes

Suchen Sie alle Instanzen von In-Process-Aufrufen zu Microsoft.Identity.Web und ersetzen Sie diese durch HTTP-Aufrufe an das Microsoft Entra SDK für Agent-ID-Endpunkte.

Vorher (C# with IDownstreamApi):

public class UserController : ControllerBase
{
    private readonly IDownstreamApi _downstreamApi;
    
    public UserController(IDownstreamApi downstreamApi)
    {
        _downstreamApi = downstreamApi;
    }
    
    [HttpGet]
    public async Task<ActionResult<User>> GetMe()
    {
        var user = await _downstreamApi.GetForUserAsync<User>(
            "Graph",
            options => options.RelativePath = "me"
        );
        return Ok(user);
    }
}

Nach (Jede Sprache mit HTTP-Client)

Im folgenden Codeausschnitt werden Aufrufe des Microsoft Entra SDK für Agent-ID mithilfe des endpunkts /DownstreamApi angezeigt, um Benutzerdaten abzurufen. Beispiele werden in C# und TypeScript bereitgestellt.

public class UserController : ControllerBase
{
    private readonly HttpClient _httpClient;
    private readonly string _SidecarUrl;
    
    public UserController(IHttpClientFactory httpClientFactory, IConfiguration config)
    {
        _httpClient = httpClientFactory.CreateClient();
        _SidecarUrl = config["SIDECAR_URL"];
    }
    
    [HttpGet]
    public async Task<ActionResult<User>> GetMe()
    {
        var inboundAuthorizationHeader = Request.Headers["Authorization"].ToString();
        // this validates the inbound authorization header and calls the downstream API.
        // If you don't call a downstream API, Do validate the inbound authorization header 
        // (calling the /Validate endpoint)
        var request = new HttpRequestMessage(
            HttpMethod.Get,
            $"{_SidecarUrl}/DownstreamApi/Graph?optionsOverride.RelativePath=me"
        );
        request.Headers.Add("Authorization", inboundAuthorizationHeader);
        
        var response = await _httpClient.SendAsync(request);
        var result = await response.Content.ReadFromJsonAsync<SidecarResponse>();
        var user = JsonSerializer.Deserialize<User>(result.Content);
        return Ok(user);
    }
}

TypeScript

Sie können dieselbe Logik in TypeScript wie folgt implementieren:

export async function getMe(incomingToken: string): Promise<User> {
  const SidecarUrl = process.env.SIDECAR_URL!;
  
  const response = await fetch(
    `${SidecarUrl}/DownstreamApi/Graph?optionsOverride.RelativePath=me`,
    {
      headers: {
        'Authorization': incomingToken
      }
    }
  );
  
  const result = await response.json();
  return JSON.parse(result.content) as User;
}

Schritt 4: Entfernen Microsoft. Identity.Web-Abhängigkeiten

Nachdem Sie die vorherigen Schritte abgeschlossen haben, bereinigen Sie Ihre Anwendung, indem Sie die NuGet-Pakete für Microsoft.Identity.Web aus Ihrem Projekt entfernen.

<!-- Remove these from .csproj -->
<PackageReference Include="Microsoft.Identity.Web" Version="..." />
<PackageReference Include="Microsoft.Identity.Web.MicrosoftGraph" Version="..." />
<PackageReference Include="Microsoft.Identity.Web.DownstreamApi" Version="..." />

Wenn Sie weiterhin Token in Ihrer App überprüfen möchten, müssen Sie die ursprüngliche Authentifizierungskonfiguration nicht entfernen. Stattdessen können Sie die Überprüfung vollständig an das Microsoft Entra SDK für AgentID delegieren.

// Remove from Program.cs or Startup.cs
services.AddMicrosoftIdentityWebApiAuthentication(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDownstreamApi("Graph", Configuration.GetSection("DownstreamApis:Graph"))
    .AddInMemoryTokenCaches();

Schritt 5: Testen und Überprüfen

1. Komponententests: Aktualisieren Sie Tests, um HTTP-Aufrufe des SDK zu modellieren.
2. Integrationstests: Testen der SDK-Kommunikation in Staging.
3. Leistungstests: Messen der AUSWIRKUNGEN auf den HTTP-Overhead.
4. Sicherheitstests: Überprüfen der Tokenbehandlung und Netzwerkrichtlinien.

Leistungsüberlegungen

SDK-Aufwand

Das Microsoft Entra SDK für Agent-ID führt zu HTTP-Kommunikationsaufwand:

In-Prozess-Leistung

Verwenden von Microsoft. Identity.Web hat einen minimalen Aufwand, da er innerhalb desselben Prozesses wie Ihre Anwendung ausgeführt wird. Es bietet systemeigene Methodenaufrufe mit Mikrosekundenlatenz und freigegebenem Prozessspeicher ohne HTTP-Einschränkungen. Wenn die Leistung kritisch ist, ist die Prozessintegration die optimale Wahl. Das Microsoft Entra SDK für das Flexibilitäts- und sprachunabhängige Design von AgentID kann jedoch in vielen Szenarien die Leistungsabwärmungen überwiegen.

In der folgenden Tabelle sind einige Leistungs- und Kostenvergleiche für die in-Prozess-Verwendung und die Verwendung des Microsoft Entra SDK für die Verwendung der Agent-ID (außerhalb des Prozesses) aufgeführt.

Kostenaspekte

Kostenbeispiel

Für 10 Replikate mit 128 MiB/100m SDK-Konfiguration:

Support und Wartung

Hybridansatz

Sie können beide Ansätze innerhalb derselben Architektur kombinieren. Verwenden Sie Microsoft. Identity.Web für .NET-Dienste, die eine maximale Leistung erfordern, und das Microsoft Entra SDK für Agent-ID für Nicht-.NET-Dienste verwenden oder wenn Sie sprachunabhängige Authentifizierungsmuster benötigen. Diese Hybridstrategie hilft Ihnen, die Leistung zu optimieren, wo es wichtig ist, während sie Konsistenz und Flexibilität in Ihrem gesamten Dienstökosystem beibehalten.

Eine Beispielarchitektur lautet wie folgt:

graph TB
    subgraph cluster["Kubernetes Cluster"]
        subgraph netpod["<b>.NET API Pod</b>"]
            netapi["<b>.NET API</b><br/>(Microsoft.Identity.Web)"]
            style netapi fill:#0078d4,stroke:#005a9e,stroke-width:2px,color:#fff
        end
        subgraph nodepod["<b>Node.js API Pod</b>"]
            nodeapi["<b>Node.js API</b>"]
            sidecar["<b>Microsoft Entra SDK for AgentID</b>"]
            style nodeapi fill:#68a063,stroke:#4a7c45,stroke-width:2px,color:#fff
            style sidecar fill:#f2711c,stroke:#d85e10,stroke-width:2px,color:#fff
        end
    end
    style cluster fill:#f0f0f0,stroke:#333,stroke-width:3px
    style netpod fill:#e8f4f8,stroke:#0078d4,stroke-width:2px
    style nodepod fill:#e8f4e8,stroke:#68a063,stroke-width:2px

Verwandte Inhalte

• Installationshandbuch
• Konfigurationsreferenz
• Nachgeschaltete API aufrufen
• Übersicht