Implementacja aplikacji workflowowych z wykorzystaniem Temporal w Go: Kompletny przewodnik

Tworzenie przepływów pracy w Go z wykorzystaniem SDK Temporal

Page content

Temporal to silnik workflowów klasy enterprise o otwartym kodzie źródłowym, który umożliwia developerom budowanie trwałościowych, skalowalnych i odpornych na błędy aplikacji workflowowych, wykorzystując znane języki programowania, takie jak Go.

Aplikacje rozproszone o złożonych przejściach stanów i mechanizmach ponówień wymagają niezawodnego frameworka orkiestracyjnego.

Ten przewodnik wyjaśnia, jak implementować aplikacje workflowowe z Temporal w Go, obejmując konfigurację, przykłady kodu, strategie wdrażania, najlepsze praktyki oraz rozwiązywanie problemów.

Go Workplace

Czym jest Temporal i dlaczego używać go z Go

Temporal to framework orkiestracji workflowów zaprojektowany do budowania odpornych na błędy, długotrwałych aplikacji rozproszonych. Temporal zarządza stanem, ponowieniami, timerami i odzyskiwaniem po awariach w tle, pozwalając developerom skupić się na logice aplikacji bez konieczności pisania szablonowego kodu orkiestracyjnego. Obsługuje Go, wraz z innymi językami, poprzez SDK Temporal Go.

Dzięki używaniu Temporal z Go:

  • Workflows są trwałościowe i możliwe do odtworzenia.
  • Ponowienia i limity czasowe aktywności są obsługiwane automatycznie.
  • Stan systemu przetrwa awarie.
  • Logika orkiestracji zadań znajduje się w idiomaticznym kodzie Go.

Podstawowe pojęcia: Workflows, Aktywności (Activities), Workerzy

Zanim stworzysz swoją pierwszą aplikację Temporal Go, zrozum te kluczowe pojęcia:

Workflows

Workflow to trwała logika koordynacji, która wywołuje aktywności. Musi być deterministyczna – silnik Temporal musi móc ją niezawodnie odtworzyć. W Go workflows to zwykłe funkcje Go ze specjalnym parametrem workflow.Context.

Aktywności (Activities)

Aktywności to jednostki pracy zawierające operacje niedeterministyczne (I/O, zewnętrzne wywołania API). Aktywności wykonują się poza workflowem i zwracają wyniki do logiki workflowu.

Workerzy

Worker hostuje i wykonuje funkcje Workflow i Activity. Workerzy zapytują kolejki zadań serwera Temporal i przetwarzają zadania. Muszą zarejestrować workflows i aktywności przed uruchomieniem.

Kolejki Zadań (Task Queues)

Kolejka Zadań to sposób, w jaki worker otrzymuje zadania od serwera Temporal. Workflows i aktywności określają nazwę kolejki zadań, której będą używać.

Konfiguracja projektu Go z Temporal

Wymagania wstępne

  • Go (1.16+)
  • Serwer Temporal (lokalny lub w chmurze)
  • Docker (dla serwera lokalnego)
  • Zależność go.temporal.io/sdk

Instalacja SDK Temporal Go

go get go.temporal.io/sdk

Uruchomienie serwera deweloperskiego Temporal

Do rozwoju lokalnego:

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

Lub użyj CLI Temporal:

temporal server start-dev

Domyślnie uruchamia to serwer Temporal oraz interfejs Web UI.

Konfiguracja: Klienci i Kolejki Zadań

Tworzenie klienta Temporal

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

Wybór kolejki zadań

Zdefiniuj unikalną kolejkę zadań dla swojego workera:

const TaskQueue = "order-processing-queue"

Workerzy i inicjatorzy workflowów muszą używać tej samej nazwy kolejki zadań.

Przykłady w Go: Workflows i Aktywności

Definiowanie prostego workflowu

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
}

Definiowanie aktywności

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

Rejestracja i uruchomienie workera

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

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

Rozpoczęcie wykonania workflowu

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

Wdrażanie Temporal i Workerów Go

Opcje wdrażania produkcyjnego

  • Własny klastr Temporal: Konfiguracja usług Temporal (frontend, history, matching) ze trwałościowym magazynem (Cassandra, MySQL).
  • Temporal Cloud: Zarządzana usługa Temporal ze SLA i skalowaniem.
  • Docker Compose lub Kubernetes: Do środowisk stagingowych lub produkcyjnych.

Upewnij się, że skonfigurowałeś:

  • Warstwę trwałościową
  • Konfigurację namespace’u
  • Autoryzację TLS/bezpieczną (klucze API, mTLS)

Skalowalność Workerów

Wdrażaj wielu workerów za load balancerem. Workerzy skalują się horyzontalnie, dołączając do tych samych kolejek zadań i dzieląc obciążenie.

Testowanie Workflowów i Aktywności w Go

Temporal zawiera zestaw testowy:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Weryfikacja wyników:

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

Testowanie z zestawami testowymi zapewnia determinizm i niezawodność kodu workflowu przed wdrożeniem. Dla usług Go, które stanowią podstawę aktywności Temporal — szczególnie tych z pętlami ponówień, limitami kontekstu i logiką napędzaną timerami — Testowanie konkurentnego kodu Go z testing/synctest omawia, jak testować jednostkowo to zależne od czasu zachowanie w izolacji, używając fałszywych zegarów i izolowanych bąbelków.

Najlepsze praktyki w środowisku produkcyjnym

  • Limity czasowe i polityki ponówień: Określ rozsądne limity czasowe i ponowienia dla aktywności i workflowów.
  • Strukturalne logowanie: Emituj logi z ID śledzenia i metadanymi korelacji.
  • ID Workflowów: Używaj znaczących ID workflowów dla śledzenia.
  • Child Workflows i ContinueAsNew: Dzielić złożoną logikę na modułowe wykonania, aby zmniejszyć rozmiar historii.
  • Metryki i monitorowanie: Integracja z Prometheus lub innymi narzędziami observability.
  • Niezawodne publikowanie zdarzeń z aktywności: Gdy aktywność zapisuje do bazy danych i jednocześnie musi powiadomić inną usługę, użyj wzorca transakcyjnego outbox aby zagwarantować, że zdarzenie nie zostanie zgubione między commitowaniem bazy danych a publikacją w brokerze.

Rozwiązywanie typowych problemów

Worker nie zapytuje (Not Polling)

  • Upewnij się, że nazwa kolejki zadań jest poprawna.
  • Potwierdź łączność sieciową z serwerem Temporal.

Workflow nie może się uruchomić

  • Zweryfikuj rejestrację workflowu przed uruchomieniem workera.
  • Potwierdź parametry połączenia klienta.

Błędy Aktywności

  • Sprawdź konfigurację polityki ponówień.
  • Przeanalizuj stos błędów w Web UI.

Błędy niedeterministycznych workflowów

Temporal wymusza deterministyczne wykonanie workflowu. Przeglądaj kod pod kątem:

  • Używania math/rand
  • Gorutin wewnątrz logiki workflowu
  • Zewnętrznych wywołań systemowych wewnątrz workflowów

Zawsze upewnij się, że workflows to czysty kod orkiestracyjny, wywołujący zewnętrzne systemy poprzez aktywności.

Implementacja aplikacji workflowowych z Temporal w Go pozwala Ci budować stanową, odporną i skalowalną logikę biznesową, używając znanych idiomów Go. Dzięki gwarantowanemu modelowi wykonania Temporal, wbudowanym ponowieniom, kolejkach zadań i wsparciu dla observability, możesz skupić się na głównej logice aplikacji, nie wynalazając orkiestracji od nowa. Zacznij od prostych workflowów i aktywności, a następnie skaluj do złożonej, rozproszonej orkiestracji z pewnością siebie.

Przydatne linki

Subskrybuj

Otrzymuj nowe wpisy o systemach, infrastrukturze i inżynierii AI.