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

Crea workflow in Go con il Temporal SDK

Indice

Temporal è un motore di workflow open-source di livello enterprise che consente agli sviluppatori di creare applicazioni di workflow durevoli, scalabili e tolleranti ai guasti utilizzando linguaggi di programmazione familiari come Go.

Le applicazioni distribuite con transizioni di stato complesse e meccanismi di retry richiedono un framework di orchestrazione affidabile.

Questa guida spiega come implementare applicazioni di workflow con Temporal in Go, coprendo configurazione, codice campione, strategie di distribuzione, best practice e risoluzione dei problemi.

Go Workplace

Cos’è Temporal e perché usarlo con Go

Temporal è un framework di orchestrazione dei workflow progettato per la creazione di applicazioni distribuite a lunga esecuzione e tolleranti ai guasti. Temporal gestisce stato, retry, timer e recupero dagli errori in background, permettendo agli sviluppatori di concentrarsi sulla logica dell’applicazione senza codice boilerplate per l’orchestrazione. Supporta Go, tra gli altri linguaggi, tramite il SDK Go di Temporal.

Utilizzando Temporal con Go:

  • I workflow sono durevoli e riproducibili.
  • I retry e i timeout delle attività sono gestiti automaticamente.
  • Lo stato del sistema persiste nonostante i guasti.
  • La logica di orchestrazione delle attività risiede in codice Go idiomatico.

Concetti fondamentali: Workflow, Attività, Worker

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

Workflow

Un Workflow è una logica di coordinamento durevole che invoca le attività. Deve essere deterministico: il motore di Temporal può riprodurlo in modo affidabile. In Go, i workflow sono normali funzioni Go con un parametro speciale workflow.Context.

Attività

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

Worker

Un Worker ospita ed esegue le funzioni di Workflow e Attività. Gli worker interrogano le code di任务 del server Temporal e elaborano i compiti. Devono registrare workflow e attività prima dell’avvio.

Code di任务 (Task Queues)

Una Coda di任务 è il modo in cui un worker riceve compiti dal server Temporal. I workflow e le attività specificano il nome della coda di任务 che utilizzeranno.

Configurazione del progetto Go con Temporal

Prerequisiti

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

Installa l’SDK Go di Temporal

go get go.temporal.io/sdk

Avvia il server di sviluppo Temporal

Per lo sviluppo locale:

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

Oppure usa il CLI di Temporal:

temporal server start-dev

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

Configurazione: Clienti e Code di任务

Crea un client Temporal

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

Scegli una Coda di任务

Definisci una coda di任务 univoca per il tuo worker:

const TaskQueue = "order-processing-queue"

Gli worker e gli inizializzatori del workflow devono utilizzare lo stesso nome della coda di任务.

Esempi Go: Workflow e Attività

Definisci un Workflow semplice

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
}

Definisci un’Attività

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

Registra ed esegui il Worker

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

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

Avvia l’esecuzione del Workflow

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

Distribuzione di Temporal e Worker Go

Opzioni di distribuzione in produzione

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

Assicurati di configurare:

  • Livello di persistenza
  • Configurazione dello spazio dei nomi (Namespace)
  • Autenticazione sicura TLS (chiavi API, mTLS)

Scalabilità degli Worker

Distribuisci più worker dietro un load balancer. Gli worker scalano orizzontalmente unendosi alle stesse code di任务 e condividendo il carico di lavoro.

Test di Workflow e Attività in Go

Temporal include una suite 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)

Testare con suite di test garantisce la determinazione e l’affidabilità del codice del workflow prima della distribuzione. Per i servizi Go alla base delle attività Temporal — in particolare quelli con loop di retry, scadenze del contesto e logica basata su timer — Testare il codice Go concorrente con testing/synctest illustra come eseguire test unitari di quel comportamento dipendente dal tempo in isolamento utilizzando orologi finti e bolle isolate.

Best Practice per la Produzione

  • Timeout e Politiche di Retry: Definisci timeout e retry sensati per attività e workflow.
  • Logging Strutturato: Emetti log con ID di traccia e metadati di correlazione.
  • ID Workflow: Utilizza ID di workflow significativi per la tracciabilità.
  • Workflow Figli e ContinueAsNew: Dividi la logica complessa in esecuzioni modulari per ridurre le dimensioni della cronologia.
  • Metriche e Monitoraggio: Integra con Prometheus o altri strumenti di osservabilità.
  • Pubblicazione affidabile degli eventi dalle attività: Quando un’attività scrive in un database e deve anche notificare un altro servizio, utilizza il modello transactional outbox per garantire che l’evento non vada perso tra l’impegno del database e la pubblicazione nel broker.

Risoluzione dei Problemi Comuni

Worker non interroga (Not Polling)

  • Assicurati che il nome della coda di任务 sia corretto.
  • Conferma la connettività di rete al server Temporal.

Avvio del Workflow fallito

  • Valida la registrazione del workflow prima dell’avvio dell’worker.
  • Conferma i parametri di connessione del client.

Fallimenti dell’Attività

  • Controlla la configurazione della politica di retry.
  • Esamina l’interfaccia Web UI per gli stack trace degli errori.

Errori di Workflow Non Deterministici

Temporal impone l’esecuzione deterministica dei workflow. Rivedi il codice per:

  • Uso di math/rand
  • Goroutine all’interno della logica del workflow
  • Chiamate a sistemi esterni all’interno dei workflow

Assicurati sempre che i workflow siano codice di orchestrazione puro mentre invocano sistemi esterni tramite attività.

Implementare applicazioni di workflow con Temporal in Go ti permette di costruire logica di business statale, resiliente e scalabile utilizzando idiomi Go familiari. Con il modello di esecuzione garantito di Temporal, i retry integrati, le code di任务 e il supporto per l’osservabilità, puoi concentrarti sulla logica principale della tua applicazione senza dover reinventare l’orchestrazione. Inizia con workflow e attività semplici e scala verso orchestrazioni distribuite complesse con fiducia.

Iscriviti

Ricevi nuovi articoli su sistemi, infrastruttura e ingegneria AI.