Workflowtoepassingen implementeren met Temporal in Go: Een complete gids

Bouw workflows in Go met de Temporal SDK

Inhoud

Temporal is een open-source workflow-engine op enterprise-niveau die ontwikkelaars in staat stelt duurzame, schaalbare en fouttolerante workflow-applicaties te bouwen met behulp van bekende programmeertalen zoals Go.

En gedistribueerde applicaties met complexe staatstransities en herpogingen vereisen een betrouwbare orchestratie-framework.

In deze gids wordt uitgelegd hoe je workflow-applicaties implementeert met Temporal in Go, inclusief configuratie, voorbeeldcode, implementatiestrategieën, best practices en probleemoplossing.

Go Werkplek

Wat is Temporal en waarom gebruiken we het met Go

Temporal is een workflow-orchestratie-framework ontworpen voor het bouwen van fouttolerante, langlopende gedistribueerde applicaties. Temporal beheert status, herpogingen, timers en herstel na falen op de achtergrond, zodat ontwikkelaars zich kunnen concentreren op de applicatielogica zonder boilerplate-orchestratiecode. Het ondersteunt Go, naast andere talen, via de Temporal Go SDK.

Door Temporal met Go te gebruiken:

  • Workflows zijn duurzaam en opnieuw afspeelbaar (replayable).
  • Activiteitsherpoogingen en time-outs worden automatisch afgehandeld.
  • Systeemstatus blijft behouden bij fouten.
  • Orchestratielogica voor taken blijft in idiomatische Go-code.

Kernconcepten: Workflows, Activities, Workers

Voordat je je eerste Temporal Go-applicatie bouwt, moet je deze kernconcepten begrijpen:

Workflows

Een Workflow is duurzame coördinatielogica die activiteiten aanroept. Deze moet deterministisch zijn – de Temporal-engine kan deze betrouwbaar opnieuw afspelen. In Go zijn workflows reguliere Go-functies met een speciale workflow.Context-parameter.

Activities

Activities zijn de eenheden van werk die niet-deterministische operaties bevatten (I/O, externe API-aanroepen). Activities worden buiten de workflow uitgevoerd en keren resultaten terug naar de workflow-logica.

Workers

Een Worker host en voert Workflow- en Activity-functies uit. Workers poll de taakwachtrij van de Temporal-server en verwerken taken. Ze moeten workflows en activities registreren voordat ze starten.

Task Queues

Een Task Queue is hoe een worker taken ontvangt van de Temporal-server. Workflows en activities specificeren de naam van de taakwachtrij die ze zullen gebruiken.

Je Go-project instellen met Temporal

Vereisten

  • Go (1.16+)
  • Temporal Server (lokaal of cloud)
  • Docker (voor lokale server)
  • go.temporal.io/sdk afhankelijkheid

Temporal Go SDK installeren

go get go.temporal.io/sdk

Start de Temporal development server

Voor lokale ontwikkeling:

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

Of gebruik de Temporal CLI:

temporal server start-dev

Hiermee start je standaard de Temporal-server en de Web UI.

Configuratie: Clients & Task Queues

Maak een Temporal Client

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

Kies een Task Queue

Definieer een unieke taakwachtrij voor je worker:

const TaskQueue = "order-processing-queue"

Workers en workflow-initiatoren moeten dezelfde taakwachtrijnaam gebruiken.

Go-voorbeelden: Workflows en Activities

Definieer een eenvoudige 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
}

Definieer een Activity

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

Registreer en start de Worker

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

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

Start Workflow-uitvoering

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

Implementeren van Temporal en Go Workers

Opties voor productie-implementatie

  • Zelf-gehoste Temporal Cluster: Zet Temporal-services (frontend, history, matching) op met persistente opslag (Cassandra, MySQL).
  • Temporal Cloud: Beheerde Temporal-service met SLA en schaalbaarheid.
  • Docker Compose of Kubernetes: Voor staging- of productieomgevingen.

Zorg ervoor dat je het volgende configureert:

  • Persistentielaag
  • Namespace-instelling
  • TLS/veilige authenticatie (API-sleutels, mTLS)

Worker Schaalbaarheid

Implementeer meerdere workers achter een load balancer. Workers schalen horizontaal door deel te nemen aan dezelfde taakwachtrijen en de werklast te delen.

Testen van Workflows en Activities in Go

Temporal bevat een testsuite:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Verifieer resultaten:

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

Testen met testsuites zorgt voor determinisme en betrouwbaarheid van workflow-code voordat deze wordt geïmplementeerd. Voor de Go-services die Tenporal-activities ondersteunen – met name die met herpogingslussen, context-timeouts en timer-gestuurde logica – Concurrente Go-code testen met testing/synctest behandelt hoe je die tijdafhankelijke gedragingen geïsoleerd kunt unit-testen met behulp van nep-klokken en geïsoleerde bubbles.

Best Practices voor Productie

  • Time-outs & Herpogingsbeleid: Definieer zinvolle time-outs en herpogingen voor activities en workflows.
  • Gestructureerde Logging: Log met trace-IDs en correlatiemetadata.
  • Workflow-IDs: Gebruik betekenisvolle workflow-IDs voor traceerbaarheid.
  • Child Workflows & ContinueAsNew: Verdeel complexe logica in modulaire uitvoeringen om de geschiedenisgrootte te verkleinen.
  • Metrics & Monitoring: Integreer met Prometheus of andere observability-tools.
  • Betrouwbare gebeurtenispublicatie vanuit activities: Wanneer een activity naar een database schrijft en ook een andere service moet informeren, gebruik dan het transactionele outbox-patroon om te garanderen dat de gebeurtenis niet verloren gaat tussen de database-commit en het broker-publiceren.

Veelvoorkomende problemen oplossen

Worker Pollt Niet

  • Zorg voor de juiste taakwachtrijnaam.
  • Bevestig netwerkconnectiviteit naar de Temporal-server.

Workflow Start Niet

  • Valideer workflowregistratie voordat de worker start.
  • Bevestig client-verbindingparameters.

Activiteiten Falen

  • Controleer de configuratie van het herpogingsbeleid.
  • Bekijk de Web UI voor foutstacktraces.

Niet-deterministische Workflow-fouten

Temporal handhaaft deterministische workflow-uitvoering. Controleer de code op:

  • Gebruik van math/rand
  • Goroutines binnen workflow-logica
  • Externe systeemoproepen binnen workflows

Zorg altijd dat workflows zuivere orchestratiecode zijn en roep externe systemen aan via activities.

Het implementeren van workflow-applicaties met Temporal in Go stelt je in staat stateful, veerkrachtige en schaalbare businesslogic te bouwen met behulp van bekende Go-idiomen. Met het gegarandeerde uitvoeringsmodel van Temporal, ingebouwde herpogingen, taakwachtrijen en observability-ondersteuning, kun je je concentreren op je kernapplicatielogica zonder orchestratie opnieuw uit te vinden. Begin met eenvoudige workflows en activities, en schaal met vertrouwen naar complexe, gedistribueerde orchestratie.

Abonneren

Ontvang nieuwe berichten over systemen, infrastructuur en AI-engineering.