Construyendo Flujos de Trabajo Duraderos Desde Cero en JavaScript

Hola, soy Peter, y hoy quiero hablarles sobre cómo pueden construir flujos de trabajo duraderos desde cero en JavaScript puro. Así que todos ustedes son desarrolladores, y saben lo difícil que es construir sistemas verdaderamente confiables. Es difícil hacer que sus aplicaciones sean confiables porque cuando están construyendo una aplicación compleja, casi cualquier paso puede romperse en cualquier lugar. Si están construyendo algo como Money Transfer, por ejemplo, tienen que preocuparse de que su aplicación se rompa, como cuando comienzan a transferir, mientras están en medio de la transferencia, al final, cuando están tratando de enviar una confirmación. Y las cosas pueden romperse por casi cualquier razón.

Las aplicaciones pueden romperse y fallar porque son bloqueos de procesos, porque se quedan sin recursos o encuentran un error. Pueden fallar debido a tiempos de espera, porque alguien tarda demasiado en responder. Pueden fallar porque una API externa que utilizan se descompone, porque está limitada por tasa, porque falla transitoriamente, porque tiene una interrupción. Y, por supuesto, las fallas son una preocupación aún mayor si están operando a gran escala, donde simplemente hay más cosas que pueden fallar. O si están usando IA, que muchas personas están haciendo hoy en día, porque la IA es un poco inherentemente frágil, y los proveedores de IA, los proveedores de modelos en los que confiamos, frecuentemente tienen problemas e interrupciones que pueden romper las aplicaciones de IA.

Si algo falla, lo fácil es volver a intentar desde el principio, reiniciar lo que falló. Pero a menudo no pueden hacer eso. Si están reiniciando un proceso de negocio, como un Money Transfer desde el principio, están arriesgando algún tipo de corrupción o duplicación, donde transfieren dinero dos veces, o reservan una cita dos veces. Si están tratando de reiniciar una tarea realmente grande, entonces están arriesgando desperdiciar recursos de cómputo o ser increíblemente lentos. Así que a menudo, en lugar de simplemente reiniciar algo que falla, tienen que implementar un código de recuperación complicado que determine exactamente cuál es la falla, y trate de remediarla directamente. Y ese tipo de cosas son difíciles de escribir.

Así que una nueva herramienta que realmente puede ayudar con esto son los flujos de trabajo duraderos. Así que la idea detrás de los flujos de trabajo duraderos es que regularmente creas puntos de control del estado de tu programa. De modo que si algo falla, puedes usar esos puntos de control para recuperar tu programa desde su último paso completado. Y puedes pensar en los flujos de trabajo y sus puntos de control como funcionando mucho como los puntos de guardado en un videojuego, donde si estás jugando, puedes guardar regularmente, de modo que si mueres, puedes recargar desde el último guardado. Y cuando estás ejecutando un flujo de trabajo duradero, estás creando puntos de control en cada paso, de modo que si tu programa falla, puedes recargar, reanudar, recuperar desde el último paso completado.

Así que este tipo de flujos de trabajo son realmente útiles para todo tipo de aplicaciones, para procesos de negocio importantes, para pipelines de CI, para pipelines de datos, y hoy en día también para agentes. Así que hay muchos sistemas de flujos de trabajo por ahí, pero la mayoría de ellos son bastante grandes y complicados. No son fáciles de integrar en una aplicación JavaScript. La arquitectura clásica para flujos de trabajo duraderos es lo que me gusta llamar orquestación externa. Y la idea aquí es que tienes una superficie de orquestador central que orquesta tus flujos de trabajo. Y si quieres ejecutar un flujo de trabajo, ahora ejecutas el flujo de trabajo y no en tu propia aplicación JavaScript, sino en el servicio.

Ejemplos de estos servicios incluyen AWS Step Functions, Airflow, Temporal, ya sabes, esos tipos de sistemas. Y luego la forma en que funcionan es que tu servidor envía una solicitud al servicio de flujo de trabajo para iniciar un flujo de trabajo. El servicio de flujo de trabajo despacha el primer paso en el flujo de trabajo a un trabajador. El trabajador ejecuta la tarea. El servicio despacha el segundo paso y así sucesivamente hasta que cada paso ha sido despachado y el flujo de trabajo está terminado. Estos son sistemas grandes y pesados y funcionan, pero requieren que asumas grandes dependencias, añadas nuevos servicios, re-arquitectures tu aplicación. También pueden tener una alta sobrecarga de latencia desde el despacho de pasos.

Podrías estar añadiendo decenas o cientos de milisegundos a la latencia de cada uno de tus pasos. Así que sistemas efectivos, pero pesados y tal vez no algo que quieras añadir a tu aplicación backend node. Así que lo que quiero decirte es que los flujos de trabajo deben ser simples. Tu flujo de trabajo debe ser algo que puedas simplemente poner en tu aplicación node sin necesitar toda esta infraestructura. Y los flujos de trabajo que construyas en tu aplicación node deben ser tan confiables y poderosos como los que se construyen y escalan como los que se construyen usando toda esta infraestructura.

Y específicamente, te voy a mostrar cómo puedes implementar flujos de trabajo como una biblioteca de JavaScript, como una biblioteca que puedes instalar en tu aplicación. Puedes npm install esta biblioteca y esta biblioteca te dará a tu aplicación flujos de trabajo duraderos. Podrás crear puntos de control de flujos de trabajo y pasos directamente desde tus servidores de aplicaciones, tal como lo harías con un gran clúster complicado. Así que esta es la arquitectura. Vamos a diseñar esta biblioteca juntos. Así es como se ve la arquitectura de esta biblioteca, donde tienes la biblioteca instalada con tus servidores de aplicaciones y ejecuta los flujos de trabajo directamente en tus servidores y crea puntos de control de sus flujos de trabajo y pasos en una base de datos.

Así que aquí está cómo se ve la interfaz de esta biblioteca que vamos a diseñar. Es realmente bastante simple. Escribes flujos de trabajo y pasos como funciones normales de JavaScript. Luego, solo hay dos métodos en la interfaz de nuestra biblioteca y vamos a diseñar ambos métodos. El primero es register workflow, que registra una función ordinaria de JavaScript como un flujo de trabajo. Y el otro es run step, que ejecuta una función ordinaria de JavaScript como un paso en un flujo de trabajo. Así que construiremos estas dos interfaces y a partir de estas, obtendremos flujos de trabajo duraderos. Y la forma en que esta biblioteca va a funcionar es que va a crear puntos de control de flujos de trabajo y pasos en una base de datos. Así que cuando un flujo de trabajo comienza, la biblioteca creará un punto de control de las entradas del flujo de trabajo. Y luego, a medida que cada paso del flujo de trabajo se completa, la biblioteca creará un punto de control del resultado de ese paso en una base de datos.

Y finalmente, cuando el flujo de trabajo termina, la biblioteca realizará un punto de control del resultado del flujo de trabajo. Y debido a que la entrada del flujo de trabajo y cada paso tiene un punto de control, si algo falla o se rompe o se bloquea, la biblioteca puede buscar el punto de control para recuperar cada flujo de trabajo desde su último paso completado.

Así que comencemos a implementar esta biblioteca juntos en JavaScript. Y es lo suficientemente simple como para que podamos ajustar la mayor parte del código, al menos una versión simplificada del código justo aquí en estas diapositivas. Así que comencemos con el primer método. Bueno, veremos tres métodos. Y el primero es run workflow. Y este método va a tomar una función de JavaScript, el flujo de trabajo, y sus argumentos, y ejecutará esta función como un flujo de trabajo duradero, realizando puntos de control de ella y sus pasos para que puedan ser recuperados de manera segura. Y sé que este bloque de código puede parecer intimidante, pero lo revisaremos línea por línea para ver exactamente qué hace.

Así que el primer paso para ejecutar un flujo de trabajo es generar un ID globalmente único para el flujo de trabajo que pueda ser usado para referenciarlo. Luego vamos a realizar un punto de control de los flujos de trabajo, vamos a realizar un punto de control de las entradas de los flujos de trabajo. Así que vamos a escribir nuestros registros en la base de datos con este ID de flujo de trabajo, sus entradas y el estado pendiente. Así que ahora tenemos un registro que dice que este flujo de trabajo ha comenzado con estas entradas y este ID único. Y podemos usar ese registro más tarde para recuperar el flujo de trabajo si algo falla. Ahora que hemos, ya sabes, persistido de manera duradera un registro que dice que el flujo de trabajo comenzó, ahora podemos realmente ejecutar la función del flujo de trabajo. Así que la función del flujo de trabajo, solo una función ordinaria de JavaScript, la llamaremos con sus argumentos originales.

Y finalmente, cuando el flujo de trabajo se completa, actualizaremos su registro de estado con su salida y lo marcaremos como un éxito. Así es como ejecutas una función de flujo de trabajo. Generas un ID único, realizas un punto de control de sus entradas, ejecutas la función real en sí, y realizas un punto de control de sus salidas. Por supuesto, no solo queremos tener puntos de control al principio y al final. Queremos tener algunos en el medio también. Así que la siguiente función que tenemos que implementar es run step. Y esto realizará un punto de control de cada paso en un flujo de trabajo para que podamos realizar un punto de control de cada paso que el flujo de trabajo toma. Y si algo se rompe, te recuperarás desde el último paso complicado. Así que lo primero que haces, esto es run step. Toma un paso, que puede ser cualquier función de JavaScript y los argumentos del paso, y ejecuta de manera duradera y realiza un punto de control del paso.

Entonces, lo primero que haces en run step es recuperar el contexto de los flujos de trabajo. Así que recuperas el ID del flujo de trabajo y el ID del paso, que es solo un índice en el número de pasos que este flujo de trabajo está ejecutando. Así que recuperas el ID del flujo de trabajo y el ID del paso del contexto, que podría ser de un argumento de contexto que estás pasando o de un almacenamiento local. Luego, después de tener tu ID de flujo de trabajo y ID de paso, a continuación, verificas si ya existe un punto de control para el paso porque tal vez estás recuperándote de una falla y el paso ya se ejecutó y queremos recuperar una salida con punto de control en lugar de volver a ejecutarlo. Así que vamos a buscar en la base de datos, si existe un punto de control para este ID de flujo de trabajo y ID de paso. Y si existe uno, devolveremos ese punto de control directamente en lugar de volver a ejecutar el flujo de trabajo. Si no hay paso, si no hay punto de control, entonces simplemente ejecutaremos directamente la función del paso, llamándola con sus argumentos originales y obteniendo su salida. Y luego escribiremos esta salida en la base de datos.

Así que escribiremos un punto de control para este ID de flujo de trabajo, el ID del paso y el resultado que acabamos de recuperar. Así que para resumir, cuando quieres ejecutar un paso, primero vas a verificar si ya existe un punto de control para el paso. Si existe uno, devuelve un punto de control directamente, de lo contrario, ejecuta el paso y verifica cuál es el resultado. Así que ahora estamos casi terminando de implementar nuestra pequeña biblioteca. El último paso, lo último que necesitamos es una forma de recuperar flujos de trabajo que han fallado previamente. Usando estos puntos de control, en los que acabamos de pasar tanto tiempo construyendo. Así que aquí está cómo se ve nuestra función de recuperación de flujos de trabajo. Y de nuevo, bastante simple.

Esta función se ejecutará cada vez que un programa con nuestra biblioteca se inicie. Lo primero que hará es obtener una lista de todos los flujos de trabajo pendientes, todos los flujos de trabajo que comenzaron pero no terminaron. Estos son flujos de trabajo que presumiblemente fallaron y vamos a recuperarlos. Luego iteramos a través de cada uno de estos flujos de trabajo fallidos y forjamos estos flujos de trabajo. Vamos a recuperar su entrada con punto de control. ¿Recuerdas cómo hicimos puntos de control antes? Y vamos a buscar la función real del flujo de trabajo de un mapa en memoria que creamos cuando cada flujo de trabajo fue registrado. Ahora que tenemos el ID único del flujo de trabajo, sus argumentos y la función en sí, simplemente vamos a llamar a run workflow, a través del cual hicimos anteriormente en la función del flujo de trabajo, el ID único y los argumentos.

Y run workflow, simplemente ejecutaremos el flujo de trabajo nuevamente desde el principio. Pero cada vez que el flujo de trabajo llega a un paso, verá que el paso ya ha sido registrado. Y en lugar de volver a ejecutar el paso, devolverá la salida registrada del paso. Y al hacer esto una y otra vez, el flujo de trabajo eventualmente se recuperará, eventualmente llegará al primer paso que no tiene un punto de control y reanudará la ejecución normal desde ese punto. Así que, en otras palabras, nuestro flujo de trabajo se recuperará desde el último paso completado siguiendo este procedimiento. Genial.

Así que ahora podemos ver aproximadamente cómo se ve nuestra biblioteca. Una última cosa que quiero mostrarte es un proceso diagramático de lo que esta biblioteca podría hacer cuando se aplica a una aplicación real. Así que vamos a ver un ejemplo de un flujo de trabajo. Así que un servicio de checkout, un servicio de checkout simplificado del tipo que podrías ejecutar cuando haces clic en el botón de compra en un sitio web. Así que este flujo de trabajo se implementaría como una función de JavaScript. Y cada uno de estos pasos como crear pedido, reservar inventario, procesar pago, también serían funciones de JavaScript. Así que cuando ejecutamos este flujo de trabajo, llamamos a run workflow.

Lo primero que hacemos es registrar las entradas. Así que escribiremos un registro en la base de datos que contenga las entradas del flujo de trabajo, el ID único, y marcaremos el flujo de trabajo con un estado pendiente. Luego, una vez que hemos escrito ese punto de control, podemos comenzar a ejecutar realmente el flujo de trabajo. Así que creamos un pedido, reservamos inventario, procesamos el pago, y después de cada paso, registramos el resultado de los pasos. Entonces, digamos que algo se rompe. Acabamos de procesar el pago, y de repente nuestro servidor falla. Y nuestro proceso ya no está en ejecución. Normalmente, eso sería bastante malo porque nuestros clientes pagaron por algo, y esperan que su pedido sea cumplido, pero no lo sabemos porque nuestro proceso simplemente se estrelló.

Recuperar eso podría ser complicado, pero tenemos flujos de trabajo duraderos, así que es mucho más fácil. Así que cuando nuestro servidor se reanuda, mirará la base de datos y verá que hay este flujo de trabajo que está en un estado pendiente, por lo que necesita ser recuperado. Luego recuperará el flujo de trabajo, buscando cada uno de sus pasos, y devolviendo el resultado registrado. Así que verá que los pasos de crear pedido, reservar inventario, y procesar pago fueron todos exitosos. Así que los adelantará, recargará desde sus puntos de control, y ahora los volverá a ejecutar. Luego finalmente, llegaremos al primer, paso aún no completado, cumplir pedido. Lo ejecutaremos, cumpliremos el pedido, haremos feliz al cliente, y luego marcaremos los flujos de trabajo como exitosos, y haremos todo eso sin volver a ejecutar nada, sin doble reservar inventario, o doble cobrar al cliente.