bash - servidor - rsync no se encontró la orden

¿Acelera rsync con transferencias de archivos simultáneas/simultáneas?

Question

Necesitamos transferir 15TB de datos de un servidor a otro lo más rápido posible. Actualmente estamos usando rsync pero solo estamos obteniendo velocidades de alrededor de 150Mb/s , cuando nuestra red es capaz de 900+Mb/s (probado con iperf ). He realizado pruebas de los discos, la red, etc. y he pensado que es solo que rsync solo transfiere un archivo a la vez, lo que está causando la desaceleración.

Encontré una secuencia de comandos para ejecutar un rsync diferente para cada carpeta en un árbol de directorios (lo que le permite limitar el número x), pero no puedo hacer que funcione, solo ejecuta un rsync a la vez.

Encontré el script here (copiado abajo).

Nuestro árbol de directorios es así:

/main
   - /files
      - /1
         - 343
            - 123.wav
            - 76.wav
         - 772
            - 122.wav
         - 55
            - 555.wav
            - 324.wav
            - 1209.wav
         - 43
            - 999.wav
            - 111.wav
            - 222.wav
      - /2
         - 346
            - 9993.wav
         - 4242
            - 827.wav
      - /3
         - 2545
            - 76.wav
            - 199.wav
            - 183.wav
         - 23
            - 33.wav
            - 876.wav
         - 4256
            - 998.wav
            - 1665.wav
            - 332.wav
            - 112.wav
            - 5584.wav

Entonces, lo que me gustaría que sucediera es crear un rsync para cada uno de los directorios en / main / files, hasta un máximo de, por ejemplo, 5 a la vez. Entonces, en este caso, se ejecutarán 3 rsyncs, para /main/files/1 , /main/files/2 y /main/files/3 .

Lo intenté así, pero solo ejecuta 1 rsync a la vez para la carpeta /main/files/2 :

#!/bin/bash

# Define source, target, maxdepth and cd to source
source="/main/files"
target="/main/filesTest"
depth=1
cd "${source}"

# Set the maximum number of concurrent rsync threads
maxthreads=5
# How long to wait before checking the number of rsync threads again
sleeptime=5

# Find all folders in the source directory within the maxdepth level
find . -maxdepth ${depth} -type d | while read dir
do
    # Make sure to ignore the parent folder
    if [ `echo "${dir}" | awk -F''/'' ''{print NF}''` -gt ${depth} ]
    then
        # Strip leading dot slash
        subfolder=$(echo "${dir}" | sed ''s@^/./@@g'')
        if [ ! -d "${target}/${subfolder}" ]
        then
            # Create destination folder and set ownership and permissions to match source
            mkdir -p "${target}/${subfolder}"
            chown --reference="${source}/${subfolder}" "${target}/${subfolder}"
            chmod --reference="${source}/${subfolder}" "${target}/${subfolder}"
        fi
        # Make sure the number of rsync threads running is below the threshold
        while [ `ps -ef | grep -c [r]sync` -gt ${maxthreads} ]
        do
            echo "Sleeping ${sleeptime} seconds"
            sleep ${sleeptime}
        done
        # Run rsync in background for the current subfolder and move one to the next one
        nohup rsync -a "${source}/${subfolder}/" "${target}/${subfolder}/" </dev/null >/dev/null 2>&1 &
    fi
done

# Find all files above the maxdepth level and rsync them as well
find . -maxdepth ${depth} -type f -print0 | rsync -a --files-from=- --from0 ./ "${target}/"

Answer 1

Esto parece más simple:

ls /srv/mail | parallel -v -j8 rsync -raz --progress {} myserver.com:/srv/mail/{}

Answer 2

Hay una serie de herramientas y enfoques alternativos para hacer esto en la web. Por ejemplo:

• El Blog de NCSA tiene una descripción del uso de xargs y find para paralelizar rsync sin tener que instalar ningún software nuevo para la mayoría de los sistemas * nix.

• Y parsync proporciona un contenedor de Perl rico en características para rsync paralelo.

Answer 3

He desarrollado un paquete de python llamado: parallel_sync

https://pythonhosted.org/parallel_sync/pages/examples.html

Aquí hay un código de ejemplo de cómo usarlo:

from parallel_sync import rsync
creds = {''user'': ''myusername'', ''key'':''~/.ssh/id_rsa'', ''host'':''192.168.16.31''}
rsync.upload(''/tmp/local_dir'', ''/tmp/remote_dir'', creds=creds)

el paralelismo por defecto es 10; puedes aumentarlo:

from parallel_sync import rsync
creds = {''user'': ''myusername'', ''key'':''~/.ssh/id_rsa'', ''host'':''192.168.16.31''}
rsync.upload(''/tmp/local_dir'', ''/tmp/remote_dir'', creds=creds, parallelism=20)

sin embargo, tenga en cuenta que, por lo general, ssh tiene el MaxSessions establecido de forma predeterminada en 10, por lo que para aumentarlo más allá de 10, deberá modificar la configuración de ssh.

Answer 4

Puede utilizar xargs que admite la ejecución de muchos procesos a la vez. Para su caso será:

ls -1 /main/files | xargs -I {} -P 5 -n 1 rsync -avh /main/files/{} /main/filesTest/

Answer 5

rsync transfiere archivos tan rápido como puede a través de la red. Por ejemplo, intente usarlo para copiar un archivo grande que no existe en absoluto en el destino. Esa velocidad es la velocidad máxima que rsync puede transferir datos. Compáralo con la velocidad de scp (por ejemplo). rsync es incluso más lento en la transferencia sin formato cuando existe el archivo de destino, porque ambas partes tienen que tener un chat bidireccional sobre qué partes del archivo se cambian, pero se amortizan identificando los datos que no es necesario transferir.

Una forma más sencilla de ejecutar rsync en paralelo sería usar parallel . El siguiente comando ejecutaría hasta 5 rsync s en paralelo, cada uno copiando un directorio. Tenga en cuenta que el cuello de botella puede no ser su red, pero la velocidad de sus CPU y discos, y el funcionamiento en paralelo solo los hace más lentos, no más rápidos.

run_rsync() {
    # e.g. copies /main/files/blah to /main/filesTest/blah
    rsync -av "$1" "/main/filesTest/${1#/main/files/}"
}
export -f run_rsync
parallel -j5 run_rsync ::: /main/files/*