Intégrer Gestion des API Azure (APIM) à l’API Fabric pour GraphQL

L’intégration de Gestion des API Azure (APIM) à l’API de Microsoft Fabric pour GraphQL améliore considérablement les fonctionnalités de votre API en fournissant une scalabilité et des fonctionnalités de sécurité robustes. APIM agit comme une passerelle de niveau entreprise qui ajoute des fonctionnalités avancées, notamment la gestion des identités, la limitation de débit, la mise en cache des réponses, la protection contre les menaces et la surveillance centralisée, sans modifier votre configuration d’API Fabric.

En acheminant vos requêtes GraphQL via APIM, vous pouvez effectuer une mise à l’échelle pour gérer un trafic accru, implémenter des stratégies de sécurité sophistiquées et obtenir une visibilité sur les modèles d’utilisation des API au sein de votre organisation.

Cet article vous guide tout au long de l’intégration d’APIM à l’API Fabric pour GraphQL, la configuration de l’authentification d’identité managée et l’implémentation de stratégies de limitation de débit et de mise en cache.

Qui utilise Gestion des API Azure avec GraphQL

L’intégration d’APIM est précieuse pour :

Architectes d’entreprise exposant des données Fabric via une passerelle d’API centralisée et régie pour un accès à l’échelle de l’organisation
Administrateurs de Fabric implémentant des stratégies de limitation de débit, de mise en cache et de sécurité pour protéger la capacité et les données Fabric.
Les équipes de sécurité informatique nécessitant une authentification avancée, une autorisation et une protection contre les menaces pour l’accès aux données Fabric
Équipes de plateforme gérant et régissant plusieurs API Fabric GraphQL entre les services et les unités commerciales

Utilisez l’intégration d’APIM lorsque vous avez besoin de fonctionnalités de gestion des API de niveau entreprise, telles que la limitation de débit, la mise en cache, les stratégies de sécurité et la gouvernance centralisée pour vos API Fabric GraphQL.

Prerequisites

Avant de commencer, vérifiez que vous disposez des points suivants :

API Fabric pour GraphQL déjà créée. Si ce n’est pas le cas, consultez Créer une API pour GraphQL ou commencez par l’exemple de base de données SQL dans le portail API pour GraphQL.
Une instance du service Gestion des API Azure. Pour obtenir des instructions d’installation, consultez Créer une instance Gestion des API
Autorisations pour créer des identités managées et configurer des stratégies APIM

Ajouter une API Fabric GraphQL à Gestion des API Azure

La première étape de l’intégration d’APIM à Fabric consiste à importer votre API GraphQL dans Gestion des API Azure. Ce processus crée un proxy qui route les requêtes via APIM tout en conservant la connexion à vos sources de données Fabric. En important l’API, vous établissez la base de l’ajout de fonctionnalités d’entreprise telles que les stratégies d’authentification, la mise en cache et la limitation du débit.

Le processus d’importation nécessite deux informations de votre API Fabric GraphQL : l’URL du point de terminaison (où APIM envoie des requêtes) et le fichier de schéma (qui définit la structure de l’API et les opérations disponibles).

Exporter les détails de votre API GraphQL

Tout d’abord, collectez les informations requises à partir de votre API Fabric GraphQL :

Ouvrir votre API GraphQL dans le portail Fabric
Dans le ruban, sélectionnez Copier le point de terminaison pour obtenir l’URL de votre API
Sélectionnez Exporter le schéma pour télécharger le fichier de schéma GraphQL sur votre appareil local

Importer l’API dans APIM

Avec l’URL de votre point de terminaison et le fichier de schéma prêts, vous pouvez maintenant inscrire l’API GraphQL dans APIM. Cela crée une définition d’API utilisée par APIM pour valider les demandes, générer de la documentation et appliquer des stratégies. Le schéma que vous chargez définit les requêtes et mutations que les clients peuvent exécuter.

Accédez à votre instance Gestion des API dans le portail Azure
Sélectionner des API> une API
Sélectionner l’icône GraphQL
Dans l’écran Créer à partir du schéma GraphQL , indiquez :
- Nom d'affichage : nom convivial de l’API
- Nom : identificateur de l’API
- Point de terminaison de l’API GraphQL : URL de point de terminaison que vous avez copiée à partir de Fabric
Sélectionnez Charger le schéma et choisissez le fichier de schéma que vous avez téléchargé.

Configurer l’authentification d’identité managée

Maintenant que votre API GraphQL est inscrite dans APIM, vous devez configurer la façon dont APIM s’authentifie auprès de Fabric. Les identités managées fournissent une méthode d’authentification sécurisée sans mot de passe qui élimine la nécessité de stocker les informations d’identification dans votre configuration APIM. Azure gère automatiquement le cycle de vie des identités et gère l’acquisition de jetons, ce qui rend cette approche plus sécurisée et plus facile à gérer que les méthodes d’authentification traditionnelles.

La configuration de l’authentification implique trois étapes principales : la création de l’identité managée dans Azure, son octroi d’autorisations pour accéder à votre espace de travail Fabric et à vos sources de données, et la configuration d’APIM pour utiliser cette identité lors de l’exécution de demandes à Fabric.

Créer et affecter une identité managée

Tout d’abord, créez l’identité managée utilisée par APIM pour authentifier :

Créez une identité managée affectée par l’utilisateur dans le portail Azure.
Notez l’ID client de l’identité managée : vous avez besoin de l’ID client pour la configuration de la stratégie.

Accorder les autorisations d’identité managée dans Fabric

Après avoir créé l’identité managée, vous devez lui accorder les autorisations nécessaires pour accéder à vos ressources Fabric. L'identité gérée a besoin d'accéder à l'élément API GraphQL lui-même ainsi qu'à toutes les sources de données auxquelles elle se connecte (comme les entrepôts de données ou les entrepôts). L’ajout de l’identité en tant que membre d’espace de travail est l’approche la plus simple, car elle accorde l’accès à tous les éléments de l’espace de travail en même temps.

Ouvrir l’espace de travail Fabric contenant votre API GraphQL
Sélectionner Gérer l’accès
Ajouter l’identité managée (par exemple, apim-id) avec au moins un rôle Contributeur

Conseil / Astuce

Pour un contrôle plus précis, vous pouvez accorder des autorisations directement à des éléments Fabric individuels (l’API et ses sources de données) au lieu d’un accès au niveau de l’espace de travail. Le contrôle granulaire est particulièrement important si votre API utilise l’authentification unique (SSO). Pour plus d’informations, consultez le résumé de l’authentification et des autorisations.

Configurer APIM pour utiliser l’identité managée

Avec les autorisations accordées dans Fabric, vous devez indiquer à APIM quelle identité managée utiliser. Cette association permet à APIM de s’authentifier en tant qu’identité lors de demandes adressées à votre API Fabric GraphQL.

Dans le portail Azure, accédez à votre instance APIM
Accéder à Sécurité>Identités gérées
Ajouter l’identité managée assignée à l'utilisateur que vous avez précédemment créée

Ajouter une stratégie d’authentification

L’étape d’authentification finale consiste à ajouter une stratégie APIM qui obtient un jeton d’accès à l’aide de l’identité managée et l’inclut dans les demandes adressées à Fabric. Cette stratégie s’exécute sur chaque requête, gérant automatiquement l’acquisition et le renouvellement des jetons. La stratégie utilise l'élément authentication-managed-identity pour obtenir un jeton pour la ressource d’API Fabric, puis l’ajoute à l’en-tête d'autorisation.

Dans votre API GraphQL dans APIM, sélectionnez l’onglet Stratégies d’API
Modifier la stratégie de traitement entrant

Ajoutez le code XML suivant sous <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>

Remplacer YOUR-MANAGED-IDENTITY-CLIENT-ID par l’ID client de votre identité managée
Enregistrer la stratégie

Tester la connexion

Avant de continuer à ajouter la mise en cache et la limitation du débit, vérifiez que la configuration de l’authentification fonctionne correctement. Le test garantit maintenant que les problèmes rencontrés ultérieurement ne sont pas liés à la configuration de l’authentification.

Dans APIM, accédez à votre API GraphQL
Accédez à l’onglet Test
Exécuter un exemple de requête ou de mutation pour confirmer que la connexion fonctionne

Configurer la mise en cache des réponses

La mise en cache des réponses réduit considérablement la latence pour les appelants d’API et réduit la charge back-end sur vos sources de données Fabric. APIM prend en charge la mise en cache intégrée ou les instances Redis externes. Pour les API GraphQL, la mise en cache utilise le corps de la requête (requête GraphQL) comme clé de cache, ce qui garantit que les requêtes identiques retournent des réponses mises en cache.

Avantages de la mise en cache des réponses GraphQL :

Latence réduite : les réponses mises en cache retournent instantanément sans interroger Fabric
Réduction de la consommation de capacité : moins de demandes adressées à Fabric réduisent l’utilisation de CU (unité de capacité)
Meilleure scalabilité : gérer plus d’utilisateurs simultanés sans augmenter la charge back-end

Ajouter une stratégie de mise en cache

Pour implémenter la mise en cache, vous modifiez la stratégie d’authentification existante pour ajouter la logique de recherche et de stockage du cache. La stratégie vérifie les réponses mises en cache avant de transférer des demandes vers Fabric et stocke les réponses réussies pour une utilisation ultérieure. Cet exemple de stratégie complet montre comment l’authentification et la mise en cache fonctionnent ensemble :

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

Fonctionnement de cette stratégie :

Entrant : s’authentifie avec l’identité managée et vérifie si la réponse est mise en cache en fonction de la requête GraphQL
Back-end : ignore le transfert de la requête vers Fabric si une réponse mise en cache existe
Sortant : retourne des réponses mises en cache ou met en cache de nouvelles réponses réussies pendant 60 secondes

Vérifier que la mise en cache fonctionne

Pour confirmer que les demandes sont mises en cache :

Dans APIM, exécutez deux fois la même requête GraphQL
Suivre l’appel d’API pour afficher les accès au cache

Optimiser la durée du cache

L’exemple utilise une durée de cache de 60 secondes. Ajustez la durée en fonction des exigences de fraîcheur des données :

Mises à jour à haute fréquence : utilisez des durées plus courtes (10 à 30 secondes) pour les données fréquemment modifiées
Données statiques ou de référence : utilisez des durées plus longues (5 à 60 minutes) pour les données qui changent rarement
Exigences en temps réel : ne ayez pas besoin de mettre en cache les requêtes qui doivent toujours retourner les données les plus récentes

Pour les scénarios de mise en cache avancés, notamment l’invalidation du cache et la configuration de Redis externe, consultez les stratégies de mise en cache APIM.

Limitation du débit

Vous pouvez limiter le nombre d’appels d’API qu’un client peut effectuer dans une période spécifique. Voici un exemple d’entrée de stratégie de limitation de débit que vous pouvez ajouter ci-dessous <inbound><base/> qui applique pas plus de deux appels toutes les 60 secondes pour un utilisateur donné :

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

Après avoir envoyé plus de deux appels d’API en une minute, vous recevrez un message d’erreur :

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

Pour plus d’informations sur la configuration des stratégies de limitation de débit dans APIM, consultez la documentation.

Meilleures pratiques

Lors de l’intégration d’APIM à l’API Fabric pour GraphQL, suivez les recommandations suivantes :

Security

Utiliser des identités managées : préférer les identités managées par rapport aux clés API ou aux chaînes de connexion pour l’authentification
Implémenter le privilège minimum : accordez uniquement les autorisations minimales nécessaires pour l’identité managée
Activer HTTPS uniquement : Configurer APIM pour rejeter les requêtes HTTP et appliquer HTTPS
Valider les entrées : Utiliser des stratégies APIM pour valider les requêtes GraphQL avant de les transférer vers Fabric

Performance

Mettre en cache les données fréquemment sollicitées : identifier les requêtes courantes et définir les durées de cache appropriées
Surveiller les taux d’accès au cache : utiliser l’analytique APIM pour suivre l’efficacité du cache
Optimiser les limites de débit : équilibrer l’expérience utilisateur avec la protection de la capacité
Utiliser le déploiement régional : déployer APIM dans la même région que votre capacité Fabric

Surveillance et gouvernance

Activer les diagnostics : configurer la journalisation des diagnostics APIM pour suivre l’utilisation de l’API
Configurer des alertes : Créer des alertes pour les violations de limite de débit et les erreurs
Version de vos API : utiliser le contrôle de version APIM pour gérer les modifications cassantes
Documenter vos API : utiliser le portail des développeurs d’APIM pour fournir une documentation sur l’API

Optimisation des coûts

Limites de débit optimisées : Fixer des limites qui s’alignent sur votre niveau de capacité
Surveiller la consommation de capacité : suivre l’utilisation des capacités APIM et Fabric
Utiliser la mise en cache de manière stratégique : équilibrer les exigences de fraîcheur avec les économies de capacité
Passer en revue les modèles d’utilisation : analysez régulièrement les requêtes qui consomment la plupart des ressources

Résumé

L’intégration de l’API Microsoft Fabric pour GraphQL à Gestion des API Azure réunit les puissantes fonctionnalités de données de Fabric avec les fonctionnalités de passerelle API de niveau entreprise d’APIM. Cette combinaison fournit les éléments suivants :

Sécurité renforcée : authentification d’identité managée, protection contre les menaces et contrôle d’accès en fonction de la stratégie
Scalabilité améliorée : mise en cache des réponses, limitation de débit et distribution de charge sur plusieurs back-ends
Meilleures performances : réduction de la latence grâce à la mise en cache et au routage des requêtes optimisés
Gouvernance centralisée : supervision unifiée, contrôle de version et gestion sur plusieurs API
Contrôle des coûts : limitation du flux et mise en cache réduisent l'utilisation de la capacité du Fabric

En suivant les étapes de configuration et les bonnes pratiques de cet article, vous pouvez créer une couche d’API robuste, sécurisée et évolutive qui prend en charge les charges de travail de production au sein de votre organisation.

Commentaires

Est-ce que cette page vous a été utile?

Last updated on 2026-01-21