Cloud et automatisation

Construire un moteur de rapports multi-tenant sur Azure et Microsoft Fabric

Concevez un moteur de rapports multi-tenant sur Azure et Microsoft Fabric avec métadonnées, requêtes personnalisées contrôlées, cache, pagination, exports asynchrones et protection de capacité.

Par JaviPublié 14 min de lectureAvancé

Dans cet article

Les plateformes de reporting deviennent difficiles à faire évoluer lorsque chaque demande de rapport est traitée comme une requête directe.

Une interface interactive peut avoir besoin de JSON frais pour une grille ou un graphique. Des consommateurs d’API externes peuvent demander le même rapport de manière répétée. Certains utilisateurs ont besoin d’exports CSV ou XLSX. D’autres ont besoin de Parquet pour des traitements en aval. Une plateforme multi-tenant doit aussi garantir qu’un client ne puisse jamais interroger les données d’un autre, même lorsque le reporting personnalisé est introduit.

En parallèle, les tables de faits analytiques peuvent résider dans Microsoft Fabric, où la capacité de calcul est partagée et où des requêtes coûteuses peuvent affecter les autres charges.

Comment construire un moteur de rapports qui fournit des données fraîches lorsque nécessaire, réutilise les résultats déjà générés lorsque c’est possible, protège la capacité Fabric et prend en charge à la fois les rapports prédéfinis et les rapports définis par les clients ?

Une bonne réponse consiste à faire du Report Engine la frontière de politique et d’exécution entre les consommateurs et la plateforme analytique.

  1. UI Angular
  2. Azure API Management
  3. Report Engine
  4. Microsoft Fabric
Le Report Engine comme frontière de reporting

Les clients API externes passent par la même passerelle et le même moteur. Le consommateur ne devrait pas avoir à connaître l’emplacement physique des données, le mécanisme d’exécution utilisé, ni savoir si le résultat provient d’un artefact réutilisable.

Si le concept est nouveau pour vous, commencez par Qu’est-ce qu’un moteur de rapports ?. Cet article va plus loin : il décrit l’architecture multi-tenant sur Azure et Microsoft Fabric, du modèle de métadonnées à la protection de capacité et aux exports asynchrones.

1. Le principe de conception central

Le Report Engine fournit une abstraction au-dessus du comportement de reporting.

Il reçoit une demande de rapport et décide :

  • qui est l’appelant ;
  • quels tenants et comptes il peut consulter ;
  • quelle définition de rapport s’applique ;
  • si les paramètres sont valides ;
  • si la demande peut être satisfaite à partir d’un artefact existant ;
  • si la requête peut être exécutée de manière interactive sans risque ;
  • si une procédure stockée ou une requête pilotée par métadonnées doit être utilisée ;
  • si le traitement doit être synchrone ou asynchrone ;
  • quel format de sortie doit être retourné.

Cela permet de garder les clients simples.

L’application Angular doit demander un rapport, pas une table Fabric.

Une intégration externe doit demander un rapport, pas soumettre du SQL.

Un générateur de rapports personnalisés doit sélectionner des champs métier approuvés, pas des noms de colonnes physiques.

Cette séparation donne aussi au backend la liberté d’évoluer. La source peut être un Fabric Warehouse aujourd’hui et une autre couche de serving demain sans modifier le contrat public de reporting.

2. Responsabilités du Report Engine

Un Report Engine de production est bien plus qu’un endpoint de requête.

  1. Demande
  2. Définition du rapportRésoudre les métadonnées standard ou personnalisées
  3. Sécurité + validationTenant, compte, paramètres, champs autorisés
  4. Planificateur d’exécutionCache, requête interactive ou export asynchrone
  5. Traitement du résultatTrier, paginer, agréger, formater
  6. Livraison
    • JSON
    • CSV
    • XLSX
    • Parquet
Cycle de vie d’une demande de rapport

Ses responsabilités typiques couvrent le contexte d’authentification, l’autorisation tenant/compte, la résolution de la définition du rapport, la validation des paramètres, l’évaluation des requêtes, la planification, le cache, la génération de SQL dynamique, l’exécution de procédures stockées, le tri, la pagination, le formatage, le suivi d’exécution, la génération d’artefacts, la télémétrie et l’audit. Architecture d’un moteur de rapports : de la demande au résultat suit une demande à travers ces étapes, dans l’ordre.

3. Les rapports standard et personnalisés doivent utiliser le même moteur

Une erreur fréquente consiste à créer un sous-système pour les rapports standard et un autre pour les rapports personnalisés. Cela duplique la sécurité, la pagination, le cache, la génération de fichiers, le monitoring, l’accès à Fabric et la gestion des erreurs.

Une meilleure approche consiste à considérer standard et personnalisé comme deux styles de définition.

  1. Demande de rapport
  2. Définition du rapport
    • prédéfini
      StandardProcédure stockée ou requête prédéfinie
    • métadonnées
      PersonnaliséModèle de requête dynamique validé
  3. Report Engine partagé
Définitions de rapports standard et personnalisés

Un rapport standard peut se résoudre en :

Type: STANDARD
ExecutorType: STORED_PROCEDURE
ExecutorName: rpt.SalesByAccount

Un rapport personnalisé peut se résoudre en :

Type: CUSTOM
ExecutorType: DYNAMIC_QUERY
DatasetId: SalesReporting

Les deux partagent malgré tout les mêmes règles d’autorisation, le même planificateur, le même cache, le même état d’exécution, la même pagination, le même tri, les mêmes artefacts et la même télémétrie.

Standard ou personnalisé doit décrire la manière dont un rapport est défini, pas créer deux plateformes de reporting séparées.

4. Reporting piloté par métadonnées

Le reporting personnalisé devient plus sûr lorsque les utilisateurs construisent les rapports à partir de métadonnées approuvées plutôt qu’à partir d’objets physiques de base de données.

ReportDefinition

ReportId
Name
Type: STANDARD | CUSTOM
ExecutorType: STORED_PROCEDURE | DYNAMIC_QUERY
ExecutorName
DatasetId
CacheTTL
Enabled
Version

DatasetDefinition

DatasetId
Name
Source
AllowedFields
Relationships

FieldDefinition

FieldId
DisplayName
SourceExpression
DataType
Aggregation
Filterable
Sortable
Groupable

Le modèle métier expose par exemple :

Ventes
Compte
Canal
Date
Revenus
Nombre de commandes

et non :

fact_sales.sales_amount
dim_account.account_name
dim_channel.channel_name

Le moteur garde ainsi le contrôle sur les champs visibles, les relations valides, les groupements, les agrégations, les filtres et les expressions exécutables, tout en masquant les évolutions du schéma physique derrière un contrat métier stable.

5. Microsoft Fabric comme couche analytique

Le Report Engine doit interroger un contrat de reporting curé, pas les tables d’ingestion brutes.

  1. BronzeIngestion brute ou très légèrement transformée
  2. SilverDonnées nettoyées, validées et conformées
  3. GoldCouche de reporting curée
    • fact_sales
    • fact_orders
    • fact_payments
    • dim_account
    • dim_channel
    • dim_date
Couches de données de reporting dans Microsoft Fabric

La manière dont les données arrivent en Bronze est une décision d’intégration à part entière, traitée dans Patterns d’intégration de données ; les couches elles-mêmes sont expliquées dans Architecture Medallion expliquée.

La surface de serving peut être un Fabric Warehouse, un Lakehouse exposé via son SQL analytics endpoint ou une autre surface de serving prise en charge. Microsoft Fabric Lakehouse ou Warehouse : lequel choisir ? compare les deux principales options.

Le SQL analytics endpoint fournit une surface T-SQL en lecture seule au-dessus des données OneLake et convient bien aux scénarios de reporting où les requêtes analytiques doivent être séparées des charges opérationnelles.

La règle d’architecture essentielle est que le Report Engine dépende d’une couche de reporting stable.

Cela fournit un contrat stable, un meilleur tuning, une génération de requêtes plus simple, une isolation vis-à-vis de l’ingestion, une revue de sécurité plus claire et des responsabilités mieux définies. Pour voir comment workspaces, capacités et couches s’articulent autour de ce contrat, consultez Concevoir une architecture Microsoft Fabric évolutive.

6. Query Evaluator vs Dynamic Query Executor

Le reporting personnalisé nécessite deux composants distincts.

Query Evaluator

L’évaluateur répond à :

Cette demande peut-elle s’exécuter ?

Il valide le dataset, les champs demandés, les filtres, les agrégations, le périmètre tenant/compte, la période, les dimensions, le tri, la complexité et le chemin d’exécution attendu.

Sa sortie est un modèle interne validé, jamais du SQL fourni par le client.

{
  "dataset": "SalesReporting",
  "dimensions": ["date", "account"],
  "metrics": ["sales_amount"],
  "filters": [
    {"field": "channel", "operator": "eq", "value": "Online"}
  ],
  "dateRange": {
    "start": "2026-10-01",
    "end": "2026-10-31"
  }
}

Dynamic Query Executor

L’exécuteur répond à :

Comment exécuter un plan déjà approuvé ?

  1. Demande personnalisée
  2. Query EvaluatorValider champs, filtres, portée et complexité
  3. Modèle validéReprésentation interne, jamais du SQL brut
  4. Générateur SQLSQL paramétré à partir des métadonnées approuvées
  5. Dynamic Query Executor
  6. Fabric
Exécution contrôlée des requêtes personnalisées

Les clients ne soumettent jamais de SQL arbitraire.

7. Coût des requêtes et protection de la capacité Fabric

Le reporting personnalisé introduit un risque opérationnel : les utilisateurs peuvent demander des requêtes extrêmement coûteuses.

Le moteur doit estimer le coût avant exécution à partir de signaux comme la plage de dates, le nombre de dimensions, les métriques, la sélectivité des filtres, le nombre de lignes attendu, la complexité d’agrégation et la disponibilité d’un artefact en cache.

Classe de coût Comportement
LOW Exécution interactive
MEDIUM Interactive avec limites renforcées ou préférence cache
HIGH Export asynchrone
TOO EXPENSIVE Rejet ou demande de filtres plus étroits
  1. Demande validée
  2. Évaluation du coût
    • interactif
      LOWExécuter maintenant
    • limité
      MEDIUMAppliquer des limites et préférer le cache
    • async
      HIGHMettre l’export en file
    • rejeter
      TOO EXPENSIVEExiger une demande plus étroite
  3. Exécution contrôlée
Planification consciente de la capacité

Azure API Management peut également appliquer des politiques de rate limit, quota et concurrence avant que la requête n’atteigne le moteur. APIM protège le service contre les pointes de trafic ; le moteur protège Fabric contre les travaux analytiques trop coûteux. Mesurer le volume de requêtes API et de rapports présente les signaux qui indiquent quand ajuster ces limites.

8. Sécurité multi-tenant

Le périmètre multi-tenant doit être imposé par le moteur, jamais délégué aux paramètres envoyés par le client.

  1. Tenant
  2. Compte
  3. Rapport
Portée du reporting multi-tenant

Le tenant autorisé et la liste des comptes doivent provenir du contexte d’authentification ou d’une source d’autorisation de confiance.

Ne faites pas confiance à ceci simplement parce que le client l’envoie :

?tenantId=123
&accountId=456

Résolvez plutôt un périmètre autoritatif :

tenant_id = 123
authorized_accounts = [456, 457, 480]

et injectez-le dans chaque plan d’exécution.

WHERE tenant_id = @tenantId
  AND account_id IN (
      SELECT value
      FROM STRING_SPLIT(@authorizedAccountIds, ',')
  )

Fabric Warehouse et le SQL analytics endpoint ne prennent pas en charge les types de table définis par l’utilisateur : un paramètre table (table-valued parameter) n’y est donc pas disponible. Transmettez la liste résolue par le moteur sous forme de paramètre délimité, comme ci-dessus, ou faites une jointure avec une table de correspondance des accès fiable, maintenue par la plateforme.

Les métadonnées de rapport définies par l’utilisateur ne doivent jamais pouvoir supprimer ni remplacer les prédicats de sécurité obligatoires.

La sécurité native de Fabric (RLS ou OneLake security) peut constituer une couche supplémentaire, mais le Report Engine conserve la responsabilité de l’autorisation applicative, car c’est lui qui porte le contrat de reporting.

9. Cache et artefacts de rapport

Les requêtes répétées sont de bonnes candidates au cache lorsque la clé représente réellement le dataset sous-jacent. Savoir si un rapport donné doit être servi à partir d’un résultat stocké est une autre question, traitée dans Rapports précalculés ou requêtes en direct : comment choisir.

Exemple :

groupBy=Date
groupBy=Channel
groupBy=Account
startDate=2026-10-01
endDate=2026-10-31

Normalisez vers :

tenant
périmètre du compte
report definition + version
dimensions
metrics
filters
date range

Puis hachez cette représentation.

Pour un dataset réutilisable, n’incluez pas les valeurs uniquement liées à la présentation :

page
pageSize
sort

sauf si elles modifient réellement l’artefact généré.

Parquet est un bon format canonique pour des résultats analytiques réutilisables : il est orienté colonnes, typé et efficace pour les relectures analytiques.

Un artefact Parquet réutilisable peut ensuite alimenter du JSON paginé, du CSV, du XLSX ou des traitements analytiques en aval.

OneLake est un bon candidat pour les artefacts analytiques proches de Fabric. Les applications externes peuvent aussi accéder à OneLake via des API compatibles ADLS lorsque les paramètres du tenant le permettent, et OneLake prend en charge des SAS user-delegated de courte durée lorsque cette fonction est activée.

Mais le stockage d’un artefact et sa livraison sont deux décisions différentes.

Si le besoin principal est de proposer un téléchargement externe via URL signée, Azure Blob Storage ou ADLS Gen2 peut être plus simple à exploiter pour la couche de livraison. OneLake peut donc conserver l’artefact analytique canonique tandis qu’Azure Storage sert les exports distribués à l’extérieur.

10. Interface interactive vs chemin d’export

Le reporting interactif et l’export de fichiers ne doivent pas être forcés dans le même modèle de réponse. Concevoir un moteur de rapports pour les consommateurs d’interface et d’API détaille le côté consommateur de cette séparation.

UI Angular interactive

  1. Angular
  2. Report Engine
  3. Couche de reporting Fabric
  4. Pagination + tri serveur
  5. JSON
Chemin du reporting interactif

JSON est adapté aux grilles, graphiques, totaux, pagination et filtres interactifs.

L’UI ne devrait pas télécharger un énorme CSV pour le paginer dans le navigateur.

Export et intégrations

  1. Demande d’export
  2. Report Engine
  3. Recherche d’artefact
    • hit
      Artefact en cacheRéutiliser le résultat
    • miss
      Requête FabricGénérer et persister l’artefact
  4. Fichier demandé
    • CSV
    • XLSX
    • Parquet
Chemin d’export

Cela évite que les fichiers d’export statiques deviennent la base interactive.

11. Pagination et tri

Les rapports interactifs ont besoin d’une pagination côté serveur.

Une implémentation simple peut commencer ainsi :

ORDER BY sales_amount DESC, account_id ASC
OFFSET @Offset ROWS
FETCH NEXT @PageSize ROWS ONLY;

Le second critère est essentiel : la pagination nécessite un ordre déterministe.

Pour des résultats très volumineux, une pagination cursor/keyset peut éviter le coût croissant des offsets profonds.

WHERE (
    sales_amount < @LastSales
    OR (
        sales_amount = @LastSales
        AND account_id > @LastAccountId
    )
)
ORDER BY sales_amount DESC, account_id ASC;

Ces mécanismes doivent être gérés par le moteur pour éviter que l’UI ne connaisse les détails spécifiques de la base.

12. Mapping des services Azure

Responsabilité Service
UI Angular
API gateway Azure API Management
Report Engine Azure App Service
Métadonnées et état d’exécution Azure SQL ou Azure Table Storage
Données analytiques Microsoft Fabric
Artefacts analytiques canoniques OneLake
Livraison externe OneLake ou Azure Blob / ADLS Gen2 selon le modèle d’accès
File asynchrone Azure Service Bus
Worker App Service ou Azure Container Apps
Identité Microsoft Entra ID + managed identities
Monitoring Application Insights / Azure Monitor

Azure Table Storage vs Azure SQL

Azure Table Storage peut convenir à un état simple, massif et adressé par clé :

ExecutionId
TenantId
Status
CreatedAt
CompletedAt
ArtifactLocation

Son design repose fortement sur PartitionKey et RowKey.

Azure SQL devient plus intéressant lorsque les métadonnées comportent des relations, des transactions multi-entités, des requêtes administratives riches, davantage de besoins d’indexation ou du versioning relationnel.

Un système pragmatique peut utiliser Azure SQL pour les métadonnées de rapport et Table Storage uniquement pour l’état d’exécution simple, ou Azure SQL pour les deux afin de réduire la complexité de l’architecture.

Managed identities

App Service et Azure Functions prennent en charge les managed identities pour accéder aux ressources Azure protégées par Entra sans stocker de secrets applicatifs. Le même principe peut être utilisé avec Service Bus et d’autres services Azure compatibles.

13. Génération asynchrone des rapports

Les exports volumineux ne devraient pas maintenir une requête HTTP ouverte indéfiniment.

  1. Demande d’export
  2. Report Engine
  3. Enregistrement d’exécutionCréer le job et retourner un ID
  4. Azure Service Bus
  5. WorkerExécuter, formater, persister
  6. Artefact
Exécution asynchrone d’un export

La réponse initiale peut être :

{
  "executionId": "rpt_7f13...",
  "status": "queued"
}

Le client peut ensuite interroger un endpoint de statut, recevoir un callback si disponible ou être notifié lorsque l’export est prêt.

Les files Service Bus sont utiles parce qu’elles absorbent les pics de travail et découplent le chemin API de l’exécution en arrière-plan.

14. Exemple de requête de bout en bout

GET /api/reports/sales
    ?groupBy=Date
    &groupBy=Channel
    &groupBy=Account
    &startDate=2026-10-01
    &endDate=2026-10-31

Séquence possible :

  1. API Management applique les politiques de passerelle.
  2. Le Report Engine résout le tenant et les comptes autorisés.
  3. Le moteur charge ReportDefinition.
  4. Les paramètres sont analysés et normalisés.
  5. L’évaluateur valide les champs, dimensions, dates et droits.
  6. Une clé de cache déterministe est générée.
  7. Le moteur vérifie si un artefact réutilisable existe.
  8. Le planificateur estime le coût.
  9. Il choisit cache, exécution synchrone Fabric, export asynchrone ou rejet.
  10. Si Fabric est requis, le moteur exécute une procédure stockée ou du SQL généré approuvé.
  11. Les résultats sont traités et suivis.
  12. Les artefacts réutilisables sont persistés.
  13. L’UI reçoit du JSON ou le consommateur d’export reçoit le fichier ou sa référence.
  1. APIM
  2. Résoudre la portéeTenant + comptes
  3. Charger la définition
  4. Valider + normaliser
  5. Cache + plan de coût
  6. Exécuter si nécessaire
  7. Traiter + persister
  8. Livrer
De la requête au résultat

15. Évolution vers un reporting personnalisé contrôlé

Phase 1 — Reporting standard

  • Rapports standard
  • API + Angular
  • Couche de reporting Fabric
  • JSON / CSV
  • Cache de base

Phase 2 — Exports asynchrones

  • Exports asynchrones
  • Réutilisation des artefacts
  • Service Bus
  • Worker d’exécution

Phase 3 — Reporting personnalisé piloté par métadonnées

  • Catalogue de datasets
  • Métadonnées des champs
  • Query Evaluator
  • Générateur SQL
  • Dynamic Query Executor

Phase 4 — Capacités de plateforme

Possibilités : rapports planifiés, rapports sauvegardés, templates, quotas par tenant, limites d’usage, pré-génération des rapports populaires, cache warming et subscriptions.

Toutes ces fonctions doivent étendre le même moteur plutôt que créer des piles parallèles. Le projet Modern Report Engine (en anglais) contient la conception complète et le plan de mise en œuvre de ce type de moteur.

16. Principes de conception

  • Traiter le reporting comme une plateforme, pas comme une collection d’endpoints.
  • Séparer la définition du rapport de son exécution.
  • Garder la sécurité hors des métadonnées définies par les clients.
  • Interroger les données Fabric curées, pas les tables brutes.
  • Mettre en cache les résultats coûteux réutilisables.
  • Séparer la livraison interactive de la livraison d’exports.
  • Rendre le reporting personnalisé contraint et piloté par métadonnées.
  • Protéger la capacité Fabric avant d’ajouter plus de compute.

17. Conclusion

L’objectif n’est pas de construire un nouveau produit de BI.

L’objectif est de fournir un moteur de rapports gouverné qui expose les données analytiques de façon sûre, efficace et cohérente aux applications comme aux clients.

Azure API Management fournit la frontière API et les contrôles de trafic. Le Report Engine centralise la sécurité, les métadonnées, la planification, le cache, l’exécution et la livraison. Microsoft Fabric fournit la couche analytique curée. Service Bus et les workers prennent en charge les exports coûteux en asynchrone. OneLake ou Azure Storage peuvent persister les artefacts réutilisables selon la manière dont ils sont consommés.

Surtout, les rapports standard et personnalisés partagent la même plateforme.

On obtient ainsi une architecture de reporting capable d’évoluer des rapports prédéfinis vers une analytique contrôlée définie par les clients, sans renoncer à l’isolation des tenants, au contrôle opérationnel ni à la capacité Fabric.

Références officielles

Étiquettes

  • Architecture de données
  • API
  • Rapports
  • Microsoft Fabric
  • Azure
  • Multi-locataire
  • Mise en cache
  • Capacité