Parcourir les aide-mémoire · Microsoft Fabric

Technologie: Microsoft FabricCatégorie: PerformanceNiveau: IntermédiaireMis à jour

Session tags dans Fabric

Utilisez les session tags de Microsoft Fabric pour réutiliser des sessions Spark compatibles entre activités de notebook, réduire le temps de démarrage et éviter une fragmentation inutile des sessions.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Définir un session tag sur une activité Notebook d’un pipeline Fabric
  5. 2. Activer High Concurrency avant de compter sur les session tags
  6. 3. Réutiliser un même tag pour les activités de notebook liées
  7. 4. Utiliser des tags distincts pour les charges de travail sans rapport
  8. 5. Garder une configuration de calcul compatible
  9. 6. Aligner l’Environment et les paramètres Spark
  10. 7. Ne pas rendre les session tags uniques à chaque exécution du pipeline
  11. 8. Ne pas utiliser un tag global unique pour tous les notebooks
  12. 9. N’ajuster la densité des sessions qu’après avoir mesuré la concurrence
  13. 10. Utiliser la réutilisation de session pour les chaînes de notebooks courts
  14. 11. Mesurer séparément le démarrage et l’exécution
  15. 12. Confirmer la réutilisation via la supervision Fabric
  16. 13. Comprendre l’isolation REPL en High Concurrency
  17. 14. Transmettre l’état explicitement entre notebooks
  18. 15. Faire attention aux vues temporaires
  19. 16. Utiliser le cache de manière réfléchie
  20. 17. Libérer les données mises en cache une fois terminé
  21. 18. Ne pas utiliser les session tags pour corriger une requête Spark lente
  22. 19. Éviter un excès de notebooks concurrents dans une même session partagée
  23. 20. Utiliser des tags différents lorsque l’isolation des charges de travail compte davantage
  24. 21. Comprendre le session tag comme une indication de réutilisation
  25. 22. Ne pas considérer le tag comme un mécanisme d’idempotence
  26. 23. Ne pas utiliser les session tags comme mécanisme de verrouillage
  27. 24. Éviter de dépendre de chemins relatifs dans les scénarios High Concurrency
  28. 25. Utiliser des conventions de nommage explicites pour les session tags
  29. 26. Documenter les frontières de partage attendues
  30. Interpréter le résultat
  31. Points à vérifier
  32. Même tag, mais une nouvelle session Spark démarre
  33. Le démarrage du pipeline s’améliore, mais pas la durée d’exécution du notebook
  34. Les notebooks d’une session partagée se ralentissent mutuellement
  35. Les résultats deviennent incohérents parce que les notebooks dépendent d’un état en mémoire
  36. Une charge de travail est courte, mais la durée du pipeline reste dominée par le démarrage
  37. Notes de production
  38. Les session tags exigent High Concurrency pour la réutilisation entre notebooks de pipeline
  39. Le partage de session reste dans les limites de compatibilité
  40. Un tag n’est pas une garantie
  41. Les sessions partagées utilisent des ressources partagées
  42. La limite de partage High Concurrency par défaut est configurable
  43. Réutilisation de session et facturation sont liées, mais ne se confondent pas avec la performance
  44. Le code du pipeline doit rester correct de manière autonome
  45. Erreurs fréquentes
  46. 1. Définir un session tag sans activer High Concurrency
  47. 2. Supposer qu’un même tag garantit une même session
  48. 3. Attribuer un tag unique à chaque exécution
  49. 4. Attribuer le même tag à tous les notebooks de l’espace de travail
  50. 5. Partager implicitement des variables Python entre notebooks
  51. 6. Utiliser les session tags pour corriger des transformations Spark lentes
  52. 7. Porter immédiatement spark.highConcurrency.max au maximum
  53. 8. Supposer qu’une session partagée implique une exécution sérialisée
  54. 9. Ignorer les différences de configuration du Lakehouse ou de Spark
  55. Étape suivante
  56. Pour aller plus loin

Problème

Un pipeline Fabric exécute plusieurs activités de notebook, et chaque notebook passe un temps important à acquérir ou à démarrer la capacité de calcul Spark avant que le vrai travail ne commence.

Pour les notebooks courts, le démarrage de la session peut représenter une part importante de la durée totale.

Les session tags de Fabric peuvent aider des activités de notebook compatibles à réutiliser une session Spark existante au lieu d’en démarrer une nouvelle à chaque fois.

Les questions importantes sont :

  • Quand un session tag permet-il réellement la réutilisation ?
  • Qu’est-ce qui doit correspondre entre les activités de notebook ?
  • Quand faut-il réutiliser le même tag ?
  • Quand les charges de travail doivent-elles utiliser des tags distincts ?
  • Comment savoir si la réutilisation de session est utile ?
  • Quels problèmes les session tags ne peuvent-ils pas résoudre ?

Réponse rapide

Utilisez le même session tag pour les activités de notebook qui font volontairement partie d’une même charge de travail compatible.

Exemple de conception logique :

Pipeline: Daily Sales

Notebook 1: ingest_sales
Session tag: daily-sales

Notebook 2: transform_sales
Session tag: daily-sales

Notebook 3: publish_sales
Session tag: daily-sales

Fabric peut réutiliser une session Spark compatible existante pour les activités portant le même tag au lieu de provisionner une nouvelle session.

Pour les activités Notebook des pipelines, les session tags exigent :

Workspace settings
→ Spark settings
→ High concurrency mode
→ Enable high concurrency for pipelines running multiple notebooks

Un session tag est avant tout une optimisation du démarrage et de la réutilisation des sessions Spark.

Il ne rend pas plus rapides, à lui seul, des transformations Spark inefficaces.

Code / commandes

1. Définir un session tag sur une activité Notebook d’un pipeline Fabric

Les session tags se configurent sur l’activité Notebook du pipeline Fabric.

Conceptuellement :

Notebook activity
→ Settings
→ Session tag
→ daily-sales

Le tag peut être n’importe quelle chaîne explicite.

Privilégiez des noms stables fondés sur la finalité de la charge de travail :

daily-sales
commission-processing
customer-refresh
reporting-batch

Évitez les valeurs aléatoires propres à chaque exécution si votre objectif est la réutilisation de session.


2. Activer High Concurrency avant de compter sur les session tags

Les session tags destinés à la réutilisation entre notebooks de pipeline dépendent du mode High Concurrency (haute concurrence).

Activez l’option de l’espace de travail pour les notebooks de pipeline :

Workspace settings
→ Data Engineering / Spark settings
→ High concurrency mode
→ Pipelines running multiple notebooks

Si High Concurrency est désactivé, définir un tag n’apporte pas le comportement de session partagée attendu.


3. Réutiliser un même tag pour les activités de notebook liées

Exemple :

Notebook                 Session tag
-----------------------  ----------------
01_ingest_sales          daily-sales
02_transform_sales       daily-sales
03_validate_sales        daily-sales
04_publish_sales         daily-sales

Utilisez cette approche lorsque les notebooks :

  • appartiennent à une seule charge de travail
  • sont lancés avec des paramètres Spark compatibles
  • peuvent partager sans risque la capacité de calcul Spark sous-jacente
  • bénéficient d’un démarrage de session réduit

4. Utiliser des tags distincts pour les charges de travail sans rapport

Exemple :

Pipeline des ventes       -> daily-sales
Pipeline des commissions  -> commission
Pipeline de reporting     -> reporting

Des tags distincts évitent de regrouper des charges de travail sans rapport dans la même session lorsque vous voulez des frontières plus claires entre elles.

Un session tag est une indication de réutilisation, pas une frontière de sécurité.


5. Garder une configuration de calcul compatible

La réutilisation de session exige un contexte Spark compatible.

Pour High Concurrency dans les notebooks, les conditions de compatibilité importantes sont notamment :

  • le même périmètre utilisateur
  • la même configuration de Lakehouse par défaut
  • la même configuration de calcul Spark

Si ces éléments diffèrent, Fabric peut créer une session Spark distincte même lorsque le tag est identique.

Ne supposez pas :

même tag = même session Spark garantie

6. Aligner l’Environment et les paramètres Spark

Si des notebooks liés sont censés partager une session, évitez les différences inutiles dans :

  • la configuration du pool Spark
  • l’Environment
  • les propriétés Spark
  • le Lakehouse par défaut

Une différence de configuration peut empêcher la réutilisation de session.

Considérez la configuration de session commune comme faisant partie du contrat de la charge de travail.


7. Ne pas rendre les session tags uniques à chaque exécution du pipeline

Ceci empêche la réutilisation :

daily-sales-20261004-170001
daily-sales-20261004-171501
daily-sales-20261004-173002

Préférez :

daily-sales

lorsque des activités répétées doivent réutiliser une capacité de calcul Spark compatible.

N’utilisez des tags propres à une exécution que lorsqu’une isolation délibérée compte davantage que la réutilisation.


8. Ne pas utiliser un tag global unique pour tous les notebooks

Mauvaise conception :

session tag = shared

pour chaque pipeline Data Engineering de l’espace de travail.

Cela peut créer une contention inutile et rend le comportement des charges de travail plus difficile à comprendre.

Utilisez des tags qui reflètent un regroupement réel des charges de travail.


9. N’ajuster la densité des sessions qu’après avoir mesuré la concurrence

Fabric expose la limite de partage des sessions High Concurrency via la propriété Spark de l’Environment :

spark.highConcurrency.max

Exemple :

spark.highConcurrency.max = 10

Elle détermine combien de charges de travail de notebook compatibles peuvent partager une même session Spark High Concurrency.

La valeur par défaut de la plateforme est inférieure au maximum pris en charge.

Ne l’augmentez pas systématiquement.

Une densité plus élevée signifie que davantage de charges de travail se partagent les mêmes ressources Spark limitées.


10. Utiliser la réutilisation de session pour les chaînes de notebooks courts

Les session tags sont particulièrement utiles lorsque chaque notebook est court.

Exemple :

Notebook A – travail Spark : 25 s
Notebook B – travail Spark : 35 s
Notebook C – travail Spark : 20 s

Si chaque notebook nécessite aussi un démarrage de session Spark important, la réutilisation de session peut réduire sensiblement la latence de bout en bout du pipeline.

Pour un notebook qui s’exécute pendant des heures, le démarrage peut représenter une part bien plus faible de la durée totale.


11. Mesurer séparément le démarrage et l’exécution

Suivez :

début de l’activité
session Spark disponible
début de la première action Spark
fin de l’action Spark
fin du notebook

Cela vous permet de distinguer :

surcoût de session

de :

exécution Spark réelle

N’attribuez pas toute la durée du notebook aux performances des requêtes Spark.


12. Confirmer la réutilisation via la supervision Fabric

Lors du diagnostic de la réutilisation de session, examinez la supervision Fabric et les informations sur les sessions et jobs Spark.

Vérifiez si les activités de notebook liées :

  • se rattachent à la même application/session Spark sous-jacente
  • évitent les délais répétés de démarrage complet
  • s’exécutent toujours dans des contextes de notebook isolés

Si plusieurs nouvelles sessions Spark apparaissent malgré un tag identique, examinez les différences de compatibilité.


13. Comprendre l’isolation REPL en High Concurrency

High Concurrency peut héberger plusieurs charges de travail de notebook dans une seule application Spark.

Chaque charge de travail s’exécute dans son propre contexte REPL.

Vous ne devez donc pas concevoir de pipelines en supposant que les variables Python d’un notebook existent automatiquement dans un autre.

Par exemple, ne comptez pas sur :

# Notebook A
my_value = 123

pour être disponible dans :

# Notebook B
print(my_value)

Utilisez plutôt une persistance explicite ou des paramètres.


14. Transmettre l’état explicitement entre notebooks

Utilisez des mécanismes pris en charge comme :

  • les paramètres de pipeline
  • les paramètres de notebook
  • les tables Delta
  • les fichiers du Lakehouse
  • les tables de contrôle
  • les métadonnées persistées

Exemple :

# Notebook A
result.write.format("delta").mode("overwrite").saveAsTable(
    "control.daily_sales_stage"
)

Puis :

# Notebook B
result = spark.table(
    "control.daily_sales_stage"
)

La réutilisation de session doit améliorer le démarrage, pas créer des dépendances d’état cachées entre notebooks.


15. Faire attention aux vues temporaires

Une vue temporaire est limitée à la session :

df.createOrReplaceTempView(
    "sales_stage"
)

Même si des charges de travail partagent une application Spark sous-jacente, l’isolation des contextes REPL signifie que l’état temporaire d’un notebook ne doit pas être traité comme un contrat fiable entre notebooks.

Persistez les données lorsqu’un autre notebook en dépend.


16. Utiliser le cache de manière réfléchie

Une session Spark partagée ne signifie pas que chaque notebook doit mettre en cache de manière agressive.

Exemple :

df.cache()
df.count()

Le cache consomme la mémoire partagée des executors.

Dans une session High Concurrency, un cache excessif provenant de plusieurs charges de travail peut créer de la contention.

Ne mettez en cache que les données coûteuses à calculer et suffisamment réutilisées pour justifier le coût en mémoire.


17. Libérer les données mises en cache une fois terminé

df.unpersist()

Faites-le lorsque les données mises en cache ne sont plus nécessaires.

Les sessions partagées rendent la bonne gestion de la mémoire plus importante, car plusieurs charges de travail de notebook peuvent se disputer les mêmes ressources Spark sous-jacentes.


18. Ne pas utiliser les session tags pour corriger une requête Spark lente

Si un notebook passe :

20 s à démarrer la session
15 min à effectuer une jointure avec beaucoup de shuffle

la réutilisation de session peut réduire la part de 20 secondes consacrée au démarrage.

Elle ne corrigera pas la jointure de 15 minutes.

Examinez :

  • le volume scanné
  • la stratégie de jointure
  • le shuffle
  • le skew
  • les partitions
  • les opérations côté driver

séparément.


19. Éviter un excès de notebooks concurrents dans une même session partagée

Si de nombreux notebooks partagent une session, ils se disputent :

  • les executors
  • le CPU
  • la mémoire
  • les ressources de shuffle

Davantage de réutilisation de session n’est pas automatiquement préférable.

Mesurez :

durée du pipeline
temps d’acquisition de la session
durée de chaque notebook
mise en file d’attente
durée des stages Spark
consommation de capacité

Optimisez pour le débit plutôt que pour la densité maximale.


20. Utiliser des tags différents lorsque l’isolation des charges de travail compte davantage

Des tags distincts peuvent être appropriés lorsque les notebooks :

  • ont des profils de calcul très différents
  • exécutent d’importants shuffles concurrents
  • nécessitent une configuration Spark différente
  • ne doivent pas trop se concurrencer
  • appartiennent à des domaines opérationnels différents

Exemple :

heavy-monthly-report
realtime-enrichment
daily-ingestion

La réutilisation de session est une optimisation, pas une obligation.


21. Comprendre le session tag comme une indication de réutilisation

Un session tag indique à Fabric de rechercher une session compatible existante.

S’il en existe une et qu’elle peut accepter la charge de travail, Fabric peut la réutiliser.

Sinon, Fabric peut créer une nouvelle session.

Par conséquent :

même session tag

ne signifie pas :

une seule session Spark physique garantie pour toujours

La capacité, la compatibilité, le moment d’exécution et les emplacements de session disponibles comptent toujours.


22. Ne pas considérer le tag comme un mécanisme d’idempotence

Un session tag ne signifie pas :

exécuter ce notebook une seule fois

ni :

renvoyer la même exécution

Il concerne le placement et la réutilisation des sessions Spark.

L’idempotence du pipeline doit être conçue séparément au moyen de :

  • clés de chargement
  • checkpoints
  • logique de merge
  • journaux d’exécution
  • tables de contrôle

23. Ne pas utiliser les session tags comme mécanisme de verrouillage

Un session tag ne sérialise pas les charges de travail.

Plusieurs activités de notebook peuvent s’exécuter simultanément dans la même application Spark High Concurrency.

Si des notebooks modifient la même table Delta, concevez explicitement la concurrence des écritures.

Utilisez de manière appropriée :

  • le partitionnement
  • la logique de merge
  • les modèles de transaction
  • la gestion des nouvelles tentatives et des erreurs

Le partage de session ne supprime pas les problématiques de concurrence Delta.


24. Éviter de dépendre de chemins relatifs dans les scénarios High Concurrency

Fabric documente des limitations concernant les chemins relatifs dans les sessions de notebook High Concurrency.

Privilégiez, le cas échéant, des chemins explicites tenant compte du Lakehouse/OneLake ou des références de table.

Exemple :

df = spark.table(
    "sales_curated"
)

plutôt que de vous fier à des hypothèses fragiles sur des chemins relatifs du système de fichiers.


25. Utiliser des conventions de nommage explicites pour les session tags

Bon :

sales-daily
commission-daily
reporting-refresh
customer-dim-build

À éviter :

test
spark
session1
abc

Un tag utile doit indiquer à un opérateur à quelle charge de travail appartient la session partagée.


26. Documenter les frontières de partage attendues

Pour chaque pipeline, documentez :

Session tag :
daily-sales

Notebooks attendus :
- ingest_sales
- transform_sales
- publish_sales

Lakehouse par défaut :
lh_sales

Environment :
env_sales_prod

High Concurrency :
activé

Il devient alors beaucoup plus simple de diagnostiquer pourquoi une activité démarre une nouvelle session de façon inattendue.

Interpréter le résultat

Concept Signification
Session tag Indication utilisée pour réutiliser une session existante ou y regrouper des charges de travail de notebook Spark compatibles.
High Concurrency Mode Fabric qui permet à des charges de travail de notebook compatibles de partager une application Spark.
REPL Contexte d’exécution de notebook isolé au sein d’une application Spark partagée.
Réutilisation de session Éviter le démarrage d’une nouvelle session Spark lorsqu’une session compatible existe déjà.
spark.highConcurrency.max Limite configurable qui contrôle la densité de notebooks dans une session High Concurrency.
Même tag Rend la réutilisation possible, sans la garantir.
Tag différent Favorise un regroupement des charges de travail et un placement de session distincts.

Points à vérifier

Même tag, mais une nouvelle session Spark démarre

Vérifiez :

  • High Concurrency est-il activé ?
  • même périmètre utilisateur ?
  • même Lakehouse par défaut ?
  • même configuration de calcul Spark ?
  • Environment et configuration compatibles ?
  • la session est-elle toujours active ?
  • des emplacements High Concurrency sont-ils disponibles ?

Le tag seul ne suffit pas.

Le démarrage du pipeline s’améliore, mais pas la durée d’exécution du notebook

C’est normal si le goulot d’étranglement est la charge de travail Spark elle-même.

Les session tags réduisent le temps de démarrage, pas le coût du scan, du shuffle ou du calcul.

Les notebooks d’une session partagée se ralentissent mutuellement

Il y a peut-être trop de concurrence pour les ressources disponibles.

Envisagez de :

  • réduire le nombre de notebooks simultanés
  • diminuer spark.highConcurrency.max
  • utiliser des tags distincts
  • modifier l’orchestration
  • augmenter la capacité de calcul adaptée seulement après une revue du code

Les résultats deviennent incohérents parce que les notebooks dépendent d’un état en mémoire

C’est un problème d’architecture.

Persistez ou transmettez l’état explicitement.

N’utilisez pas les sessions partagées comme substitut à un contrat de données.

Une charge de travail est courte, mais la durée du pipeline reste dominée par le démarrage

C’est le cas d’usage le plus pertinent pour les session tags et High Concurrency.

Notes de production

Les session tags exigent High Concurrency pour la réutilisation entre notebooks de pipeline

Pour les activités Notebook des pipelines Fabric, le paramètre High Concurrency correspondant de l’espace de travail doit être activé.

Sans lui, la conception fondée sur les session tags n’apportera pas le partage de session attendu.

Le partage de session reste dans les limites de compatibilité

High Concurrency pour les notebooks Fabric exige un contexte de session compatible.

Les frontières importantes sont notamment :

  • l’utilisateur
  • le Lakehouse par défaut
  • les paramètres de calcul Spark

Une dérive de configuration peut fragmenter les sessions.

Un tag n’est pas une garantie

Considérez le tag comme une indication de placement et de réutilisation.

Fabric peut tout de même créer une nouvelle session Spark si aucune session compatible réutilisable n’est disponible.

Les sessions partagées utilisent des ressources partagées

Les contextes de notebook sont isolés, mais les executors et les ressources de l’application Spark sont partagés.

Des notebooks lourds peuvent affecter la durée d’exécution les uns des autres.

La limite de partage High Concurrency par défaut est configurable

Fabric permet de modifier la densité de notebooks via :

spark.highConcurrency.max

La valeur par défaut est cinq, et Fabric permet de l’augmenter jusqu’au maximum documenté de la plateforme.

Une valeur plus élevée n’est pas automatiquement préférable.

Réutilisation de session et facturation sont liées, mais ne se confondent pas avec la performance

High Concurrency dans Fabric peut améliorer l’utilisation des ressources et réduire les démarrages de session répétés.

N’optimisez pas exclusivement pour la densité des sessions si cela ralentit l’exécution à cause de la contention des ressources.

Le code du pipeline doit rester correct de manière autonome

Un notebook doit rester correct si Fabric lui attribue une session Spark neuve.

La réutilisation de session doit être une couche d’optimisation, pas une condition de l’exactitude.

Erreurs fréquentes

1. Définir un session tag sans activer High Concurrency

La réutilisation de session attendue dans le pipeline ne se produira pas.

2. Supposer qu’un même tag garantit une même session

La compatibilité et la capacité disponible déterminent toujours si la réutilisation a lieu.

3. Attribuer un tag unique à chaque exécution

Cela empêche la réutilisation voulue.

4. Attribuer le même tag à tous les notebooks de l’espace de travail

Cela crée de mauvaises frontières entre charges de travail et peut accroître la contention.

5. Partager implicitement des variables Python entre notebooks

Les contextes REPL sont isolés.

Persistez ou transmettez l’état explicitement.

6. Utiliser les session tags pour corriger des transformations Spark lentes

Les tags aident au démarrage et à la réutilisation des sessions, pas à une exécution Spark inefficace.

7. Porter immédiatement spark.highConcurrency.max au maximum

Une concurrence plus élevée peut accroître la contention sur le CPU, la mémoire et le shuffle.

Mesurez d’abord.

8. Supposer qu’une session partagée implique une exécution sérialisée

High Concurrency est précisément conçu pour des charges de travail concurrentes.

Concevez les écritures de données en conséquence.

9. Ignorer les différences de configuration du Lakehouse ou de Spark

Ces différences peuvent entraîner des sessions distinctes même lorsque le tag correspond.

Étape suivante

Utilisez le comportement observé pour choisir l’action suivante.

  • Chaque notebook démarre une nouvelle session Spark → vérifiez High Concurrency et la configuration des session tags.
  • Le même tag ne réutilise pas la session → comparez le Lakehouse, l’utilisateur, l’Environment et les paramètres de calcul Spark.
  • Le démarrage domine la durée du pipeline → regroupez les notebooks courts compatibles sous un session tag stable.
  • Les notebooks partagés se concurrencent fortement → réduisez la concurrence, diminuez la densité des sessions ou séparez les tags des charges de travail.
  • L’exécution Spark reste lente après la réutilisation → passez au diagnostic des performances des notebooks Fabric.
  • Les notebooks dépendent d’un état temporaire en mémoire → remplacez cette dépendance par des données persistées ou des paramètres.
  • Des écritures concurrentes entrent en conflit → revoyez les modèles d’écriture et de concurrence Delta.
  • Vous devez prouver la réutilisation → examinez la supervision Fabric et le comportement des applications/sessions Spark.

← Tous les aide-mémoire