Exécuter un pipeline

Jusqu'à présent, le pipeline n'était qu'un modèle abstrait. La matérialisation est le processus qui transforme ce modèle en acteurs en cours d'exécution qui déplacent réellement les données.

Rien ne se passe tant que vous n'exécutez pas explicitement le graphe, ce qui rend Akka Streams composable et réutilisable.

La matérialisation nécessite un ActorSystem, qui fournit les threads et le répartiteur utilisés par les étapes du flux. Dans les versions modernes d'Akka, le système sert également de matérialiseur implicite.

Un ActorSystem sert généralement une application entière et de nombreux flux concurrents.

La manière la plus directe d'exécuter une source est d'utiliser runWith, qui lui associe un puits et la matérialise en une seule étape, en renvoyant la valeur matérialisée de ce puits.

Ici, le résultat est un Future[Int] qui se termine avec la somme lorsque le flux s'achève.

Si vous avez déjà construit un RunnableGraph fermé avec to ou toMat, appelez run() pour le matérialiser. La valeur renvoyée est la valeur matérialisée conservée par le graphe.

Cela sépare clairement la construction du pipeline de son exécution.

Les sources proposent des raccourcis : runForeach, runFold et runReduce associent chacun le puits correspondant et l'exécutent immédiatement.

Ils sont concis pour les opérations terminales courantes sur une source.

Les puits terminaux renvoient une Future qui se termine lorsque le flux s'achève ou échoue. Enregistrez des fonctions de rappel avec onComplete pour réagir au succès ou à l'erreur.

Utilisez le répartiteur de l'ActorSystem comme ExecutionContext implicite pour ces fonctions de rappel.

Un pipeline de données classique lit depuis une source, transforme les données avec des flux, effectue des entrées-sorties asynchrones avec mapAsync, regroupe les éléments avec grouped et écrit dans un puits.

Chaque étape est petite et l'ensemble est matérialisé par un seul run.

Pour renforcer la résilience, entourez une source ou un flux avec RestartSource.withBackoff afin que les défaillances transitoires (comme une connexion interrompue) déclenchent un redémarrage automatique avec temporisation exponentielle.

Les pipelines d'ingestion de longue durée restent ainsi actifs sans supervision manuelle.

Un KillSwitch permet à du code externe d'arrêter proprement un flux en cours d'exécution. Insérez KillSwitches.single avec viaMat et conservez sa valeur matérialisée pour appeler shutdown() ultérieurement.

C'est essentiel pour les flux de longue durée qui doivent s'arrêter lors de l'arrêt de l'application.

Lorsque l'application se termine, arrêtez l'ActorSystem pour libérer ses threads. Enchaînez l'appel d'arrêt après la Future d'achèvement du flux afin que l'arrêt se déroule correctement.

Une fuite d'ActorSystem maintient la JVM en vie et conserve les ressources ouvertes.

Matérialiser plusieurs fois le même modèle crée des flux indépendants en cours d'exécution qui partagent les ressources de l'ActorSystem. Le modèle lui-même reste immuable et dépourvu d'effets de bord.

Vous pouvez ainsi définir un pipeline une seule fois et l'exécuter à la demande pour chaque tâche entrante.

Exécuter un pipeline signifie matérialiser un modèle avec un ActorSystem via run, runWith ou des opérateurs pratiques, chacun renvoyant un résultat Future.

Vous avez découvert des pipelines réalistes à plusieurs étapes, les redémarrages automatiques avec temporisation, l'arrêt progressif avec KillSwitch, le nettoyage des ressources avec system.terminate() et la réutilisation sûre d'un modèle immuable lors d'exécutions indépendantes.