Executar vários 'cat | Comandos zgrep' simultaneamente

Neste script Python, vários 'cat | Os comandos zgrep' são executados sequencialmente em um servidor remoto e suas saídas são coletadas individualmente para processamento. No entanto, para aumentar a eficiência, pretendemos executar esses comandos em paralelo.

Usando subprocessos sem threading

Ao contrário de usar multiprocessamento ou threading, você pode executar subprocessos em paralelo usando a seguinte abordagem:

#!/usr/bin/env python
from subprocess import Popen

# create a list of subprocesses
processes = [Popen("echo {i:d}; sleep 2; echo {i:d}".format(i=i), shell=True) for i in range(5)]

# collect statuses of subprocesses
exitcodes = [p.wait() for p in processes]

Este código inicia cinco comandos shell simultaneamente e coleta seus códigos de saída. Observe que o caractere & não é necessário neste contexto, pois Popen não espera a conclusão dos comandos por padrão. Você deve chamar explicitamente .wait() para recuperar seus status.

Subprocessos com coleta de saída

Embora seja conveniente coletar saída de subprocessos sequencialmente, você também pode usar threads para coleta paralela, se desejar . Considere o seguinte exemplo:

#!/usr/bin/env python
from multiprocessing.dummy import Pool # thread pool
from subprocess import Popen, PIPE, STDOUT

# create a list of subprocesses with output handling
processes = [Popen("echo {i:d}; sleep 2; echo {i:d}".format(i=i), shell=True,
                   stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
             for i in range(5)]

# collect outputs in parallel
def get_lines(process):
    return process.communicate()[0].splitlines()

outputs = Pool(len(processes)).map(get_lines, processes)

Este código executa subprocessos em paralelo e coleta suas saídas simultaneamente usando threads.

Execução paralela baseada em assíncio

Para Python versões 3.8 e superiores, asyncio oferece uma maneira elegante de executar subprocessos simultaneamente. Aqui está um exemplo:

#!/usr/bin/env python3
import asyncio
import sys
from subprocess import PIPE, STDOUT

async def get_lines(shell_command):
    p = await asyncio.create_subprocess_shell(
        shell_command, stdin=PIPE, stdout=PIPE, stderr=STDOUT
    )
    return (await p.communicate())[0].splitlines()


async def main():
    # create a list of coroutines for subprocess execution
    coros = [get_lines(f'"{sys.executable}" -c "print({i:d}); import time; time.sleep({i:d})"') for i in range(5)]

    # get subprocess outputs in parallel
    print(await asyncio.gather(*coros))

if __name__ == "__main__":
    asyncio.run(main())

Este código demonstra como executar subprocessos simultaneamente em um único thread.

Ao implementar essas abordagens, você pode melhorar significativamente a eficiência do seu script executando vários 'gato | comandos zgrep' em paralelo no servidor remoto.