Implémenter des applications de workflow avec Temporal en Go : un guide complet

Construisez des workflows en Go avec le SDK Temporal

Sommaire

Temporal est un moteur de workflow open source, à usage 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 familiers comme Go.

Et les applications distribuées avec des transitions d’état complexes et des redémarrages nécessitent un cadre d’orchestration fiable.

Ce guide explique comment implémenter des applications de workflow avec Temporal en Go, couvrant la configuration, le code d’exemple, les stratégies de déploiement, les bonnes pratiques et la résolution des problèmes.

Go Workplace

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

Temporal est un cadre d’orchestration de workflow conçu pour construire des applications distribuées longues durables et tolérantes aux pannes. Temporal gère l’état, les redémarrages, les temporisateurs et la récupération après échec en arrière-plan, permettant aux développeurs de se concentrer sur la logique de l’application sans avoir à écrire du code d’orchestration. Il prend en charge Go, ainsi que d’autres langages, via le Temporal Go SDK.

En utilisant Temporal avec Go :

  • Les workflows sont durables et réexécutables.
  • Les redémarrages et les délais d’activité sont gérés automatiquement.
  • L’état du système persiste malgré les échecs.
  • La logique d’orchestration des tâches réside dans le code Go idiomatique.

Concepts clés : Workflows, Activités, Workers

Avant de créer votre première application Temporal en Go, comprenez ces concepts clés :

Workflows

Un Workflow est une logique de coordination durable qui appelle des activités. Il doit être déterministe – le moteur Temporal peut le réexécuter de manière fiable. En Go, les workflows sont des fonctions Go normales 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 (I/O, appels d’API externes). Les activités s’exécutent en dehors du workflow et retournent 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 s’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 la manière dont 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

Installer le SDK Temporal pour Go

go get go.temporal.io/sdk

Démarrer le serveur de développement Temporal

Pour le développement local :

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

Ou utilisez l’outil 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éer un client Temporal

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

Choisir 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 en Go : Workflows et Activités

Définir 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éfinir une activité

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

Enregistrer et lancer le worker

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

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

Lancer l’exécution du workflow

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

Déploiement de Temporal et de workers Go

Options de déploiement en production

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

Assurez-vous de configurer :

  • Couche de persistance
  • Configuration du namespace
  • TLS/autentification sécurisée (API keys, mTLS)

Échelle des workers

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

Test des workflows et des activités en Go

Temporal inclut un ensemble de tests :

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

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

env.ExecuteWorkflow(SampleWorkflow, "Testeur")

Vérifiez les résultats :

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

Les tests avec suites de tests garantissent la déterminisme et la fiabilité du code de workflow avant le déploiement.

Bonnes pratiques pour la production

  • Délais et politiques de redémarrage : Définissez des délais et des redémarrages sensibles pour les activités et les workflows.
  • Journalisation structurée : Émettez des logs avec des identifiants de trace et des métadonnées de corrélation.
  • ID de workflow : Utilisez des ID de workflow significatifs pour la traçabilité.
  • Workflows enfants et ContinueAsNew : Découpez la logique complexe en exécutions modulaires pour réduire la taille de l’historique.
  • Métriques et surveillance : Intégrez-vous à Prometheus ou à d’autres outils d’observabilité.

Dépannage des problèmes courants

Worker ne poll

  • Vérifiez le nom de la file d’attente.
  • Confirmez la connectivité réseau avec le serveur Temporal.

Workflow ne démarre pas

  • 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 redémarrage.
  • Examinez l’interface Web pour les traces d’erreur.

Erreurs de workflow non déterministe

Temporal impose l’exécution déterministe des workflows. Vérifiez votre code pour :

  • Utilisation de math/rand
  • Goroutines à l’intérieur de la logique de workflow
  • Appels de systèmes externes à l’intérieur des workflows

Assurez-vous toujours que les workflows sont du code d’orchestration pur tout en appelant des systèmes externes 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. Grâce au modèle d’exécution garanti de Temporal, aux redémarrages intégrés, aux files d’attente de tâches et au soutien à l’observabilité, vous pouvez vous concentrer sur votre logique d’application centrale sans avoir à réinventer l’orchestration. Commencez par des workflows et activités simples, puis échelonnez vers une orchestration complexe et distribuée avec confiance.

Liens utiles