Azure API Management (APIM) integreren met Fabric-API voor GraphQL

De integratie van Azure API Management (APIM) met de API van Microsoft Fabric voor GraphQL verbetert de mogelijkheden van uw API aanzienlijk door robuuste schaalbaarheids- en beveiligingsfuncties te bieden. APIM fungeert als een hoogwaardige gateway die geavanceerde mogelijkheden toevoegt, waaronder identiteitsbeheer, snelheidsbeperking, reactiecaching, bedreigingsbeveiliging en gecentraliseerde bewaking, allemaal zonder de configuratie van uw Fabric-API te wijzigen.

Door uw GraphQL-aanvragen te routeren via APIM, kunt u schalen om meer verkeer te verwerken, geavanceerde beveiligingsbeleidsregels te implementeren en inzicht te krijgen in API-gebruikspatronen in uw organisatie.

In dit artikel wordt u begeleid bij het integreren van APIM met Fabric-API voor GraphQL, het configureren van verificatie van beheerde identiteiten en het implementeren van beleid voor caching- en frequentiebeperking.

Wie gebruikt Azure API Management met GraphQL

APIM-integratie is waardevol voor:

Ondernemingsarchitecten die Fabric-gegevens beschikbaar maken via een gecentraliseerde, beheerde API-gateway voor toegang voor de hele organisatie
Fabric-beheerders implementeren snelheidsbeperking, caching en beveiligingsbeleid om infrastructuurcapaciteit en -gegevens te beveiligen
IT-beveiligingsteams die geavanceerde verificatie, autorisatie en bedreigingsbeveiliging vereisen voor toegang tot Fabric-gegevens
Platformteams beheren en besturen meerdere Fabric GraphQL-API's over afdelingen en bedrijfseenheden

Gebruik APIM-integratie wanneer u hoogwaardige API Management-functies nodig hebt, zoals snelheidsbeperking, caching, beveiligingsbeleid en gecentraliseerd beheer voor uw Fabric GraphQL-API's.

Vereiste voorwaarden

Voordat u begint, moet u ervoor zorgen dat u het volgende hebt:

Er is al een Fabric-API voor GraphQL gemaakt. Zie Een API voor GraphQL maken of gebruik Beginnen met een SQL-voorbeelddatabase in de API voor GraphQL-portal
Een Azure API Management-exemplaar. Zie Een API Management-exemplaar maken voor installatie-instructies
Machtigingen voor het maken van beheerde identiteiten en het configureren van APIM-beleid

Een Fabric GraphQL-API toevoegen aan Azure API Management

De eerste stap bij het integreren van APIM met Fabric is het importeren van uw GraphQL-API in Azure API Management. Met dit proces maakt u een proxy waarmee aanvragen via APIM worden gerouteerd terwijl de verbinding met uw Fabric-gegevensbronnen behouden blijft. Door de API te importeren, stelt u de basis voor het toevoegen van bedrijfsfuncties, zoals verificatiebeleid, caching en snelheidsbeperking.

Voor het importproces zijn twee stukjes informatie van uw Fabric GraphQL-API vereist: de eindpunt-URL (waarbij APIM aanvragen verzendt) en het schemabestand (waarmee de API-structuur en beschikbare bewerkingen worden gedefinieerd).

Uw GraphQL API-gegevens exporteren

Verzamel eerst de vereiste informatie uit uw Fabric GraphQL-API:

Open uw GraphQL-API in de Fabric-portal
Selecteer op het lint Het eindpunt kopiëren om de URL van uw API op te halen
Selecteer Schema exporteren om het GraphQL-schemabestand naar uw lokale apparaat te downloaden

De API importeren in APIM

Nu uw eindpunt-URL en schemabestand gereed zijn, kunt u de GraphQL-API registreren in APIM. Hiermee maakt u een API-definitie die door APIM wordt gebruikt om aanvragen te valideren, documentatie te genereren en beleid toe te passen. Het schema dat u uploadt definieert welke query's en mutatieclients kunnen uitvoeren.

Navigeer naar uw API Management-exemplaar in de Azure-portal
API's>selecteren+ API toevoegen
Selecteer het GraphQL-pictogram
Geef in het scherm Maken van GraphQL-schema het volgende op:
- Weergavenaam: een vriendelijke naam voor de API
- Naam: De API-id
- GraphQL API-eindpunt: de eindpunt-URL die u hebt gekopieerd uit Fabric
Selecteer Schema uploaden en kies het schemabestand dat u hebt gedownload

Verificatie van beheerde identiteit configureren

Nu uw GraphQL-API is geregistreerd in APIM, moet u configureren hoe APIM wordt geverifieerd met Fabric. Beheerde identiteiten bieden een veilige, wachtwoordvrije verificatiemethode waarmee u geen referenties meer hoeft op te slaan in uw APIM-configuratie. Azure beheert automatisch de identiteitslevenscyclus en verwerkt het verkrijgen van tokens, waardoor deze benadering zowel veiliger als eenvoudiger te onderhouden is dan traditionele verificatiemethoden.

De verificatie-instelling omvat drie hoofdstappen: het maken van de beheerde identiteit in Azure, het verlenen van machtigingen voor toegang tot uw Fabric-werkruimte en -gegevensbronnen en het configureren van APIM voor het gebruik van deze identiteit bij het indienen van aanvragen bij Fabric.

Een beheerde identiteit maken en toewijzen

Maak eerst de beheerde identiteit die APIM gebruikt om te verifiëren:

Maak een door de gebruiker toegewezen beheerde identiteit in Azure Portal.
Noteer de client-id van de beheerde identiteit. U hebt de client-id voor de beleidsconfiguratie nodig.

Machtigingen voor beheerde identiteiten verlenen in Fabric

Nadat u de beheerde identiteit hebt gemaakt, moet u deze machtigingen verlenen voor toegang tot uw Fabric-resources. De beheerde identiteit moet toegang hebben tot zowel het GraphQL-API-item zelf als alle gegevensbronnen die hiermee worden verbonden (zoals lakehouses of magazijnen). Het toevoegen van de identiteit als lid van een werkruimte is de eenvoudigste benadering, omdat het toegang verleent tot alle items in de werkruimte tegelijk.

Open de Fabric-werkruimte met uw GraphQL-API
Selecteer Toegang beheren
De beheerde identiteit (bijvoorbeeld apim-id) toevoegen met ten minste de rol Inzender

Aanbeveling

Voor gedetailleerdere controle kunt u machtigingen rechtstreeks verlenen aan afzonderlijke Fabric-items (de API en de bijbehorende gegevensbronnen) in plaats van toegang op werkruimteniveau. Gedetailleerde controle is vooral belangrijk als uw API gebruikmaakt van verificatie met eenmalige aanmelding (SSO). Zie de samenvatting van verificatie en machtigingen voor meer informatie.

APIM configureren voor het gebruik van de beheerde identiteit

Met machtigingen die zijn verleend in Fabric, moet u APIM vertellen welke beheerde identiteit moet worden gebruikt. Deze koppeling stelt APIM in staat om zich te authenticeren als die identiteit wanneer er verzoeken worden gedaan aan uw Fabric GraphQL-API.

Navigeer in Azure Portal naar uw APIM-exemplaar
Ga naar Beveiliging>Beheerde identiteiten
De door de gebruiker toegewezen beheerde identiteit toevoegen die u eerder hebt gemaakt

Verificatiebeleid toevoegen

De laatste verificatiestap is het toevoegen van een APIM-beleid dat een toegangstoken verkrijgt met behulp van de beheerde identiteit en deze in aanvragen voor Fabric opneemt. Dit beleid wordt uitgevoerd op elke aanvraag en verwerkt automatisch het verkrijgen en verlengen van tokens. Het beleid gebruikt het authentication-managed-identity element om een token op te halen voor de Fabric-API-resource en voegt het vervolgens toe aan de autorisatieheader.

Selecteer in uw GraphQL-API in APIM het tabblad API-beleid
Het beleid voor binnenkomende verwerking bewerken

Voeg de volgende XML toe onder <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>

Vervang YOUR-MANAGED-IDENTITY-CLIENT-ID door de client-id van uw beheerde identiteit
Het beleid opslaan

Test de verbinding

Voordat u doorgaat met het toevoegen van caching en frequentiebeperking, controleert u of de verificatie-instelling correct werkt. Testen zorgt er nu voor dat eventuele problemen die u later tegenkomt, niet zijn gerelateerd aan de verificatieconfiguratie.

Navigeer in APIM naar uw GraphQL-API
Naar het tabblad Testen gaan
Voer een voorbeeldquery of mutatie uit om te bevestigen dat de verbinding werkt

Antwoordcache configureren

Reactiecaching vermindert de latentie voor API-aanroepers aanzienlijk en vermindert de back-endbelasting op uw Fabric-gegevensbronnen. APIM biedt ondersteuning voor ingebouwde caching of externe Redis-exemplaren. Voor GraphQL-API's gebruikt caching de aanvraagbody (de GraphQL-query) als cachesleutel, zodat identieke query's antwoorden in de cache retourneren.

Voordelen van het opslaan van GraphQL-antwoorden in de cache:

Verminderde latentie: reacties in cache worden direct geretourneerd zonder een query uit te voeren op Fabric
Lager capaciteitsverbruik: Minder verzoeken aan Fabric verminderen het gebruik van CU (capaciteitseenheid)
Betere schaalbaarheid: meer gelijktijdige gebruikers verwerken zonder de back-endbelasting te vergroten

Cachebeleid toevoegen

Als u caching wilt implementeren, wijzigt u het bestaande verificatiebeleid om cachezoek- en opslaglogica toe te voegen. Het beleid controleert op antwoorden in de cache voordat aanvragen naar Fabric worden doorgestuurd en slaat succesvolle antwoorden op voor toekomstig gebruik. In dit volledige beleidsvoorbeeld ziet u hoe verificatie en caching samenwerken:

<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>

Hoe dit beleid werkt:

Inkomend: verifieert met beheerde identiteit en controleert of het antwoord in de cache wordt opgeslagen op basis van de GraphQL-query
Back-end: slaat het doorsturen van de aanvraag naar Fabric over als er een antwoord in de cache bestaat
Uitgaand: retourneert antwoorden in de cache of slaat nieuwe geslaagde antwoorden gedurende 60 seconden in de cache op

Controleren of caching werkt

Ga als volgt te werk om te bevestigen dat aanvragen in de cache worden opgeslagen:

Voer in APIM dezelfde GraphQL-query twee keer uit
De API-aanroep traceren om cachetreffers te bekijken

Cacheduur optimaliseren

In het voorbeeld wordt een cacheduur van 60 seconden gebruikt. Pas de duur aan op basis van de vereisten voor het vernieuwen van gegevens:

Updates met hoge frequentie: gebruik kortere duur (10-30 seconden) voor vaak veranderende gegevens
Statische of referentiegegevens: langere duur (5-60 minuten) gebruiken voor gegevens die onregelmatig worden gewijzigd
Real-time vereisten: cachevragen die altijd de meest recente gegevens moeten retourneren

Zie APIM-cachebeleidsregels voor geavanceerde cachingscenario's, waaronder ongeldige cache en externe Redis-configuratie.

Snelheidsbeperking

U kunt het aantal API-aanroepen beperken dat een client in een bepaalde periode kan uitvoeren. Hier volgt een voorbeeld van een beperkingsbeleidsvermelding die u hieronder <inbound><base/> kunt toevoegen om maximaal twee aanroepen elke 60 seconden af te dwingen voor een bepaalde gebruiker:

<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" />

Nadat u binnen een minuut meer dan twee API-aanroepen hebt verzonden, ontvangt u een foutbericht:

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

Zie de documentatie voor meer informatie over het configureren van beleidsregels voor frequentiebeperking in APIM.

Beste praktijken

Wanneer u APIM integreert met Fabric API voor GraphQL, volgt u deze aanbevelingen:

Security

Beheerde identiteiten gebruiken: Voorkeur geven aan beheerde identiteiten via API-sleutels of verbindingsreeksen voor verificatie
Minimale bevoegdheden implementeren: alleen de minimale machtigingen verlenen die nodig zijn voor de beheerde identiteit
Alleen HTTPS inschakelen: APIM configureren om HTTP-aanvragen af te wijzen en HTTPS af te dwingen
Invoer valideren: APIM-beleid gebruiken om GraphQL-query's te valideren voordat u doorstuurt naar Fabric

Performance

Veelgebruikte gegevens in de cache opslaan: algemene query's identificeren en de juiste cacheduur instellen
Cachetrefferpercentages bewaken: APIM-analyse gebruiken om de effectiviteit van de cache bij te houden
Frequentielimieten optimaliseren: de gebruikerservaring verdelen met capaciteitsbeveiliging
Regionale implementatie gebruiken: APIM implementeren in dezelfde regio als uw Fabric-capaciteit

Bewaking en beheer

Diagnostische gegevens inschakelen: diagnostische logboekregistratie voor APIM configureren om API-gebruik bij te houden
Waarschuwingen instellen: Waarschuwingen maken voor schendingen en fouten van frequentielimiet
Versie van uw API's: APIM-versiebeheer gebruiken om belangrijke wijzigingen te beheren
Uw API's documenteren: de ontwikkelaarsportal van APIM gebruiken om API-documentatie te bieden

Kostenoptimalisatie

Limieten voor de juiste grootte: limieten instellen die overeenkomen met uw capaciteitslaag
Capaciteitsverbruik bewaken: zowel APIM- als Fabric-capaciteitsgebruik bijhouden
Caching strategisch gebruiken: Versheidsvereisten verdelen met capaciteitsbesparing
Gebruikspatronen bekijken: Analyseer regelmatig welke query's de meeste resources verbruiken

Samenvatting

De integratie van Microsoft Fabric-API voor GraphQL met Azure API Management brengt de krachtige gegevensmogelijkheden van Fabric samen met de geavanceerde API-gatewayfuncties van APIM. Deze combinatie biedt:

Verbeterde beveiliging: verificatie van beheerde identiteiten, beveiliging tegen bedreigingen en op beleid gebaseerd toegangsbeheer
Verbeterde schaalbaarheid: reactiecaching, snelheidsbeperking en belastingsdistributie over meerdere back-ends
Betere prestaties: verminderde latentie via caching en geoptimaliseerde aanvraagroutering
Gecentraliseerd beheer: Geïntegreerde bewaking, versiebeheer en beheer voor meerdere API's
Kostenbeheer: snelheidsbeperking en caching verminderen het capaciteitsverbruik van fabric

Door de configuratiestappen en aanbevolen procedures in dit artikel te volgen, kunt u een robuuste, veilige en schaalbare API-laag bouwen die ondersteuning biedt voor productieworkloads in uw organisatie.

Feedback

Is deze pagina nuttig?

Last updated on 2026-01-21