Python durable : créer des flux de travail de longue durée à l'épreuve des balles, en toute simplicité

Dans le développement de logiciels modernes, la création de flux de travail robustes qui connectent les API de divers services et gèrent les événements synchrones et asynchrones est un défi courant. L'approche conventionnelle consiste à utiliser une combinaison de files d'attente, de microservices et de systèmes de gestion d'état pour créer des applications évolutives. Bien qu'efficace, cette architecture entraîne des frais généraux importants : configuration et maintenance d'infrastructures telles que des files d'attente de messages, exécution de serveurs ou de fonctions lambda, gestion de l'état dans les bases de données et mise en œuvre de mécanismes complexes de gestion des erreurs.

Et s'il existait un moyen plus simple et plus fiable de gérer des flux de travail de longue durée sans avoir à gérer toute cette infrastructure ? C'est le but de Durable Python, pour l'essayer, inscrivez-vous à la bêta.

Le problème des solutions naïves pour les processus de longue durée

Imaginez que vous souhaitiez surveiller les demandes d'extraction (PR) dans GitHub. Chaque fois qu'un nouveau PR est ouvert, vous souhaitez créer un canal Slack dédié à la discussion et envoyer des rappels quotidiens jusqu'à ce que le PR soit fermé ou fusionné. Cela semble simple, vous pourriez donc penser que vous pouvez le résoudre avec une fonction Python de base (voici une fonction Python de base générée par 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'})

Cet extrait de code semble gérer la tâche, mais il ne convient que pour le scénario « happy flow ». Dans les applications du monde réel, cette approche naïve ne suffit pas. La boucle while repose sur une disponibilité continue du serveur, ce qui n'est pas garanti. Les processus peuvent planter, les serveurs peuvent redémarrer et tout à coup, votre flux de travail est interrompu.

Solution concrète : applications basées sur les événements

Une approche plus fiable consiste à créer une application basée sur les événements. Ici, vous utiliserez des files d'attente pour écouter les événements GitHub, des tâches cron pour envoyer des rappels, des bases de données pour stocker le PR et l'état du canal, et des fonctions pour gérer ces événements. En règle générale, cette configuration s'exécute sur une infrastructure cloud, en tirant parti de services tels qu'AWS Lambda pour le déploiement et l'exécution.

Bien que cette méthode soit réalisable et robuste, elle nécessite également une configuration, une maintenance et une expertise considérables. La gestion de l'infrastructure, la garantie de la disponibilité et la gestion des états d'erreur nécessitent des ressources importantes et une équipe qualifiée.

Entrez dans Python durable : la simplicité rencontre la fiabilité

Et si vous pouviez combiner la simplicité du code Python naïf avec la fiabilité d'une conception asynchrone ? Et si Python pouvait garantir que même si un processus plante ou si le serveur redémarre, il reprendrait là où il s'était arrêté ?

AutoKitteh relève précisément ce défi avec Durable Python. Grâce à Durable Python, l'utilisateur écrit du code Python tandis que le système garantit que si un processus redémarre, il continue de s'exécuter à partir du même point. Bien qu'il existe des limites (par exemple, un temps d'arrêt prolongé n'est peut-être pas idéal), dans la plupart des cas d'utilisation, cette solution fonctionne parfaitement.

Ce que propose Durable-Python

Durable-Python vous évite de gérer l'état manuellement, vous permettant d'écrire votre flux de travail sous la forme d'un flux continu plutôt que d'une machine à états pilotée par les événements, ce qui peut être difficile à créer et à déboguer. AutoKitteh, en tant qu'infrastructure, dispose de files d'attente intégrées et d'intégrations avec des applications et des API externes, ce qui facilite le développement rapide de flux de travail robustes en Python.

Comment ça marche

Il n’y a pas de magie en jeu, juste une ingénierie solide. AutoKitteh est alimenté par Temporal, un framework permettant de créer des flux de travail durables. Le temporel nécessite une méthode de codage spécifique, y compris une compréhension du déterminisme, de l'idempotence et d'autres concepts pour garantir la fiabilité. AutoKitteh résume ces complexités, permettant aux développeurs d'écrire du code Python standard. Sous le capot, toute fonction ayant des effets secondaires est convertie en une activité temporelle. En tant que développeur, vous n'avez pas à vous soucier de ces détails : concentrez-vous simplement sur l'écriture de la logique métier.

Pour plus de détails techniques, reportez-vous à la documentation AutoKitteh.

Y a-t-il un coût ?

Bien sûr, chaque abstraction a un prix. Sous le capot, Durable Python enregistre le flux du flux de travail pour permettre la récupération après une panne, ce qui entraîne des coûts de stockage et de performances.

Durable Python est conçu pour l'orchestration d'API plutôt que pour la création d'applications de données. Si vous avez besoin d'applications hautes performances, vous devriez envisager de créer une solution personnalisée. Cependant, si vous souhaitez développer rapidement des flux de travail fiables avec un minimum de développement et d'investissement en infrastructure, Durable Python pourrait être une bonne option.

Applications du monde réel

Durable Python peut être appliqué à un large éventail de flux de travail, en particulier dans les domaines où la fiabilité est cruciale, tels que :

• Orchestration d'API : créez des flux de travail internes fiables.
• Automatisation DevOps : automatisez les pipelines de déploiement ou l'automatisation de la révision du code avec une récupération garantie en cas de panne.
• ChatOps : intégrez les plateformes de chat pour automatiser les notifications d'équipe et gérer les flux de travail.
• MLOps : garantissez que les flux de travail d'apprentissage automatique de longue durée se poursuivent de manière transparente malgré les interruptions.

Des exemples de workflows peuvent être trouvés ici.

Conclusion : moins de code, moins de tracas

Le concept Python durable, mis en œuvre avec AutoKitteh, permet aux développeurs de créer, déployer et gérer une automatisation fiable des flux de travail avec un minimum de code. L'exécution durable et la récupération transparente sont gérées en coulisses, afin que vous puissiez vous concentrer sur ce qui compte vraiment : votre logique métier.

Bien qu'il existe de nombreux excellents outils pour atteindre la durabilité (comme Temporal et Restate), Durable-Python offre un moyen rapide, simple et rentable d'obtenir les mêmes résultats.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!