Processos de script em paralelo

Estou assumindo que você está fazendo isso em um loop de shell em todos os endereços IP, possivelmente com os endereços IP provenientes de um arquivo de texto. Sim, isso seria lento, com uma invocação de sedou greppor endereço IP.

Em vez disso, você pode se safar com um único uso de sed, se se preparar com cuidado.

Primeiro temos que criar um sedscript, e fazemos isso a partir de um arquivo ip.listque contém os endereços IP, um endereço por linha:

sed -e 'h' \
    -e 's/\./\\./g' \
    -e 's#.*#/^&[[:blank:]]/w /tmp/access-#' \
    -e 'G' \
    -e 's/\n//' \
    -e 's/$/.log/' ip.list >ip.sed

Este sedmaterial faz, para cada endereço IP,

1. Copie o endereço para o "hold space" (um buffer extra em sed).
2. Altere .o "espaço padrão" (a linha de entrada) para \.(para corresponder aos pontos corretamente, seu código não fez isso).
3. Anexar ^e anexar [[:blank:]]/w /tmp/access-ao espaço padrão.
4. Anexe a linha de entrada não modificada do espaço de retenção ao espaço do padrão com uma nova linha entre eles.
5. Exclua essa nova linha.
6. Acrescente .logao final da linha (e imprima implicitamente o resultado).

Para um arquivo que contém

127.0.0.1
10.0.0.1
10.0.0.100

isso criaria o sedscript

/^127\.0\.0\.1[[:blank:]]/w /tmp/access-127.0.0.1.log
/^10\.0\.0\.1[[:blank:]]/w /tmp/access-10.0.0.1.log
/^10\.0\.0\.100[[:blank:]]/w /tmp/access-10.0.0.100.log

Observe que você terá que corresponder a um caractere em branco (espaço ou tabulação) após o endereço IP, caso contrário, as entradas de log 10.0.0.100irão para o /tmp/access-10.0.0.1.logarquivo. Seu código omitiu isso.

Isso pode ser usado em seu arquivo de log (sem loop):

sed -n -f ip.sed /var/log/http/access.log

Nunca testei a gravação em 1200 arquivos de um único e mesmo sedscript. Se não funcionar, tente a awkvariação abaixo.

Uma solução semelhante awkenvolve primeiro ler os endereços IP em uma matriz e, em seguida, compará-los com cada linha. Isso requer uma única awkinvocação:

awk 'FNR == NR  { list[$1] = 1; next }
     $1 in list { name = $1 ".log"; print >>name; close name }' ip.list /var/log/http/access.log

Aqui, fornecemos awka lista de IP e o arquivo de log ao mesmo tempo. Quando NR == FNRsabemos que ainda estamos lendo o primeiro arquivo (a lista), adicionamos os números IP na matriz associativa listcomo chaves e continuamos com a próxima linha de entrada.

Se a FNR == NRcondição não for verdadeira, estamos lendo do segundo arquivo (o arquivo de log) e testamos se o primeiro campo da linha de entrada é uma chave list(esta é uma comparação de string simples, não uma correspondência de expressão regular) . Se for, anexamos a linha ao arquivo nomeado apropriadamente.

Devemos ter cuidado ao fechar o arquivo de saída, caso contrário, podemos ficar sem descritores de arquivo aberto. Portanto, haverá muitos arquivos abrindo e fechando para anexar, mas ainda será mais rápido do que chamar awk(ou qualquer utilitário) uma vez por endereço IP.

Eu estaria interessado em saber se essas coisas funcionam para você e qual pode ser o tempo de execução aproximado. Testei as soluções apenas em conjuntos de dados extremamente pequenos.

Claro, poderíamos seguir sua ideia de apenas força bruta, lançando várias instâncias de, por exemplo grep, no sistema em paralelo:

Ignorando o fato de que não combinamos os pontos nos endereços IP corretamente, podemos fazer algo como

xargs -P 4 -n 100 sh -c '
    for n do
        grep "^$n[[:blank:]]" /var/log/http/access.log >"/tmp/access-$n.log"
    done' sh <ip.list

Aqui, xargsfornecerá no máximo 100 endereços IP por vez do ip.listarquivo para um script de shell curto. Ele providenciará quatro invocações paralelas do script.

O script de shell curto:

for n do
    grep "^$n[[:blank:]]" /var/log/http/access.log >"/tmp/access-$n.log"
done

Isso apenas iterará sobre os 100 endereços IP fornecidos xargsem sua linha de comando e aplicará praticamente o mesmo grepcomando que você tinha, a diferença é que haverá quatro desses loops executando em paralelo.

Aumente -P 4para -P 16ou algo relacionado ao número de CPUs que você possui. A aceleração provavelmente não seria linear, pois cada instância paralela de grepleria e gravaria no mesmo disco.

Exceto pelo -Psinalizador para xargs, todas as coisas nesta resposta devem poder ser executadas em qualquer sistema POSIX. O -Psinalizador para xargsnão é padrão, mas implementado em sistemas GNU xargse BSD.

Para várias abordagens: https://stackoverflow.com/questions/9066609/fastest-possible-grep

Além disso, se você está fazendo muito isso, um SSD provavelmente é o caminho a percorrer. Tocar no HD é o assassino para algo assim.

Você tem um grande número de greps diferentes para executar. Crie um script que inicie comandos de script (digamos, um por núcleo) em segundo plano e, em seguida, rastreie quando eles terminarem, conforme forem concluídos, inicie mais.

Quando eu estava fazendo isso, consegui que todos os 12 núcleos rodassem com 100% de uso da CPU, mas você pode descobrir que seu limite de recursos é outra coisa. Dado que todos os seus trabalhos desejam o mesmo arquivo, se você não estiver em um SSD, convém copiar esse arquivo para que não sejam compartilhados.

Se /var/log/http/access.logfor maior que a RAM e, portanto, não puder ser armazenado em cache, executar mais processos em paralelo pode ser uma boa alternativa para ler access.logvárias vezes - especialmente se você tiver vários núcleos. Isso executará um greppor IP em paralelo (+ alguns processos de empacotamento de ajuda).

pargrep() {
    # Send standard input to grep with different match strings in parallel
    # This command would be enough if you only have 250 match strings
    parallel --pipe --tee grep ^{} '>' /tmp/access-{}.log ::: "$@"
}
export -f pargrep
# Standard input is tee'ed to several pargreps.
# Each pargrep gets 250 match strings and thus starts 250 processes.
# For 1200 ips this starts 3600 processes taking around 1 GB RAM,
# but it reads access.log only once
cat /var/log/http/access.log |
  parallel --pipe --tee -N250 pargrep {} :::: ips