Exclua com eficiência o diretório grande que contém milhares de arquivos

Temos um problema com uma pasta que se torna pesada com centenas de milhares de arquivos minúsculos.

Existem tantos arquivos que executar rm -rfretornam um erro e, em vez disso, o que precisamos fazer é algo como:

find /path/to/folder -name "filenamestart*" -type f -exec rm -f {} \;

Isso funciona, mas é muito lento e constantemente falha ao ficar sem memória.

Existe uma maneira melhor de fazer isso? Idealmente, eu gostaria de remover o diretório inteiro sem me preocupar com o conteúdo dele.

Usar o rsync é surpreendente, rápido e simples.

mkdir empty_dir
rsync -a --delete empty_dir/    yourdirectory/

A resposta do @ sarath mencionou outra opção rápida: Perl! Seus benchmarks são mais rápidos que rsync -a --delete.

cd yourdirectory
perl -e 'for(<*>){((stat)[9]<(unlink))}'

Fontes:

1. https://stackoverflow.com/questions/1795370/unix-fast-remove-directory-for-cleaning-up-daily-builds
2. http://www.slashroot.in/which-is-the-fastest-method-to-delete-files-in-linux

Alguém no Twitter sugeriu usar em -deletevez de-exec rm -f{} \;

Isso melhorou a eficiência do comando, mas ainda usa recursão para passar por tudo.

Que tal algo como: find /path/to/folder -name "filenamestart*" -type f -print0 | xargs -0rn 20 rm -f

Você pode limitar o número de arquivos a serem excluídos de uma só vez, alterando o argumento para o parâmetro -n. Os nomes dos arquivos com espaços em branco também estão incluídos.

Um truque inteligente:

rsync -a --delete empty/ your_folder/

É super intensivo em CPU, mas realmente muito rápido. Consulte https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html

Expandindo um dos comentários, não acho que você esteja fazendo o que pensa que está fazendo.

Primeiro, criei uma enorme quantidade de arquivos para simular sua situação:

$ mkdir foo
$ cd foo/
$ for X in $(seq 1 1000);do touch {1..1000}_$X; done

Depois, tentei o que esperava falhar e o que parece que você está fazendo na pergunta:

$ rm -r foo/*
bash: /bin/rm: Argument list too long

Mas isso faz o trabalho:

$ rm -r foo/
$ ls foo
ls: cannot access foo: No such file or directory

Tive a oportunidade de testar -deleteem comparação com -exec rm \{\} \;e para mim -deletefoi a resposta para esse problema.

O uso de -deletearquivos excluídos em uma pasta de 400.000 arquivos pelo menos 1.000 vezes mais rápido que rm.

O artigo 'Como excluir grande número de arquivos no Linux' sugere que é cerca de três vezes mais rápido, mas no meu teste a diferença foi muito mais dramática.

Sobre a -deleteopção acima: Estou usando-o para remover um grande número de arquivos (1M + est) em uma pasta temporária que eu criei e esqueci inadvertidamente a limpeza noturna. Enchi meu disco / partição acidentalmente e nada mais poderia removê-los, a não ser o find .comando. Está lento, no começo eu estava usando:

find . -ls -exec rm {} \;

Mas isso levou um tempo EXTREMO. Ele foi iniciado após cerca de 15 minutos para remover alguns arquivos, mas meu palpite é que ele estava removendo menos de 10 ou mais por segundo depois que finalmente foi iniciado. Então, eu tentei o:

find . -delete

em vez disso, e estou deixando isso funcionar agora. Parece estar rodando mais rápido, apesar de estar EXTREMAMENTE sobrecarregando a CPU, o que o outro comando não estava. Está em execução há mais de uma hora e acho que estou recuperando espaço na minha unidade e a partição gradualmente "diminuindo", mas ainda está demorando muito tempo. Eu duvido seriamente que esteja rodando 1.000 vezes mais rápido que o outro. Como em todas as coisas, eu só queria apontar a troca no espaço versus tempo. Se você tiver a largura de banda da CPU de sobra (temos), execute a última. A minha CPU está funcionando ( uptimerelatórios):

10:59:17 up 539 days, 21:21,  3 users,  load average: 22.98, 24.10, 22.87

E já vi a média de carga ultrapassar as 30,00, o que não é bom para um sistema ocupado, mas para o nosso, que normalmente é carregado com pouca carga, fica bom por algumas horas. Eu verifiquei a maioria das outras coisas no sistema e elas ainda respondem, por isso estamos bem por enquanto.

Existem alguns métodos que podem ser usados ​​para excluir um grande número de arquivos no linux. Você pode usar a opção find with delete, que é mais rápida que a opção exec. Então você pode usar o perl unlink e até o rsync. Como excluir um grande número de arquivos no linux

Considere usar o volume Btrfs e simplesmente exclua o volume inteiro desse diretório com grande número de arquivos.

Como alternativa, você pode criar um arquivo de imagem FS, desmontar e excluir o arquivo para remover tudo de uma só vez muito rápido.

Supondo que o GNU esteja parallelinstalado, eu usei isso:

parallel rm -rf dir/{} ::: `ls -f dir/`

e foi rápido o suficiente.

A exclusão de diretórios REALMENTE GRANDES precisa de uma abordagem diferente, como aprendi neste site - você precisará utilizar o ionice. Ele garante (com -c3) que exclusões somente serão executadas quando o sistema tiver tempo de IO para isso. A carga de seus sistemas não aumentará muito e tudo permanecerá responsivo (embora o tempo de busca da CPU tenha sido bastante alto em cerca de 50%).

find <dir> -type f -exec ionice -c3 rm {} \;

ls -1 | xargs rm -rf 

deve funcionar dentro da pasta principal

Para a dica de Izkata acima:

Mas isso faz o trabalho:

$ rm -r foo/
$ ls foo
ls: cannot access foo: No such file or directory

Isso quase funcionou - ou teria funcionado - mas eu tive alguns problemas de permissão; os arquivos estavam em um servidor, mas ainda não entendo de onde veio esse problema de permissão. De qualquer forma, o Terminal pediu confirmação em todos os arquivos. A quantidade de arquivos era de cerca de 20.000, portanto não era uma opção. Depois de "-r", adicionei a opção "-f", então todo o comando foi " rm -r -f foldername / ". Então pareceu funcionar bem. Sou iniciante no Terminal, mas acho que tudo bem, certo? Obrigado!

Dependendo de quão bem você precise se livrar desses arquivos, sugiro usá-lo shred.

$ shred -zuv folder

se você deseja limpar o diretório, mas não pode removê-lo e recriá-lo, sugiro movê-lo e recriá-lo instantaneamente.

mv folder folder_del
mkdir folder
rm -rf folder_del

isso é mais rápido, acredite ou não, pois apenas um inode deve ser alterado. Lembre-se: você não pode realmente paralelizar essa prova em um computador com vários núcleos. Tudo se resume ao acesso ao disco, limitado pelo RAID ou pelo que você possui.

Se você possui milhões de arquivos e todas as soluções acima colocam seu sistema em estresse, tente esta inspiração:

Arquivo nice_delete:

#!/bin/bash

MAX_LOAD=3
FILES=("$@")
BATCH=100

while [ ${#FILES[@]} -gt 0 ]; do
    DEL=("${FILES[@]:0:$BATCH}")
    ionice -c3 rm "${DEL[@]}"
    echo -n "#"
    FILES=("${FILES[@]:$BATCH}")
    while [[ $(cat /proc/loadavg | awk '{print int($1)}') -gt $MAX_LOAD ]]; do
        echo -n "."
        sleep 1
    done
done

E agora exclua os arquivos:

find /path/to/folder -type f -exec ./nice_delete {} \+

O Find criará lotes (consulte getconf ARG_MAX) de algumas dezenas de milhares de arquivos e os passará para nice_delete. Isso criará lotes ainda menores para permitir suspensão quando a sobrecarga for detectada.

Se você quiser se livrar de muitos arquivos o mais rápido possível, ls -f1 /path/to/folder/with/many/files/ | xargs rmpode funcionar bem, mas é melhor não executá-lo nos sistemas de produção, pois seu sistema pode se tornar um problema de E / S e os aplicativos podem ficar presos durante a operação de exclusão.

Esse script funciona bem para muitos arquivos e não deve afetar o ioload do sistema.

#!/bin/bash

# Path to folder with many files
FOLDER="/path/to/folder/with/many/files"

# Temporary file to store file names
FILE_FILENAMES="/tmp/filenames"

if [ -z "$FOLDER" ]; then
    echo "Prevented you from deleting everything! Correct your FOLDER variable!"
    exit 1
fi

while true; do
    FILES=$(ls -f1 $FOLDER | wc -l)
    if [ "$FILES" -gt 10000 ]; then
        printf "[%s] %s files found. going on with removing\n" "$(date)" "$FILES"
        # Create new list of files
        ls -f1 $FOLDER | head -n 5002 | tail -n 5000 > "$FILE_FILENAMES"

        if [ -s $FILE_FILENAMES ]; then
            while read FILE; do
                rm "$FOLDER/$FILE"
                sleep 0.005
            done < "$FILE_FILENAMES"
        fi
    else
        printf "[%s] script has finished, almost all files have been deleted" "$(date)"
        break
    fi
    sleep 5
done