Parcourir les aide-mémoire · PySpark
Lire et écrire des tables Delta
Lire et écrire des tables Delta avec PySpark à l’aide de modèles sûrs d’ajout (append), d’écrasement (overwrite), de merge, d’évolution du schéma, de partitionnement et de maintenance pour les pipelines de données en production.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Lire une table Delta enregistrée
- 2. Lire une table Delta par son chemin
- 3. Ne lire que les colonnes nécessaires
- 4. Filtrer le plus tôt possible
- 5. Ajouter des lignes immuables
- 6. Ajouter des métadonnées de lot avant l’ajout
- 7. Écraser volontairement une table entière
- 8. N’écraser avec remplacement du schéma que de façon délibérée
- 9. Ajouter des colonnes compatibles grâce à l’évolution du schéma
- 10. Faire un upsert avec MERGE
- 11. Préférer des correspondances explicites de mise à jour/insertion pour des contrats stables
- 12. Dédupliquer les lignes source avant le merge
- 13. Valider l’unicité de la source
- 14. Faire un merge sur des clés métier composées
- 15. Ne mettre à jour que si la source est plus récente
- 16. N’insérer que les clés manquantes
- 17. Gérer explicitement les suppressions issues de la source
- 18. Utiliser MERGE en SQL lorsque c’est plus clair
- 19. Lire l’historique de la table
- 20. Lire une version antérieure d’une table Delta
- 21. Lire la table à un horodatage donné
- 22. Valider la granularité de la cible après les écritures
- 23. Rapprocher le nombre de lignes
- 24. Rapprocher les totaux métier
- 25. Partitionner une table lorsque le modèle d’accès le justifie
- 26. Éviter le surpartitionnement
- 27. Éviter repartition(1) avant les écritures Delta
- 28. Réduire le nombre de partitions de sortie avec prudence
- 29. Compacter les petits fichiers avec OPTIMIZE
- 30. Utiliser le Z-Order pour des modèles d’accès sélectifs répétés
- 31. Utiliser VACUUM pour nettoyer le stockage
- 32. Ne pas réduire la rétention à la légère
- 33. Utiliser le staging pour les producteurs concurrents
- 34. Ne relancer que les conflits de concurrence compris
- 35. Examiner la configuration du low shuffle merge lorsque c’est pertinent
- 36. Éviter de réécrire toute la table pour une petite modification incrémentale
- 37. Garder Bronze en ajout seul lorsque c’est possible
- 38. Sécuriser les relances
- 39. Journaliser les métadonnées d’écriture
- 40. Examiner le plan avant les écritures coûteuses
- Interpréter le résultat
- Points à vérifier
- La cible grossit à chaque relance
- Le merge est plus lent que prévu
- Le merge échoue par intermittence en situation de concurrence
- Les lectures ralentissent après de nombreuses mises à jour
- Les anciennes versions ne fonctionnent plus
- Le schéma de la table change de façon inattendue
- Notes de production
- Delta fournit des transactions ACID au niveau de la table
- L’idempotence relève de l’application
- Les performances du merge dépendent du volume de données de la cible touché
- Les opérations de maintenance consomment des ressources
- Le partitionnement est facultatif
- L’évolution du schéma doit être encadrée
- Erreurs fréquentes
- 1. Faire un ajout aveugle sur des données rejouables
- 2. Utiliser l’écrasement à chaque relance
- 3. Faire un merge avec des clés source en double
- 4. Utiliser updateAll() / insertAll() sans examiner le couplage des schémas
- 5. Partitionner par des clés à forte cardinalité
- 6. Utiliser repartition(1) pour une sortie Delta de production
- 7. Exécuter VACUUM pour accélérer les requêtes
- 8. Réduire la rétention sans planifier la reprise
- 9. Considérer une écriture réussie comme la preuve d’une granularité correcte
- 10. Relancer chaque échec d’écriture
- Étape suivante
- Pour aller plus loin
Problème
Vous devez lire des tables Delta depuis PySpark, y ajouter des données, les écraser ou y faire un upsert, sans introduire de lignes en double, de dérive de schéma, de réécritures complètes accidentelles ni de comportement dangereux lors des relances.
La syntaxe est simple.
Les décisions de production ne le sont pas.
Vous devez répondre aux questions suivantes :
- Ce chargement est-il en ajout seul ou modifiable ?
- Le même lot peut-il être rejoué ?
- Quelle est la clé métier ?
- La table doit-elle être reconstruite ou mise à jour de façon incrémentale ?
- Des changements de schéma peuvent-ils apparaître automatiquement ?
- Des traitements concurrents vont-ils écrire dans la même cible ?
- La table est-elle partitionnée de manière appropriée ?
- Comment allez-vous valider l’écriture ?
L’objectif est d’aligner le modèle d’écriture sur le contrat de données.
Réponse rapide
Utilisez ce modèle de décision :
Lire une table Delta existante
→ spark.read.table(...) ou format("delta").load(...)
Nouvelles lignes immuables
→ append
Reconstruction complète et déterministe
→ overwrite
Insérer + mettre à jour des clés existantes
→ MERGE
Source rejouable
→ MERGE idempotent ou logique de lot résistante au rejeu
Producteurs concurrents
→ ajout en staging, puis réconciliation dans la cible
Lire une table enregistrée :
df = spark.read.table("sales")
Ajout (append) :
(
df.write
.format("delta")
.mode("append")
.saveAsTable("sales")
)
Upsert :
from delta.tables import DeltaTable
target = DeltaTable.forName(
spark,
"sales",
)
(
target.alias("t")
.merge(
source.alias("s"),
"t.sale_id = s.sale_id",
)
.whenMatchedUpdateAll()
.whenNotMatchedInsertAll()
.execute()
)
N’utilisez pas l’écrasement comme stratégie de relance par défaut pour des données de production modifiables.
Code / commandes
1. Lire une table Delta enregistrée
df = spark.read.table(
"sales"
)
Équivalent :
df = spark.sql(
"SELECT * FROM sales"
)
Utilisez les noms de tables enregistrées lorsque le contexte du catalogue/Lakehouse est stable et clair.
2. Lire une table Delta par son chemin
df = (
spark.read
.format("delta")
.load("Tables/sales")
)
Utilisez les lectures par chemin lorsque le chemin fait lui-même partie du contrat.
Évitez de mélanger à la légère l’accès par nom et l’accès par chemin pour une même table.
3. Ne lire que les colonnes nécessaires
df = (
spark.read.table("sales")
.select(
"sale_id",
"merchant_id",
"sale_date",
"amount",
)
)
L’élagage des colonnes réduit la mémoire utilisée en aval et la largeur du shuffle.
4. Filtrer le plus tôt possible
from pyspark.sql import functions as F
df = (
spark.read.table("sales")
.filter(
F.col("sale_date") >= "2026-10-01"
)
.select(
"sale_id",
"merchant_id",
"sale_date",
"amount",
)
)
Filtrez tôt lorsque cela ne modifie pas la sémantique métier attendue.
5. Ajouter des lignes immuables
(
new_rows.write
.format("delta")
.mode("append")
.saveAsTable("sales")
)
Utilisez l’ajout lorsque :
- les lignes sont nouvelles
- les lignes existantes ne doivent pas changer
- la gestion du rejeu est déjà conçue
L’ajout n’est pas automatiquement idempotent.
6. Ajouter des métadonnées de lot avant l’ajout
output = (
new_rows
.withColumn(
"_batch_id",
F.lit(batch_id),
)
.withColumn(
"_ingested_at_utc",
F.current_timestamp(),
)
)
Cela facilite :
- la détection des rejeux
- la traçabilité (lineage)
- l’investigation des incidents
Cela n’empêche pas les doublons à lui seul.
7. Écraser volontairement une table entière
(
rebuilt.write
.format("delta")
.mode("overwrite")
.saveAsTable("sales_summary")
)
À n’utiliser que lorsque le remplacement complet constitue réellement le contrat de la table.
Exemples :
- petites dimensions déterministes
- agrégats reconstructibles
- rechargements historiques (backfills) contrôlés
8. N’écraser avec remplacement du schéma que de façon délibérée
(
rebuilt.write
.format("delta")
.mode("overwrite")
.option(
"overwriteSchema",
"true",
)
.saveAsTable("sales_summary")
)
Cela peut modifier le schéma de la cible.
Ne l’activez pas globalement.
9. Ajouter des colonnes compatibles grâce à l’évolution du schéma
(
new_rows.write
.format("delta")
.mode("append")
.option(
"mergeSchema",
"true",
)
.saveAsTable("sales")
)
À n’utiliser que lorsque l’évolution du schéma est une politique opérationnelle acceptée.
Ne vous en servez pas pour masquer une dérive de schéma non maîtrisée en amont.
10. Faire un upsert avec MERGE
from delta.tables import DeltaTable
target = DeltaTable.forName(
spark,
"sales",
)
(
target.alias("t")
.merge(
source.alias("s"),
"t.sale_id = s.sale_id",
)
.whenMatchedUpdateAll()
.whenNotMatchedInsertAll()
.execute()
)
À utiliser lorsque les lignes entrantes peuvent mettre à jour des clés métier existantes.
11. Préférer des correspondances explicites de mise à jour/insertion pour des contrats stables
(
target.alias("t")
.merge(
source.alias("s"),
"t.sale_id = s.sale_id",
)
.whenMatchedUpdate(
set={
"merchant_id": "s.merchant_id",
"sale_date": "s.sale_date",
"amount": "s.amount",
"updated_at": "s.updated_at",
}
)
.whenNotMatchedInsert(
values={
"sale_id": "s.sale_id",
"merchant_id": "s.merchant_id",
"sale_date": "s.sale_date",
"amount": "s.amount",
"updated_at": "s.updated_at",
}
)
.execute()
)
Cela réduit le couplage accidentel entre les schémas source et cible.
12. Dédupliquer les lignes source avant le merge
from pyspark.sql import Window
w = (
Window
.partitionBy("sale_id")
.orderBy(
F.col("updated_at").desc(),
F.col("source_sequence").desc(),
)
)
source_deduped = (
source
.withColumn(
"_rn",
F.row_number().over(w),
)
.filter(F.col("_rn") == 1)
.drop("_rn")
)
Utilisez un ordre déterministe lorsque plusieurs lignes source peuvent viser la même clé.
13. Valider l’unicité de la source
duplicates = (
source
.groupBy("sale_id")
.count()
.filter(
F.col("count") > 1
)
)
Échouez si les doublons ne sont pas autorisés :
if duplicates.limit(1).count() > 0:
raise RuntimeError(
"Duplicate sale_id values in merge source"
)
14. Faire un merge sur des clés métier composées
condition = """
t.member_id = s.member_id
AND t.merchant_id = s.merchant_id
AND t.site_id = s.site_id
"""
Puis :
(
target.alias("t")
.merge(
source.alias("s"),
condition,
)
.whenMatchedUpdateAll()
.whenNotMatchedInsertAll()
.execute()
)
Utilisez la clé métier complète.
15. Ne mettre à jour que si la source est plus récente
(
target.alias("t")
.merge(
source.alias("s"),
"t.sale_id = s.sale_id",
)
.whenMatchedUpdateAll(
condition="s.updated_at > t.updated_at"
)
.whenNotMatchedInsertAll()
.execute()
)
À n’utiliser que lorsque updated_at est suffisamment fiable pour définir la priorité entre versions.
16. N’insérer que les clés manquantes
(
target.alias("t")
.merge(
source.alias("s"),
"t.sale_id = s.sale_id",
)
.whenNotMatchedInsertAll()
.execute()
)
Cela peut rendre les lots répétés idempotents par clé métier.
17. Gérer explicitement les suppressions issues de la source
(
target.alias("t")
.merge(
source.alias("s"),
"t.sale_id = s.sale_id",
)
.whenMatchedDelete(
condition="s.is_deleted = true"
)
.whenMatchedUpdateAll(
condition="s.is_deleted = false"
)
.whenNotMatchedInsertAll(
condition="s.is_deleted = false"
)
.execute()
)
Ne supprimez que lorsque le contrat source indique explicitement que la ligne est supprimée.
L’absence d’une ligne dans un lot incrémental ne prouve pas sa suppression.
18. Utiliser MERGE en SQL lorsque c’est plus clair
MERGE INTO sales AS t
USING sales_stage AS s
ON t.sale_id = s.sale_id
WHEN MATCHED
AND s.updated_at > t.updated_at
THEN UPDATE SET
t.merchant_id = s.merchant_id,
t.sale_date = s.sale_date,
t.amount = s.amount,
t.updated_at = s.updated_at
WHEN NOT MATCHED
THEN INSERT
(
sale_id,
merchant_id,
sale_date,
amount,
updated_at
)
VALUES
(
s.sale_id,
s.merchant_id,
s.sale_date,
s.amount,
s.updated_at
);
Choisissez la forme API ou SQL la plus facile à relire.
19. Lire l’historique de la table
history = spark.sql(
"DESCRIBE HISTORY sales"
)
history.show(
truncate=False
)
Utilisez l’historique pour investiguer :
- les ajouts
- les écrasements
- les merges
- les optimisations
- les changements opérationnels liés à VACUUM
- les modifications inattendues
20. Lire une version antérieure d’une table Delta
older = (
spark.read
.format("delta")
.option(
"versionAsOf",
42,
)
.table("sales")
)
Utilisez-la pour :
- le débogage
- la comparaison
- l’analyse de reprise
La disponibilité dépend de l’historique et des fichiers conservés.
21. Lire la table à un horodatage donné
older = (
spark.read
.format("delta")
.option(
"timestampAsOf",
"2026-10-03T12:00:00Z",
)
.table("sales")
)
Soyez explicite sur la sémantique des fuseaux horaires lorsque vous comparez des versions historiques.
22. Valider la granularité de la cible après les écritures
Si sale_id doit être unique :
duplicates = (
spark.table("sales")
.groupBy("sale_id")
.count()
.filter(
F.col("count") > 1
)
)
Puis :
if duplicates.limit(1).count() > 0:
raise RuntimeError(
"Target grain validation failed"
)
Une transaction Delta réussie ne garantit pas l’unicité des clés métier.
23. Rapprocher le nombre de lignes
source_count = source.count()
target_count = (
spark.table("sales")
.count()
)
print(
"Source:",
source_count,
)
print(
"Target:",
target_count,
)
Le nombre de lignes seul ne prouve pas l’exactitude.
Utilisez-le avec :
- les clés métier distinctes
- les identifiants de lot
- le nombre de valeurs nulles
- les totaux métier
24. Rapprocher les totaux métier
source_total = (
source
.agg(
F.sum("amount").alias("amount")
)
.first()["amount"]
)
Comparez avec la tranche appropriée de la cible.
Utilisez des types décimaux exacts pour les données financières lorsque c’est possible.
25. Partitionner une table lorsque le modèle d’accès le justifie
(
df.write
.format("delta")
.mode("append")
.partitionBy(
"sale_year",
"sale_month",
)
.saveAsTable("sales")
)
Le partitionnement peut faciliter :
- l’élagage
- l’isolation des écrivains
- la gestion du cycle de vie
Ne partitionnez pas par des identifiants à forte cardinalité.
26. Éviter le surpartitionnement
Mauvais candidats :
transaction_id
customer_id avec des millions de valeurs
horodatage exact
Un trop grand nombre de partitions peut créer :
- de nombreux petits fichiers
- une surcharge de métadonnées
- des lectures inefficaces
Ne partitionnez qu’en fonction de vrais modèles d’accès/d’écriture.
27. Éviter repartition(1) avant les écritures Delta
Risqué :
(
df.repartition(1)
.write
.format("delta")
.mode("append")
.saveAsTable("sales")
)
Cela crée un goulot d’étranglement d’écriture unique.
Une table Delta est censée contenir plusieurs fichiers.
28. Réduire le nombre de partitions de sortie avec prudence
Si la sortie est petite :
small = df.coalesce(20)
Puis :
(
small.write
.format("delta")
.mode("append")
.saveAsTable("sales_summary")
)
Mesurez d’abord.
Un nombre trop faible de partitions peut aussi créer des tâches surdimensionnées et lentes.
29. Compacter les petits fichiers avec OPTIMIZE
spark.sql(
"OPTIMIZE sales"
)
À utiliser lorsque des écritures répétées créent de nombreux petits fichiers et dégradent les performances de lecture.
Ne l’exécutez pas par défaut après chaque petite écriture.
30. Utiliser le Z-Order pour des modèles d’accès sélectifs répétés
spark.sql(
"""
OPTIMIZE sales
ZORDER BY (merchant_id, sale_date)
"""
)
À utiliser lorsque les requêtes filtrent fréquemment sur ces colonnes et que la table est assez volumineuse pour en tirer profit.
N’appliquez pas le Z-Order à toutes les colonnes.
31. Utiliser VACUUM pour nettoyer le stockage
spark.sql(
"VACUUM sales"
)
Ou avec une rétention explicite :
spark.sql(
"VACUUM sales RETAIN 168 HOURS"
)
VACUUM supprime les anciens fichiers non référencés une fois le seuil de rétention dépassé.
Il ne remplace pas OPTIMIZE pour les performances des requêtes.
32. Ne pas réduire la rétention à la légère
Les anciens fichiers peuvent encore être nécessaires pour :
- le voyage dans le temps (time travel)
- les lecteurs de longue durée
- la reprise après incident
- l’analyse d’un retour arrière
Une fois supprimés, ils sont perdus.
Traitez la rétention comme une décision opérationnelle de reprise.
33. Utiliser le staging pour les producteurs concurrents
Un modèle plus sûr :
- Producteur A
- Producteur B
- Producteur C
- Delta de staging
- Merge contrôlé
- Delta cible
Cela réduit le chevauchement entre écrivains indépendants.
34. Ne relancer que les conflits de concurrence compris
Modèle conceptuel :
import time
for attempt in range(3):
try:
run_merge()
break
except Exception as exc:
if not is_expected_delta_conflict(exc):
raise
if attempt == 2:
raise
time.sleep(2 ** attempt)
Ne relancez pas :
- les bogues de schéma
- les données incorrectes
- une logique de merge invalide
- les échecs d’autorisation
35. Examiner la configuration du low shuffle merge lorsque c’est pertinent
Sur les plateformes/runtimes qui le prennent en charge :
print(
spark.conf.get(
"spark.microsoft.delta.merge.lowShuffle.enabled"
)
)
Ne considérez pas les paramètres d’optimisation du runtime comme un substitut à des clés de merge correctes et à une bonne organisation des données.
36. Éviter de réécrire toute la table pour une petite modification incrémentale
Mauvais modèle :
target = spark.table("sales")
combined = (
target
.unionByName(source)
)
# global dedupe
# full overwrite
Mieux :
source incrémentale
→ dédoublonnage déterministe
→ MERGE ciblé
Ne faites des reconstructions complètes que lorsqu’elles sont réellement appropriées.
37. Garder Bronze en ajout seul lorsque c’est possible
Un modèle courant :
Bronze
→ ajout de l’historique source brut
Silver
→ MERGE de l’état courant
Gold
→ couche de consommation organisée
Cela préserve la capacité de rejeu et simplifie la reprise après incident.
38. Sécuriser les relances
Avant d’autoriser les relances, décidez :
Que se passe-t-il si le même lot s’exécute deux fois ?
Les bons modèles incluent :
MERGE par clé métier
garde-fou contre le rejeu de lot
remplacement de partition
staging + promotion
Mauvais choix par défaut :
ajout aveugle
pour les flux modifiables et rejouables.
39. Journaliser les métadonnées d’écriture
Champs utiles :
pipeline_run_id
batch_id
source_system
ingested_at_utc
source_modified_at
Exemple :
output = (
output
.withColumn(
"_pipeline_run_id",
F.lit(pipeline_run_id),
)
.withColumn(
"_batch_id",
F.lit(batch_id),
)
.withColumn(
"_ingested_at_utc",
F.current_timestamp(),
)
)
Veillez à ce que les métadonnées opérationnelles restent sûres et non sensibles.
40. Examiner le plan avant les écritures coûteuses
output.explain("formatted")
Avant une écriture volumineuse, vérifiez que la transformation ne fait pas accidentellement :
- un shuffle inutile
- une jointure croisée (cross join)
- des scans répétés
- un énorme tri global
- une UDF Python coûteuse
Le réglage de l’écriture ne peut pas corriger un mauvais plan en amont.
Interpréter le résultat
| Modèle | À utiliser pour |
|---|---|
read.table() |
Table Delta enregistrée |
format("delta").load() |
Chemin Delta explicite |
| append | Nouvelles lignes immuables |
| overwrite | Reconstruction complète voulue |
MERGE |
Upsert / réconciliation incrémentale |
mergeSchema |
Évolution additive et contrôlée du schéma |
overwriteSchema |
Remplacement volontaire du schéma |
OPTIMIZE |
Compacter/réorganiser les fichiers de données actifs |
| Z-Order | Améliorer le saut de fichiers pour des filtres répétés |
VACUUM |
Supprimer les anciens fichiers non référencés |
| time travel | Lire l’état historique de la table |
| staging + merge | Modèle plus sûr pour les producteurs concurrents |
La distinction essentielle est la suivante :
transaction Delta réussie
!=
exactitude métier
Validez le contrat de données obtenu.
Points à vérifier
La cible grossit à chaque relance
Cause probable :
- ajout aveugle
- absence de protection contre le rejeu
- clé métier incorrecte
Le merge est plus lent que prévu
Vérifiez :
- la taille de la source
- la sélectivité de la condition de merge
- l’organisation de la cible
- l’élagage des partitions
- le nombre de fichiers
- le déséquilibre (skew)
Le merge échoue par intermittence en situation de concurrence
Vérifiez les écrivains qui se chevauchent et le chevauchement des fichiers de la cible.
Envisagez le staging + un merge contrôlé.
Les lectures ralentissent après de nombreuses mises à jour
Vérifiez :
- l’accumulation de petits fichiers
- l’organisation
- le besoin d’un
OPTIMIZE
Les anciennes versions ne fonctionnent plus
Vérifiez si d’anciens fichiers ont été supprimés par la rétention/VACUUM.
Le schéma de la table change de façon inattendue
Vérifiez :
mergeSchema- la dérive de la source
- le comportement d’écrasement du schéma
- les changements de déploiement
Notes de production
Delta fournit des transactions ACID au niveau de la table
Cela protège l’intégrité des commits.
Cela n’impose pas automatiquement :
- l’unicité
- les clés étrangères
- les règles d’une ligne par clé métier
Validez-les vous-même.
L’idempotence relève de l’application
Une écriture Delta peut être valide sur le plan transactionnel tout en dupliquant des données lors d’une relance.
Concevez délibérément le comportement de rejeu.
Les performances du merge dépendent du volume de données de la cible touché
Une très petite source peut quand même entraîner un travail coûteux sur la cible si la condition de merge ou l’organisation des données est trop large.
Les opérations de maintenance consomment des ressources
OPTIMIZE et VACUUM doivent être planifiés volontairement.
Ne les exécutez pas aveuglément après chaque écriture.
Le partitionnement est facultatif
Ne partez pas du principe que chaque table Delta a besoin d’un partitionnement physique.
Ne l’utilisez que lorsqu’il favorise :
- l’élagage
- le cycle de vie
- l’isolation des écrivains
L’évolution du schéma doit être encadrée
La croissance automatique du schéma peut être pratique, mais elle peut aussi casser les consommateurs.
Traitez le schéma comme un contrat.
Erreurs fréquentes
1. Faire un ajout aveugle sur des données rejouables
Cela crée des doublons.
2. Utiliser l’écrasement à chaque relance
Cela transforme de petites mises à jour incrémentales en réécritures complètes coûteuses.
3. Faire un merge avec des clés source en double
Dédupliquez d’abord de façon déterministe.
4. Utiliser updateAll() / insertAll() sans examiner le couplage des schémas
Ce qui est pratique aujourd’hui peut devenir fragile demain.
5. Partitionner par des clés à forte cardinalité
Cela produit de nombreux petits fichiers/partitions.
6. Utiliser repartition(1) pour une sortie Delta de production
Cela crée un goulot d’étranglement à tâche unique.
7. Exécuter VACUUM pour accélérer les requêtes
Utilisez OPTIMIZE et le réglage de l’organisation des données pour les performances de lecture.
8. Réduire la rétention sans planifier la reprise
Vous pouvez perdre la possibilité d’utiliser le time travel.
9. Considérer une écriture réussie comme la preuve d’une granularité correcte
Validez les clés métier et les totaux.
10. Relancer chaque échec d’écriture
Ne relancez que les échecs transitoires ou de concurrence que vous comprenez.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
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.