Att implementera arbetsflödesapplikationer med Temporal i Go: En komplett guide

Skapa arbetsflöden i Go med Temporal SDK

Sidinnehåll

Temporal är en öppen källkodsarbetsflödesmotor av företagsklass som möjliggör för utvecklare att bygga varaktiga, skalbara och feltoleranta arbetsflödesapplikationer med hjälp av välkända programmeringsspråk som Go.

Distribuerade applikationer med komplexa statövergångar och återförsök kräver ett pålitligt orchestreringsramverk.

Den här guiden förklarar hur du implementerar arbetsflödesapplikationer med Temporal i Go, och täcker 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 orchestreringsramverk för arbetsflöden som är designat för att bygga feltoleranta, långvariga distribuerade applikationer. Temporal hanterar tillstånd, återförsök, tidtagare och felåterhämtning i bakgrunden, vilket låter utvecklare fokusera på applikationslogik utan boilerplate-kod för orchestriering. Det stödjer Go, bland andra språk, via Temporal Go SDK.

Genom att använda Temporal med Go:

  • Arbetsflöden är varaktiga och återuppspelbara.
  • Återförsök och timeout för aktiviteter hanteras automatiskt.
  • Systemtillståndet bevaras vid fel.
  • Logik för orchestriering av uppgifter finns i idiomatisk Go-kod.

Grundläggande koncept: Arbetsflöden, aktiviteter, arbetare

Innan du bygger din första Temporal Go-applikation, förstå dessa nyckelkoncept:

Arbetsflöden

Ett Arbetsflöde är varaktig koordineringslogik som anropar aktiviteter. Det måste vara deterministiskt – Temporal-motorn kan spela upp det på ett pålitligt sätt. I Go är arbetsflöden vanliga Go-funktioner med en speciell workflow.Context-parameter.

Aktiviteter

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

Arbetare

En Arbetare värdar och exekverar Workflow- och Activity-funktioner. Arbetare pollar Temporal-serverns uppgiftsköer och bearbetar uppgifter. De måste registrera arbetsflöden och aktiviteter innan de startar.

Uppgiftsköer

En Uppgiftskö är hur en arbetare mottar uppgifter från Temporal-servern. Arbetsflöden och aktiviteter specificerar namnet på den uppgiftskö de ska använda.

Ställa in ditt Go-projekt med Temporal

Förutsättningar

  • Go (1.16+)
  • Temporal Server (lokal eller moln)
  • Docker (för lokal server)
  • go.temporal.io/sdk-beroende

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 webbläsargränssnittet som standard.

Konfiguration: Kunder 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 arbetare:

const TaskQueue = "order-processing-queue"

Arbetare och arbetsflödesinitiatorer måste använda samma uppgiftskö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 arbetaren

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

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

Starta arbetsflödesexekvering

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

Distribuera Temporal och Go-arbetare

Alternativ för produktiondistribution

  • Självhostad Temporal-cluster: Stoppa upp Temporal-tjänster (frontend, history, matching) med persistent lagring (Cassandra, MySQL).
  • Temporal Cloud: Hanterad Temporal-tjänst med SLA och skalning.
  • Docker Compose eller Kubernetes: För stegrings- eller produktionsmiljöer.

Se till att konfigurera:

  • Persistenta lager
  • Namespace-inställningar
  • TLS/säker autentisering (API-nycklar, mTLS)

Skalbarhet för arbetare

Distribuera flera arbetare bakom en lastbalansering. Arbetare skalar horisontellt genom att gå med i samma uppgiftsköer och dela arbetsbelastningen.

Testa arbetsflöden och aktiviteter i Go

Temporal inkluderar en testsvit:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Påstå resultat:

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

Testning med testsviter säkerställer determinism och pålitlighet i arbetsflödeskoden innan distribution. För de Go-tjänster som ligger till grund för Temporal-aktiviteter – särskilt de med återförsöksslingor, kontextdeadlinear och tidstyr logik – Testing Concurrent Go Code with testing/synctest täcker hur man enhetstestar den tidberoende beteendet i isolering med falska klockor och isolerade bubblor.

Bästa praxis för produktion

  • Timeouts & Återförsökspolicyer: Definiera rimliga timeouts och återförsök för aktiviteter och arbetsflöden.
  • Strukturerad loggning: Skicka ut loggar med spårnings-ID:n och korrelationsmetadata.
  • Arbetsflödes-ID:n: Använd meningsfulla arbetsflödes-ID:n för spårbarhet.
  • Underarbetsflöden & ContinueAsNew: Dela upp komplex logik i modulära exekveringar för att minska historikstorleken.
  • Mätningar & Övervakning: Integrera med Prometheus eller andra observability-verktyg.
  • Pålitlig händelsepublicering från aktiviteter: När en aktivitet skriver till en databas och också behöver notifiera en annan tjänst, använd mönstret för transaktionell utbunds för att garantera att händelsen inte förloras mellan databaskommit och brokerpublicering.

Felsökning av vanliga problem

Arbetare pollar inte

  • Se till att rätt uppgiftskönamn används.
  • Bekräfta nätverksanslutning till Temporal-servern.

Arbetsflödet startar inte

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

Aktivitetsfel

  • Kontrollera konfigurationen för återförsökspolicy.
  • Granska Web UI för felstackspår.

Icke-deterministiska arbetsflödesfel

Temporal kräver deterministisk arbetsflödesexekvering. Granska koden för:

  • Användning av math/rand
  • Goroutines inuti arbetsflödeslogik
  • Anrop till externa system inuti arbetsflöden

Se alltid till att arbetsflöden är ren orchestrieringskod medan du anropar externa system via aktiviteter.

Att implementera arbetsflödesapplikationer med Temporal i Go möjliggör för dig att bygga tillståndsberoende, resiliens och skalbar affärslogik med hjälp av välkända Go-idiom. Med Temporal’s garanterade exekveringsmodell, inbyggda återförsök, uppgiftsköer och observability-stöd, kan du fokusera på din kärnapplikationslogik utan att uppfinner orchestrieringen på nytt. Börja med enkla arbetsflöden och aktiviteter, och skala mot komplex, distribuerad orchestriering med självförtroende.

Användbara länkar

Prenumerera

Få nya inlägg om system, infrastruktur och AI-ingenjörskonst.