通过同时/并发文件传输加速 rsync？

Question

我们需要尽快将15TB 的数据从一台服务器传输到另一台服务器。我们目前正在使用rsync，但是当我们的网络能够达到900+Mb/s（使用iperf 测试）时，我们只能获得大约150Mb/s 的速度。我已经对磁盘、网络等进行了测试，并认为只是 rsync 一次只传输一个文件导致速度变慢。

我找到了一个脚本，可以为目录树中的每个文件夹运行不同的 rsync（允许您限制 x 个数），但我无法让它工作，它仍然一次只运行一个 rsync。

我找到了script here（复制如下）。

我们的目录树是这样的：

/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

所以我希望为 /main/files 中的每个目录创建一个 rsync，一次最多可以创建 5 个。所以在这种情况下，将运行 3 个 rsync，分别用于 /main/files/1、/main/files/2 和 /main/files/3。

我这样尝试过，但它一次只为 /main/files/2 文件夹运行 1 个 rsync：

#!/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

我发现 UDR/UDT 是一个了不起的工具。 TLDR；它是 rsync 的 UDT 包装器，利用多个 UPD 连接而不是单个 TCP 连接。

参考：https://udt.sourceforge.io/ & https://github.com/jaystevens/UDR#udr

如果您使用任何 RHEL 发行版，他们已经为您预编译了...http://hgdownload.soe.ucsc.edu/admin/udr

我遇到的唯一缺点是您不能指定不同的 SSH 端口，因此您的远程服务器必须使用 22。

不管怎样，安装完 rpm 之后，就这么简单：

udr rsync -aP user@IpOrFqdn:/source/files/* /dest/folder/

在大多数情况下，您的传输速度会大幅提高，具体取决于服务器，我发现传输速度可以轻松提高 10 倍。

旁注：如果您选择先对所有内容进行 gzip，请确保使用 --rsyncable arg 以便它只更新已更改的内容。

Answer 2

我找到的最短版本是使用parallel 的--cat 选项，如下所示。这个版本避免使用xargs，只依赖parallel的特性：

cat files.txt | \
  parallel -n 500 --lb --pipe --cat rsync --files-from={} user@remote:/dir /dir -avPi

#### Arg explainer
# -n 500           :: split input into chunks of 500 entries
#
# --cat            :: create a tmp file referenced by {} containing the 500 
#                     entry content for each process
#
# user@remote:/dir :: the root relative to which entries in files.txt are considered
#
# /dir             :: local root relative to which files are copied

来自files.txt的示例内容：

/dir/file-1
/dir/subdir/file-2
....

请注意，这不会使用 -j 50 来计算工作，这在我这里不起作用。相反，我使用-n 500 来计算每个作业的记录数，根据记录总数计算为一个合理的数字。

Answer 3

您是否尝试过使用rclone.org？

使用rclone，您可以执行类似的操作

rclone copy "${source}/${subfolder}/" "${target}/${subfolder}/" --progress --multi-thread-streams=N

其中--multi-thread-streams=N 表示您希望生成的线程数。

Answer 4

更新答案（2020 年 1 月）

xargs 现在是实现并行执行的推荐工具。它几乎无处不在。要运行多个rsync 任务，命令将是：

ls /srv/mail | xargs -n1 -P4 -I% rsync -Pa % myserver.com:/srv/mail/

这将列出/srv/mail 中的所有文件夹，将它们通过管道传送到xargs，它会一一读取它们并一次运行4 个rsync 进程。 % 字符替换每个命令调用的输入参数。

使用parallel的原始答案：

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

Answer 5

我发现最简单的方法是在 shell 中使用后台作业：

for d in /main/files/*; do
    rsync -a "$d" remote:/main/files/ &
done

注意它不会限制工作的数量！如果你是网络绑定的，这不是一个真正的问题，但如果你正在等待旋转生锈，这将破坏磁盘。

你可以添加

while [ $(jobs | wc -l | xargs) -gt 10 ]; do sleep 1; done

在原始形式的作业控制的循环内。

Answer 6

网络上列出了许多替代工具和方法来执行此操作。例如：

• NCSA Blog 描述了使用 xargs 和 find 来并行化 rsync，而无需为大多数 *nix 系统安装任何新软件。

• 而parsync 为并行rsync 提供了一个功能丰富的Perl 包装器。

Answer 7

您可以使用xargs，它支持一次运行多个进程。对于您的情况，它将是：

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

Answer 8

我开发了一个名为：parallel_sync 的 python 包

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

这是一个示例代码如何使用它：

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)

默认并行度为 10；你可以增加它：

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)

但请注意，ssh 通常将 MaxSessions 默认设置为 10，因此要将其增加到 10 以上，您必须修改 ssh 设置。

Answer 9

rsync 通过网络尽可能快地传输文件。例如，尝试使用它来复制目标上根本不存在的一个大文件。该速度是 rsync 可以传输数据的最大速度。将其与scp 的速度进行比较（例如）。当目标文件存在时，rsync 在原始传输时甚至更慢，因为双方必须就文件的哪些部分进行了双向交谈，但通过识别不需要传输的数据来为自己付出代价.

并行运行rsync 的更简单方法是使用parallel。下面的命令最多可以并行运行 5 个rsyncs，每个都复制一个目录。请注意，瓶颈可能不是您的网络，而是您的 CPU 和磁盘的速度以及并行运行只会让它们变得更慢，而不是更快。

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/*