La technologie financière exige une fiabilité absolue, une intégrité des données et un traitement à faible latence. Les architectures monolithiques traditionnelles peinent souvent face à la complexité de la gestion des transactions longue durée, des nouvelles tentatives et de la cohérence éventuelle. Découvrez Temporal, une plateforme d'orchestration de workflows distribuée qui apporte la relecture déterministe et l'exécution durable aux applications modernes. Dans ce guide, nous explorerons comment construire un moteur de workflow personnalisé en utilisant Go et Temporal, spécifiquement adapté aux transactions financières à haut débit.
Pourquoi Temporal pour les flux de travail financiers ?
Dans le domaine financier, une transaction n'est pas simplement un appel API unique ; c'est un processus avec état impliquant la validation, la détection de fraude, la mise à jour des grands livres et les services de notification. Si une étape échoue, le système doit gérer les nouvelles tentatives sans provoquer d'effets secondaires ni de corruption des données. Temporal résout ce problème en enregistrant l'intégralité de l'historique d'exécution. Si un worker plante lors d'une activité spécifique, Temporal rejoue le workflow depuis le dernier point de contrôle connu, garantissant une sémantique « exactement une fois » même en cas de défaillance de l'infrastructure.
Configuration de l'environnement Go
Pour commencer, assurez-vous d'avoir Go installé (version 1.18 ou supérieure) et l'interface de ligne de commande (CLI) Temporal pour exécuter le serveur localement. Nous définirons la structure de notre workflow à l'aide d'interfaces Go, ce qui permet une séparation propre entre la logique d'orchestration et la logique métier.
package main
import (
"go.temporal.io/sdk/client"
"go.temporal.io/sdk/worker"
"go.temporal.io/sdk/activity"
"context"
)
// Définir la structure d'entrée du workflow
type TransactionInput struct {
TransactionID string
Amount float64
Currency string
}
// Définir la signature de la fonction de workflow
func MyWorkflow(ctx workflow.Context, input TransactionInput) (result string, err error) {
// La logique du workflow va ici
return
}Mise en œuvre de la logique de workflow principale
Le cœur de notre moteur est le workflow lui-même. Nous allons implémenter un workflow de transfert simple qui valide l'entrée, traite le paiement et met à jour le grand livre. Notez l'utilisation de `workflow.ExecuteActivity`. Cela planifie une tâche d'activité, qui est exécutée par un worker de manière asynchrone.
func TransferWorkflow(ctx workflow.Context, input TransactionInput) (string, error) {
ao := workflow.ActivityOptions{
StartToCloseTimeout: 10 * time.Second,
RetryPolicy: &temporal.RetryPolicy{
MaximumAttempts: 3,
},
}
ctx = workflow.WithActivityOptions(ctx, ao)
var validationOutput bool
err := workflow.ExecuteActivity(ctx, ValidateTransaction, input).Get(ctx, &validationOutput)
if err != nil {
return "", err
}
if !validationOutput {
return "Transaction Rejetée", nil
}
// Procéder au traitement du paiement
var paymentResult string
err = workflow.ExecuteActivity(ctx, ProcessPayment, input).Get(ctx, &paymentResult)
if err != nil {
return "", err
}
return paymentResult, nil
}Gestion des activités et des effets secondaires
Les activités sont les blocs de construction de votre logique métier. Ce sont des fonctions sans état qui effectuent des opérations d'E/S, telles que des écritures en base de données ou des appels à des API externes. Dans les applications financières, il est crucial de s'assurer que ces opérations sont idempotentes. Par exemple, l'envoi d'une notification doit être marqué comme un effet secondaire afin qu'il ne soit exécuté qu'une seule fois, même si le workflow est rejoué en raison d'un redémarrage du worker.
En tirant parti de la relecture déterministe de Temporal, vous éliminez le besoin de mécanismes complexes de verrouillage distribué. Le framework garantit que les activités sont exécutées exactement une fois et que les décisions du workflow restent cohérentes entre les redémarrages. Cela simplifie considérablement le code et réduit le risque de conditions de course dans les scénarios à haut débit.
Conclusion
Construire un moteur de workflow personnalisé avec Temporal et Go fournit une base robuste pour gérer des transactions financières complexes. En déléguant la gestion de l'état et la gestion des erreurs à la plateforme Temporal, les développeurs peuvent se concentrer sur la logique métier plutôt que sur l'infrastructure sous-jacente. La combinaison de la performance de Go et de la durabilité de Temporal rend cette pile idéale pour les systèmes financiers à haut débit. À mesure que vous développez votre implémentation, envisagez d'intégrer les fonctionnalités de visibilité de Temporal pour surveiller la santé et les performances des workflows en temps réel, garantissant ainsi que votre moteur financier reste fiable et évolutif sous charge.