Implementando aplicaciones de flujo de trabajo con Temporal en Go: Una guía completa

Construya flujos de trabajo en Go con el SDK de Temporal

Índice

Temporal es un motor de flujo de trabajo de código abierto, de nivel empresarial, que permite a los desarrolladores construir aplicaciones de flujo de trabajo duraderas, escalables y tolerantes a fallos utilizando lenguajes de programación familiares como Go.

Y las aplicaciones distribuidas con transiciones de estado complejas y reintentos requieren un marco de orquestación confiable.

Esta guía explica cómo implementar aplicaciones de flujo de trabajo con Temporal en Go, cubriendo la configuración, código de ejemplo, estrategias de implementación, mejores prácticas y solución de problemas.

Go Workplace

¿Qué es Temporal y por qué usarlo con Go

Temporal es un marco de orquestación de flujo de trabajo diseñado para construir aplicaciones distribuidas a largo plazo y tolerantes a fallos. Temporal gestiona el estado, reintentos, temporizadores y recuperación de fallos en segundo plano, permitiendo a los desarrolladores centrarse en la lógica de la aplicación sin tener que escribir código de orquestación innecesario. Soporta Go, entre otros lenguajes, mediante el Temporal Go SDK.

Al usar Temporal con Go:

  • Los flujos de trabajo son duraderos y regrabables.
  • Los reintentos y tiempos de espera de actividades se manejan automáticamente.
  • El estado del sistema persiste incluso tras fallos.
  • La lógica de orquestación de tareas vive en código Go idiomático.

Conceptos clave: Flujos de trabajo, actividades y trabajadores

Antes de construir su primera aplicación de Go con Temporal, entienda estos conceptos clave:

Flujos de trabajo

Un Flujo de trabajo es una lógica de coordinación duradera que invoca actividades. Debe ser determinista — el motor de Temporal puede regrabarlo de forma confiable. En Go, los flujos de trabajo son funciones normales de Go con un parámetro especial workflow.Context.

Actividades

Actividades son las unidades de trabajo que contienen operaciones no deterministas (I/O, llamadas a API externas). Las actividades se ejecutan fuera del flujo de trabajo y devuelven resultados de vuelta a la lógica del flujo de trabajo.

Trabajadores

Un Trabajador aloja y ejecuta funciones de flujo de trabajo y actividades. Los trabajadores consultan las colas de tareas del servidor de Temporal y procesan tareas. Deben registrar flujos de trabajo y actividades antes de iniciar.

Colas de tareas

Una Cola de tareas es cómo un trabajador recibe tareas del servidor de Temporal. Los flujos de trabajo y las actividades especifican el nombre de la cola de tareas que usarán.

Configuración: Clientes y colas de tareas

Crear un cliente de Temporal

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

Elegir una cola de tareas

Defina una cola de tareas única para su trabajador:

const TaskQueue = "order-processing-queue"

Los trabajadores y los iniciadores de flujo de trabajo deben usar el mismo nombre de cola de tareas.

Ejemplos en Go: Flujos de trabajo y actividades

Definir un flujo de trabajo simple

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
}

Definir una actividad

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

Registrar y ejecutar el trabajador

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

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

Iniciar la ejecución del flujo de trabajo

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

Implementar Temporal y trabajadores en Go

Opciones de implementación en producción

  • Clúster de Temporal autogestionado: Configurar los servicios de Temporal (frontend, historial, coincidencia) con almacenamiento persistente (Cassandra, MySQL).
  • Temporal Cloud: Servicio gestionado de Temporal con SLA y escalado.
  • Docker Compose o Kubernetes: Para entornos de pruebas o producción.

Asegúrese de configurar:

  • Capa de persistencia
  • Configuración del espacio de nombres
  • TLS/autenticación segura (claves API, mTLS)

Escalabilidad de trabajadores

Implemente múltiples trabajadores detrás de un balanceador de carga. Los trabajadores se escalan horizontalmente al unirse a las mismas colas de tareas y comparten la carga de trabajo.

Pruebas de flujos de trabajo y actividades en Go

Temporal incluye un conjunto de pruebas:

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

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

env.ExecuteWorkflow(SampleWorkflow, "Prueba")

Afirme los resultados:

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

Las pruebas con conjuntos de pruebas garantizan la determinación y confiabilidad del código del flujo de trabajo antes del despliegue.

Mejores prácticas para producción

  • Tiempo de espera y políticas de reintento: Defina tiempos de espera y reintentos sensatos para actividades y flujos de trabajo.
  • Registro estructurado: Emita registros con identificadores de trazas y metadatos de correlación.
  • Identificadores de flujo de trabajo: Use identificadores significativos de flujo de trabajo para rastrear.
  • Flujos de trabajo secundarios y ContinueAsNew: Divida la lógica compleja en ejecuciones modulares para reducir el tamaño del historial.
  • Métricas y monitoreo: Integre con Prometheus u otras herramientas de observabilidad.

Solución de problemas de problemas comunes

Trabajador no consulta

  • Asegúrese de usar el nombre correcto de la cola de tareas.
  • Confirme la conectividad de red con el servidor de Temporal.

El flujo de trabajo no inicia

  • Valide el registro del flujo de trabajo antes del inicio del trabajador.
  • Confirme los parámetros de conexión del cliente.

Fallos de actividad

  • Revise la configuración de la política de reintento.
  • Examine la interfaz Web UI para ver los rastros de errores.

Errores de flujo de trabajo no determinista

Temporal impone la ejecución determinista de los flujos de trabajo. Revise el código en busca de:

  • Uso de math/rand
  • Goroutines dentro de la lógica del flujo de trabajo
  • Llamadas a sistemas externos dentro de los flujos de trabajo

Siempre asegúrese de que los flujos de trabajo sean código de orquestación puro mientras invoca sistemas externos a través de actividades.

Implementar aplicaciones de flujo de trabajo con Temporal en Go le permite construir lógica empresarial con estado, resistente y escalable utilizando idiomas familiares de Go. Con el modelo de ejecución garantizado de Temporal, reintentos integrados, colas de tareas y soporte de observabilidad, puede centrarse en su lógica de aplicación principal sin reinventar la orquestación. Comience con flujos de trabajo y actividades simples, y escale hacia orquestaciones distribuidas complejas con confianza.

Enlaces útiles