Guide

Temporal : un processus qui survit au redémarrage d'un serveur

Temporal exécute des processus durables en plusieurs étapes qui survivent aux pannes : workflows, activités, signaux, versionnage, tarifs, agents IA, alternatives.

L'équipe CodeWorlds16 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article11

Un processus de sept étapes où chacune peut échouer est un cauchemar dans du code ordinaire. Il faut conserver l'état après chaque étape, gérer les nouvelles tentatives, prévoir ce qui se passe quand le serveur meurt entre les étapes quatre et cinq, et s'assurer qu'une nouvelle tentative ne prélève pas deux fois le paiement.

Temporal inverse ce problème. Vous écrivez le processus comme une fonction ordinaire avec des boucles et des conditions, et la plateforme enregistre l'historique d'exécution et le rejoue après une panne. Une fonction interrompue en plein milieu reprend au même endroit, chaque variable ayant sa valeur.

Ce que signifie l'exécution durable

Le rejeu est la clé. La plateforme n'enregistre pas l'état des variables mais un historique d'événements : ce qui a été appelé et ce que cela a renvoyé. Après une panne, elle exécute la fonction depuis le début et, au lieu de refaire les étapes, elle substitue les résultats de l'historique jusqu'à atteindre le point d'interruption.

Cette construction a une conséquence qu'il faut comprendre, car toutes les limitations en découlent. Le code d'un workflow doit être déterministe : avec les mêmes événements, il doit exécuter les mêmes étapes dans le même ordre. Sinon le rejeu diverge de l'historique.

En pratique, cela signifie qu'un workflow ne peut pas lire l'heure actuelle, tirer un nombre aléatoire ni appeler directement une interface externe. Ces choses se passent dans des activités, c'est-à-dire des fonctions appelées depuis le workflow dont les résultats entrent dans l'historique.

La séparation entre workflow et activité est donc le concept fondamental. Un workflow est de la logique : ce qui suit quoi, sous quelle condition, combien de nouvelles tentatives. Une activité est une action à effet extérieur : un appel d'interface, une écriture en base, un message envoyé.

Votre premier workflow

TypeScript
import { proxyActivities, sleep } from '@temporalio/workflow'
import type * as activities from './activities'

const { chargePayment, sendConfirmation, reserveStock } =
  proxyActivities<typeof activities>({
    startToCloseTimeout: '1 minute',
    retry: { maximumAttempts: 5 }
  })

export async function fulfilOrder(orderId: string) {
  await reserveStock(orderId)
  const payment = await chargePayment(orderId)

  await sleep('2 hours')
  await sendConfirmation(orderId, payment.id)

  return { status: 'fulfilled' }
}

La pause de deux heures ne bloque aucun processus. La plateforme enregistre le moment de reprise, libère les ressources et exécute de nouveau la fonction deux heures plus tard, en reconstruisant l'état depuis l'historique. La même construction gère une pause de trente jours.

La configuration des nouvelles tentatives se trouve sur la déclaration de l'activité, donc il n'y a pas de boucle avec délai croissant à écrire. Une activité en échec est retentée selon la politique, et le workflow n'en sait rien.

C'est l'économie principale. Le code se lit comme une description du processus, et tout ce qui prend d'habitude les trois quarts de l'implémentation se passe en dehors.

La compensation au lieu des transactions

Un processus qui touche plusieurs systèmes n'a pas de transaction distribuée. Quand l'étape trois échoue, les effets des étapes un et deux doivent être annulés, et c'est un travail qu'il faut concevoir.

TypeScript
export async function fulfilOrder(orderId: string) {
  const undo: Array<() => Promise<void>> = []

  try {
    await reserveStock(orderId)
    undo.push(() => releaseStock(orderId))

    const payment = await chargePayment(orderId)
    undo.push(() => refundPayment(payment.id))

    await dispatchShipment(orderId)
  } catch (error) {
    for (const step of undo.reverse()) await step()
    throw error
  }
}

Ce motif est la seule façon raisonnable de gérer des processus qui couvrent de nombreux systèmes. La plateforme ne le fait pas pour vous, et elle permet de l'écrire lisiblement, car le code de compensation se trouve à côté du code principal plutôt que dans un mécanisme de reprise séparé.

Concevez les étapes de façon qu'elles puissent se répéter sans effets de bord. Une activité appelée deux fois avec le même identifiant doit effectuer l'opération une seule fois, car les nouvelles tentatives sont ici la norme et non l'exception.

Signaux et requêtes

Un processus qui dure des semaines doit accepter des informations de l'extérieur et répondre à des questions sur son état.

TypeScript
import { defineSignal, defineQuery, setHandler, condition } from '@temporalio/workflow'

const approve = defineSignal<[string]>('approve')
const status = defineQuery<string>('status')

export async function approvalProcess(requestId: string) {
  let decision: string | null = null
  setHandler(approve, (who) => { decision = who })
  setHandler(status, () => decision ? 'approved' : 'pending')

  const arrived = await condition(() => decision !== null, '7 days')
  if (!arrived) return { status: 'expired' }

  await executeRequest(requestId)
  return { status: 'executed', approvedBy: decision }
}

Un signal apporte une information dans un processus en cours, et une requête lit l'état sans l'affecter. Ce mécanisme remplace l'interrogation d'une base en boucle et prend en charge des processus dont une étape attend une décision humaine.

Le même motif sert aux agents avec un modèle de langage, quand une action irréversible demande une approbation. Le processus se met en pause, une personne approuve, le processus continue, le tout sans que vous ayez à maintenir un état dans une base.

Versionnage des workflows

Ce sujet paraît théorique au premier déploiement et devient le plus important au troisième.

Le problème découle directement du rejeu. Un processus démarré il y a une semaine et repris aujourd'hui est rejoué contre le code qui se trouve maintenant dans le dépôt. Si quelqu'un a ajouté une étape au milieu entre-temps, le rejeu rencontre dans l'historique des événements que le nouveau code n'attend pas.

TypeScript
import { patched } from '@temporalio/workflow'

export async function fulfilOrder(orderId: string) {
  await reserveStock(orderId)

  if (patched('address-verification')) {
    await verifyAddress(orderId)
  }

  await chargePayment(orderId)
}

Le marqueur permet aux nouveaux processus d'exécuter l'étape supplémentaire tandis que les anciens la sautent, donc les deux versions se rejouent correctement. Une fois tous les anciens processus terminés, le marqueur peut disparaître.

L'alternative est le versionnage par le nom : une nouvelle version du workflow prend un nouveau nom et l'ancienne tourne jusqu'à l'expiration des processus démarrés. C'est plus simple pour de gros changements, au prix de deux versions de code dans le dépôt pendant un temps.

La règle pratique : sur des processus qui durent des heures, les changements comportent peu de risque ; sur des processus qui durent des semaines, chaque changement exige une décision sur ce qui est déjà en cours. Pesez cela à la conception, car un processus de trente jours signifie trente jours de rétrocompatibilité.

Visibilité et diagnostic

L'un des avantages les moins évidents est que l'état de chaque processus est visible sans écrire votre propre journalisation.

L'interface montre l'historique d'exécution : quelle étape s'est exécutée, ce qu'elle a renvoyé, combien de fois elle a été retentée et où en est le processus maintenant. Quand on signale qu'une commande est bloquée, répondre à « où en est-elle » prend quelques secondes au lieu d'une recherche dans des journaux.

La deuxième chose est l'intervention manuelle. Un processus peut être mis en pause, terminé, remis à un événement choisi ou recevoir un signal. C'est parfois la seule issue raisonnable quand un service externe a renvoyé quelque chose que personne n'avait prévu.

La troisième est que l'historique est complet par définition. Il n'y a pas de cas où quelqu'un oublie de journaliser une étape, car l'enregistrement est produit automatiquement et c'est la base du fonctionnement et non un ajout. Sur des processus qui touchent de l'argent, cette propriété est parfois un argument en soi, car elle donne une piste d'audit sans travail séparé.

Faites attention à la rétention, cependant. L'historique occupe du stockage et est facturé, donc à grand volume vous devez décider combien de temps les processus terminés sont conservés. Sur la version managée, la durée de rétention atteint quatre-vingt-dix jours, et garder l'historique plus longtemps signifie l'exporter hors de la plateforme, où l'export lui-même génère des actions et atterrit sur la facture.

Tarifs et déploiement

VarianteCoûtCe que couvre le prix
Open source auto-hébergé0 USDServeur, base de données et maintenance à votre charge
Cloud Essentialsà partir de 100 USD par mois1 M d'actions, 1 Go de stockage actif, 40 Go conservés
Cloud Businessà partir de 500 USD par mois2,5 M d'actions, 2,5 Go et 100 Go, remises d'engagement
Cloud Enterprise et Mission Criticalsur devis, durée annuelle10 M d'actions chacun, 10 Go et 400 Go, garanties de support renforcées

La facturation managée combine des frais de forfait avec un usage compté en actions. Une action est une opération facturable précise : démarrer un workflow, exécuter ou retenter une activité, démarrer un minuteur, un signal, une mise à jour et une requête. Ce n'est pas la même chose que chaque événement de l'historique, et la différence joue en votre faveur : rejouer un workflow après une panne ne génère aucune action, et chaque activité locale au sein d'une même tâche de workflow compte pour une. Un workflow avec dix activités et cinq nouvelles tentatives génère tout de même plus que ne le suggère le nombre d'étapes, car chaque nouvelle tentative est une action séparée.

Les frais du forfait ne sont pas non plus un abonnement ordinaire ajouté à l'usage, et c'est là que les budgets dérapent le plus facilement. Vous payez le plus élevé de deux montants : le minimum du forfait ou un pourcentage de votre facture de consommation, cinq pour cent sur Essentials et dix sur Business. L'allocation incluse d'actions et de stockage entre dans ce montant, et vous ne payez séparément que le dépassement, à 50 dollars pour le premier million d'actions supplémentaires, avec des remises qui tombent à 25 dollars aux gros volumes.

La version open source est gratuite et demande un serveur, une base de données et de la maintenance. Pour une équipe, ce coût dépasse généralement l'abonnement ; dans une grande organisation, la proportion s'inverse. Des changements récents ont aussi ajouté l'exécution de workers dans un environnement serverless, ce qui change l'arithmétique sous charge inégale. Vérifiez toutefois le stade : la variante AWS Lambda est entrée en préversion publique en août 2026, et celle pour Google Cloud Run est à un stade de prérelease encore plus précoce.

Vérifiez les paliers actuels avant de budgéter, car la structure des forfaits change de temps en temps.

Temporal face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
TemporalExécution durable, processus de plusieurs semaines, visibilité de l'étatExigence de déterminisme, coût de mise en placeProcessus en plusieurs étapes qui touchent de l'argent
File de jobsSimple, familière, peu chèreVous écrivez vous-même l'état et les nouvelles tentativesTâches de fond isolées
n8n ou MakeVisuel, rapide à déployerMoins de contrôle, plus faible sur la logique complexeAutomatisations qui relient des services
Votre propre machine à étatsContrôle totalVous maintenez ce que la plateforme donne tout faitProcessus simple en deux étapes
AirflowPlanification, graphe de dépendances, intégrations maturesPipelines récurrents plutôt que processus à la demandeTraitement de données à heures fixes

Choisir entre les deux premières lignes dépend du nombre d'étapes du processus et de ce qui se passe s'il échoue à mi-chemin. Envoyer un message en arrière-plan est un travail pour une file. Un processus qui couvre la réservation, le paiement, l'expédition et la notification, où chaque étape peut échouer et où une exécution partielle signifie un problème d'argent, est le cas où la plateforme se rembourse vite.

La troisième ligne est une autre catégorie. Les outils d'automatisation conviennent pour relier des services prêts à l'emploi plutôt que pour des processus à la logique élaborée et à l'exigence d'exécution exactement une fois.

Il vaut aussi la peine de compter honnêtement le coût d'entrée. La plateforme introduit des concepts que l'équipe doit apprendre : la séparation entre workflows et activités, le déterminisme, le versionnage, les processus workers. C'est une semaine ou deux avant que le premier processus arrive en production, et encore un mois avant que l'équipe cesse de trébucher sur le déterminisme.

Si ce coût paraît disproportionné au problème, une couche intermédiaire existe. Trigger.dev donne des tâches de fond sans limite de temps d'exécution, des nouvelles tentatives et une vue de chaque exécution, sans le concept de déterminisme et sans découper le code en workflows et activités. Ce qu'il ne donne pas, c'est une garantie d'exécution exactement une fois au sens de cette plateforme, donc pour des processus qui déplacent l'argent des autres, la différence compte.

Dans la même catégorie se trouve Inngest, qui diffère par son modèle : au lieu d'invoquer directement une tâche, vous envoyez un événement et les fonctions y réagissent d'elles-mêmes. Le contrôle de flux vient avec, ce que les autres outils n'offrent pas pleinement : des limites de simultanéité par clé, du throttling et du debounce. Vérifiez cependant la licence du serveur avant de choisir, car c'est la Server Side Public License, qui exige de publier le code source du service quand vous proposez cette fonctionnalité à des tiers comme service.

Ce coût se rembourse au troisième processus plutôt qu'au premier. Si l'on ne prévoit qu'un workflow et rien de plus, une solution plus simple suffit généralement. Si le backend contiendra une douzaine de processus qui touchent des paiements, des commandes et des intégrations externes, une plateforme commune évite d'écrire le même mécanisme une douzaine de fois.

La dernière ligne est entrée dans le tableau non parce qu'elle concurrence mais parce qu'on confond les deux. Un orchestrateur de pipelines de données planifie un traitement répété à heures fixes ou après un événement et montre ce qui est passé. L'exécution durable gère un processus démarré une fois par commande qui peut attendre une semaine un paiement. Le recouvrement est petit, et se tromper de catégorie coûte une réécriture, car tordre un outil pour lui faire faire le travail de l'autre est faisable et jamais maintenable.

Utilisation avec des agents

Les tâches d'agents se sont révélées l'un des usages les plus naturels de cette plateforme, et il est utile de comprendre pourquoi.

Un agent qui fait dix appels au modèle et aux outils est un processus en plusieurs étapes où chaque étape peut échouer et où tout répéter coûte des tokens. Reprendre à l'étape sept plutôt qu'à l'étape un fait économiser en proportion directe de l'avancement du processus.

La deuxième chose est le temps. Une tâche d'agent peut durer un quart d'heure et, avec des outils qui attendent une réponse humaine, des jours. Garder cela dans la mémoire d'un processus serveur est fragile ; dans ce modèle c'est naturel.

Python
@workflow.defn
class ResearchAgent:
    @workflow.run
    async def run(self, question: str) -> str:
        plan = await workflow.execute_activity(
            plan_steps, question, start_to_close_timeout=timedelta(minutes=2)
        )

        results = []
        for step in plan.steps:
            results.append(await workflow.execute_activity(
                run_step, step, start_to_close_timeout=timedelta(minutes=5)
            ))

        return await workflow.execute_activity(compose_answer, results)

Les appels au modèle vont dans des activités, car ils sont non déterministes. Les boucles et les conditions restent dans le workflow, donc la logique du processus se lit clairement et la résilience vient gratuitement.

Des bibliothèques d'agents comme PydanticAI et LangGraph fournissent des intégrations avec cette plateforme, donc l'adaptateur n'a pas à être écrit par vous. Vérifiez cela avant de construire le vôtre.

Erreurs courantes

La première, c'est du code non déterministe dans un workflow. Lire l'heure actuelle, tirer un nombre aléatoire ou appeler directement une interface depuis un workflow casse le rejeu, et le bug n'apparaît qu'après une panne, c'est-à-dire au pire moment.

La deuxième, ce sont des activités sans protection contre la répétition. Les nouvelles tentatives sont normales ici, donc une activité qui prélève un paiement sans clé d'idempotence facture deux fois le client.

La troisième, c'est de modifier le code d'un workflow pendant que des processus tournent. Un processus d'une semaine est rejoué contre le nouveau code, donc réordonner les étapes diverge de l'historique. Le versionnage des workflows existe pour cela et doit être appliqué dès le début plutôt qu'après le premier incident.

La quatrième, ce sont des activités trop fines. Chacune génère des événements d'historique, donc un workflow avec mille petits appels coûte plus cher et se rejoue plus lentement qu'un avec dix appels significatifs.

La cinquième, ce sont des délais d'expiration manquants. Une activité sans délai peut se bloquer indéfiniment, bloquant le processus sans rien signaler.

La sixième, c'est de recourir à la plateforme pour des tâches qui sont une simple file. Le coût de mise en place et de maintenance a du sens sur des processus complexes et est disproportionné pour une seule étape de fond.

FAQ

À quoi sert exactement Temporal ?

À exécuter des processus en plusieurs étapes de façon qu'ils survivent aux pannes : un redémarrage de serveur, une erreur réseau, un service externe indisponible. Un processus interrompu reprend là où il s'est arrêté avec l'état de ses variables, donc il n'y a pas de persistance manuelle après chaque étape.

Temporal est-il gratuit ?

La version open source l'est, et vous l'exploitez vous-même, en payant par les coûts de serveur, de base de données et de maintenance. La version managée démarre à cent dollars par mois sur le forfait Essentials, avec un million d'actions et une allocation de stockage inclus, et vous ne complétez que le dépassement. Un nouveau compte reçoit mille dollars de crédits valables quatre-vingt-dix jours.

Pourquoi un workflow doit-il être déterministe ?

Parce que le rejeu après une panne signifie exécuter de nouveau la fonction avec des résultats substitués depuis l'historique. Un code qui prendrait des étapes différentes avec les mêmes événements diverge de l'enregistrement. Les choses non déterministes, l'heure et les appels externes compris, vont dans des activités.

Convient-il aux agents avec un modèle de langage ?

Oui, et c'est un usage en croissance. Une tâche d'agent se compose de nombreux appels, chacun peut échouer, et tout répéter à zéro coûte des tokens. Reprendre au point d'interruption économise de l'argent, et le mécanisme des signaux gère la pause pour une décision humaine avant une action irréversible.

Quels langages sont pris en charge ?

TypeScript, Go, Java, Python, PHP, .NET, Ruby et Rust, ce dernier en préversion publique, avec le même modèle conceptuel dans chacun. Des processus écrits dans des langages différents peuvent s'appeler mutuellement, ce qui aide avec un backend composé de plusieurs services.

La documentation se trouve sur le site du projet, et le détail de la facturation sur la page des tarifs du cloud.

À lire aussi