Temporal, l'outil parfait pour coder un besoin métier

Dans le développement, une des quêtes les plus complexes est de transcrire fidèlement un besoin métier en code.

Souvent, la logique métier se dilue dans les détails techniques, les opérations manuels, la gestion d'état distribuée, ou pire encore, des workflow dont le process est dilué dans des dizaines de repo GIT.

Temporal.io propose une approche radicalement différente : et si les étapes métier étaient littéralement le code d'exécution ?

1 - Présentation de Temporal

Temporal est un orchestrateur de workflows open-source, je m'en sers souvent pour mes projets perso tant il est simple d'utilisation et extrêmement efficace.

Il permet d’écrire du code métier (dans des langages classiques comme TypeScript, Go, Java ou Python) qui sera exécuté de manière résiliente, durable et observable, tout en étant insensible aux pannes.

La promesse : écrire votre logique métier comme une suite d'étapes synchrones, sans avoir à gérer la persistance, les échecs, les délais ou les redémarrages. Temporal gère le tout.

Un workflow, c’est quoi ?

Dans Temporal, un workflow est une fonction déterministe (qu'on va définir plus loin), qui orchestre des activities (les steps).

Temporal garantit que ce workflow peut reprendre à n'importe quel moment, exactement là où il s’était arrêté, sans double-exécution ni perte d’état.

Architecture : un orchestrateur central et des workers

Temporal repose sur une architecture distribuée très claire :

• Un orchestrateur central (le Temporal Server) gère les workflows, stocke l’état, s’occupe des retries, du scheduling, etc. Il expose aussi une Web UI très pratique pour suivre l’exécution des workflows en temps réel (étapes, logs, erreurs, etc.).

• Des workers, que vous déployez vous-même, exécutent le code métier (les activities). Ce sont eux qui appellent les APIs, écrivent en base, envoient des emails, etc. Les workers sont découplés de l’orchestrateur, ce qui rend l’ensemble très scalable.

L’orchestrateur peut être auto-hébergé ou utilisé via Temporal Cloud. Une fois en place, vous n’avez plus qu’à déployer des workers contenant vos workflows et activities, comme vous le feriez pour une app classique.

2 - Le besoin : transcrire le métier en étapes de code

Quand on modélise un processus métier, ouverture de compte, envoi de notifications, validation de paiement, on pense en étapes :

• Vérifier les infos
• Enregistrer l’utilisateur
• Envoyer un email
• Démarrer une période d’essai

Mais en pratique, quand on implémente ça sans outils adaptés, on finit avec :

• des services asynchrones déclenchés par des événements Kafka,
• des fonctions serverless temporaires
• des scripts cron pour rejouer les échecs
• des bases de données détournées pour stocker de l’état intermédiaire.

Résultat : le code ne ressemble plus du tout au métier.

Temporal inverse cette tendance : il remet la logique métier au centre du code.

Un workflow Temporal est littéralement la traduction des étapes métier dans une fonction de haut niveau, dans le langage du développeur.

3 - Exemple : une inscription utilisateur résiliente

Prenons un processus d’inscription avec vérification email. On veut :

• Créer l'utilisateur en base
• Envoyer un email avec un lien
• Attendre que l'utilisateur clique (jusqu’à 7 jours)
• Activer le compte

En Temporal TypeScript, ce processus se code comme une simple fonction :

export async function signupWorkflow(userData: UserData) {
  const userId = await createUserActivity(userData);
  await sendVerificationEmailActivity(userId);
  const verified = await waitForEmailVerificationSignal({ timeout: '7 days' });

  if (verified) {
    await activateUserAccountActivity(userId);
  } else {
    await deleteUserActivity(userId); // cleanup
  }
}

Ce code est :

• Lisible : chaque ligne reflète une étape métier
• Résilient : une panne serveur ou un crash n’arrête pas le workflow
• Durable : Temporal stocke l’état du workflow de façon fiable
• Testable : le workflow est une fonction testable comme une autre

Et surtout : ce code est exécuté exactement comme vous le lisez, avec la garantie que chaque étape s'exécutera une fois, même en cas de retry.

Le point clé : le déterminisme

Dans Temporal, un workflow est rejoué automatiquement pour reconstruire son état (par exemple après un redémarrage). Pour que cela fonctionne, le code doit être déterministe : à partir des mêmes entrées, il doit produire les mêmes résultats à chaque exécution.

Prenons un cas concret : enregistrer un utilisateur.

INSERT INTO users (email) VALUES (...)
ON CONFLICT DO NOTHING

Cette requête est idempotente : si elle est relancée 20 fois (à cause d’une reprise ou d’une perte réseau), elle n’ajoutera qu’une seule ligne.

Résultat : le workflow reste cohérent, et l’état métier aussi.

Autre exemple : un paiement Stripe avec un payment_id connu.

Vous pouvez enregistrer l’opération comme ceci :

INSERT INTO payments (payment_id, ...) VALUES (...)
ON CONFLICT DO NOTHING

Ensuite, vous vérifiez si le payment_id existe pour décider si l'achat est finalisé. Là encore, l’opération est déterministe car elle renverra toujours le même résultat.

À noter : l’idempotence est souvent un outil pour garantir le déterminisme. Mais le déterminisme va plus loin : même une opération qui ne change rien (ex : Math.random() ou Date.now()) doit être contrôlée pour ne pas produire des valeurs différentes entre deux exécutions du même workflow.

Temporal impose cette rigueur non pas pour embêter les devs, mais pour garantir une fiabilité à toute épreuve : crash serveur, perte de connexion, redémarrage... peu importe. Le workflow reprend là où il s'était arrêté, comme si rien ne s’était passé.

Pourquoi passer à Temporal ?

Temporal n’est pas qu’un outil d'orchestration : c’est une manière de rapprocher la technique du métier.

En permettant d'écrire des workflows qui traduisent littéralement les étapes métier, il devient l’un des outils les plus puissants pour construire des systèmes distribués fiables sans perdre de vue l’intention fonctionnelle.

Temporal a littéralement changé ma façon de coder.

Il a résolu des problématiques que je traînais depuis des années : gestion d’état, retries, timeouts, orchestration, résilience…

On passe souvent beaucoup trop de temps à bricoler des solutions avec RabbitMQ, Kafka, des workers maison, des scripts cron, etc. pour orchestrer des workflows métier. Tout ça devient inutilement complexe.

Avec Temporal, tout est intégré dans une seule plateforme.

Et surtout : ça s’intègre parfaitement avec le reste de votre codebase. Vous importez vos types, vous écrivez vos étapes comme une fonction, et vous avez un système distribué, fiable, lisible et maintenable.

Commencez petit : prenez un process métier, implémentez-le en workflow, et voyez la différence.

C’est bluffant.

Disclaimer: Un ami me fait remarquer que ce n'est pas fait pour la high availability et il a raison. Pour ce besoin, rien ne vous empêche de laisser un Kafka en front pour le système d'acknowledgement et permettre à Temporal de gérer de gros flux entrants.