Implementare Applicazioni di Workflow con Temporal in Go: Una Guida Completa

Costruisci flussi di lavoro in Go con l'SDK Temporal

Indice

Temporal è un motore open-source, enterprise-grade per i flussi di lavoro che consente agli sviluppatori di costruire applicazioni di flusso di lavoro durature, scalabili e tolleranti ai guasti utilizzando linguaggi di programmazione familiari come Go.

E applicazioni distribuite con transizioni di stato complesse e riprovate richiedono un framework di orchestrazione affidabile.

Questo documento spiega come implementare applicazioni di flusso di lavoro con Temporal in Go, coprendo la configurazione, il codice di esempio, le strategie di deployment, le best practice e la risoluzione dei problemi.

Go Workplace

Che cos’è Temporal e perché usarlo con Go

Temporal è un framework di orchestrazione dei flussi di lavoro progettato per costruire applicazioni distribuite a lungo termine e tolleranti ai guasti. Temporal gestisce lo stato, le riprovate, i timer e il recupero dagli errori in background, permettendo agli sviluppatori di concentrarsi sulla logica dell’applicazione senza dover scrivere codice di orchestrazione boilerplate. Supporta Go, tra gli altri linguaggi, tramite il Temporal Go SDK.

Utilizzando Temporal con Go:

  • I flussi di lavoro sono duraturi e riproducibili.
  • Le riprovate e i timeout delle attività vengono gestiti automaticamente.
  • Lo stato del sistema persiste anche in caso di errori.
  • La logica di orchestrazione delle attività vive nel codice Go idiomatico.

Concetti chiave: Flussi di lavoro, attività, lavoratori

Prima di creare la tua prima applicazione Go con Temporal, comprendi questi concetti chiave:

Flussi di lavoro

Un Flusso di lavoro è una logica di coordinamento duratura che invoca attività. Deve essere deterministica - il motore Temporal può riprodurlo in modo affidabile. In Go, i flussi di lavoro sono funzioni Go normali con un parametro speciale workflow.Context.

Attività

Attività sono unità di lavoro che contengono operazioni non deterministiche (I/O, chiamate API esterne). Le attività vengono eseguite al di fuori del flusso di lavoro e restituiscono i risultati alla logica del flusso di lavoro.

Lavoratori

Un Lavoratore ospita ed esegue funzioni di flusso di lavoro e attività. I lavoratori interrogano le code dei compiti del server Temporal e processano i compiti. Devono registrare i flussi di lavoro e le attività prima di avviarsi.

Code dei compiti

Una Code dei compiti è il modo in cui un lavoratore riceve compiti dal server Temporal. I flussi di lavoro e le attività specificano il nome della coda dei compiti che utilizzeranno.

Configurazione del progetto Go con Temporal

Requisiti preliminari

  • Go (1.16+)
  • Server Temporal (locale o in cloud)
  • Docker (per il server locale)
  • Dipendenza go.temporal.io/sdk

Installare il Temporal Go SDK

go get go.temporal.io/sdk

Avviare il server di sviluppo Temporal

Per lo sviluppo locale:

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

Oppure utilizzare il CLI Temporal:

temporal server start-dev

Questo avvia il server Temporal e l’interfaccia web di default.

Configurazione: Client e Code dei compiti

Creare un client Temporal

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

Scegliere una coda dei compiti

Definisci una coda dei compiti unica per il tuo lavoratore:

const TaskQueue = "order-processing-queue"

I lavoratori e i initiator dei flussi di lavoro devono utilizzare lo stesso nome della coda dei compiti.

Esempi in Go: Flussi di lavoro e attività

Definire un semplice flusso di lavoro

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
}

Definire un’attività

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

Registrare e avviare il lavoratore

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

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

Avviare l’esecuzione del flusso di lavoro

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

Deployment di Temporal e lavoratori Go

Opzioni di deployment in produzione

  • Cluster Temporal autohostato: Configura i servizi Temporal (frontend, history, matching) con un layer di persistenza (Cassandra, MySQL).
  • Temporal Cloud: Servizio gestito Temporal con SLA e scalabilità.
  • Docker Compose o Kubernetes: Per ambienti di staging o produzione.

Assicurati di configurare:

  • Layer di persistenza
  • Configurazione del namespace
  • TLS/autenticazione sicura (chiavi API, mTLS)

Scalabilità dei lavoratori

Distribuisci diversi lavoratori dietro un load balancer. I lavoratori si scalano orizzontalmente unendo le stesse code dei compiti e condividendo il carico di lavoro.

Test di flussi di lavoro e attività in Go

Temporal include un insieme di test:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Tester")

Verifica i risultati:

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

I test con test suite garantiscono la deterministica e l’affidabilità del codice dei flussi di lavoro prima del deployment.

Best practice per la produzione

  • Timeout e policy di riprovate: Definisci timeout e riprovate sensibili per attività e flussi di lavoro.
  • Log strutturati: Emetti log con ID di tracciamento e metadati di correlazione.
  • ID dei flussi di lavoro: Utilizza ID significativi per i flussi di lavoro per la tracciabilità.
  • Flussi di lavoro figli e ContinueAsNew: Suddividi la logica complessa in esecuzioni modulari per ridurre la dimensione della storia.
  • Metriche e monitoraggio: Integra con Prometheus o altri strumenti di osservabilità.

Risoluzione dei problemi comuni

Lavoratore non in ascolto

  • Assicurati che il nome della coda dei compiti sia corretto.
  • Conferma la connettività di rete con il server Temporal.

Flusso di lavoro non riesce a partire

  • Verifica la registrazione del flusso di lavoro prima dell’avvio del lavoratore.
  • Conferma i parametri di connessione del client.

Errori di attività

  • Controlla la configurazione della policy di riprovate.
  • Esamina l’interfaccia web per tracciare gli errori.

Errori di flusso di lavoro non deterministici

Temporal impone l’esecuzione deterministica dei flussi di lavoro. Rivedi il codice per:

  • Utilizzo di math/rand
  • Goroutine all’interno della logica del flusso di lavoro
  • Chiamate a sistemi esterni all’interno dei flussi di lavoro

Assicurati sempre che i flussi di lavoro siano codice puramente di orchestrazione mentre si invocano sistemi esterni tramite attività.

Implementando applicazioni di flusso di lavoro con Temporal in Go puoi costruire logiche aziendali stateful, resilienti e scalabili utilizzando idiomi familiari di Go. Con il modello di esecuzione garantito di Temporal, le riprovate integrate, le code dei compiti e il supporto all’osservabilità, puoi concentrarti sulla logica principale dell’applicazione senza dover riscrivere l’orchestrazione. Inizia con flussi di lavoro e attività semplici, e scalare verso orchestrazioni complesse e distribuite con fiducia.