Vergleich: Microsoft Entra ID Auth SDK (Sidecar) und In-Process Microsoft. Identity.Web

Dieser Leitfaden hilft Ihnen, die Unterschiede zwischen dem Microsoft Entra ID Auth SDK (Sidecar) und der prozessinternen Bibliothek Microsoft.Identity.Web für die Authentifizierung in Ihren Anwendungen zu erkennen. Die Microsoft. Identity.Web library ist direkt in .NET Anwendungen integriert, um maximale Leistung zu erzielen. Das Microsoft Entra ID Auth SDK (Sidecar) 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 ID Auth SDK (Sidecar) fungiert als unabhängiger Dienst zusammen mit Ihrer Anwendung. 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 ID Auth SDK (Sidecar) (Out-of-Process)

Dieser Codeausschnitt veranschaulicht, wie das Microsoft Entra ID Auth SDK (Sidecar) 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 ID Auth SDK (sidecar) 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

Migration von Microsoft.Identity.Web zu Microsoft Entra ID Auth SDK (sidecar)

In bestimmten Szenarien möchten Sie möglicherweise eine vorhandene .NET-Anwendung migrieren, die Microsoft.Identity.Web verwendet, um für die Authentifizierung das Microsoft Entra ID Auth SDK (sidecar) 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 ID Auth SDK (sidecar)
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 an Microsoft.Identity.Web und ersetzen Sie sie durch HTTP-Aufrufe an die Endpunkte des Microsoft Entra ID Auth SDK (Sidecar):

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 sehen Sie Aufrufe an das Microsoft Entra ID Auth SDK (Sidecar) über den Endpunkt /DownstreamApi, 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 ID Auth SDK (Sidecar) 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 ID Auth SDK (Sidecar) 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. Die Flexibilität und das sprachunabhängige Design des Microsoft Entra ID Auth SDK (Sidecar) könnten jedoch in vielen Szenarien die Leistungskompromisse aufwiegen.

Die folgende Tabelle zeigt einige Leistungs- und Kostenvergleiche für die Verwendung in Prozessen und Microsoft Entra ID Auth SDK (Sidecar) (Out-of-Process)-Verwendung:

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 maximale Leistung erfordern, und das Microsoft Entra ID Auth SDK (Sidecar) 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 ID Auth SDK (sidecar)</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