Implementera Workflow-applikationer med Temporal i Go: En komplett guide

Bygg arbetsflöden i Go med Temporal SDK

Sidinnehåll

Temporal är en öppen källkod, enterprise-nivå arbetsflödesmotor som gör det möjligt för utvecklare att bygga hållbara, skalerbara och feltoleranta arbetsflödesprogram med hjälp av bekanta programmeringsspråk som Go.

Och distribuerade program med komplexa tillståndstransitioner och återförsök kräver ett tillförlitligt orchestration-ramverk.

Den här guiden förklarar hur du implementerar arbetsflödesprogram med Temporal i Go, med täckning av konfiguration, exempelkod, distributionsstrategier, bästa praxis och felsökning.

Go Workplace

Vad är Temporal och varför använda det med Go

Temporal är ett arbetsflödesorchestration-ramverk som är utformat för att bygga feltoleranta, långvariga distribuerade program. Temporal hanterar tillstånd, återförsök, timers och återställning vid fel bakom kulisserna, vilket gör att utvecklare kan fokusera på applikationslogik utan onödiga orchestration-kod. Det stöder Go, bland andra språk, via Temporal Go SDK.

Genom att använda Temporal med Go:

  • Arbetsflöden är hållbara och kan återspelas.
  • Aktivitetsåterförsök och tidsgränser hanteras automatiskt.
  • Systemtillståndet varar kvar vid fel.
  • Orchestration-logiken finns i idiomatisk Go-kod.

Kärnkoncept: Arbetsflöden, Aktiviteter, Arbetare

Före du bygger ditt första Temporal Go-program, förstå dessa viktiga koncept:

Arbetsflöden

Ett Arbetsflöde är hållbar koordination logik som anropar aktiviteter. Det måste vara deterministiskt – Temporal-motorn kan återspela det pålitligt. I Go är arbetsflöden vanliga Go-funktioner med en särskild workflow.Context-parameter.

Aktiviteter

Aktiviteter är enheter av arbete som innehåller icke-deterministiska operationer (I/O, externa API-anrop). Aktiviteter körs utanför arbetsflödet och returnerar resultat tillbaka till arbetsflödeslogiken.

Arbetare

Ett Arbete värd och kör Workflow- och Activity-funktioner. Arbetare pollar Temporal-servrarnas uppgifts köer och bearbetar uppgifter. De måste registrera workflows och aktiviteter innan de startar.

Uppgiftsköer

En Uppgiftskö är hur en arbete mottar uppgifter från Temporal-servern. Arbetsflöden och aktiviteter anger namnet på uppgiftskön de kommer att använda.

Konfigurera ditt Go-projekt med Temporal

Förutsättningar

  • Go (1.16+)
  • Temporal Server (lokalt eller molntjänst)
  • Docker (för lokal server)
  • Beroende go.temporal.io/sdk

Installera Temporal Go SDK

go get go.temporal.io/sdk

Starta Temporal Utvecklingsserver

För lokal utveckling:

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

Eller använd Temporal CLI:

temporal server start-dev

Detta startar Temporal-servern och Web UI som standard.

Konfiguration: Klienter och Uppgiftsköer

Skapa en Temporal-klient

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

Välj en uppgiftskö

Definiera en unik uppgiftskö för din arbete:

const TaskQueue = "order-processing-queue"

Arbete och arbetsflödesinitierare måste använda samma uppgiftsköns namn.

Go-exempel: Arbetsflöden och Aktiviteter

Definiera ett enkelt arbetsflöde

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
}

Definiera en aktivitet

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

Registrera och kör arbetet

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

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

Starta arbetsflödeskörning

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

Distribution av Temporal och Go-arbete

Produktionsdistributionsoptioner

  • Eget värd Temporal-kluster: Ställ in Temporal-tjänster (frontend, history, matching) med varaktig lagring (Cassandra, MySQL).
  • Temporal Cloud: Hanterad Temporal-tjänst med SLA och skalning.
  • Docker Compose eller Kubernetes: För test- eller produktionsmiljöer.

Se till att konfigurera:

  • Varaktig lager
  • Namnomsättning
  • TLS/säker autentisering (API-nycklar, mTLS)

Arbetsflödesutökning

Distribuera flera arbete bakom en belastningsbalanserare. Arbete skalar horisontellt genom att ansluta till samma uppgiftsköer och dela arbetsbelastningen.

Testa arbetsflöden och aktiviteter i Go

Temporal innehåller ett testningsutrustning:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Bekräfta resultat:

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

Testa med testningsutrustning säkerställer arbetsflödeskodens determinism och tillförlitlighet innan distribution.

Bästa praxis för produktion

  • Tidsgränser & återförsökspolicyer: Definiera rimliga tidsgränser och återförsök för aktiviteter och arbetsflöden.
  • Strukturerad loggning: Skapa loggar med spår-ID och korrelationsmetadata.
  • Arbetsflödes-ID: Använd meningsfulla arbetsflödes-ID för spårbarhet.
  • Barnarbetsflöden & ContinueAsNew: Dela komplex logik i modulära utföranden för att minska historia storlek.
  • Mått & övervakning: Integrera med Prometheus eller andra observabilitetsverktyg.

Felsöka vanliga problem

Arbetare som inte pollar

  • Se till att uppgiftsköns namn är korrekt.
  • Bekräfta nätverksanslutning till Temporal-servern.

Arbetsflöde som inte kan starta

  • Validera arbetsflödesregistrering innan arbete startar.
  • Bekräfta klientanslutningsparametrar.

Aktivitetsfel

  • Kontrollera återförsökspolicykonfigurationen.
  • Undersök Web UI för felstacktrådar.

Icke-deterministiska arbetsflödesfel

Temporal kräver deterministisk arbetsflödesutförning. Granska kod för:

  • Användning av math/rand
  • Goroutines inom arbetsflödeslogik
  • Externa systemanrop inom arbetsflöden

Se alltid till att arbetsflöden är ren orchestration-kod medan externa system anropas via aktiviteter.

Att implementera arbetsflödesprogram med Temporal i Go gör det möjligt för dig att bygga tillståndskänsliga, hållbara och skalerbara affärslogik med hjälp av bekanta Go-idiom. Med Temporal’s garanterade utförningsmodell, inbyggda återförsök, uppgiftsköer och stöd för observabilitet kan du fokusera på din kärnapplikationslogik utan att behöva återupptäcka orchestration. Börja med enkla arbetsflöden och aktiviteter, och skala mot komplexa, distribuerade orchestration med självförtroende.

Några användbara länkar