L'architecture en microservices introduit souvent de la complexité dans la gestion des transactions distribuées. Bien que les services soient découplés, la coordination de leurs interactions nécessite une orchestration robuste. Temporal répond à ce problème en offrant des capacités d'exécution durable, permettant aux développeurs d'écrire des workflows fiables de manière tolérante aux pannes. Ce guide explore comment tirer parti de Temporal avec Python, Go et TypeScript, créant ainsi un véritable environnement client polyglotte.
La puissance des clients polyglottes
L'une des fonctionnalités les plus fortes de Temporal est ses SDK agnostiques au niveau du langage. Les équipes peuvent choisir le meilleur langage pour chaque service sans sacrifier la cohérence des workflows. Que votre backend principal soit en Go pour la performance, votre couche de traitement des données en Python pour l'analyse, ou votre intégration frontend en TypeScript, Temporal fournit un modèle de programmation unifié utilisant le langage de définition de workflow (WDL).
Définir des workflows en Go
Go est souvent la colonne vertébrale des microservices haute performance. Dans Temporal, un workflow Go est défini comme une fonction régulière. La clé consiste à utiliser la fonction workflow.ExecuteActivity, qui permet d'appeler des activités (fonctions sans état) qui effectuent le travail réel.
package main
import (
"go.temporal.io/sdk/workflow"
)
func MyWorkflow(ctx workflow.Context) error {
ao := workflow.ActivityOptions{
StartToCloseTimeout: 10 * time.Second,
}
ctx = workflow.WithActivityOptions(ctx, ao)
var result string
// Exécuter l'activité et attendre la fin
err := workflow.ExecuteActivity(ctx, GreetActivity, "Hello").Get(ctx, &result)
return err
}
func GreetActivity(ctx context.Context, name string) (string, error) {
return "Salutation : " + name, nil
}
Implémenter des workers en Python
Les développeurs Python bénéficient des décorateurs intuitifs de Temporal. Les décorateurs @workflow.defn et @activity.defn simplifient l'enregistrement des workflows et des activités. Cette approche garde la logique métier propre et sépare le flux de contrôle du workflow de l'implémentation de l'activité.
from temporalio import workflow
from temporalio import activity
from typing import Dict
@activity.defn
async def greet_activity(name: str) -> str:
return f"Salutation : {name}"
@workflow.defn
class MyWorkflow:
@workflow.run
async def run(self, name: str) -> str:
result = await workflow.execute_activity(
greet_activity,
name,
schedule_to_close_timeout=timedelta(seconds=10)
)
return result
Intégration client avec TypeScript
Les clients TypeScript sont idéaux pour les fonctions serverless ou les workers connectés au frontend. Le SDK fournit des interfaces typées qui s'alignent bien avec les pratiques modernes de développement web. Vous pouvez démarrer des workflows et interroger leur statut directement depuis vos applications Node.js.
import { Client } from '@temporalio/client';
async function startWorkflow() {
const client = new Client({
connectionOptions: {
address: 'localhost:7233',
},
});
const handle = await client.start('MyWorkflow', {
taskQueue: 'default',
args: ['World'],
});
console.log(`Workflow démarré avec l'ID : ${handle.workflowId}`);
}
startWorkflow();
Meilleures pratiques pour les environnements polyglottes
Lorsque vous travaillez avec plusieurs langages, la cohérence est essentielle. Assurez-vous que tous les clients utilisent la même version du serveur Temporal pour éviter les problèmes de compatibilité. Utilisez des interfaces partagées ou des schémas Protobuf pour les structures de données transmises entre les activités dans différents langages. Cela permet d'éviter les erreurs de sérialisation et garantit la sécurité des types dans l'ensemble du workflow.
Conclusion
Temporal permet aux développeurs de construire des microservices résilients et évolutifs sans être verrouillés dans un seul écosystème de langage. En tirant parti de Python, Go et TypeScript, les équipes peuvent exploiter les forces de chaque langage tout en maintenant un modèle d'exécution unifié. À mesure que vous adoptez ces modèles, concentrez-vous sur l'exécution durable et la tolérance aux pannes pour fournir des applications robustes capables de résister aux pannes de manière élégante.