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

Construye flujos de trabajo en Go con el SDK de Temporal

Índice

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

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 configuración, código de muestra, estrategias de despliegue, 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 flujos de trabajo diseñado para construir aplicaciones distribuidas de larga ejecución y tolerantes a fallos. Temporal gestiona el estado, los reintentos, los temporizadores y la recuperación ante fallos en segundo plano, permitiendo a los desarrolladores centrarse en la lógica de la aplicación sin código de orquestación repetitivo. Soporta Go, entre otros lenguajes, a través del SDK de Go de Temporal.

Al usar Temporal con Go:

  • Los flujos de trabajo son duraderos y reproducibles.
  • Los reintentos y tiempos de espera de las actividades se manejan automáticamente.
  • El estado del sistema persiste a través de los fallos.
  • La lógica de orquestación de tareas reside en código Go idiomático.

Conceptos básicos: Flujos de trabajo, Actividades, Trabajadores

Antes de construir tu primera aplicación de Go con Temporal, comprende estos conceptos clave:

Flujos de trabajo (Workflows)

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

Actividades

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

Trabajadores (Workers)

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

Colas de tareas (Task Queues)

Una Cola de tareas es la forma en que un trabajador recibe tareas del servidor de Temporal. Los flujos de trabajo y las actividades especifican el nombre de la cola de tareas que utilizarán.

Configuración de tu proyecto de Go con Temporal

Requisitos previos

  • Go (1.16+)
  • Servidor de Temporal (local o en la nube)
  • Docker (para el servidor local)
  • Dependencia go.temporal.io/sdk

Instalar el SDK de Go de Temporal

go get go.temporal.io/sdk

Iniciar el servidor de desarrollo de Temporal

Para desarrollo local:

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

O utiliza la CLI de Temporal:

temporal server start-dev

Esto inicia el servidor de Temporal y la interfaz web por defecto.

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

Define una cola de tareas única para tu trabajador:

const TaskQueue = "order-processing-queue"

Los trabajadores y los iniciadores de flujos 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, "Developer")

Despliegue de Temporal y trabajadores de Go

Opciones de despliegue en producción

  • Clúster de Temporal autoadministrado: Configura los servicios de Temporal (frontend, history, matching) con almacenamiento persistente (Cassandra, MySQL).
  • Temporal Cloud: Servicio de Temporal administrado con SLA y escalabilidad.
  • Docker Compose o Kubernetes: Para entornos de staging o producción.

Asegúrate de configurar:

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

Escalabilidad de los trabajadores

Despliega múltiples trabajadores detrás de un equilibrador de carga. Los trabajadores escalan horizontalmente uniéndose a las mismas colas de tareas y compartiendo 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, "Tester")

Afirmar resultados:

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

Probar con conjuntos de pruebas asegura la determinación y fiabilidad del código del flujo de trabajo antes del despliegue. Para los servicios de Go que sustentan las actividades de Temporal, especialmente aquellos con bucles de reintento, plazos de contexto y lógica impulsada por temporizadores, Pruebas de código concurrente en Go con testing/synctest cubre cómo realizar pruebas unitarias de ese comportamiento dependiente del tiempo de forma aislada usando relojes falsos y burbujas aisladas.

Mejores prácticas para producción

  • Tiempos de espera y Políticas de reintento: Define tiempos de espera y reintentos sensatos para actividades y flujos de trabajo.
  • Registro Estructurado: Emite registros con IDs de traza y metadatos de correlación.
  • IDs de flujo de trabajo: Utiliza IDs de flujo de trabajo significativos para la trazabilidad.
  • Flujos de trabajo secundarios y ContinueAsNew: Divide la lógica compleja en ejecuciones modulares para reducir el tamaño del historial.
  • Métricas y Monitoreo: Integra con Prometheus u otras herramientas de observabilidad.
  • Publicación fiable de eventos desde actividades: Cuando una actividad escribe en una base de datos y también necesita notificar a otro servicio, utiliza el patrón de caja de salida transaccional para garantizar que el evento no se pierda entre el compromiso de la base de datos y la publicación en el intermediario.

Solución de problemas comunes

El trabajador no está consultando

  • Asegúrate de usar el nombre correcto de la cola de tareas.
  • Confirma la conectividad de red al servidor de Temporal.

El flujo de trabajo no inicia

  • Valida el registro del flujo de trabajo antes de iniciar el trabajador.
  • Confirma los parámetros de conexión del cliente.

Fallos en las Actividades

  • Revisa la configuración de la política de reintento.
  • Examina la interfaz web para ver los rastros de pila de errores.

Errores de flujo de trabajo no determinista

Temporal exige una ejecución determinista de los flujos de trabajo. Revisa 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

Asegúrate siempre de que los flujos de trabajo sean código de orquestación puro mientras invocas sistemas externos a través de actividades.

Implementar aplicaciones de flujo de trabajo con Temporal en Go te permite construir lógica de negocio con estado, resiliente y escalable utilizando idios de Go familiares. Con el modelo de ejecución garantizado de Temporal, reintentos integrados, colas de tareas y soporte de observabilidad, puedes centrarte en la lógica central de tu aplicación sin reinventar la orquestación. Comienza con flujos de trabajo y actividades simples, y escala hacia una orquestación distribuida compleja con confianza.

Enlaces útiles

Suscribirse

Recibe nuevas publicaciones sobre sistemas, infraestructura e ingeniería de IA.