Workflowtoepassingen implementeren met Temporal in Go: een compleet gids

Maak workflows in Go met de Temporal SDK

Inhoud

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

En gedistribueerde toepassingen met complexe toestandstransities en herproeven vereisen een betrouwbare orkestratieframework.

Deze gids legt uit hoe je workflow toepassingen kunt implementeren met Temporal in Go, met een overzicht van configuratie, voorbeeldcode, implementatiestrategieën, beste praktijken en probleemoplossing.

Go Workplace

Wat is Temporal en waarom gebruik je het met Go

Temporal is een orkestratieframework voor het bouwen van fouttolerante, lange lopende gedistribueerde toepassingen. Temporal beheert toestand, herproeven, timers en foutherstel in de achtergrond, waardoor ontwikkelaars zich kunnen richten op de toepassingslogica zonder dat er orkestratiecode moet worden geschreven. Het ondersteunt Go, onder andere, via de Temporal Go SDK.

Door Temporal te gebruiken met Go:

  • Workflows zijn duurzaam en herstartbaar.
  • Activiteitenherproeven en time-outs worden automatisch afgehandeld.
  • Systeemtoestand blijft bestaan bij fouten.
  • Taakorkestratie logica bevindt zich in idiomatische Go code.

Kernconcepten: Workflows, Activiteiten, Workers

Voordat je je eerste Temporal Go toepassing bouwt, begrijp deze belangrijke concepten:

Workflows

Een Workflow is duurzame coördinatie logica die activiteiten aanroept. Het moet deterministisch zijn – de Temporal engine kan het betrouwbaar herstarten. In Go zijn workflows gewone Go functies met een speciale workflow.Context parameter.

Activiteiten

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

Workers

Een Worker host en voert Workflow en Activiteitenfuncties uit. Workers vragen taken op bij de taakwachtrij van de Temporal server en verwerken taken. Ze moeten workflows en activiteiten registreren voordat ze worden gestart.

Taakwachtrijen

Een Taakwachtrij is de manier waarop een worker taken ontvangt van de Temporal server. Workflows en activiteiten specificeren de naam van de taakwachtrij die ze zullen gebruiken.

Instellen van je Go project met Temporal

Voorwaarden

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

Installeer Temporal Go SDK

go get go.temporal.io/sdk

Start de Temporal ontwikkelserver

Voor lokale ontwikkeling:

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

Of gebruik de Temporal CLI:

temporal server start-dev

Hiermee wordt de Temporal server en Web UI gestart.

Configuratie: Clients & Taakwachtrijen

Maak een Temporal Client

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

Kies een Taakwachtrij

Definieer een unieke taakwachtrij voor je worker:

const TaskQueue = "order-processing-queue"

Workers en workflow initiators moeten dezelfde taakwachtrij naam gebruiken.

Go voorbeelden: Workflows en Activiteiten

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 Activiteit

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

Registreer en voer de worker uit

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")

Implementatie van Temporal en Go Workers

Productie-implementatieopties

  • Eigen gehoste Temporal cluster: Stel 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 configureert:

  • Persistance laag
  • Namespace instellingen
  • TLS/veilig authenticatie (API-sleutels, mTLS)

Worker schaalbaarheid

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

Testen van workflows en activiteiten in Go

Temporal bevat een test suite:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Assert resultaten:

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

Testen met test suites zorgt ervoor dat workflow-code deterministisch en betrouwbaar is voorafgaand aan implementatie.

Beste praktijken voor productie

  • Time-outs & herproefbeleid: Definieer redelijke time-outs en herproeven voor activiteiten en workflows.
  • Gestructureerde logboekregistratie: Emit logboeken met trace IDs en correlatie metadata.
  • Workflow IDs: Gebruik betekenisvolle workflow IDs voor traceerbaarheid.
  • Child Workflows & ContinueAsNew: Breng complexe logica op in modulaire uitvoeringen om de geschiedenisomvang te verminderen.
  • Metrics & Monitoring: Integreer met Prometheus of andere observabiliteits-tools.

Probleemoplossing van veelvoorkomende problemen

Worker roept niet op

  • Zorg dat de juiste taakwachtrij naam wordt gebruikt.
  • Controleer netwerkconnectiviteit naar de Temporal server.

Workflow kan niet starten

  • Valideer workflow registratie voor het starten van de worker.
  • Controleer clientverbinding parameters.

Activiteitenfouten

  • Controleer herproefbeleid configuratie.
  • Bekijk Web UI voor foutstacktraces.

Niet-deterministische workflow fouten

Temporal dwingt deterministische workflowuitvoering op. Bekijk code op:

  • Gebruik van math/rand
  • Goroutines binnen workflowlogica
  • Externe systeemoproepen binnen workflows

Zorg altijd dat workflows zuivere orkestratiecode zijn terwijl externe systemen worden aangeroepen via activiteiten.

Implementeren van workflow toepassingen met Temporal in Go stelt je in staat om stateful, betrouwbare en schaalbare zakelijke logica te bouwen met bekende Go idioomen. Met de gegarandeerde uitvoeringsmodel van Temporal, ingebouwde herproeven, taakwachtrijen en observabiliteitsondersteuning, kun je je richten op je kern toepassingslogica zonder orkestratie opnieuw uit te moeten vinden. Start met eenvoudige workflows en activiteiten, en schaal naar complexe, gedistribueerde orkestratie met vertrouwen.