> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lerian.studio/llms.txt
> Use this file to discover all available pages before exploring further.
# Motor de orquestación
> Coordina las verificaciones y aprobaciones alrededor de una transacción, con un registro por paso de qué se ejecutó y qué devolvió.
Las operaciones financieras involucran múltiples pasos, aprobaciones y verificaciones externas. Cuando escribes lógica personalizada para cada flujo, las mismas reglas se dispersan entre tus servicios, y le siguen errores, demoras y brechas de cumplimiento. Flowker mantiene esa lógica en un solo lugar. Defines el proceso una vez como un grafo de nodos y aristas, y Flowker lo ejecuta de la misma forma cada vez. Tu proveedor de antifraude, tu servicio de KYC, Tracer y el ledger de Midaz son nodos en ese grafo.
El campo `stepResults` contiene una entrada por cada nodo ejecutor, condicional o de acción ejecutado, en orden. Las entradas informan estado y duración, pueden incluir salida, y los pasos fallidos pueden incluir `errorMessage`. Los nodos disparadores no crean ningún registro de paso.
## Lo que obtienes
***
La plataforma de orquestación de workflows. Coordina los pasos alrededor de una transacción: verificaciones antifraude, llamadas a sistemas externos de aprobación, enrutamiento de pagos y alta de clientes.
El catálogo registra a Midaz como el proveedor `ledger` y a Tracer como el proveedor `tracer`, ambos sintetizados a partir de sus especificaciones OpenAPI. Un nodo de workflow llama a sus operaciones.
El módulo de Flowker. Los operadores crean y editan workflows, configuran proveedores y monitorean ejecuciones.
Con `PLUGIN_AUTH_ENABLED=true`, cada llamada a un disparador de webhook requiere un Bearer token, y quien llama necesita el permiso `execute` sobre el recurso `webhooks`.
## Cómo encajan las piezas
***
```mermaid theme={null}
flowchart LR
Trigger["Disparador
tu llamada de webhook o una programación"]
Flow["Flowker
un grafo de nodos y aristas"]
Yours["Tus servicios
KYC, AML, puntuación de fraude"]
Tracer["Tracer
permitir, denegar o revisión"]
Midaz["Ledger de Midaz
registra la transacción"]
Console["Console
módulo de Flowker"]
AM["Access Manager
emite los tokens"]
Trigger -->|"inicia una ejecución"| Flow
Flow -->|"conector HTTP genérico"| Yours
Flow -->|"proveedor nativo tracer"| Tracer
Flow -->|"proveedor nativo ledger"| Midaz
Console -->|"lee workflows y ejecuciones"| Flow
AM -.->|"bearer token, execute sobre webhooks"| Trigger
classDef lerian fill:#fff8e1,stroke:#f4b400,color:#333;
classDef yours fill:#e8f0fe,stroke:#4285f4,color:#333;
classDef ext fill:#f1f3f4,stroke:#9aa0a6,color:#333;
class Flow,Tracer,Midaz,Console,AM lerian;
class Trigger,Yours yours;
```
1. Una llamada de webhook o una programación inicia una ejecución. Solo un workflow activo registra cada combinación de ruta y método.
2. Los nodos ejecutores llaman a tus servicios a través de configuraciones de proveedor.
3. Un nodo condicional evalúa su condición y devuelve un resultado con nombre. Flowker sigue la arista de salida que lleva ese nombre.
4. Un nodo `tracer` le pide una decisión a Tracer. Un nodo `ledger` llama a Midaz. Ambos proveedores aparecen cuando el registro de esquemas nativos está configurado y la síntesis se completa con éxito.
5. El campo `stepResults` contiene una entrada por cada nodo ejecutor, condicional o de acción ejecutado, en orden. Las entradas informan estado y duración, pueden incluir salida, y los pasos fallidos pueden incluir `errorMessage`. Los nodos disparadores no crean ningún registro de paso.
6. Los operadores leen la ejecución en el módulo de Flowker de Console.
Flowker reintenta una llamada de ejecutor que falla por un error transitorio. No reintenta un `POST` ni un `PATCH` de forma predeterminada. Un circuit breaker protege cada proveedor. Se abre después de 20 fallos consecutivos, espera 30 segundos y luego permite una solicitud para probar el servicio.
Flowker orquesta las verificaciones que preceden a un paso de contabilización en el ledger. No vigila el límite en el ledger mismo. Tu integración con el ledger debe garantizar que ninguna otra ruta pueda contabilizar sin las verificaciones requeridas.
## Qué posee cada pieza
***
| Pieza | Fuente de verdad para | Se comunica con | Tú mantienes |
| -------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| Flowker | las definiciones de workflow, las ejecuciones, las configuraciones de proveedor, el registro de esquemas | tus servicios, Tracer, Midaz | la lógica de flujo en un solo lugar |
| Tracer | la decisión de permitir, denegar o revisión | un nodo ejecutor que lo llama | tus reglas y límites de gasto |
| Midaz | la transacción que registra | un nodo ejecutor que lo llama | tu ledger. Flowker no garantiza que cada contabilización haya pasado las verificaciones |
| Access Manager | quién puede ejecutar un disparador de webhook | Flowker, en cada ruta protegida | tus usuarios y tus aplicaciones máquina a máquina |
| Console | el registro de ejecución que lee un operador | el módulo de Flowker | un solo inicio de sesión para los operadores |
| Tus servicios | KYC, AML, puntuación de fraude, aprobaciones | el conector HTTP genérico, sobre los hosts que permites | tus proveedores y tus contratos |
## Adóptalo pieza por pieza
***
Crea una configuración de proveedor para cada instancia de servicio que llamas. Contiene la URL base, las credenciales y los hosts públicos que la conexión puede alcanzar. El conector HTTP genérico rechaza una lista `allowedHosts` vacía.
Define `MIDAZ_BASE_URL` y `TRACER_BASE_URL` en el despliegue. Un `OPENAPI_NATIVE_PROVIDERS` vacío hace que cada proveedor nativo sea elegible para la síntesis. Una lista no vacía reduce la elegibilidad a los ids que nombras.
Con `PLUGIN_AUTH_ENABLED=true`, cada solicitud a una ruta de webhook necesita un Bearer token, y quien llama necesita `execute` sobre `webhooks`. Otorga ese permiso a una identidad máquina a máquina por cada sistema al que le permites llamar a tus webhooks.
Habilita el módulo de Flowker en Console, donde los operadores leen workflows y ejecuciones. Define `ENABLE_TELEMETRY=true` y un endpoint OTLP para exportar telemetría a tu propio collector.
## Trae lo tuyo
***
* **Cualquier ledger.** Flowker llama a Midaz o a otro ledger a través de una configuración de proveedor. No requiere ningún ledger en particular.
* **Tus proveedores de KYC, AML y antifraude.** El conector HTTP genérico los llama sobre los hosts públicos que enumeras en la conexión.
* **Tu propia API.** Sube su documento OpenAPI al registro de esquemas. Apunta una configuración de proveedor a ese documento. Un nodo entonces llama a una operación de tu API.
* **Tus disparadores.** Registras una ruta de webhook, o defines una cadencia cron con la zona horaria que nombras.
* **Tu backend de observabilidad.** Cuando habilitas la telemetría, Flowker emite datos de OpenTelemetry de sus operaciones HTTP y de servicio hacia el collector que ejecutas.
## Un ejemplo práctico
***
El catálogo incluye una plantilla que valida una transacción a través de Tracer y la crea en Midaz cuando Tracer aprueba. Este ejemplo agrega una verificación de KYC delante de ese par.
1. Tu servicio de pagos envía la solicitud a la ruta de webhook que registra el workflow.
2. Un nodo ejecutor llama a tu servicio de KYC a través de su configuración de proveedor.
3. Un nodo condicional lee el resultado de KYC y enruta una verificación fallida hacia una ruta de rechazo.
4. Un nodo ejecutor envía el payload a Tracer a través del proveedor `tracer`.
5. Cuando Tracer aprueba la transacción, un nodo `ledger` la crea en Midaz.
6. El webhook responde a tu servicio en el modo de respuesta que elegiste. El modo predeterminado devuelve un recibo `202`, y `sync` espera el resultado.
## Empieza aquí
***
Lee qué coordina la plataforma, y los registros que mantiene por cada ejecución.
Configura Flowker y ejecuta tu primer workflow de principio a fin.
Aprende sobre workflows, nodos, aristas, el catálogo, las configuraciones de proveedor y las ejecuciones.