Choix d’un noyau de notebook dans Microsoft Fabric

Les notebooks dans Microsoft Fabric prennent en charge trois types de noyau : Python, Spark et T-SQL. Le noyau Spark prend en charge quatre langages ( PySpark, SparkSQL, Scala et SparkR) soutenus par le même calcul Spark. Ce guide se concentre sur la décision entre le noyau Python et le noyau Spark, car ces noyaux sont les choix les plus courants pour les charges de travail d’ingénierie des données. Les deux s’exécutent dans la même interface de notebook, mais se distinguent par leur modèle de calcul, leur capacité de montée en charge, les capacités du moteur et la compatibilité avec Delta Lake. Ce guide fournit une évaluation équilibrée pour vous aider à choisir le noyau approprié et à éviter les idées fausses courantes sur les coûts et les performances.

Important

Le choix du noyau de notebook n’est pas simplement lié au coût ou à la taille des données. La configuration de calcul, les exigences des fonctionnalités Delta Lake, la maturité du moteur et la croissance attendue des données jouent tous des rôles importants dans la prise de décision appropriée.

Comprendre vos options de calcul

Une idée fausse courante est que le noyau Python est toujours moins cher que le noyau Spark pour les petites charges de travail de données. En réalité, le coût dépend de la façon dont vous configurez le calcul pour chaque noyau.

calcul du noyau Python

Le noyau Python s’exécute sur une machine à nœud unique qui utilise par défaut 2 vCores (1 CU) et peut être configuré pour démarrer jusqu’à 64 vCores (32 CU). Cet environnement n’a pas d’exécution distribuée. Le pool initial s’initialise en environ 5 secondes, ce qui le rend adapté au travail interactif.

Calcul du noyau Spark

Le noyau Spark utilise des pools Spark avec plusieurs options de configuration :

Configuration du cluster vCores disponibles pour les exécuteurs Heure de début de session CU consommées après le début de la session
Pool de démarrage (par défaut) Nœuds de travail à 8 cœurs, mise à l’échelle automatique activée ; commence avec un seul nœud et passe de manière proactive à un nœud de travail dédié dans les minutes qui suivent le démarrage de la session ~5 secondes 8 CU (minimum, après mise à l’échelle proactive vers le haut)
À nœud unique*, 8 vCores (via le pool Starter) L’exécuteur et le pilote à 8 cœurs partagent le même nœud ~5 secondes (avec un pool préchauffé) 4 CUs
Pool personnalisé à nœud unique*, 4-vCore Exécuteur 4 cœurs et pilote partagent le même nœud Nécessite un pool personnalisé ; le démarrage de session est généralement compris entre 3 et 5 minutes 2 CUs
Pool personnalisé à plusieurs nœuds Évolue selon la taille du cluster Le démarrage de session est généralement compris entre 3 et 5 minutes Varie

Lors de l’utilisation du pool de démarrage, une session Spark à nœud unique 8-vCore démarre en environ 5 secondes, comparable au noyau Python. Un cluster Spark à nœud unique conserve les coûts similaires au noyau Python tout en fournissant l’accès à toutes les fonctionnalités natives Spark, y compris le moteur d’exécution natif (NEE).

Note

Il existe deux façons de configurer des pools Spark à nœud unique. Pour la plupart des charges de travail, il est généralement recommandé d’utiliser la première méthode, Overprovisioned single-node. La deuxième méthode, classique à nœud unique est meilleure lorsqu’il existe des processus lourds de pilotes, mais limite la quantité de ressources utilisables par les exécuteurs Spark.

  • Nœud unique surprovisionné : commencez avec un pool Spark (c’est-à-dire un pool de démarrage) configuré avec la mise à l’échelle automatique et l’allocation dynamique activées, avec la mise à l’échelle automatique réglée sur 1 à > 1 nœud. Créez un élément d’environnement référençant le pool Spark et définissez le nombre d’exécuteurs sur 1. Les notebooks utilisant cet environnement sont provisionnés avec un cluster Spark à nœud unique, dans lequel le pilote et l’exécuteur partagent toutes les ressources.
  • Nœud unique classique : créez un pool Spark avec le nombre maximal de nœuds défini sur 1. Cette configuration fonctionne avec la mise à l’échelle automatique et l’allocation dynamique activée ou désactivée, car la sélection n’a aucun effet sur la stratégie d’approvisionnement. Les notebooks utilisant ce pool Spark ont 50% de cœurs virtuels alloués au pilote et 50% alloués en tant qu’exécuteurs.

Performances par échelle de charge de travail

Les benchmarks comparant Fabric Spark avec le moteur d’exécution natif par rapport aux moteurs de Python à machine unique (comme Pandas, DuckDB ou Polars) entre les charges de travail ELT de bout en bout montrent des modèles clairs en fonction de l’échelle des données :

Taille des données (compressées) Avantage du moteur
Ultra-petit (< ~140 Mo) Les moteurs Python à machine unique (DuckDB, Polars) sont plus rapides.
Petite (~1 à 2 Go) Les moteurs Python conservent toutefois un avantage, mais Fabric Spark avec NEE devient compétitif à mesure que le nombre de cœurs disponibles pour chaque moteur augmente, en particulier pour les opérations à forte intensité d’écriture.
Petit-moyen (~10 à 13 Go) Fabric Spark avec le moteur d’exécution natif est concurrentiel ou plus rapide que la plupart des moteurs à machine unique. Les moteurs Python sur une seule machine peuvent rencontrer des erreurs de mémoire insuffisante (OOM) avec un nombre réduit de vCores.
Environ 100 Go et plus Pour la plupart des charges de travail, Fabric Spark avec le moteur d’exécution natif est le moteur le plus rapide et le plus fiable.

Mise à l’échelle au-delà des petites données

Tenez compte du taux de croissance des données lors de la sélection d’un moteur. Les moteurs de Python non distribués fonctionnent bien pour les petites données, mais la migration de votre code lorsque les données dépassent leurs limites sont coûteuses. En commençant avec Spark sur une configuration à nœud unique, vous pouvez passer en toute transparence à une configuration multinœud sans réécrire vos pipelines d’ingénierie des données.

Compatibilité Delta Lake

La compatibilité delta Lake est une considération essentielle lors de la sélection d’un moteur. Fabric Spark dispose d’une prise en charge native et complète de Delta Lake, tandis que les moteurs Python peuvent avoir des lacunes significatives :

Important

Le tableau de prise en charge des fonctionnalités suivant reflète l’état de chaque moteur à compter de juin 2026 et est basé sur des tests directs sur Fabric Spark Runtime 1.3 et 2.0. L’écosystème Python des logiciels open source (OSS) pour Delta Lake évolue rapidement : delta-rs, DuckDB et Polars publient tous fréquemment de nouvelles versions qui ajoutent régulièrement une prise en charge étendue du protocole Delta. Vérifiez toujours par rapport à la documentation actuelle et aux notes de publication de chaque moteur avant de vous appuyer sur une fonctionnalité spécifique en production :

Fonctionnalité Delta Lake Fabric Spark delta-rs (Python) DuckDB Polaires
Lire les tables Delta ✅ ✅ ✅ ✅
Écrire des tables Delta ✅ ✅ Ajout, écrasement (y compris basé sur des prédicats), UPDATE, DELETE, MERGE ⚠️ INSERT uniquement (nécessite ATTACH ... (TYPE delta, READ_WRITE)) ; pas de UPDATE/DELETE/MERGE ; utiliser delta-rs pour les autres opérations d’écriture ⚠️ Ajout, écrasement (y compris basé sur des prédicats), fusion uniquement ; pas de UPDATE/DELETE
Garanties ACID / contrôle optimiste de la concurrence ✅ ✅ ⚠️ INSERT fonctionne uniquement par ajout ; aucune détection native des conflits ; utiliser delta-rs avec l’épinglage de version pour garantir l’isolation lecture-puis-écriture ⚠️ OCC pour les écritures ; les lectures effectuées avec Polars sont en dehors du périmètre de la transaction — nécessitent un épinglage explicite de version pour garantir l’isolation entre lecture et écriture
Évolution du schéma en écriture ✅ ✅ ❌ Aucune modification du schéma sur INSERT ✅
Mappage de colonnes ✅ ❌ ✅ ❌
Vecteurs de suppression (lecture) ✅ ❌ ✅ ✅
Vecteurs de suppression (écriture) ✅ ❌ ❌ ❌
Élargissement de type (lecture) ✅ ❌ ✅ ❌
Élargissement du type (écriture) ✅ ❌ ❌ ❌
Saut de fichier ✅ ✅ ✅ ✅
Écritures partitionnées ✅ ✅ ❌ Utiliser delta-rs pour écrire avec partitionnement ✅
Regroupement liquide (écriture) ✅ ❌ ❌ ❌
Voyage dans le temps ✅ ✅ ✅ ✅
RESTORE ✅ ✅ ❌ Utiliser delta-rs pour restaurer des tables ❌ Utiliser delta-rs pour restaurer des tables
Clone peu profond (créer) ✅ ❌ ❌ ❌
Clone peu profond (lecture) ✅ ❌ ❌ ❌
Suivi des lignes ✅ ⚠️ La lecture et l’écriture réussissent, mais le suivi au niveau des lignes _metadata n’est pas accessible ; les pipelines qui s’appuient sur row_id pour la déduplication ou la capture des données modifiées (CDC) doivent utiliser Spark pour lire ⚠️ La lecture et l’écriture réussissent, mais le suivi des lignes _metadata n’est pas accessible ; les pipelines qui s’appuient sur row_id pour la déduplication ou la capture des changements de données doivent utiliser Spark pour effectuer la lecture ⚠️ La lecture et l’écriture réussissent, mais le suivi des lignes _metadata n’est pas accessible ; les pipelines qui s’appuient sur row_id pour la déduplication ou la capture des changements de données doivent utiliser Spark pour effectuer la lecture
Colonnes d’identité (lecture) ✅ ✅ ✅ ✅
Colonnes d’identité (écriture) ✅ ❌ ❌ ❌
Colonnes générées (lecture seule) ✅ ✅ ✅ ✅
Colonnes générées (écriture) ✅ ❌ ❌ ❌
Flux de données modifiées (lecture) ✅ ✅ ❌ Utiliser delta-rs pour lire le flux de données modifiées ❌ Utiliser delta-rs pour lire le flux de données modifiées
Flux de données modifiées (écriture) ✅ ❌ ❌ ❌
Points de contrôle V2 (lecture) ✅ ❌ ✅ ❌
Points de contrôle V2 (écriture) ✅ ❌ ❌ ❌
Intervalle de point de contrôle ✅ Paramétrable (10 par défaut) ⚠️ Paramétrable (par défaut 100) ❌ INSERT n’écrit pas de checkpoints ; le journal grossit sans limite sans intervention de maintenance externe via delta-rs ⚠️ Paramétrable (par défaut 100)
OPTIMISER ✅ ✅ ❌ Utiliser delta-rs pour optimiser ❌ Utiliser delta-rs pour optimiser
Compactage automatique ✅ ❌ ❌ ❌
VIDE ✅ ❌ Risque : accumulation de fichiers orphelins ❌ Risque : accumulation de fichiers orphelins ❌ Risque : accumulation de fichiers orphelins
VACUUM LITE ✅ ✅ ❌ Utiliser delta-rs pour vider lite ❌ Utiliser delta-rs pour vider lite

Implications clés :

  • Nouvelles fonctionnalités de Delta : la prise en charge des fonctionnalités Delta Lake les plus récentes, notamment l’élargissement des types, les points de contrôle v2, le clustering liquide, les colonnes d’identité, les écritures dans le Change Data Feed et la lecture de clones superficiels, est incohérente ou absente dans les moteurs Python open source. Si votre pipeline de données dépend de l’une de ces fonctionnalités, utilisez Fabric Spark. Considérez les moteurs Python comme un complément de Spark pour des charges de travail spécifiques (lectures légères, développement local, ajouts de données simples) plutôt que comme une solution de remplacement universelle.

  • Vecteurs de suppression : les vecteurs de suppression sont une bonne pratique pour les tables Delta (activées par défaut à partir de Fabric Spark Runtime 2.0), car elles améliorent considérablement les performances des opérations MERGE, UPDATE et DELETE via une stratégie de fusion en lecture. Aucun moteur Python (delta-rs, DuckDB ou Polars) ne prend en charge l’écriture de vecteurs de suppression. Si vous utilisez un moteur Python pour écrire dans des tables avec des vecteurs de suppression activés, vous rencontrez des erreurs de compatibilité.

  • Garanties ACID : Tous les moteurs Python ne fournissent pas de garanties ACID natives. Delta-rs prend en charge le contrôle de concurrence optimiste (OCC) pour les opérations de fusion, de mise à jour et de suppression. Toutefois, les pipelines inter-moteurs dans lesquels DuckDB ou Polars effectuent la lecture et delta-rs effectue l’écriture nécessitent un épinglage explicite des versions des deux côtés afin de maintenir l’isolation entre lecture et écriture. DuckDB INSERT est une opération d’ajout uniquement sans détection de conflit.

  • Points de contrôle : tous les moteurs Python n’écrivent pas de points de contrôle, et ceux qui le font le font par défaut toutes les 100 validations plutôt que toutes les 10 validations par défaut de Spark. DuckDB INSERT n’écrit jamais de points de contrôle, ce qui entraîne la croissance du journal des transactions Delta sans limite. Envisagez de définir un intervalle de point de contrôle inférieur dans delta-rs et Polars, et d’exécuter une maintenance périodique delta-rs pour les tables écrites par DuckDB.

  • Suivi des lignes : tous les moteurs Python peuvent lire et écrire dans des tables avec le suivi des lignes activé, mais la _metadata colonne contenant row_id et row_commit_version n'est pas accessible en dehors de Spark. Les pipelines qui s’appuient sur row_id pour la déduplication ou la capture des changements de données doivent être lus avec Spark.

  • OPTIMIZE et VACUUM: Les moteurs Python s’appuient sur la bibliothèque deltalake pour le compactage et VACUUM. Bien que delta-rs puisse être rapide pour ces opérations, cette approche introduit une gestion des dépendances supplémentaire et les opérations ne sont pas orchestrées en mode natif comme elles se trouvent dans Spark. Les tables écrites uniquement à l’aide de moteurs Python accumulent de petits fichiers et des journaux de transactions qui croissent sans limite en l’absence de maintenance explicite.

  • Clones superficiels : les moteurs Python ne prennent pas en charge la lecture des tables créées à l’aide d’un clone superficiel en raison de limitations de résolution des chemins absolus. Aucun moteur Python ne prend en charge la création de clones peu profonds.

Maturité du moteur et support Microsoft

Prise en charge de Spark dans Fabric

Fabric Spark est la propre version dérivée par Microsoft du projet open source Apache Spark. Microsoft gère et envoie le runtime, ce qui signifie :

  • Microsoft prend en charge les composants internes Spark et Delta Lake de bout en bout, y compris le moteur d’exécution natif (NEE), qui est basé sur Velox et Apache Gluten.
  • Vous pouvez ouvrir des tickets de support pour le comportement Spark, les plans de requête, les problèmes de mémoire et les bogues du moteur.
  • Les améliorations de performances sont déployées en continu dans le cadre des mises à jour du runtime Fabric : votre code existant s’exécute plus rapidement sans aucune modification de code.

prise en charge du moteur Python

Microsoft n’entretient pas de fork de moteurs Python open source comme DuckDB ou Polars. La prise en charge est limitée aux problèmes liés aux intégrations OneLake fournies dans le cadre du runtime Fabric, comme l’authentification ou l’accès au système de fichiers. Si vous rencontrez une régression des performances, un bogue du moteur ou une API rompue entre les versions de bibliothèque, vous devez vous engager directement avec les communautés open source pour ces bibliothèques.

Maturité opérationnelle

L’expérience acquise dans la mise en place de benchmarks ELT de bout en bout avec ces moteurs met en évidence des différences significatives de maturité opérationnelle :

  • Spark : Le code écrit pour une version d’exécution s’exécute sans modification sur les versions plus récentes et s’effectue plus rapidement en raison d’un investissement continu Microsoft d’ingénierie. L’interface utilisateur Spark et les données de télémétrie Fabric fournissent une surveillance dynamique avec une visibilité complète des requêtes actives, des plans d’exécution et des exécutions de travaux historiques.
  • DuckDB et Polars : les changements d’API et de comportement entre les versions peuvent nécessiter une refactorisation du code à mesure que les moteurs mûrissent et que les API évoluent. Les deux moteurs n’ont pas de surveillance dynamique : lorsqu’un travail s’exécute plus longtemps que prévu, il n’y a pas d’équivalent à l’interface utilisateur Spark pour comprendre ce qui se passe. L’authentification auprès de OneLake peut nécessiter des solutions de contournement spécifiques à la version.
  • Surcoût d’une stack de données composable : utiliser DuckDB ou Polars pour un workflow ELT complet implique généralement de combiner plusieurs bibliothèques (par exemple, DuckDB pour la lecture et la transformation des données, delta-rs pour l’écriture et la maintenance). La compatibilité de la bibliothèque doit être maintenue entre les composants et doit être considérée chaque fois que la version de la bibliothèque est mise à niveau au-delà de ce qui est fourni dans le runtime.

Conseils de décision

Utiliser le noyau Python quand

  • Vos données sont petites — moins d’environ 1 Go une fois compressées — et les performances brutes des moteurs s’exécutant sur une seule machine comptent avant tout.
  • Vous créez une orchestration d’API légère, des intégrations REST/gRPC ou une automatisation de flux de contrôle où le calcul distribué ajoute une surcharge inutile.
  • Vous effectuez une exploration interactive rapide des petits jeux de données où la latence des requêtes ad hoc est la priorité.
  • Votre charge de travail nécessite une version Python plus ancienne que celle fournie dans le runtime Spark Fabric actuel.
  • Vous comprenez et acceptez les limitations des fonctionnalités Delta Lake du moteur de Python que vous utilisez.

Utilisez le noyau Spark quand

  • Vos données sont de 1 Go ou plus sous forme compressée, ou vous vous attendez à ce que les données augmentent à cette échelle.
  • Vous avez besoin d’une compatibilité totale avec Delta Lake, y compris les vecteurs de suppression, le mappage de colonnes, l’élargissement des types, OPTIMIZE, VACUUM et les garanties ACID.
  • Vous avez besoin de fonctionnalités prêtes pour la production, telles que les variables d’environnement, la gestion des bibliothèques par élément, une forte concurrence, ainsi qu’un ordonnancement des travaux de type FAIR ou premier entré, premier sorti (FIFO).
  • Vous avez besoin d’une supervision dynamique et d’une visibilité opérationnelle complète sur l’exécution des travaux.
  • Vous vous appuyez sur des API natives Spark telles que MLlib, Spark SQL ou Spark Streaming.
  • Vous souhaitez une prise en charge Microsoft de bout en bout pour votre moteur de traitement des données.
  • Vous souhaitez pouvoir passer d’un calcul sur un seul nœud à un calcul sur plusieurs nœuds sans réécrire le code.
  • Vous devez créer des notebooks dans PySpark, SparkSQL, Scala ou SparkR.

Conseil / Astuce

Pour les charges de travail d’une taille compressée de 1 Go ou plus, envisagez de commencer avec un cluster Spark à nœud unique de 8 vCores en utilisant le pool de démarrage. Vous obtenez des heures de démarrage de session quasi-instantanées, des fonctionnalités spark complètes Fabric, y compris NEE, et la possibilité d’effectuer une mise à l’échelle vers plusieurs nœuds si nécessaire, tout en fonctionnant sur un seul nœud comme le noyau Python.

Principales différences en un clin d’œil

Catégorie Noyau Python Moteur Spark
Calcul par défaut Machine virtuelle à nœud unique à 2 vCore (extensible jusqu’à 64 vCores) Pool initial : nœuds de travail à 8 vCores avec mise à l’échelle automatique
Configuration minimale à nœud unique 2 vCores 8 vCores (pool de démarrage, ~5 secondes de démarrage) ; 4 vCores (pool personnalisé, démarrage plus long)
Heure de démarrage ~5 secondes ~5 secondes (pool de démarrage) ; plus long pour les pools personnalisés
Exécution distribuée No Oui
Langues prises en charge Python PySpark, SparkSQL, Scala, SparkR
Version de Python Plusieurs versions disponibles Lié à la version du runtime Spark de Fabric
Delta Lake (prise en charge complète des fonctionnalités) No Oui
Surveillance dynamique Limited Complet (page surveillance des travaux + interface utilisateur Spark)
prise en charge du moteur Microsoft Intégrations OneLake uniquement Prise en charge complète du runtime
accès à la bibliothèque Python Installation de PIP pip install + éléments d’environnement
API natives de Spark (MLlib, Streaming) No Oui
Fonctionnalités de production (env vars, environnements) Limited Complète
Prise en charge de la concurrence élevée No Oui
Ordre V pour les modèles sémantiques rapides de Direct Lake No Oui
Cache de stockage d’objets accélérant les lectures répétées Dépendant du moteur (DuckDB a une mise en cache intégrée, Polars ne le fait pas) Oui (cache intelligent)
Mise à l’échelle vers plusieurs nœuds No Oui

Glossaire

  • Transactions ACID : ensemble de propriétés (Atomicité, Cohérence, Isolation, Durabilité) qui garantissent que les opérations de base de données sont traitées de manière fiable. Delta Lake implémente la sémantique ACID à l’aide du contrôle d’accès concurrentiel optimiste et des journaux des transactions.
  • Contrôle d’accès concurrentiel optimiste (OCC) : stratégie d’accès concurrentiel dans laquelle les transactions continuent sans verrouillage, puis vérifiez au moment de la validation qu’aucune modification en conflit n’a eu lieu. Delta Lake utilise l’OCC ; Les pipelines entre moteurs (par exemple, les lectures polaires suivies d’écritures delta-rs) nécessitent une épinglage de version explicite pour maintenir l’isolation.
  • Compactage automatique : fonctionnalité Delta Lake dans le runtime Fabric Spark qui fusionne automatiquement les petits fichiers en fichiers plus volumineux après les opérations d’écriture, ce qui réduit la fragmentation des fichiers sans étape OPTIMIZE distincte.
  • Flux de données modifiées (CDF) : fonctionnalité Delta Lake qui enregistre les modifications au niveau des lignes (insertion, mise à jour, suppression) dans une table, permettant le traitement incrémentiel des données et les pipelines CDC. Seul Fabric Spark prend en charge l’écriture des métadonnées du flux de modifications de données (CDF) ; les moteurs Python OSS peuvent les lire, mais pas en produire.
  • Mappage des colonnes : une fonctionnalité de Delta Lake qui permet de renommer ou de supprimer des colonnes sans réécrire les fichiers Parquet sous-jacents. Pris en charge par Fabric Spark ; non pris en charge par delta-rs ou Polars.
  • delta-rs : implémentation Rust open source du protocole Delta Lake avec des liaisons Python (package deltalake PyPI). Fournit la prise en charge de la lecture/écriture Delta dans les environnements Python OSS, mais couvre moins de fonctionnalités que delta-spark, qui sous-tend l’environnement d’exécution Fabric Spark.
  • Vecteurs de suppression : optimisation Delta Lake qui utilise la fusion en lecture pour réduire la quantité de données réécrites pendant les opérations MERGE, UPDATE et DELETE. Activé par défaut dans Fabric Spark Runtime 2.0 ; non pris en charge pour les écritures par un moteur Python OSS.
  • Planification FAIR : stratégie de planification Spark qui alloue des ressources de cluster équitablement entre les travaux simultanés, ce qui garantit qu’aucun travail unique ne monopolise le cluster.
  • Ordonnancement FIFO : une stratégie d’ordonnancement de Spark qui exécute les travaux selon le principe du premier entré, premier sorti, en donnant la priorité au premier travail soumis.
  • Clustering liquide : fonctionnalité Delta Lake qui réorganise de façon incrémentielle les données pour optimiser les performances des requêtes sans nécessiter de partitionnement explicite. Prise en charge uniquement par Fabric Spark.
  • NEE (moteur d’exécution natif) : un moteur de requêtes C++ vectorisé basé sur Velox et Apache Gluten qui accélère les charges de travail Spark de Fabric. NEE est disponible sans coût de calcul supplémentaire et ne nécessite aucune modification du code.
  • Suivi des lignes : fonctionnalité de Delta Lake qui attribue un row_id et un row_commit_version stables à chaque ligne via une colonne _metadata. Tous les moteurs peuvent lire et écrire dans des tables avec le suivi des lignes activé, mais uniquement Fabric Spark peut accéder au contenu de la _metadata colonne.
  • Pool Spark : ressource de calcul partagée pour l’exécution de charges de travail Spark distribuées. Le pool initial fournit des nœuds préchauffés pour des démarrages de session quasi instantanés (environ 5 secondes), avec la mise à l’échelle automatique activée par défaut.
  • V-order : Une optimisation d’écriture Fabric qui trie et compresse les données Parquet de manière à améliorer les performances de lecture pour les modèles sémantiques Power BI Direct Lake et autres chemins de lecture Fabric.
  • Cache intelligent : cache de disque intelligent dans Fabric Spark qui accélère les lectures répétées des mêmes fichiers de table Delta en mettant en cache les données de fichier localement sur les nœuds exécuteurs.