Mise en œuvre d’applications de flux de travail avec Temporal en Go : un guide complet

Créez des workflows en Go avec le SDK Temporal

Sommaire

Temporal est un moteur de flux de travail (workflow) open source de qualité entreprise qui permet aux développeurs de créer des applications de workflow durables, évolutives et tolérantes aux pannes en utilisant des langages de programmation courants comme Go.

Les applications distribuées avec des transitions d’état complexes et des mécanismes de nouvelle tentative nécessitent un framework d’orchestration fiable.

Ce guide explique comment implémenter des applications de workflow avec Temporal en Go, couvrant la configuration, des exemples de code, les stratégies de déploiement, les bonnes pratiques et le dépannage.

Go Workplace

Qu’est-ce que Temporal et pourquoi l’utiliser avec Go

Temporal est un framework d’orchestration de workflow conçu pour construire des applications distribuées à long terme et tolérantes aux pannes. Temporal gère l’état, les nouvelles tentatives, les minuteries et la récupération après erreur en coulisses, permettant aux développeurs de se concentrer sur la logique de l’application sans écrire de code d’orchestration répétitif. Il prend en charge Go, entre autres langages, via le SDK Go de Temporal.

En utilisant Temporal avec Go :

  • Les workflows sont durables et rejouables.
  • Les nouvelles tentatives et les délais d’expiration des activités sont gérés automatiquement.
  • L’état du système persiste à travers les pannes.
  • La logique d’orchestration des tâches réside dans un code Go idiomatique.

Concepts fondamentaux : Workflows, Activités, Workers

Avant de construire votre première application Temporal en Go, comprennez ces concepts clés :

Workflows

Un Workflow est une logique de coordination durable qui invoque des activités. Il doit être déterministe : le moteur Temporal peut le rejouer de manière fiable. En Go, les workflows sont des fonctions Go régulières avec un paramètre spécial workflow.Context.

Activités

Les Activités sont les unités de travail qui contiennent des opérations non déterministes (E/S, appels d’API externes). Les activités s’exécutent en dehors du workflow et renvoient les résultats à la logique du workflow.

Workers

Un Worker héberge et exécute les fonctions de Workflow et d’Activité. Les workers interrogent les files d’attente de tâches du serveur Temporal et traitent les tâches. Ils doivent enregistrer les workflows et les activités avant de démarrer.

Files d’attente de tâches

Une File d’attente de tâches est le moyen par lequel un worker reçoit des tâches du serveur Temporal. Les workflows et les activités spécifient le nom de la file d’attente de tâches qu’ils utiliseront.

Configuration de votre projet Go avec Temporal

Prérequis

  • Go (1.16+)
  • Serveur Temporal (local ou cloud)
  • Docker (pour le serveur local)
  • Dépendance go.temporal.io/sdk

Installation du SDK Go de Temporal

go get go.temporal.io/sdk

Démarrage du serveur de développement Temporal

Pour le développement local :

docker run -d --network host temporalio/temporal-server

Ou utilisez l’interface en ligne de commande (CLI) Temporal :

temporal server start-dev

Cela démarre le serveur Temporal et l’interface Web par défaut.

Configuration : Clients et Files d’attente de tâches

Création d’un client Temporal

c, err := client.NewClient(client.Options{
    HostPort: "localhost:7233",
})
if err != nil {
    log.Fatal(err)
}
defer c.Close()

Choix d’une file d’attente de tâches

Définissez une file d’attente de tâches unique pour votre worker :

const TaskQueue = "order-processing-queue"

Les workers et les initiateurs de workflow doivent utiliser le même nom de file d’attente de tâches.

Exemples Go : Workflows et Activités

Définition d’un workflow simple

func SampleWorkflow(ctx workflow.Context, input string) (string, error) {
    ao := workflow.ActivityOptions{
        TaskQueue:           TaskQueue,
        ScheduleToCloseTimeout: time.Minute,
    }
    ctx = workflow.WithActivityOptions(ctx, ao)

    var result string
    err := workflow.ExecuteActivity(ctx, SampleActivity, input).Get(ctx, &result)
    if err != nil {
        return "", err
    }
    return result, nil
}

Définition d’une activité

func SampleActivity(ctx context.Context, message string) (string, error) {
    return fmt.Sprintf("Hello %s!", message), nil
}

Enregistrement et exécution du worker

w := worker.New(c, TaskQueue, worker.Options{})
w.RegisterWorkflow(SampleWorkflow)
w.RegisterActivity(SampleActivity)

err = w.Start()
if err != nil {
    log.Fatal(err)
}

Démarrage de l’exécution du workflow

we, err := c.ExecuteWorkflow(context.Background(), client.StartWorkflowOptions{
    ID:        "sample-workflow-id",
    TaskQueue: TaskQueue,
}, SampleWorkflow, "Developer")

Déploiement de Temporal et des workers Go

Options de déploiement en production

  • Cluster Temporal auto-hébergé : Configurez les services Temporal (frontend, history, matching) avec un stockage persistant (Cassandra, MySQL).
  • Temporal Cloud : Service Temporal géré avec SLA et mise à l’échelle.
  • Docker Compose ou Kubernetes : Pour les environnements de préproduction ou de production.

Assurez-vous de configurer :

  • La couche de persistance
  • La configuration des espaces de noms (namespace)
  • L’authentification TLS/sécurisée (clés API, mTLS)

Évolutivité des workers

Déployez plusieurs workers derrière un équilibreur de charge. Les workers montent en charge horizontalement en rejoignant les mêmes files d’attente de tâches et en partageant la charge de travail.

Tests des workflows et activités en Go

Temporal comprend une suite de tests :

testSuite := testsuite.WorkflowTestSuite{}
env := testSuite.NewTestWorkflowEnvironment()

env.RegisterWorkflow(SampleWorkflow)
env.RegisterActivity(SampleActivity)

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Vérification des résultats :

var result string
require.NoError(t, workflowRun.Get(context.Background(), &result))
require.Equal(t, "Hello Tester!", result)

Les tests avec des suites de tests garantissent le déterminisme et la fiabilité du code du workflow avant le déploiement. Pour les services Go qui sous-tendent les activités Temporal — en particulier ceux avec des boucles de nouvelle tentative, des délais de contexte et une logique pilotée par minuterie — Tester le code Go concurrent avec testing/synctest explique comment tester cette dépendance au temps de manière isolée en utilisant des horloges fictives et des bulles isolées.

Bonnes pratiques pour la production

  • Délais d’expiration et politiques de nouvelle tentative : Définissez des délais et des nouvelles tentatives raisonnables pour les activités et les workflows.
  • Journalisation structurée : Émettez des journaux avec des identifiants de trace et des métadonnées de corrélation.
  • Identifiants de workflow : Utilisez des identifiants de workflow significatifs pour la traçabilité.
  • Workflows enfants et ContinueAsNew : Décomposez la logique complexe en exécutions modulaires pour réduire la taille de l’historique.
  • Métriques et surveillance : Intégrez-vous avec Prometheus ou d’autres outils d’observabilité.
  • Publication fiable d’événements depuis les activités : Lorsqu’une activité écrit dans une base de données et doit également notifier un autre service, utilisez le motif de boîte de sortie transactionnelle pour garantir que l’événement n’est pas perdu entre l’engagement de la base de données et la publication du courtier.

Dépannage des problèmes courants

Worker ne pollant pas

  • Assurez-vous d’utiliser le nom de file d’attente de tâches correct.
  • Confirmez la connectivité réseau au serveur Temporal.

Échec du démarrage du workflow

  • Validez l’enregistrement du workflow avant le démarrage du worker.
  • Confirmez les paramètres de connexion du client.

Échecs d’activité

  • Vérifiez la configuration de la politique de nouvelle tentative.
  • Examinez l’interface Web pour les traces de pile d’erreurs.

Erreurs de workflow non déterministe

Temporal impose une exécution déterministe du workflow. Examinez le code pour :

  • L’utilisation de math/rand
  • Les goroutines à l’intérieur de la logique du workflow
  • Les appels de système externe à l’intérieur des workflows

Assurez-vous toujours que les workflows sont du code d’orchestration pur tandis que les systèmes externes sont invoqués via des activités.

L’implémentation d’applications de workflow avec Temporal en Go vous permet de construire une logique métier étatique, résiliente et évolutive en utilisant des idiomes Go familiers. Avec le modèle d’exécution garanti de Temporal, les nouvelles tentatives intégrées, les files d’attente de tâches et le support d’observabilité, vous pouvez vous concentrer sur la logique centrale de votre application sans réinventer l’orchestration. Commencez par des workflows et des activités simples, et évoluez vers une orchestration distribuée complexe en toute confiance.

Liens utiles

S'abonner

Recevez de nouveaux articles sur les systèmes, l'infrastructure et l'ingénierie IA.