Workflow-Anwendungen mit Temporal in Go implementieren: Eine vollständige Anleitung

Workflows in Go mit dem Temporal SDK erstellen

Inhaltsverzeichnis

Temporal ist ein Open-Source-Workflow-Engine für den Enterprise-Einsatz, die es Entwicklern ermöglicht, langlebige, skalierbare und fehlerresistente Workflow-Anwendungen mit bekannten Programmiersprachen wie Go zu entwickeln.

Verteilte Anwendungen mit komplexen Zustandsübergängen und Wiederholungsversuchen erfordern ein zuverlässiges Orchestrierungs-Framework.

Dieser Leitfaden erläutert, wie man Workflow-Anwendungen mit Temporal in Go implementiert, und behandelt Konfiguration, Beispielcode, Bereitstellungsstrategien, Best Practices und Fehlerbehebung.

Arbeitsplatz für Go

Was ist Temporal und warum sollte man es mit Go verwenden

Temporal ist ein Workflow-Orchestrierungs-Framework, das für den Aufbau fehlerresistenter, langlaufender verteilter Anwendungen konzipiert wurde. Temporal verwaltet Zustände, Wiederholungsversuche, Timer und die Fehlerwiederherstellung im Hintergrund, sodass sich Entwickler auf die Anwendungslogik konzentrieren können, ohne Boilerplate-Code für die Orchestrierung schreiben zu müssen. Es unterstützt Go unter anderem über das Temporal Go SDK.

Durch die Verwendung von Temporal mit Go:

  • Workflows sind langlebig und wiederholbar (replayable).
  • Aktivitäts-Wiederholungsversuche und Timeouts werden automatisch verarbeitet.
  • Der Systemzustand bleibt auch bei Ausfällen erhalten.
  • Die Logik zur Orchestrierung von Aufgaben befindet sich in idiomatischem Go-Code.

Kernkonzepte: Workflows, Activities, Workers

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

Workflows

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

Activities

Activities sind die Arbeitseinheiten, die nicht-deterministische Operationen enthalten (I/O, Aufrufe externer APIs). Activities werden außerhalb des Workflows ausgeführt und geben Ergebnisse an die Workflow-Logik zurück.

Workers

Ein Worker hostet und führt Workflow- und Activity-Funktionen aus. Workers abfragen die Task-Queues des Temporal-Servers und verarbeiten Aufgaben. Sie müssen Workflows und Activities registrieren, bevor sie gestartet werden.

Task Queues

Eine Task Queue ist der Mechanismus, über den ein Worker Aufgaben vom Temporal-Server empfängt. Workflows und Activities geben den Namen der Task-Queue an, die sie verwenden werden.

Einrichten Ihres Go-Projekts mit Temporal

Voraussetzungen

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

Temporal Go SDK installieren

go get go.temporal.io/sdk

Temporal Development Server starten

Für die lokale Entwicklung:

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

Oder verwenden Sie die Temporal CLI:

temporal server start-dev

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

Konfiguration: Clients und Task Queues

Einen Temporal-Client erstellen

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

Eine Task Queue auswählen

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

const TaskQueue = "order-processing-queue"

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

Go-Beispiele: Workflows und Activities

Einen einfachen Workflow definieren

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
}

Eine Activity definieren

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

Worker registrieren und starten

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

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

Workflow-Ausführung starten

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

Bereitstellen von Temporal und Go-Workern

Optionen für die Produktionsbereitstellung

  • Selbst gehosteter Temporal-Cluster: Einrichten von Temporal-Diensten (Frontend, History, Matching) mit persistentem Speicher (Cassandra, MySQL).
  • Temporal Cloud: Verwaltet Temporal-Dienst mit SLA und Skalierung.
  • Docker Compose oder Kubernetes: Für Staging- oder Produktionsumgebungen.

Stellen Sie sicher, Folgendes zu konfigurieren:

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

Worker-Skalierbarkeit

Bereitstellen Sie mehrere Worker hinter einem Load Balancer. Worker skalieren horizontal, indem sie denselben Task-Queues beitreten und die Arbeitslast gemeinsam nutzen.

Testen von Workflows und Activities in Go

Temporal enthält einen 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, "Hallo Tester!", result)

Das Testen mit Test-Suites stellt die Deterministik und Zuverlässigkeit des Workflow-Codes vor der Bereitstellung sicher. Für die Go-Dienste, die die Grundlage für Temporal-Activities bilden – insbesondere solche mit Wiederholungsloops, Kontext-Deadlines und timer-gesteuerter Logik – Testen von konkurrenzfähigem Go-Code mit testing/synctest beschreibt, wie man dieses zeitabhängige Verhalten isoliert unter Verwendung von gefälschten Uhren und isolierten Blasen unit-testet.

Best Practices für die Produktion

  • Timeouts und Retry-Richtlinien: Definieren Sie sinnvolle Timeouts und Wiederholungsversuche für Activities und Workflows.
  • Strukturierte Protokollierung: Geben Sie Logs mit Trace-IDs und Korrelationsmetadaten aus.
  • Workflow-IDs: Verwenden Sie aussagekräftige Workflow-IDs zur Nachverfolgbarkeit.
  • Child Workflows und ContinueAsNew: Zerlegen Sie komplexe Logik in modulare Ausführungen, um die Historiengröße zu reduzieren.
  • Metriken und Überwachung: Integrieren Sie Prometheus oder andere Observability-Tools.
  • Zuverlässige Ereignisveröffentlichung aus Activities: Wenn eine Activity in eine Datenbank schreibt und gleichzeitig einen anderen Dienst benachrichtigen muss, verwenden Sie das transaktionale Outbox-Muster, um zu garantieren, dass das Ereignis nicht zwischen dem Datenbank-Commit und dem Broker-Publish verloren geht.

Fehlerbehebung bei häufigen Problemen

Worker fragt nicht ab

  • Stellen Sie sicher, dass der richtige 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.

Activity-Fehler

  • Überprüfen Sie die Konfiguration der Retry-Richtlinie.
  • Untersuchen Sie die Web-Oberfläche auf Fehler-Stack-Traces.

Nicht-deterministische Workflow-Fehler

Temporal erzwingt eine deterministische Workflow-Ausführung. Überprüfen Sie den Code auf:

  • Verwendung von math/rand
  • Goroutines innerhalb der Workflow-Logik
  • Aufrufe externer Systeme innerhalb von Workflows

Stellen Sie immer sicher, dass Workflows reine Orchestrierungs-Code sind, während externe Systeme über Activities aufgerufen werden.

Die Implementierung von Workflow-Anwendungen mit Temporal in Go ermöglicht es Ihnen, zustandsbehaftete, resiliente und skalierbare Geschäftslogik mit bekannten Go-Idiomen aufzubauen. Mit dem garantierten Ausführungsmodell von Temporal, integrierten Wiederholungsversuchen, Task-Queues und Observability-Unterstützung können Sie sich auf Ihre Kernanwendungslogik konzentrieren, ohne die Orchestrierung neu erfinden zu müssen. Beginnen Sie mit einfachen Workflows und Activities und skalieren Sie mit Zuversicht hin zu komplexer, verteilter Orchestrierung.

Abonnieren

Neue Beiträge zu Systemen, Infrastruktur und KI-Engineering.