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