Vai al contenuto
Sistema

Accelerare grep su grandi file sotto Linux

Avatar illustré de Julien Macé 7 min di lettura
Poste d’administration Linux consacré à l’analyse de journaux volumineux
Illustration éditoriale générée : analyse prudente de journaux Linux volumineux. Ce n’est pas une mesure de performance.

Una ricerca su un grande application.log può richiedere tempo, ma il cronometro da solo non indica se grep sta leggendo troppi file, visualizzando troppe righe o applicando un pattern costoso. Prima di confrontare i comandi, identifica il file, verifica che sia leggibile e stabile, quindi conserva una ricerca completa come riferimento. I percorsi qui sotto sono esempi da adattare al tuo sistema.

Postazione di amministrazione Linux dedicata all'analisi di registri voluminosi
Illustrazione editoriale generata: analisi prudente di registri Linux voluminosi. Non è una misura di prestazioni.

Identificare il file e stabilire una ricerca completa

Inizia confermando lo strumento, il percorso, la dimensione, la data di modifica e i tuoi diritti di lettura. Usa una copia congelata del registro se il servizio continua a scrivere al suo interno.

grep --version
test -f application.log && test -r application.log
stat -c '%n : %s byte, modifica %y' -- application.log
test -x /usr/bin/time

Il comando stat descrive l’obiettivo senza sfogliare il suo contenuto. Se un controllo fallisce, fermati: verifica il percorso o l’accesso al file invece di ampliare la ricerca all’intero sistema. I registri possono contenere indirizzi, identificatori o token; non copiare la loro uscita in uno spazio condiviso senza averla esaminata.

In seguito, avvia una ricerca esaustiva e leggibile:

grep -nF -e 'ERROR' -- application.log
rc=$?
printf 'Codice grep: %sn' "$rc"

-n aggiunge il numero di riga. -F interpreta ERROR come testo letterale. -e designa il pattern, e -- indica che gli argomenti successivi sono percorsi, anche se iniziano con un trattino. Per un file contenente errori, il comando visualizza ogni riga selezionata; il codice 0 significa che almeno una riga corrisponde. Il codice 1 significa che nessuna riga corrisponde. Il codice 2 segnala un errore, ad esempio un file mancante o illeggibile. Mantieni i diagnostic su stderr visibili: un risultato vuoto con un errore non è una ricerca riuscita.

Questo riferimento fissa il pattern e il corpus. Permette di verificare le modifiche successive invece di confondere un’uscita più corta con un’elaborazione più rapida.

Ridurre i file esaminati prima di cambiare il pattern

Se stai cercando solo nei registri di un servizio, nomina i suoi file anziché eseguire una ricorsione ampia. Per un elenco corto, passa direttamente i percorsi interessati a grep. Verificali in anticipo con test -f e test -r se la loro presenza o accesso non è garantito.

Per selezionare i file .log da un albero escludendo esplicitamente archives, ispeziona prima l’elenco:

find . -type d -name archives -prune -o -type f -name '*.log' -print

Dopo aver confermato che questo perimetro corrisponde bene alla questione, puoi passare i percorsi direttamente a grep:

find . -type d -name archives -prune -o -type f -name '*.log' 
  -exec grep -HnF -e 'ERROR' -- {} +

-prune impedisce a find di scendere nella cartella esclusa. -exec ... {} + raggruppa i percorsi in batch; non garantisce che una sola esecuzione sia sufficiente per un elenco molto grande. -H mantiene il nome del file nell’uscita, anche quando un batch contiene solo un file. I percorsi sono passati come argomenti, senza tagli errati sugli spazi. Mantieni stderr visibile: lo stato aggregato di find con -exec ... + non distingue sempre di per sé un’assenza di corrispondenza da un errore di grep in un batch. Un albero modificato durante la traversata non è uno snapshot.

Un’altra possibilità, con GNU grep, è una ricorsione mirata:

grep -rHnF --include='*.log' --exclude='*.gz' 
  --exclude-dir=archives -e 'ERROR' -- .

Le esclusioni sono visibili nel comando e devono rimanere da adattare ai file realmente utili. -r percorre le directory senza seguire i link simbolici incontrati durante la discesa; non sostituirlo con -R, che segue anche questi link e può ampliare il corpus. Escludere i file riduce il lavoro perché alcuni non vengono più cercati: non è un’ottimizzazione a risultati equivalenti. Un unico file molto voluminoso non è accorciato dall’esclusione di una directory.

Usare -F e la locale C senza cambiare le corrispondenze

Mantieni -F quando il pattern è una stringa letterale, come ERROR. Scegli -E se la necessità descrive una struttura, ad esempio un prefisso di riga seguito da un separatore. Non accumulare -F e -E: sono due modi diversi di interpretare il pattern. Non trasformare una ricerca letterale in espressione regolare solo con la speranza di guadagnare tempo.

Un elenco può anche essere letto con -f, una regola per riga. Per preparare un elenco di pattern per grep, verifica in particolare che non contenga righe vuote involontariamente: un pattern vuoto può selezionare tutte le righe.

Per un pattern ASCII sensibile al maiuscolo/minuscolo, LC_ALL=C è un candidato da confrontare:

LC_ALL=C grep -nF -e 'ERROR' -- application.log

La locale C può rendere alcuni trattamenti più efficienti, ma cambia anche le regole dei caratteri. Non è una conversione del file in UTF-8. I comportamenti legati ai caratteri Unicode, a -i, alle classi come [[:alpha:]] e agli intervalli come [a-z] possono differire. Non usare quindi questo prefisso se il significato del pattern dipende da queste regole; non esportarlo globalmente. Verifica le corrispondenze sul corpus interessato prima di interpretare un tempo. Se grep segnala che un file è binario, controlla perché grep tratta il file come binario prima di scegliere una risposta; non mascherare il problema con un’opzione di prestazioni.

Scegliere tra tutte le righe, un conteggio e una prima prova

Queste opzioni non rispondono allo stesso obiettivo. Un’uscita più corta non significa che grep abbia letto meno dati.

Modalità Risultato ottenuto Momento di arresto Cosa non prova
Ricerca completa Tutte le righe selezionate Dopo il percorso necessario del file Che un altro pattern o corpus sarebbero equivalenti
-m 1 Al massimo una riga selezionata per file Dopo la prima corrispondenza di ogni file Che le altre corrispondenze non esistano
-l I nomi dei file che contengono una corrispondenza Al primo match di ogni file Il contenuto completo né il numero di righe
-c Il numero di righe selezionate per file Dopo il conteggio necessario Il numero di occorrenze: due pattern su una riga contano come una riga
-q Nessun risultato su stdout; codice 0 non appena un match Alla prima corrispondenza Una lettura esaustiva: un errore dopo il match può essere nascosto

Scegli -m, -l o -q solo se la questione riguarda realmente una prima prova. -c riduce l’output, ma il conteggio completo richiede generalmente di esaminare il file. Nessuna di queste modalità dovrebbe essere temporizzata contro una ricerca esaustiva come se i risultati attesi fossero identici.

Distingere il ritardo di un pipe dal tempo di ricerca

--line-buffered chiede a grep di svuotare la sua uscita dopo ogni riga quando scrive in un pipe. Questo può ridurre l’attesa prima della visualizzazione in un flusso; non è un’accelerazione universale della lettura di un grande file. Il programma successivo nel pipe può anche tamponare la sua uscita. I messaggi di errore di grep rimangono su stderr.

Per controllare gli stati dei due comandi in Bash, copia PIPESTATUS immediatamente dopo il pipe, prima di qualsiasi altro comando:

grep -nF -e 'ERROR' -- application.log | wc -l
codes=("${PIPESTATUS[@]}")
printf 'grep=%s wc=%sn' "${codes[0]}" "${codes[1]}"

Il numero visualizzato da wc non sostituisce l’uscita di riferimento e il suo codice da solo non rivela un errore di grep. Per un registro in monitoraggio o trovare un errore con il suo contesto, il bisogno è diverso da un confronto di ricerca esaustiva.

Confrontare le uscite prima di confrontare i tempi

Misura in un laboratorio privato situato al di fuori dell’albero ricercato. mktemp crea un directory temporanea; verifica che la sua posizione sia affidabile e che disponga di abbastanza spazio per due uscite complete. Lavora su un file stabile. L’esempio confronta la stessa ricerca letterale, con e senza locale C:

laboratorio=$(mktemp -d "${TMPDIR:-$HOME}/grep-perf.XXXXXX") || exit 1
stat -c '%n : %s byte, modifica %y' -- application.log

/usr/bin/time -f 'real=%e user=%U sys=%S codice=%x' 
  grep -nF -e 'ERROR' -- application.log > "$laboratorio/reference.txt"
ref_rc=$?

/usr/bin/time -f 'real=%e user=%U sys=%S codice=%x' 
  env LC_ALL=C grep -nF -e 'ERROR' -- application.log > "$laboratorio/candidate.txt"
candidate_rc=$?

printf 'riferimento=%s candidato=%sn' "$ref_rc" "$candidate_rc"
cmp -- "$laboratorio/reference.txt" "$laboratorio/candidate.txt"
cmp_rc=$?
printf 'Comparazione: %sn' "$cmp_rc"
stat -c '%n : %s byte, modifica %y' -- application.log

/usr/bin/time esterno mostra il tempo reale (real), il tempo CPU utente e di sistema (user, sys), così come lo stato del comando. Le due uscite vanno in file distinti; i diagnostici rimangono visibili. Lo stato 0 di cmp significa che le uscite sono identiche, 1 che differiscono e 2 che la comparazione è fallita.

Non interpretare i tempi se le due ricerche non hanno lo stato atteso, che nessun diagnostico è apparso, che cmp restituisce 0 e che i metadati del file di ingresso sono coerenti prima e dopo. Un’uguaglianza su un ingresso non prova l’equivalenza per tutti i file futuri. Se ti aspetti delle corrispondenze, verifica anche una riga nota.

Ripeti le misurazioni in un ordine alternato: la cache di sistema, il carico e lo storage possono influenzare il risultato. Mantieni lo stesso perimetro, le stesse opzioni e le stesse uscite; non purgare la cache in produzione. Il guadagno non è misurato qui. Un’interruzione lascia uscite parziali, non una prova completa.

Il metodo presuppone file di testo ordinari e stabili. Una rotazione durante la ricerca, una riga gigante, un file compresso o binario, un registro attivo e la mancanza di spazio per i risultati impongono una diagnostica distinta. Per una verifica finale, rileggi i codici e confronta ancora i metadati di application.log prima di conservare i risultati.

Fonti da verificare

Condividi Facebook X WhatsApp LinkedIn Pinterest Reddit E-mail