Execução paralela de automações Python: métodos e exemplo

Quando falamos de automação web, temos particularidades que as tornam mais poderosas e eficientes em alguns contextos. Fazer essa execução paralela com código Python aumenta a eficiência ao executar múltiplas tarefas simultaneamente. Com o objetivo de lidar com desafios de grande escala, essa abordagem tem um impacto significativo na redução do tempo de processamento geral.

Como exemplo de implementação, temos a possibilidade de executar várias automações em paralelo quando utilizamos webdrivers.

Como funciona o webdriver?

O webdriver fornece um protocolo de conexão com navegadores, sendo possível controlá-los com um conjunto de interfaces que permitem descobrir e manipular o Document Object Model (DOM).

Essa comunicação ocorre através do protocolo HTTP (Hypertext Transfer Protocol). O webdriver disponibiliza uma lista de endpoints que recebem comandos e geram ações (que podem ser cliques) ou retorno de informações (que podem ser textos) de uma página ou elemento específico.

Quando encontramos um elemento de botão, temos entre as opções, a possibilidade de realizar um clique nele. Através do webdriver, essa ação de clique ocorre por meio de uma chamada de API, fazendo com que os recursos físicos da máquina não fiquem ocupados.

É possível fazer o paralelismo de execução de automações web justamente por essa característica, as chamadas são individuais e vinculadas a uma sessão do webdriver, fazendo com que não haja interferência entre as execuções de automações diferentes, nem mesmo alocação de recursos I/O (input/output) da máquina.

Exemplo de código python + webdriver

Para exemplificar a construção de automações web, vamos utilizar o template de projeto da BotCity para realizar um processo simples:

Abrir o navegador na página do google;
Buscar pelo elemento DOM da caixa de pesquisa;
Digitar o texto;
Busca pelo elemento DOM do botão ‘estou com sorte’;
Clicar no botão ‘estou com sorte’;
Aguardar a página carregar totalmente;
- Cada vez que a página é carregada, uma imagem diferente aparece;
Fazer uma captura de tela;
Enviá-la para o BotCity Orquestrador;
Finalizar a tarefa.

Dentro da estrutura do projeto criado a partir do template, vamos identificar o arquivo bot.py e alterá-lo da seguinte forma:

# Imports da biblioteca BotCity
from botcity.web import WebBot, Browser, By
from botcity.maestro import *

# Desabilita os erros caso não esteja conectado ao Orquestrador
BotMaestroSDK.RAISE_NOT_CONNECTED = False

def main():
    # Instancia do BotMaestroSDK para integração com o Orquestrador
    maestro = BotMaestroSDK.from_sys_args()
    execution = maestro.get_execution()
    print(f"Task ID is: {execution.task_id}")
    print(f"Task Parameters are: {execution.parameters}")

    # Instancia do WebBot
    bot = WebBot()

    # Configura o navegador para ser executado em modo headless
    bot.headless = True

    # Seleciona o navegador que será utilizado
    bot.browser = Browser.FIREFOX

    # Define o caminho do webdriver
    bot.driver_path = "resources\geckodriver.exe"

    # Abre o navegador e navega até o site do Google
    bot.browse("https://www.google.com")

    # Encontra o elemento DOM de caixa de texto
    caixa_texto = bot.find_element("APjFqb", By.ID)

    # Digita o texto na caixa de texto
    caixa_texto.send_keys("This person does not exist")

    # Encontra o elemento DOM de botão 'estou com sorte'
    botao_sorte = bot.find_element(
        ".FPdoLc > center:nth-child(1) > input:nth-child(2)",
        By.CSS_SELECTOR
    )

    # Clica no botão
    botao_sorte.click()

    # Aguarda 3 segundos até carregar totalmente a página
    bot.wait(3000)

    # Faz uma captura de tela
    bot.save_screenshot(r"resources\foto.png")

    # Envia a foto para o Orquestrador
    maestro.post_artifact(
        task_id=execution.task_id,
        artifact_name="foto.png",
        filepath=r"resources\foto.png"
    )

    # Fecha o navegador
    bot.stop_browser()

    # Finalizando a tarefa no Orquestrador
    maestro.finish_task(
        task_id=execution.task_id,
        status=AutomationTaskFinishStatus.SUCCESS,
        message="Tarefa finalizada com sucesso!"
    )

if __name__ == '__main__':
    main()

Como gerenciar execuções paralelas?

Para fazer o paralelismo de execução de tarefas, o mais indicado é utilizar uma ferramenta de orquestração de automações, como o BotCity Orquestrador. Para isso, precisamos dos seguintes requisitos:

Automações web que interagem com navegadores via webdrivers;
Runners distintos para executar as automações em paralelo (cada runner executa uma tarefa por vez).

Além disso, ainda podemos paralelizar essas execuções com uma automação do tipo desktop, a qual utiliza os recursos I/O e visão computacional para realização de tarefas.

As automações web podem ser configuradas para executar no “modo headless”, ou seja, sem que a interface gráfica seja carregada, agindo como um serviço na máquina.

Desta forma, enquanto as automações web executam sem serem vistas, deixamos que os recursos fiquem livres para que a visão computacional opere no mesmo ambiente.

Passos a passo para a orquestração

Para esse exemplo, vamos executar uma automação desktop, que utiliza os recursos do ambiente, visão computacional e entradas de teclado. Ao mesmo tempo executar em paralelo uma automação web, em modo headless, sem necessidade de visualização da sua interface gráfica, assim não interferindo na automação desktop.

Passo 1:

Crie os Runners no BotCity Orquestrador. Configure-os com o tipo “background” para executar automações web e tipo “desktop” para executar automações desktop. Siga também o passo a passo de setup dos runners da documentação.

Passo 2:

Escolha o ambiente onde as automações executarão e faça a instalação via wizard do BotCity SDK. Após a instalação, precisamos garantir que os runners serão identificados corretamente. Então dentro da pasta de cada um, identifique o arquivo conf.bcf na pasta conf. Dentro deste arquivo, ajuste o machineID com os nomes dos runners criados. Dessa forma cada Runner poderá executar uma tarefa diferente.

Passo 3:

Crie e faça o deploy das automações na plataforma.

Passo 4:

Vincule cada automação aos runners criados anteriormente. Note que a automação desktop foi vinculada ao runner “vm-01” apenas, enquanto a automação web foi vinculada aos runners “vm-02” e “vm-03”.

Passo 5:

Crie várias tarefas para serem executadas paralelamente.

Passo 6:

Ao clicar em start na interface dos runners, eles farão a conexão com o BotCity Orquestrador, acessando a fila de tarefas e buscando as que foram vinculadas ao seu machineID. Dessa forma cada um dos Runners consegue executar uma tarefa diferente na fila.

Resultado

Após finalizar a execução, no menu de arquivos de resultado, as fotos capturadas no processo estarão disponíveis para download.

Nesse contexto, quanto mais runners disponíveis, mais tarefas podem ser executadas paralelamente. Lembrando que para execução com eficiência também é necessário que o ambiente suporte a execução dessas tarefas, verifique sempre as configurações da máquina em execução para decidir qual a quantidade ideal de runners para ela.

Tenha várias automações paralelas com RPA em Python

Se você busca uma solução de Automação de Processos Robóticos (RPA) para criar e orquestrar automações em Python, recomendamos que conheça a BotCity, que conta com um assistente de código em python e um orquestrador de automações em python para operações complexas. Você pode criar uma conta gratuita e testar todo o processo que apresentamos aqui. E caso tenha dúvidas, fique à vontade para enviá-las no fórum.