Wdrażanie aplikacji do przepływów pracy z użyciem Temporal w języku Go: kompletny przewodnik

Temporal to open-source, enterpriseowy silnik przepływów pracy, który umożliwia programistom tworzenie trwały, skalowalnych i odpornych na błędy aplikacji przepływów pracy przy użyciu znajomych języków programowania, takich jak Go.

A także rozproszone aplikacje z złożonymi przejściami stanu i ponownymi próbami wymagają niezawodnego frameworka do orchestracji.

Ten przewodnik wyjaśnia, jak zaimplementować aplikacje przepływów pracy z Temporal w Go, obejmując konfigurację, przykładowy kod, strategie wdrażania, najlepsze praktyki i rozwiązywanie problemów.

Co to jest Temporal i dlaczego warto go używać z Go

Temporal to framework do orchestracji przepływów pracy, zaprojektowany do tworzenia odpornych na błędy, długotrwałych aplikacji rozproszonych. Temporal zarządza stanem, ponownymi próbami, timery i odzyskiwaniem się po błędach w tle, umożliwiając programistom skupienie się na logice aplikacji bez potrzeby pisania kodu orchestracji. Wspiera Go, wśród innych języków, za pomocą Temporal Go SDK.

Korzystając z Temporal w Go:

• Przepływy pracy są trwałe i mogą być odtwarzane.
• Ponowne próby i timeouty aktywności są obsługiwane automatycznie.
• Stan systemu trwa przez błędy.
• Logika orchestracji zadań znajduje się w kodzie Go zgodnym z idiomy.

Podstawowe pojęcia: Przepływy pracy, Aktywności, Pracownicy

Przed stworzeniem pierwszej aplikacji Temporal w Go zrozumienie tych kluczowych pojęć jest konieczne:

Przepływy pracy

Przepływ pracy to trwała logika koordynacji, która wywołuje aktywności. Musi być deterministyczna — silnik Temporal może jej bezpiecznie odtworzyć. W Go przepływy pracy to zwykłe funkcje Go z specjalnym parametrem workflow.Context.

Aktywności

Aktywności to jednostki pracy zawierające operacje nieterministyczne (I/O, wywołania zewnętrznych API). Aktywności są wykonywane poza przepływem pracy i zwracają wyniki z powrotem do logiki przepływu pracy.

Pracownicy

Pracownik hostuje i wykonuje funkcje przepływu pracy i aktywności. Pracownicy pobierają zadania z kolejek zadań serwera Temporal i przetwarzają je. Muszą zarejestrować przepływy pracy i aktywności przed uruchomieniem.

Kolejki zadań

Kolejka zadań to sposób, w jaki pracownik otrzymuje zadania od serwera Temporal. Przepływy pracy i aktywności określają nazwę kolejki zadań, którą będą używać.

Konfiguracja projektu Go z Temporal

Wymagania wstępne

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

Zainstaluj SDK Temporal dla Go

go get go.temporal.io/sdk

Uruchom serwer Temporal do rozwoju

Dla rozwoju lokalnego:

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

Lub użyj CLI Temporal:

temporal server start-dev

To uruchamia serwer Temporal i interfejs Web UI domyślnie.

Konfiguracja: Klienci i kolejki zadań

Utwórz klienta Temporal

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

Wybierz kolejkę zadań

Zdefiniuj unikalną nazwę kolejki zadań dla swojego pracownika:

const TaskQueue = "order-processing-queue"

Pracownicy i inicjatory przepływów pracy muszą używać tej samej nazwy kolejki zadań.

Przykłady w Go: Przepływy pracy i aktywności

Zdefiniuj prosty przepływ pracy

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
}

Zdefiniuj aktywność

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

Zarejestruj i uruchom pracownika

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

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

Uruchom wykonanie przepływu pracy

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

Wdrażanie Temporal i pracowników w Go

Opcje wdrażania w środowisku produkcyjnym

• Samodzielnie hostowany klaster Temporal: Skonfiguruj usługi Temporal (frontend, history, matching) z trwałym magazynem (Cassandra, MySQL).
• Temporal Cloud: Zarządzana usługa Temporal z SLA i skalowaniem.
• Docker Compose lub Kubernetes: Dla środowisk testowych lub produkcyjnych.

Upewnij się, że skonfigurowano:

• Warstwę trwałości
• Ustawienie przestrzeni nazw
• TLS/bezpieczna autoryzacja (klucze API, mTLS)

Skalowalność pracowników

Wdrażaj wiele pracowników za pomocą modułu równoważenia obciążenia. Pracownicy skalują poziontalnie, dołączając do tej samej kolejki zadań i dzieląc obciążenie.

Testowanie przepływów pracy i aktywności w Go

Temporal zawiera zestaw testów:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Sprawdź wyniki:

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

Testowanie za pomocą zestawów testów zapewnia determinizm i niezawodność kodu przepływu pracy przed wdrożeniem.

Najlepsze praktyki w środowisku produkcyjnym

• Timeouty i polityki ponownych prób: Zdefiniuj rozsądne timeouty i ponowne próby dla aktywności i przepływów pracy.
• Strukturalne logowanie: Emituj logi z identyfikatorami śladów i metadanych korelacji.
• ID przepływów pracy: Używaj znaczących ID przepływów pracy dla śledzenia.
• Przepływy podrzędne i ContinueAsNew: Rozdziel złożoną logikę na modularyzowane wykonywania, aby zmniejszyć rozmiar historii.
• Metryki i monitorowanie: Integruj się z Prometheus lub innymi narzędziami obserwowalności.

Rozwiązywanie typowych problemów

Pracownik nie pobiera zadań

• Upewnij się, że nazwa kolejki zadań jest poprawna.
• Potwierdź połączenie sieciowe z serwerem Temporal.

Przepływ pracy nie uruchamia się

• Sprawdź rejestrację przepływu pracy przed uruchomieniem pracownika.
• Potwierdź parametry połączenia klienta.

Błędy aktywności

• Sprawdź konfigurację polityki ponownych prób.
• Przejrzyj interfejs Web UI w poszukiwaniu śladów błędów.

Błędy nieterministycznych przepływów pracy

Temporal wymusza deterministyczne wykonanie przepływów pracy. Przejrzyj kod pod kątem:

• Użycia math/rand
• Goroutines w logice przepływu pracy
• Wywołań systemów zewnętrznych w przepływach pracy

Zawsze upewnij się, że przepływy pracy są czystym kodem orchestracji, a wywołania systemów zewnętrznych odbywają się poprzez aktywności.

Wdrażanie aplikacji przepływów pracy z Temporal w Go umożliwia tworzenie stanowych, odpornych na błędy i skalowalnych logik biznesowych przy użyciu znanych idiomów Go. Dzięki modelowi gwarantowanego wykonania, wbudowanym ponownym próbom, kolejkom zadań i wsparciu obserwowalności oferowanym przez Temporal, możesz skupić się na logice swojej aplikacji bez konieczności ponownego tworzenia orchestracji. Zacznij od prostych przepływów pracy i aktywności, a następnie skaluj w kierunku złożonej, rozproszonej orchestracji z zaufaniem.

Przydatne linki

• Gotowy arkusz
• Apache Airflow dla MLOPS i ETL - Opis, korzyści i przykłady
• Podstawowa aplikacja - SDK Go. Dokumentacja platformy Temporal
• Przykłady SDK Go Temporal
• Tworzenie niezawodnych przepływów pracy z Temporal w Go - Kluczowe najlepsze praktyki
• Tworzenie aplikacji Temporal od podstaw w Go