En el desarrollo de software moderno, crear flujos de trabajo sólidos que conecten API de varios servicios y manejen eventos sincrónicos y asincrónicos es un desafío común. El enfoque convencional implica el uso de una combinación de colas, microservicios y sistemas de gestión de estado para crear aplicaciones escalables. Si bien es efectiva, esta arquitectura conlleva una sobrecarga significativa: configurar y mantener infraestructura como colas de mensajes, ejecutar servidores o funciones lambda, administrar el estado en bases de datos e implementar mecanismos complejos de manejo de errores.

¿Qué pasaría si existiera una forma más sencilla y confiable de manejar flujos de trabajo de larga duración sin la molestia de administrar toda esta infraestructura? Ese es el objetivo de Durable Python, para probarlo, regístrate en Beta.

El problema de las soluciones ingenuas para procesos de larga duración

Imagina que quieres monitorear las solicitudes de extracción (PR) en GitHub. Cada vez que se abre un nuevo PR, le gustaría crear un canal de Slack dedicado para la discusión y enviar recordatorios diarios hasta que el PR se cierre o se fusione. Esto suena sencillo, por lo que podrías pensar que puedes resolverlo con una función básica de Python (aquí tienes una función básica de Python generada por ChatGPT):

@app.route('/webhook', methods=['POST'])
def github_webhook():
    data = request.json
    if 'pull_request' in data and data['action'] == 'opened':
        pr_number = data['pull_request']['number']
        pr_url = data['pull_request']['html_url']
        # Create a new Slack channel for the PR
        channel_id = create_slack_channel(pr_number)
        send_slack_notification(channel_id, pr_number, pr_url)
        # Periodically check the PR status and send reminders until it's closed or merged
        while True:
            time.sleep(3600)  # Wait for 1 hour before checking the status again
            pr_status = check_pr_status(pr_number)
            if pr_status == 'open':
                send_slack_notification(channel_id, pr_number, pr_url)
            else:
                break
    return jsonify({'status': 'ok'})

Este fragmento de código parece manejar la tarea, pero solo es adecuado para el escenario de "flujo feliz". En aplicaciones del mundo real, este enfoque ingenuo se queda corto. El bucle while depende del tiempo de actividad continuo del servidor, que no está garantizado. Los procesos pueden fallar, los servidores pueden reiniciarse y, de repente, su flujo de trabajo se interrumpe.

Solución del mundo real: aplicaciones basadas en eventos

Un enfoque más confiable implica crear una aplicación basada en eventos. Aquí, usaría colas para escuchar eventos de GitHub, trabajos cron para enviar recordatorios, bases de datos para almacenar el PR y el estado del canal, y funciones para manejar estos eventos. Normalmente, esta configuración se ejecuta en una infraestructura de nube y aprovecha servicios como AWS Lambda para la implementación y ejecución.

Si bien este método es factible y sólido, también requiere considerable configuración, mantenimiento y experiencia. Administrar la infraestructura, garantizar el tiempo de actividad y manejar los estados de error exige importantes recursos y un equipo capacitado.

Ingrese a Durable Python: la simplicidad se une a la confiabilidad

¿Qué pasaría si pudieras combinar la simplicidad del ingenuo código Python con la confiabilidad de un diseño asincrónico? ¿Qué pasaría si Python pudiera garantizar que incluso si un proceso falla o el servidor se reinicia, continuaría justo donde lo dejó?

AutoKitteh aborda precisamente este desafío con Durable Python. Al utilizar Durable Python, el usuario escribe código Python mientras el sistema garantiza que, si un proceso se reinicia, continúa ejecutándose desde el mismo punto. Si bien existen limitaciones (por ejemplo, un tiempo de inactividad prolongado puede no ser ideal), para la mayoría de los casos de uso, esta solución funciona perfectamente.

Lo que ofrece Durable-Python

Durable-Python le evita tener que administrar el estado manualmente, lo que le permite escribir su flujo de trabajo como un flujo continuo en lugar de una máquina de estado controlada por eventos, lo que puede ser un desafío para construir y depurar. AutoKitteh, como infraestructura, tiene colas integradas e integraciones con aplicaciones y API externas, lo que facilita el desarrollo rápido de flujos de trabajo sólidos en Python.

Cómo funciona

No hay magia involucrada, solo ingeniería sólida. AutoKitteh funciona con Temporal, un marco para crear flujos de trabajo duraderos. Temporal requiere una forma específica de codificación, incluida la comprensión del determinismo, la idempotencia y otros conceptos para garantizar la confiabilidad. AutoKitteh abstrae estas complejidades y permite a los desarrolladores escribir código Python estándar. Debajo del capó, cualquier función con efectos secundarios se convierte en una actividad temporal. Como desarrollador, no tiene que preocuparse por estos detalles; solo concéntrese en escribir la lógica empresarial.

Para obtener más detalles técnicos, consulte la documentación de AutoKitteh.

¿Hay algún costo?

Por supuesto, cada abstracción tiene un precio. Debajo del capó, Durable Python registra el flujo del flujo de trabajo para permitir la recuperación después de una falla, lo que genera algunos costos de almacenamiento y rendimiento.

Python duradero está diseñado para la orquestación de API en lugar de crear aplicaciones de datos. Si necesita aplicaciones de alto rendimiento, debería considerar crear una solución personalizada. Sin embargo, si desea desarrollar rápidamente flujos de trabajo confiables con una inversión mínima en desarrollo e infraestructura, Durable Python podría ser una buena opción.

Aplicaciones del mundo real

Python duradero se puede aplicar a una amplia gama de flujos de trabajo, particularmente en dominios donde la confiabilidad es crucial, como:

• Orquestación de API: cree flujos de trabajo internos confiables.
• Automatización de DevOps: automatice los procesos de implementación o la automatización de la revisión de código con recuperación garantizada ante fallas.
• ChatOps: integre con plataformas de chat para automatizar las notificaciones del equipo y administrar los flujos de trabajo.
• MLOps: garantiza que los flujos de trabajo de aprendizaje automático de larga duración continúen sin problemas a pesar de las interrupciones.

Aquí se pueden encontrar ejemplos de flujos de trabajo.

Conclusión: menos código, menos complicaciones

El concepto duradero de Python, implementado con la tecnología de AutoKitteh, permite a los desarrolladores crear, implementar y administrar una automatización confiable del flujo de trabajo con un código mínimo. La ejecución duradera y la recuperación perfecta se gestionan entre bastidores, para que usted pueda centrarse en lo que realmente importa: su lógica empresarial.

Si bien existen muchas herramientas excelentes para lograr durabilidad (como Temporal y Restate), Durable-Python proporciona una manera rápida, simple y rentable de lograr los mismos resultados.