Workflow-Anwendungen mit Temporal in Go implementieren: Ein umfassender Leitfaden

Temporal ist ein quelloffenes, enterprise-gradiges Workflow-Engine, das Entwicklern ermöglicht, widerstandsfähige, skalierbare und fehlertolerante Workflow-Anwendungen mit vertrauten Programmiersprachen wie Go zu erstellen.

Und verteilte Anwendungen mit komplexen Zustandsübergängen und Wiederholungen benötigen einen zuverlässigen Orchestrierungsrahmen.

Dieser Leitfaden erklärt, wie man Workflow-Anwendungen mit Temporal in Go implementiert, wobei Konfiguration, Beispielcode, Bereitstellungsstrategien, Best Practices und Fehlerbehebung abgedeckt werden.

Was ist Temporal und warum sollte man es mit Go verwenden

Temporal ist ein Workflow-Orchestrierungsrahmen, der für das Erstellen fehlertoleranter, langer laufender verteilter Anwendungen konzipiert wurde. Temporal verwaltet den Zustand, Wiederholungen, Timer und Fehlerwiederherstellung im Hintergrund, wodurch Entwickler sich auf die Anwendungslogik konzentrieren können, ohne Orchestrierungscode zu schreiben. Es unterstützt Go, unter anderem, über den Temporal Go SDK.

Durch die Verwendung von Temporal mit Go:

• Workflows sind widerstandsfähig und wiederholbar.
• Aktivitätswiederholungen und Timeout werden automatisch verwaltet.
• Der Systemzustand besteht durch Fehler.
• Die Orchestrierungslogik befindet sich in idiomatischem Go-Code.

Kernkonzepte: Workflows, Aktivitäten, Worker

Bevor Sie Ihre erste Temporal Go-Anwendung erstellen, verstehen Sie diese Schlüsselkonzepte:

Workflows

Ein Workflow ist eine widerstandsfähige Koordinationslogik, die Aktivitäten aufruft. Er muss deterministisch sein – der Temporal-Engine kann ihn zuverlässig wiederholen. In Go sind Workflows reguläre Go-Funktionen mit einem besonderen workflow.Context-Parameter.

Aktivitäten

Aktivitäten sind die Einheiten der Arbeit, die nichtdeterministische Operationen enthalten (I/O, externe API-Aufrufe). Aktivitäten werden außerhalb des Workflows ausgeführt und geben Ergebnisse zurück an die Workflow-Logik.

Worker

Ein Worker hostet und führt Workflow- und Aktivitätenfunktionen aus. Worker befragen die Taskqueues des Temporal-Servers und verarbeiten Aufgaben. Sie müssen Workflows und Aktivitäten vor dem Start registrieren.

Task Queues

Eine Task Queue ist die Methode, wie ein Worker von der Temporal-Server-Aufgaben erhält. Workflows und Aktivitäten geben den Namen der Task Queue an, die sie verwenden.

Einrichten Ihres Go-Projekts mit Temporal

Voraussetzungen

• Go (1.16+)
• Temporal Server (lokal oder Cloud)
• Docker (für lokalen Server)
• Abhängigkeit go.temporal.io/sdk

Installieren Sie das Temporal Go SDK

go get go.temporal.io/sdk

Starten Sie den Temporal-Entwicklungs-Server

Für lokale Entwicklung:

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

Oder verwenden Sie die Temporal CLI:

temporal server start-dev

Dies startet den Temporal-Server und die Web-Oberfläche standardmäßig.

Konfiguration: Clients und Task Queues

Erstellen Sie einen Temporal-Client

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

Wählen Sie eine Task Queue

Definieren Sie eine eindeutige Task Queue für Ihren Worker:

const TaskQueue = "order-processing-queue"

Worker und Workflow-Initiatoren müssen den gleichen Task Queue-Namen verwenden.

Go-Beispiele: Workflows und Aktivitäten

Definieren Sie einen einfachen Workflow

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
}

Definieren Sie eine Aktivität

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

Registrieren und starten Sie den Worker

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

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

Starten Sie die Workflow-Ausführung

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

Bereitstellen von Temporal und Go-Worker

Produktionsbereitstellungsoptionen

• Eigenhosteter Temporal-Cluster: Richten Sie Temporal-Dienste (Frontend, History, Matching) mit persistenter Speicherung (Cassandra, MySQL) ein.
• Temporal Cloud: Verwalteter Temporal-Dienst mit SLA und Skalierung.
• Docker Compose oder Kubernetes: Für Staging- oder Produktionsumgebungen.

Stellen Sie sicher, dass konfiguriert ist:

• Persistenzschicht
• Namespace-Einrichtung
• TLS/sichere Authentifizierung (API-Schlüssel, mTLS)

Worker-Skalierbarkeit

Stellen Sie mehrere Worker hinter einem Lastenausgleicher bereit. Worker skalieren horizontal, indem sie sich dem gleichen Task Queue anschließen und die Last teilen.

Testen von Workflows und Aktivitäten in Go

Temporal enthält ein Test-Suite:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Ergebnisse prüfen:

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

Testen mit Test-Suites stellt die Determinismus und Zuverlässigkeit der Workflow-Code vor der Bereitstellung sicher.

Best Practices für die Produktion

• Zeitlimit und Wiederholungsrichtlinien: Definieren Sie sinnvolle Zeitlimit und Wiederholungen für Aktivitäten und Workflows.
• Strukturierte Protokollierung: Emitieren Sie Protokolle mit Trace-IDs und Korrelations-Metadaten.
• Workflow-IDs: Verwenden Sie sinnvolle Workflow-IDs für Nachverfolgbarkeit.
• Child Workflows & ContinueAsNew: Zerlegen Sie komplexe Logik in modulare Ausführungen, um die Historiegröße zu verringern.
• Metriken & Monitoring: Integrieren Sie mit Prometheus oder anderen Observabilitäts-Tools.

Fehlerbehebung bei häufigen Problemen

Worker meldet keine Aufgaben

• Stellen Sie sicher, dass der korrekte Task Queue-Name verwendet wird.
• Bestätigen Sie die Netzwerkverbindung zum Temporal-Server.

Workflow startet nicht

• Validieren Sie die Workflow-Registrierung vor dem Start des Workers.
• Bestätigen Sie die Client-Verbindungsparameter.

Aktivitätsfehler

• Prüfen Sie die Wiederholungsrichtlinien-Konfiguration.
• Untersuchen Sie die Web-Oberfläche für Fehler-Stacktraces.

Nichtdeterministische Workflow-Fehler

Temporal erzwingt deterministische Workflow-Ausführung. Prüfen Sie den Code auf:

• Verwendung von math/rand
• Goroutinen innerhalb der Workflow-Logik
• Externe Systemaufrufe innerhalb der Workflows

Stellen Sie sicher, dass Workflows immer reine Orchestrierungscode sind, während externe Systeme über Aktivitäten aufgerufen werden.

Die Implementierung von Workflow-Anwendungen mit Temporal in Go ermöglicht es Ihnen, stateful, resiliente und skalierbare Geschäftslogik mit vertrauten Go-Idiomen zu erstellen. Mit Temporal’s garantiertem Ausführungsmodell, eingebauten Wiederholungen, Task Queues und Unterstützung für Observabilität können Sie sich auf Ihre Kernanwendungslogik konzentrieren, ohne Orchestrierung erneut zu erfinden. Beginnen Sie mit einfachen Workflows und Aktivitäten und skalieren Sie zu komplexen, verteilten Orchestrierungen mit Sicherheit.

Nützliche Links

• Go Cheatsheet
• Apache Airflow für MLOPS und ETL – Beschreibung, Vorteile und Beispiele
• Kernanwendung – Go SDK. Temporal-Plattformdokumentation
• Temporal Go SDK-Beispiele
• Zuverlässige Workflows mit Temporal in Go – Wesentliche Best Practices
• Ein Temporal-Anwendung von Grund auf in Go erstellen