No desenvolvimento de software moderno, criar fluxos de trabalho robustos que conectam APIs de vários serviços e lidam com eventos síncronos e assíncronos é um desafio comum. A abordagem convencional envolve o uso de uma combinação de filas, microsserviços e sistemas de gerenciamento de estado para construir aplicativos escalonáveis. Embora eficaz, essa arquitetura traz uma sobrecarga significativa: configuração e manutenção de infraestrutura como filas de mensagens, execução de servidores ou funções lambda, gerenciamento de estado em bancos de dados e implementação de mecanismos complexos de tratamento de erros.

E se houvesse uma maneira mais simples e confiável de lidar com fluxos de trabalho de longa duração sem o incômodo de gerenciar toda essa infraestrutura? Esse é o objetivo do Durable Python, para experimentá-lo, registre-se no Beta.

O problema com soluções ingênuas para processos de longa duração

Imagine que você deseja monitorar pull requests (PRs) no GitHub. Cada vez que um novo PR é aberto, você gostaria de criar um canal Slack dedicado para discussão e enviar lembretes diários até que o PR seja fechado ou mesclado. Isso parece simples, então você pode pensar que pode resolvê-lo com uma função Python básica (aqui está uma função Python básica gerada pelo 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 trecho de código parece dar conta da tarefa, mas é adequado apenas para o cenário de “fluxo feliz”. Em aplicações do mundo real, esta abordagem ingénua é insuficiente. O loop while depende do tempo de atividade contínuo do servidor, o que não é garantido. Os processos podem travar, os servidores podem reiniciar e, de repente, seu fluxo de trabalho é interrompido.

Solução do mundo real: aplicativos orientados a eventos

Uma abordagem mais confiável envolve a construção de um aplicativo orientado a eventos. Aqui, você usaria filas para escutar eventos do GitHub, cron jobs para enviar lembretes, bancos de dados para armazenar o PR e o estado do canal e funções para lidar com esses eventos. Normalmente, essa configuração é executada em infraestrutura em nuvem, aproveitando serviços como AWS Lambda para implantação e execução.

Embora esse método seja viável e robusto, ele também requer configuração, manutenção e experiência consideráveis. Gerenciar a infraestrutura, garantir o tempo de atividade e lidar com estados de erro exigem recursos significativos e uma equipe qualificada.

Entre no Python durável: a simplicidade encontra a confiabilidade

E se você pudesse combinar a simplicidade do código Python ingênuo com a confiabilidade de um design assíncrono? E se o Python pudesse garantir que mesmo se um processo travasse ou o servidor reiniciasse, ele continuaria exatamente de onde parou?

AutoKitteh aborda precisamente esse desafio com Durável Python. Usando o Durável Python, o usuário escreve o código Python enquanto o sistema garante que, se um processo for reiniciado, ele continuará em execução a partir do mesmo ponto. Embora existam limitações (por exemplo, um longo tempo de inatividade pode não ser ideal), para a maioria dos casos de uso, esta solução funciona perfeitamente.

O que o Python durável oferece

Durable-Python evita que você gerencie o estado manualmente, permitindo que você escreva seu fluxo de trabalho como um fluxo contínuo em vez de uma máquina de estado orientada a eventos, o que pode ser desafiador para construir e depurar. O AutoKitteh, como infraestrutura, possui filas integradas e integrações com aplicativos externos e APIs, facilitando o desenvolvimento rápido de fluxos de trabalho robustos em Python.

Como funciona

Não há mágica envolvida – apenas engenharia sólida. AutoKitteh é desenvolvido com Temporal, uma estrutura para construir fluxos de trabalho duráveis. Temporal requer uma forma específica de codificação, incluindo uma compreensão de determinismo, idempotência e outros conceitos para garantir confiabilidade. O AutoKitteh abstrai essas complexidades, permitindo que os desenvolvedores escrevam código Python padrão. Nos bastidores, qualquer função com efeitos colaterais é convertida em uma atividade temporal. Como desenvolvedor, você não precisa se preocupar com esses detalhes – concentre-se apenas em escrever a lógica de negócios.

Para mais detalhes técnicos, consulte a documentação do AutoKitteh.

Existe um custo?

É claro que toda abstração tem um preço. Nos bastidores, o Durável Python registra o fluxo do fluxo de trabalho para permitir a recuperação após falha, o que incorre em alguns custos de armazenamento e desempenho.

Durable Python foi projetado para a orquestração de APIs, em vez de construir aplicativos de dados. Se você precisar de aplicativos de alto desempenho, considere criar uma solução personalizada. No entanto, se você deseja desenvolver fluxos de trabalho confiáveis ​​rapidamente com investimento mínimo em desenvolvimento e infraestrutura, o Python durável pode ser uma boa opção.

Aplicações do mundo real

Python durável pode ser aplicado a uma ampla variedade de fluxos de trabalho, especialmente em domínios onde a confiabilidade é crucial, como:

• Orquestração de API - crie fluxos de trabalho internos confiáveis.
• Automação DevOps: automatize pipelines de implantação ou automação de revisão de código com recuperação garantida de falhas.
• ChatOps: integre-se a plataformas de chat para automatizar notificações de equipe e gerenciar fluxos de trabalho.
• MLOps: garanta que fluxos de trabalho de aprendizado de máquina de longa duração continuem perfeitamente, apesar das interrupções.

Exemplos de fluxos de trabalho podem ser encontrados aqui.

Conclusão: menos código, menos complicações

O conceito Python durável, implementado com tecnologia AutoKitteh, capacita os desenvolvedores a construir, implantar e gerenciar automação de fluxo de trabalho confiável com código mínimo. A execução durável e a recuperação contínua são tratadas nos bastidores, para que você possa se concentrar no que realmente importa: sua lógica de negócios.

Embora existam muitas ferramentas excelentes para alcançar durabilidade (como Temporal e Restate), o Durável-Python fornece uma maneira rápida, simples e econômica de obter os mesmos resultados.