Integrieren von Azure API Management (APIM) in die Fabric-API für GraphQL

Durch die Integration von Azure API Management (APIM) in die Microsoft Fabric-API für GraphQL werden die Funktionen Ihrer API erheblich verbessert, indem robuste Skalierbarkeits- und Sicherheitsfeatures bereitgestellt werden. APIM fungiert als Gateway auf Unternehmensniveau, das erweiterte Funktionen wie Identitätsverwaltung, Ratelimitierung, Reaktionszwischenspeicherung, Bedrohungsschutz und zentralisierte Überwachung hinzufügt – alles ohne Änderung der Fabric-API-Konfiguration.

Durch das Routing Ihrer GraphQL-Anforderungen über APIM können Sie skaliert werden, um erhöhten Datenverkehr zu verarbeiten, komplexe Sicherheitsrichtlinien zu implementieren und Einblicke in API-Nutzungsmuster in Ihrer Organisation zu erhalten.

Dieser Artikel führt Sie durch die Integration von APIM in die Fabric-API für GraphQL, das Konfigurieren der verwalteten Identitätsauthentifizierung und die Implementierung von Zwischenspeicherungs- und Ratelimitierungsrichtlinien.

Wer Azure API Management mit GraphQL verwendet

DIE APIM-Integration ist nützlich für:

Unternehmensarchitekten , die Fabric-Daten über ein zentralisiertes, geregeltes API-Gateway für den organisationsweiten Zugriff verfügbar geben
Fabric-Administratoren implementieren Ratenbegrenzungen, Zwischenspeicherungen und Sicherheitsrichtlinien zum Schutz der Fabric-Kapazität und -daten.
IT-Sicherheitsteams , die erweiterte Authentifizierung, Autorisierung und Bedrohungsschutz für den Fabric-Datenzugriff erfordern
Plattformteams verwalten und steuern mehrere Fabric GraphQL-APIs über Abteilungen und Geschäftseinheiten hinweg.

Verwenden Sie apiM-Integration, wenn Sie API-Verwaltungsfeatures auf Unternehmensniveau benötigen, z. B. Ratelimitierung, Zwischenspeicherung, Sicherheitsrichtlinien und zentrale Governance für Ihre Fabric GraphQL-APIs.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie folgendes haben:

Eine Fabric-API für GraphQL wurde bereits erstellt. Siehe "Erstellen einer API für GraphQL" oder verwenden Sie die "Mit einer Beispiel-SQL-Datenbank starten" im GraphQL-API-Portal.
Eine API Management-Instanz. Anweisungen zum Einrichten finden Sie unter Erstellen einer API-Verwaltungsinstanz
Berechtigungen zum Erstellen verwalteter Identitäten und Konfigurieren von APIM-Richtlinien

Hinzufügen einer Fabric GraphQL-API zur Azure-API-Verwaltung

Der erste Schritt bei der Integration von APIM in Fabric besteht darin, Ihre GraphQL-API in Azure API Management zu importieren. Dieser Prozess erstellt einen Proxy, der Anforderungen über APIM leitet und gleichzeitig die Verbindung zu Ihren Fabric-Datenquellen aufrecht erhält. Durch den Import der API richten Sie die Grundlage für das Hinzufügen von Unternehmensfeatures wie Authentifizierungsrichtlinien, Zwischenspeichern und Ratenbeschränkungen ein.

Der Importvorgang erfordert zwei Informationen aus Der Fabric GraphQL-API: die Endpunkt-URL (wobei APIM Anforderungen sendet) und die Schemadatei (die die API-Struktur und die verfügbaren Vorgänge definiert).

Exportieren der GraphQL-API-Details

Sammeln Sie zunächst die erforderlichen Informationen aus Ihrer Fabric GraphQL-API:

Öffnen Der GraphQL-API im Fabric-Portal
Wählen Sie im Menüband " Endpunkt kopieren " aus, um die URL Ihrer API abzurufen.
Wählen Sie "Schema exportieren " aus, um die GraphQL-Schemadatei auf Ihr lokales Gerät herunterzuladen.

Importieren der API in APIM

Nachdem Ihre Endpunkt-URL und die Schema-Datei bereit sind, können Sie jetzt die GraphQL-API in APIM registrieren. Dadurch wird eine API-Definition erstellt, die APIM verwendet, um Anforderungen zu überprüfen, Dokumentationen zu generieren und Richtlinien anzuwenden. Das von Ihnen hochgeladene Schema definiert, welche Abfragen und Mutationen Clients ausführen können.

Navigieren Sie im Azure-Portal zu Ihrer API-Verwaltungsinstanz
APIs>auswählen+ API hinzufügen
Auswählen des GraphQL-Symbols
Geben Sie im Bildschirm "Aus GraphQL-Schema erstellen " Folgendes an:
- Anzeigename: Ein freundlicher Name für die API
- Name: Der API-Bezeichner
- GraphQL-API-Endpunkt: Die Endpunkt-URL, die Sie aus Fabric kopiert haben
Wählen Sie "Schema hochladen" aus, und wählen Sie die schemadatei aus, die Sie heruntergeladen haben.

Konfigurieren der verwalteten Identitätsauthentifizierung

Da Ihre GraphQL-API nun in APIM registriert ist, müssen Sie konfigurieren, wie APIM mit Fabric authentifiziert wird. Verwaltete Identitäten bieten eine sichere, kennwortfreie Authentifizierungsmethode, die die Notwendigkeit zum Speichern von Anmeldeinformationen in Ihrer APIM-Konfiguration eliminiert. Azure verwaltet automatisch den Identitätslebenszyklus und behandelt die Tokenakquisition, wodurch dieser Ansatz sowohl sicherer als auch einfacher verwaltet werden kann als herkömmliche Authentifizierungsmethoden.

Das Authentifizierungssetup umfasst drei Hauptschritte: Erstellen der verwalteten Identität in Azure, Erteilen von Berechtigungen für den Zugriff auf Ihren Fabric-Arbeitsbereich und -Datenquellen und Konfigurieren von APIM zur Verwendung dieser Identität bei Anforderungen an Fabric.

Erstellen und Zuweisen einer verwalteten Identität

Erstellen Sie zunächst die verwaltete Identität, die APIM für die Authentifizierung verwendet:

Erstellen Sie eine vom Benutzer zugewiesene verwaltete Identität im Azure-Portal.
Beachten Sie die Client-ID der verwalteten Identität– Sie benötigen die Client-ID für die Richtlinienkonfiguration.

Erteilen der Berechtigungen für verwaltete Identitäten in Fabric

Nachdem Sie die verwaltete Identität erstellt haben, müssen Sie ihr Berechtigungen für den Zugriff auf Ihre Fabric-Ressourcen erteilen. Die verwaltete Identität benötigt Zugriff auf das GraphQL-API-Objekt selbst sowie auf alle Datenquellen, mit denen sie verbunden ist (wie z.B. Lakehouses oder Warehouses). Das Hinzufügen der Identität als Arbeitsbereichsmitglied ist der einfachste Ansatz, da er gleichzeitig Zugriff auf alle Elemente im Arbeitsbereich gewährt.

Öffnen des Fabric-Arbeitsbereichs mit Ihrer GraphQL-API
Wählen Sie Zugriff verwalten aus
Hinzufügen der verwalteten Identität (z. B. apim-id) mit mindestens der Rolle "Mitwirkender"

Tipp

Um eine detailliertere Kontrolle zu erhalten, können Sie die Berechtigungen direkt für die einzelnen Fabric-Elemente (die API und die zugehörigen Datenquellen) statt des Zugriffs auf der Arbeitsbereichsebene erteilen. Die granulare Kontrolle ist besonders wichtig, wenn Ihre API die SSO-Authentifizierung (Single Sign-On) verwendet. Weitere Informationen finden Sie in der Zusammenfassung zu Authentifizierung und Berechtigungen.

Konfigurieren von APIM für die Verwendung der verwalteten Identität

Mit berechtigungen, die in Fabric erteilt wurden, müssen Sie APIM mitteilen, welche verwaltete Identität verwendet werden soll. Diese Zuordnung erlaubt APIM, sich als diese Identität zu authentifizieren, wenn es Anfragen an Ihre Fabric GraphQL-API stellt.

Navigieren Sie im Azure-Portal zu Ihrer APIM-Instanz.
Wechseln zu Sicherheit>Verwaltete Identitäten
Fügen Sie die vom Benutzer zugewiesene, zuvor erstellte verwaltete Identität hinzu.

Hinzufügen einer Authentifizierungsrichtlinie

Der letzte Authentifizierungsschritt besteht darin, eine APIM-Richtlinie hinzuzufügen, die ein Zugriffstoken mithilfe der verwalteten Identität abruft und sie in Anforderungen an Fabric einschließt. Diese Richtlinie wird bei jeder Anforderung ausgeführt und verarbeitet die Token-Erwerbung und -Erneuerung automatisch. Die Richtlinie verwendet das authentication-managed-identity Element, um ein Token für die Fabric-API-Ressource abzurufen, und fügt es dann dem Autorisierungsheader hinzu.

Wählen Sie in Ihrer GraphQL-API in APIM die Registerkarte "API-Richtlinien " aus.
"Bearbeiten Sie die Richtlinie für die eingehende Verarbeitung"

Fügen Sie den folgenden XML-Code unter <inbound><base/>:

<authentication-managed-identity 
    resource="https://analysis.windows.net/powerbi/api" 
    client-id="YOUR-MANAGED-IDENTITY-CLIENT-ID" 
    output-token-variable-name="token-variable" 
    ignore-error="false" />
<set-header name="Authorization" exists-action="override">
    <value>@("Bearer " + (string)context.Variables["token-variable"])</value>
</set-header>

Ersetzen Sie YOUR-MANAGED-IDENTITY-CLIENT-ID durch die Client-ID Ihrer verwalteten Identität.
Speichern der Richtlinie

Testen der Verbindung

Vergewissern Sie sich, dass das Authentifizierungssetup ordnungsgemäß funktioniert, bevor Sie fortfahren, die Zwischenspeicherung und Die Geschwindigkeitsbegrenzung hinzuzufügen. Durch Tests wird jetzt sichergestellt, dass alle Probleme, die sie später feststellen, nicht mit der Authentifizierungskonfiguration zusammenhängen.

Navigieren Sie in APIM zu Ihrer GraphQL-API
Wechseln zur Registerkarte " Test "
Führen Sie eine Beispielabfrage oder Mutation aus, um zu bestätigen, dass die Verbindung funktioniert.

Konfigurieren des Zwischenspeicherns von Antworten

Die Zwischenspeicherung von Antworten reduziert die Latenz für API-Aufrufer erheblich und verringert die Back-End-Auslastung ihrer Fabric-Datenquellen. APIM unterstützt integrierte Zwischenspeicherung oder externe Redis-Instanzen. Bei GraphQL-APIs verwendet die Zwischenspeicherung den Anforderungstext (die GraphQL-Abfrage) als Cacheschlüssel, um sicherzustellen, dass identische Abfragen zwischengespeicherte Antworten zurückgeben.

Vorteile der Zwischenspeicherung von GraphQL-Antworten:

Reduzierte Latenz: Zwischengespeicherte Antworten werden sofort ohne Abfrage von Fabric zurückgegeben.
Geringerer Kapazitätsverbrauch: Weniger Anforderungen an Fabric reduzieren die CU-Auslastung (Capacity Unit)
Bessere Skalierbarkeit: Mehr gleichzeitige Benutzer behandeln, ohne die Back-End-Auslastung zu erhöhen

Hinzufügen einer Zwischenspeicherungsrichtlinie

Zum Implementieren der Zwischenspeicherung ändern Sie die vorhandene Authentifizierungsrichtlinie, um Cache-Nachschlage- und Speicherlogik hinzuzufügen. Die Richtlinie überprüft vor dem Weiterleiten von Anforderungen an Fabric auf zwischengespeicherte Antworten und speichert erfolgreiche Antworten für die zukünftige Verwendung. Dieses vollständige Richtlinienbeispiel zeigt, wie Authentifizierung und Zwischenspeicherung zusammenarbeiten:

<policies>
    <inbound>
        <base />
        <!-- Authenticate with managed identity -->
        <authentication-managed-identity 
            resource="https://analysis.windows.net/powerbi/api" 
            client-id="YOUR-MANAGED-IDENTITY-CLIENT-ID" 
            output-token-variable-name="token-variable" 
            ignore-error="false" />
        <set-header name="Authorization" exists-action="override">
            <value>@("Bearer " + (string)context.Variables["token-variable"])</value>
        </set-header>
        <!-- Check if response is cached -->
        <cache-lookup-value 
            key="@(context.Request.Body.As<String>(preserveContent: true))" 
            variable-name="cachedResponse" 
            default-value="not_exists" />
    </inbound>
    <backend>
        <!-- Only forward request if not cached -->
        <choose>
            <when condition="@(context.Variables.GetValueOrDefault<string>("cachedResponse") == "not_exists")">
                <forward-request />
            </when>
        </choose>
    </backend>
    <outbound>
        <base />
        <choose>
            <!-- Return cached response if it exists -->
            <when condition="@(context.Variables.GetValueOrDefault<string>("cachedResponse") != "not_exists")">
                <set-body>@(context.Variables.GetValueOrDefault<string>("cachedResponse"))</set-body>
            </when>
            <!-- Cache successful responses for 60 seconds -->
            <when condition="@((context.Response.StatusCode == 200) && (context.Variables.GetValueOrDefault<string>("cachedResponse") == "not_exists"))">
                <cache-store-value 
                    key="@(context.Request.Body.As<String>(preserveContent: true))" 
                    value="@(context.Response.Body.As<string>(preserveContent: true))" 
                    duration="60" />
            </when>
        </choose>
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

Funktionsweise dieser Richtlinie:

Eingehend: Authentifiziert sich mit verwalteter Identität und überprüft, ob die Antwort basierend auf der GraphQL-Abfrage zwischengespeichert wird.
Back-End: Überspringt die Weiterleitung der Anforderung an Fabric, wenn eine zwischengespeicherte Antwort vorhanden ist.
Ausgehend: Gibt zwischengespeicherte Antworten zurück oder speichert neue erfolgreiche Antworten 60 Sekunden lang zwischen.

Überprüfen, ob die Zwischenspeicherung funktioniert

So bestätigen Sie, dass Anforderungen zwischengespeichert werden:

Führen Sie in APIM zweimal dieselbe GraphQL-Abfrage aus.
Verfolgen des API-Aufrufs zum Anzeigen von Cachetreffern

Optimieren der Cachedauer

Im Beispiel wird eine Cachedauer von 60 Sekunden verwendet. Passen Sie die Dauer basierend auf den Anforderungen an die Datenfrische an:

Aktualisierungen mit hoher Häufigkeit: Verwenden Sie kürzere Dauern (10-30 Sekunden) für häufig ändernde Daten.
Statische daten oder Referenzdaten: Verwenden Sie längere Dauer (5-60 Minuten) für Daten, die sich selten ändern
Anforderungen in Echtzeit: Keine Abfragen zwischenspeichern, die immer die neuesten Daten zurückgeben müssen

Erweiterte Zwischenspeicherungsszenarien, einschließlich Cacheinvalzierung und externe Redis-Konfiguration, finden Sie unter APIM-Zwischenspeicherungsrichtlinien.

Ratenbegrenzung

Sie können die Anzahl der API-Aufrufe einschränken, die ein Client in einem bestimmten Zeitraum tätigen kann. Hier ist eine Beispielrate, die den Richtlinieneintrag begrenzt, den Sie unten <inbound><base/> hinzufügen können, der maximal zwei Aufrufe alle 60 Sekunden für einen bestimmten Benutzer erzwingt:

<rate-limit-by-key 
    calls="2" 
    renewal-period="60" 
    counter-key="@(context.Request.Headers.GetValueOrDefault("Authorization"))" 
    increment-condition="@(context.Response.StatusCode == 200)" 
    remaining-calls-variable-name="remainingCallsPerUser" />

Nach dem Senden von mehr als zwei API-Aufrufen in einer Minute erhalten Sie eine Fehlermeldung:

{
    "statusCode": 429,
    "message": "Rate limit is exceeded. Try again in 58 seconds."
}

Weitere Informationen zum Konfigurieren von Richtlinien zum Einschränken von Raten in APIM finden Sie in der Dokumentation.

Bewährte Methoden

Befolgen Sie bei der Integration von APIM mit der Fabric-API für GraphQL die folgenden Empfehlungen:

Sicherheit

Verwenden von verwalteten Identitäten: Bevorzugen verwalteter Identitäten über API-Schlüssel oder Verbindungszeichenfolgen für die Authentifizierung
Implementieren der geringsten Berechtigungen: Erteilen Sie nur die mindestberechtigungen, die für die verwaltete Identität erforderlich sind.
Nur HTTPS aktivieren: Konfigurieren von APIM zum Ablehnen von HTTP-Anforderungen und Erzwingen von HTTPS
Überprüfen von Eingaben: Verwenden von APIM-Richtlinien zum Überprüfen von GraphQL-Abfragen vor der Weiterleitung an Fabric

Leistung

Häufig verwendete Daten zwischenspeichern: Identifizieren allgemeiner Abfragen und Festlegen geeigneter Cachedauern
Überwachen von Cachetreffraten: Verwenden von APIM-Analysen zum Nachverfolgen der Cacheeffektivität
Optimieren von Geschwindigkeitsgrenzwerten: Ausgleich der Benutzerfreundlichkeit mit Kapazitätsschutz
Regionale Bereitstellung verwenden: Bereitstellen von APIM in derselben Region wie Ihre Fabric-Kapazität

Überwachung und Governance

Diagnose aktivieren: Konfigurieren der APIM-Diagnoseprotokollierung zum Nachverfolgen der API-Nutzung
Einrichten von Warnungen: Erstellen von Warnungen für Häufigkeitsbeschränkungsverletzungen und Fehler
Versionieren Sie Ihre APIs: Verwenden Sie die APIM-Versionsverwaltung zum Management von Breaking Changes.
Dokumentieren Sie Ihre APIs: Verwenden des ENTWICKLERportals von APIM zum Bereitstellen der API-Dokumentation

Kostenoptimierung

Passende Ratenbegrenzungen: Festlegen von Grenzwerten, die an der Kapazitätsebene ausgerichtet sind
Überwachen des Kapazitätsverbrauchs: Nachverfolgen der APIM- und Fabric-Kapazitätsauslastung
Strategisches Zwischenspeichern verwenden: Ausgleich der Aktualitätsanforderungen mit Kapazitätseinsparungen
Überprüfen von Verwendungsmustern: Regelmäßig analysieren, welche Abfragen die meisten Ressourcen verbrauchen

Zusammenfassung

Die Integration der Microsoft Fabric-API für GraphQL in Azure API Management vereint die leistungsstarken Datenfunktionen von Fabric mit apiMs API-Gatewayfeatures auf Unternehmensniveau. Diese Kombination bietet Folgendes:

Erweiterte Sicherheit: Verwaltete Identitätsauthentifizierung, Bedrohungsschutz und richtlinienbasierte Zugriffssteuerung
Verbesserte Skalierbarkeit: Reaktionszwischenspeicherung, Ratelimitierung und Lastverteilung über mehrere Back-Ends hinweg
Bessere Leistung: Reduzierte Latenz durch Zwischenspeichern und optimiertes Anforderungsrouting
Zentrale Governance: Einheitliche Überwachung, Versionsverwaltung und Verwaltung über mehrere APIs hinweg
Kostenkontrolle: Kostenbegrenzung und Zwischenspeicherung reduzieren den Fabric-Kapazitätsverbrauch

Indem Sie die Konfigurationsschritte und bewährten Methoden in diesem Artikel ausführen, können Sie eine robuste, sichere und skalierbare API-Ebene erstellen, die Produktionsworkloads in Ihrer Organisation unterstützt.

Feedback

War diese Seite hilfreich?

Last updated on 2026-01-21