Microsoft Fabric
Concevoir une architecture Microsoft Fabric évolutive
Un guide pratique pour définir les frontières des charges de travail, le stockage, la capacité, les déploiements et l’exploitation dans Microsoft Fabric.

Dans cet article
Une architecture Microsoft Fabric réussie n’est pas celle qui comporte le plus d’espaces de travail, de Lakehouses, de couches ou de diagrammes. C’est celle où un ingénieur peut expliquer qui possède chaque jeu de données, quel moteur de calcul le modifie, comment il passe d’un environnement à l’autre, qui peut le lire et qui intervient en cas de panne.
Ces frontières comptent avant même que la plateforme ne prenne de l’ampleur. Lorsqu’elles restent implicites, chaque nouveau pipeline ou rapport ajoute du couplage. Lorsqu’elles sont explicites, les équipes peuvent modifier une partie de la plateforme sans deviner ce qui risque de casser ailleurs. Le but n’est pas de tout séparer, mais de rendre suffisamment clairs la responsabilité, la sécurité, les déploiements, l’isolation des charges et le fonctionnement opérationnel.
Cet article propose une méthode concrète pour raisonner sur ces choix. Il ne prétend pas fournir une architecture de référence universelle : les plateformes Fabric répondent à des besoins différents selon les organisations, les volumes de données, les compétences et les contraintes réglementaires. Une architecture utile rend ses compromis visibles.
Commencer par les frontières des charges de travail
Partez des charges et des responsabilités, pas des types d’éléments Fabric. Listez les domaines métier responsables des données, les systèmes qui les ingèrent, les transformations qui produisent des données fiables et les consommateurs qui en dépendent. Identifiez ensuite les composants qui ont des calendriers de déploiement, des règles d’accès, des profils de performance ou des équipes de support différents.
Une frontière de domaine peut justifier un espace de travail lorsqu’elle correspond à un responsable et à un cycle de vie distincts. L’ingestion peut mériter d’être séparée du reporting interactif : un gros travail Spark ne devrait pas rendre imprévisible un tableau de bord critique. Les composants de plateforme partagés — tables de journalisation, bibliothèques réutilisables, conventions de connexion ou utilitaires d’orchestration — ont besoin d’un responsable, même lorsqu’ils servent plusieurs domaines.
Le développement, les tests et la production constituent une autre frontière. Ils ne devraient pas partager des données de production modifiables ou des identifiants simplement parce que leurs artefacts se ressemblent. Le code peut être promu ; les données et la configuration doivent rester propres à chaque environnement.
Au départ, un espace de travail unique et massif est pratique. Avec le temps, il accumule notebooks, pipelines, modèles et autorisations sans rapport entre eux. Les déploiements deviennent risqués, car l’espace de travail sert à la fois d’unité d’organisation et d’unité importante de gestion du cycle de vie. Lorsqu’il enquête sur une panne, l’ingénieur doit d’abord découvrir quelle équipe et quel processus sont responsables de l’élément.
L’extrême opposé coûte également cher. Un espace de travail par petit pipeline entraîne une multiplication des autorisations, des configurations répétitives, une supervision fragmentée et de nombreuses relations de déploiement. Posez-vous une question simple : la frontière proposée change-t-elle la responsabilité, la sécurité, le cycle de vie ou l’isolation des charges ? Si elle ne change rien à ces aspects, un nouvel espace de travail n’apportera peut-être pas grand-chose.
Lakehouse ou Warehouse ?
Un Lakehouse convient naturellement à l’ingénierie axée sur Spark : lecture de fichiers, notebooks, transformation de grands jeux de données et travail avec des tables Delta. Il expose les concepts de fichiers et de tables, ce qui est utile lorsque des entrées brutes arrivent au format CSV, JSON ou Parquet avant de devenir des tables gérées. Les ingénieurs peuvent utiliser PySpark ou Spark SQL et conserver les données dans un format de table ouvert.
Un Warehouse convient naturellement aux charges axées sur SQL. Les modèles relationnels préparés, les tables servant la BI, les workflows d’analystes et les équipes à l’aise avec T-SQL bénéficient d’une interface relationnelle familière. Le Warehouse peut servir de couche de restitution même si les transformations en amont s’exécutent dans un Lakehouse.
Il ne s’agit pas d’un choix idéologique entre Spark « moderne » et SQL « traditionnel ». Différentes étapes peuvent utiliser différents moteurs. Un notebook peut normaliser des fichiers source semi-structurés dans des tables Delta ; un Warehouse peut ensuite présenter des modèles dimensionnels gouvernés aux outils de reporting. Le SQL analytics endpoint d’un Lakehouse fournit une interface de requête SQL sur ses tables, mais ne rend pas toutes les charges Lakehouse équivalentes aux charges Warehouse.
Choisissez en fonction des modes d’écriture, du comportement SQL requis, des compétences de l’équipe, de la gouvernance et des consommateurs des données. Réévaluez ce choix lorsque ces contraintes évoluent. Le parcours d’apprentissage Microsoft Fabric présente les deux approches afin d’en rendre les différences concrètes.
OneLake et déplacement des données
OneLake fournit un socle de stockage partagé, mais ce socle ne supprime pas toutes les copies. Les données sont toujours copiées lorsqu’une ingestion écrit un nouveau fichier, qu’une transformation matérialise une table ou qu’un processus de restitution crée délibérément une représentation préparée.
L’objectif architectural est de supprimer les copies qui n’ont pas de raison claire. Conservez les fichiers bruts lorsque le rejeu et l’auditabilité comptent. Créez des tables Delta lorsque le comportement transactionnel, le schéma ou les performances des requêtes l’exigent. Construisez des jeux de données préparés lorsque les consommateurs ont besoin de définitions métier stables. Utilisez des shortcuts lorsqu’ils donnent un accès gouverné aux données sans nouvelle matérialisation et que leurs caractéristiques opérationnelles conviennent à la charge.
Pour chaque copie, consignez sa raison : conversion de format, rétention, frontière de sécurité, isolation des performances ou transformation métier. « Une autre équipe avait besoin des données » justifie d’évaluer le partage, pas nécessairement de créer un nouvel export sans gouvernance.
Bronze, Silver et Gold
Le vocabulaire Medallion est utile parce qu’il exprime une intention :
- Bronze préserve les données source brutes ou peu transformées, ainsi que les métadonnées nécessaires à leur traçabilité.
- Silver nettoie, standardise, déduplique et met les données en conformité pour obtenir des entités techniques fiables.
- Gold organise les données pour un processus métier, un rapport, un modèle, une API ou une autre charge de restitution.
Ne créez pas systématiquement ces trois couches sous prétexte que la plupart des diagrammes montrent trois boîtes. Une source fiable de petite taille qui alimente un seul modèle de reporting peut ne nécessiter qu’une couche d’ingestion et une couche de restitution préparée. Ajouter une table Silver qui ne fait que transmettre les données augmente le stockage, le traitement, les tests et la surface opérationnelle sans améliorer la qualité.
Des couches supplémentaires se justifient lorsqu’elles créent un contrat : conserver une entrée immuable pour pouvoir la rejouer, séparer le nettoyage propre à chaque source de la mise en conformité entre domaines, isoler les champs sensibles ou servir plusieurs consommateurs avec des modèles différents. Documentez la responsabilité des couches, même si l’implémentation utilise les noms Bronze, Silver et Gold. L’article Architecture Medallion expliquée détaille chaque couche et les cas où il vaut mieux en utiliser moins.
Concevoir pour les grands jeux de données
À partir de centaines de millions ou de milliards de lignes, des pratiques inoffensives sur de petites tables deviennent des coûts dominants. Les réécritures complètes consomment du calcul et créent des fichiers inutiles. Les opérations MERGE générales peuvent parcourir beaucoup plus de données que le lot de changements entrant. Des partitions trop fines peuvent produire trop de répertoires et de petits fichiers, tandis qu’une stratégie d’élagage inefficace rend les lectures répétées coûteuses.
Préférez le traitement incrémentiel lorsque la source fournit une frontière fiable pour les changements. Faites circuler un watermark, un identifiant de lot ou une version source tout au long du pipeline. Rendez les écritures idempotentes afin qu’une nouvelle tentative ne duplique pas les données. Limitez les mises à jour aux clés métier et périodes concernées plutôt que de reconstruire tout l’historique.
Ne partitionnez que lorsque les filtres courants peuvent éliminer une quantité importante de données et que chaque partition reste substantielle. Un identifiant à forte cardinalité, comme celui d’une transaction ou d’un client, est généralement une mauvaise clé de partition physique. Un partitionnement par date peut aider certaines charges, mais il peut aussi être inadapté si la plupart des requêtes couvrent toutes les dates ou si les partitions récentes reçoivent de nombreuses écritures concurrentes.
La taille des fichiers fait partie de la conception des tables. Des ajouts fréquents de petite taille peuvent créer des milliers de fichiers Parquet ou Delta minuscules, ce qui augmente le coût de listing et d’ordonnancement. Des fichiers surdimensionnés réduisent le parallélisme et rendent les réécritures grossières. La bonne plage dépend de la charge et du runtime : observez la distribution réelle des fichiers et le comportement des requêtes plutôt que de reprendre une cible universelle.
Utilisez les plans de requête et les métriques d’exécution pour confirmer l’élagage des données. Mesurez les fichiers et les données lus, pas seulement la durée. Des guides approfondissent les performances de MERGE dans Delta ainsi que la taille des fichiers et le problème des petits fichiers ; un guide sur le partitionnement Delta est prévu.
Considérations de capacité
La capacité Fabric est partagée par des charges qui peuvent se comporter très différemment : notebooks, traitements Spark, pipelines, requêtes SQL, actualisations et rapports Power BI interactifs. Une plateforme peut disposer de suffisamment de calcul au total et offrir malgré tout une mauvaise expérience lorsque plusieurs charges lourdes se chevauchent.
La pression sur la capacité relève donc souvent d’abord de l’architecture ou de l’ordonnancement, avant d’être un problème d’achat. Une grande transformation démarrant pendant le pic de reporting peut concurrencer les utilisateurs interactifs. Une concurrence non maîtrisée entre notebooks peut transformer un traitement prévisible en pic soudain. Une stratégie de nouvelle tentative peut amplifier une charge défaillante. Une requête SQL mal filtrée peut reparcourir constamment une grande table de restitution.
Supervisez avant de changer d’échelle. Mettez en relation le comportement de la capacité avec les exécutions de pipelines, les notebooks, les charges SQL, les actualisations et les symptômes visibles par les utilisateurs. Déterminez si la solution consiste à modifier l’ordonnancement, la conception des requêtes ou des tables, le contrôle de la concurrence, l’isolation des charges, le traitement incrémentiel ou la capacité disponible. Acheter une capacité plus importante peut être justifié, mais seulement après avoir compris l’usage de la capacité actuelle. Le guide Capacité et consommation de calcul dans Fabric explique comment l’analyser.
Conception multi-tenant
Les plateformes multi-tenant peuvent s’appuyer sur plusieurs modèles d’isolation. Une table partagée avec une colonne de tenant est efficace à exploiter et facilite les transformations communes, mais chaque chemin d’accès doit appliquer le filtre du tenant. Des tables séparées par tenant peuvent simplifier certaines tâches de rétention ou d’export, mais elles multiplient la gestion des schémas et peuvent créer de nombreux petits objets. Des espaces de travail au niveau du tenant offrent une forte isolation organisationnelle dans certains cas, au prix d’une hausse du nombre de déploiements, d’autorisations, de tâches de supervision et de gestion de capacité.
Un compromis courant consiste à partager l’ingestion et les transformations de mise en conformité, tout en préparant des couches tenant-aware. Les tenants à risque élevé ou de très grande taille peuvent bénéficier d’une isolation renforcée. La décision doit tenir compte des frontières réglementaires, du risque de noisy neighbor, des besoins de personnalisation, du nombre de tenants, du volume des données et de la capacité de l’équipe à gérer de nombreux artefacts.
Ne considérez pas la séparation physique comme l’unique contrôle de sécurité. L’authentification, l’autorisation, les règles au niveau des lignes, l’auditabilité et des parcours de données soigneusement testés restent indispensables dans tous les modèles.
Git et environnements de déploiement
La gestion du code source et des déploiements doit être conçue avant que l’espace de travail ne contienne des dizaines d’artefacts. Connectez les espaces de développement appropriés à Git, définissez le modèle de branches et de revue, puis décidez comment les artefacts passent par les tests avant d’arriver en production. Les pipelines de déploiement Fabric peuvent faciliter la promotion, mais il faut toujours comprendre les dépendances et les paramètres propres à chaque environnement.
Séparez le code et les définitions déployables des données. Les données de production ne sont pas promues depuis une branche de développement. Les connexions, identifiants d’espaces de travail, secrets, emplacements de stockage et autres valeurs propres à un environnement nécessitent une stratégie de configuration explicite. Validez-les pendant le déploiement plutôt que de modifier ensuite les éléments de production à la main.
Privilégiez les changements petits et faciles à relire. Documentez les éléments Fabric gérés dans le contrôle de code source, le mécanisme responsable de chaque artefact et les étapes qui restent manuelles. La section Git et CI/CD du parcours Fabric relie ces décisions au reste du parcours d’apprentissage.
Observabilité
Une plateforme n’est pas prête pour la production si le seul signal de panne est le signalement de données périmées par un utilisateur. Les pipelines et notebooks doivent émettre assez d’informations structurées pour expliquer ce qui a été exécuté, ce qui a été traité et pourquoi l’exécution a échoué. Un enregistrement compact peut comprendre :
| Champ | Utilité |
|---|---|
execution_id |
Relie tous les enregistrements produits par une exécution |
pipeline_name |
Identifie le processus d’orchestration |
notebook_name |
Identifie l’unité de transformation |
started_at |
Définit la fenêtre d’exécution |
finished_at |
Permet de vérifier la durée et la fin du traitement |
status |
Indique si l’exécution a démarré, réussi, échoué ou été ignorée |
rows_processed |
Fournit un indicateur élémentaire de volume |
error_message |
Contient un résumé diagnostique expurgé des éléments sensibles |
Transmettez le même identifiant de corrélation du pipeline à ses notebooks. Journalisez les deux niveaux : le pipeline explique l’orchestration et les dépendances ; le notebook explique les étapes de transformation et les écritures. N’enregistrez pas de secrets ni de contenu sensible provenant des lignes.
Les nouvelles tentatives doivent fonctionner avec un traitement idempotent. Une nouvelle tentative qui ajoute aveuglément le même lot peut transformer un incident d’infrastructure en incident de qualité des données. Conservez la frontière du lot ou l’identité d’exécution nécessaires pour détecter les doublons et reprendre le travail sans risque.
Erreurs fréquentes
- Construire un espace de travail monolithique sans responsabilité claire.
- Créer un espace de travail par artefact et multiplier la charge opérationnelle.
- Copier les données à chaque nouveau consommateur sans évaluer le partage ou les shortcuts.
- Surpartitionner les tables ou partitionner selon une colonne à très forte cardinalité.
- Laisser les traitements répétés créer de nombreux petits fichiers Parquet ou Delta.
- Attendre la production pour définir les pratiques Git, de promotion et de configuration.
- Lancer des rechargements complets alors qu’une frontière incrémentielle fiable existe.
- Utiliser des opérations
MERGEgénérales sans limiter les données concernées. - Exploiter des pipelines sans journalisation au niveau des exécutions et sans identifiants de corrélation.
- Traiter les environnements de développement et de production comme s’ils étaient identiques.
- Augmenter la capacité sans avoir identifié les charges qui la consomment.
Exemple d’architecture de référence
Voici un point de départ, pas un plan obligatoire :
Sources
- Bases opérationnelles
- SaaS et API
- Fichiers
Ingestion
- Pipelines de données
- Notebooks
- Shortcuts
Bronze / brut
- Tables Delta brutesAlignées sur la source, avec métadonnées de lot
Silver / mise en conformité
- Entités mises en conformitéPropres, validées et dédupliquées
Gold / données préparées
- Modèles préparésTables de restitution prêtes pour le métier
Restitution
- Warehouse
- SQL analytics endpoint
- Modèles sémantiques
Consommateurs
- API
- Rapports
- Data science
Cross-cutting concerns
- Git
- CI/CD
- Journalisation
- Supervision
- Sécurité
- Configuration
Les flèches doivent correspondre à des contrats observables dont un responsable est identifié. Par exemple, l’ingestion enregistre le lot source, les transformations peuvent le rejouer, la couche préparée publie un schéma stable, et les consommateurs connaissent les attentes de fraîcheur et de qualité.
Conclusion
La scalabilité dépend moins de la prévision du plus grand cluster possible que de la clarté des frontières entre charges et responsabilités opérationnelles. Une responsabilité explicite limite le couplage accidentel. Des couches de stockage intentionnelles évitent les copies inutiles. Des mesures de capacité permettent de prendre de meilleures décisions de dimensionnement. Git, la configuration et l’observabilité rendent les changements plus sûrs.
Commencez par l’architecture la plus simple qui préserve ces qualités, puis ajoutez des frontières lorsque la sécurité, le cycle de vie, la responsabilité ou les faits observés le justifient. Les ressources associées approfondissent la conception Lakehouse et Warehouse, le partitionnement Delta, la capacité Fabric, CI/CD et la journalisation en production.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- ArticleMaterialized Lake Views dans Microsoft Fabric : guide pratiqueDécouvrez les Materialized Lake Views dans Microsoft Fabric : persistance Delta, rafraîchissement selon les dépendances, architecture Medallion et compromis.Lire l’article
- Aide-mémoireArchitecture Medallion dans FabricConcevoir une architecture Bronze, Silver et Gold pragmatique dans Microsoft Fabric, avec des contrats de données clairs, la possibilité de rejouer les chargements, un traitement incrémental, des contrôles qualité et des responsabilités de restitution bien définies.Ouvrir l’aide-mémoire
- RessourceContenu en anglaisMicrosoft Fabric Certification Study PlannerAn adaptable 6–8 week example plan that connects official Fabric certification objectives with hands-on practice, review, and exam readiness.Voir la ressource
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.