Równoległe rsync

Właśnie przeprowadziłem się i odkryłem po kilku próbach i błędach, że gdzieś między moim domem a moim zdalnym serwerem trwa dławienie ... ale dławienie nie jest zbyt inteligentne. Ogranicza tylko pojedyncze połączenia. Więc jeśli skopiuję jeden plik 1 GB, będzie on działał wesoło z prędkością 150 kB / s. Ale jeśli zainicjuję 10 kopii, każda z nich osiągnie prędkość 150 kB / s (tj. Uzyskam znacznie większą łączną przepustowość na wielu połączeniach).

Używam rsync dość często do synchronizowania niektórych dużych zbiorów danych z pracy do domu (na szczęście w postaci wielu plików). Czy istnieje sposób, aby powiedzieć rsync, aby pobierał za pomocą wielu połączeń? Teoretycznie powinno to być możliwe, ponieważ o ile mogę powiedzieć, rsync najpierw wykonuje podanie w celu ustalenia niezbędnych zmian, a następnie dokonuje faktycznej transmisji. Punkty bonusowe, jeśli istnieje magiczny sposób nakazania rsync pokroić pojedyncze pliki na N kawałków, a następnie połączyć je z powrotem. Uważam, że CuteFTP jest wystarczająco inteligentny, aby to osiągnąć.

Właśnie miałem podobny problem z koniecznością przeniesienia kilku TB z jednego NAS na inny NAS bez możliwości tworzenia kopii zapasowych / przywracania, które pozwolą mi po prostu przesłać 1 zestaw do drugiego.

Napisałem więc ten skrypt, aby uruchomić 1 rsync dla każdego napotkanego katalogu. To zależy od możliwości wylistowania katalogów źródłowych (uważaj, aby uciec przed ARG 3), ale myślę, że możesz ustawić ten etap za pomocą nierekurencyjnego rsync, który właśnie skopiował pliki i katalogi na odpowiedni poziom.

Określa również liczbę uruchomionych programów rsync na podstawie liczby procesorów, ale możesz to zmienić.

Inną możliwą opcją, która przychodzi mi na myśl, jest: uruchom rsync w trybie tylko dla listy.

To dałoby ci wszystkie pliki, które wymagają aktualizacji. Następnie uruchom 1 rsync dla każdego pliku na liście, jeśli używałeś xargs do zarządzania liczbą uruchomionych rsynców, to może być bardzo eleganckie. Prawdopodobnie bardziej eleganckie rozwiązanie niż mój mały skrypt tutaj ...

#! /bin/bash
SRC_DIR=$1
DEST_DIR=$2
LIST=$3
CPU_CNT=`cat /proc/cpuinfo|grep processor |wc -l`
#  pseudo random heuristic
let JOB_CNT=CPU_CNT*4
[ -z "$LIST" ] && LIST="-tPavW --exclude .snapshot --exclude hourly.?"
echo "rsyncing From=$SRC_DIR To=$DEST_DIR DIR_LIST=$LIST"
mkdir -p /{OLD,NEW}_NAS/home
[ -z "$RSYNC_OPTS" ] && RSYNC_OPTS="-tPavW --delete-during --exclude .snapshot --exclude hourly.?"
cd $SRC_DIR
echo $LIST|xargs -n1 echo|xargs -n1 -P $JOB_CNT -I% rsync ${RSYNC_OPTS} ${SRC_DIR}/%/ ${DEST_DIR}/%/

GNU Parallel ma rozwiązanie . 

Przesunąłem 15 TB na 1 Gbps i może nasycić łącze 1 Gbps.

Następujące uruchomienie rsync na duży plik w src-dir do dest-dir na serwerze fooserver:

cd src-dir; find . -type f -size +100000 | \
parallel -v ssh fooserver mkdir -p /dest-dir/{//}\; \
  rsync -s -Havessh {} fooserver:/dest-dir/{}

Utworzone katalogi mogą kończyć się niewłaściwymi uprawnieniami i mniejsze pliki nie są przesyłane. Aby naprawić te uruchamianie rsync po raz ostatni:

rsync -Havessh src-dir/ fooserver:/dest-dir/

Tak. Taka funkcja istnieje.

Istnieje narzędzie o nazwie pssh, które zapewnia opisaną funkcjonalność.

Ten pakiet zawiera równoległe wersje narzędzi openssh. Zawarte w dystrybucji:

• Równoległe ssh (pssh)
• Równoległy scp (pscp)
• Równoległy rsync (prsync)
• Równoległy nuke (pnuke)
• Równoległe slurp (pslurp)

Nie jestem pewien, jak łatwo jest to skonfigurować, ale może to załatwić sprawę!

Nie mogę komentować, więc dodałem nową odpowiedź z nieco lepszym kodem niż poprzedni (ładny i inteligentny) kod.

Sprawdź rsynclinię, ponieważ zawiera ona opcjonalną ionicemodyfikację.

#!/bin/bash
start_time=$(date +%s.%N)
# Transfer files in parallel using rsync (simple script)
# MAXCONN: maximum number "rsync" processes running at the same time:
MAXCONN=6
# Source and destination base paths. (not need to end with "/")
SRC_BASE=/home/user/public_html/images
[email protected]:/home/user/public_html/images
RSYNC_OPTS="-ah --partial"
# Main loop:
for FULLDIR in $SRC_BASE/*; do
    NUMRSYNC=`ps -Ao comm | grep '^'rsync'$' | wc -l `
    while [ $NUMRSYNC -ge $MAXCONN ]; do
        NUMRSYNC=`ps -Ao comm | grep '^'rsync'$' | wc -l `
        sleep 1
    done
    DIR=`basename $FULLDIR`
    echo "Start: " $DIR
    ionice -c2 -n5 rsync $RSYNC_OPTS $SRC_BASE/${DIR}/ $DST_BASE/${DIR}/ &
    # rsync $RSYNC_OPTS $SRC_BASE/${DIR}/ $DST_BASE/${DIR}/ &
    sleep 5
done

execution_time=$(echo "$(date +%s.%N) - $start" | bc)
printf "Done. Execution time: %.6f seconds\n" $execution_time

Wygląda na to, że ktoś napisał to narzędzie dla Ciebie. Rozbija transfer na równoległe fragmenty. Jest to lepsza implementacja niż wersja „równoległego dużego pliku” wymieniona w GNU Parallel:

https://gist.github.com/rcoup/5358786

Ponadto lftp może równolegle przesyłać pliki przez ftp, ftps, http, https, hftp, fish, sftp. Wiele razy korzystanie z lftp ma pewne zalety, ponieważ zarządzanie uprawnieniami, ograniczony dostęp itp. Dla rsync może być trudnym zadaniem.

Nie. Nie ma takiej funkcji. Możesz podzielić synchronizację na wiele połączeń, rsyncjeśli naprawdę tego chcesz.

Sugeruję, abyś znalazł to, co powoduje ograniczenie prędkości i poważnie porozmawiał z tym, kto go utrzymuje / zarządza.

Chciałem przenieść kilka katalogów (z wieloma plikami) jednocześnie, więc stworzyłem ten mały skrypt:

#!/bin/bash
# Transfer files in parallel using rsync (simple script)
# MAXCONN: maximum number "rsync" processes running at the same time:
MAXCONN=10
# Source and destination base paths. (not need to end with "/")
SRC_BASE=/home/sites
DST_BASE=user@example.com:/var/www
RSYNC_OPTS="--stats -ilrtpog"
# Main loop:
for FULLDIR in $SRC_BASE/*/; do
    NUMRSYNC=`ps -Ao comm | grep '^'rsync'$' | wc -l `
    while [ $NUMRSYNC -ge $MAXCONN ]; do
        NUMRSYNC=`ps -Ao comm | grep '^'rsync'$' | wc -l `
        sleep 10
    done
    DIR=`basename $FULLDIR`
    rsync $RSYNC_OPTS $SRC_BASE/${DIR}/ $DST_BASE/${DIR}/ & 
    sleep 1 
done
echo "Done."

Zrobiłem ten skrypt dość szybko, więc proszę go poprawić i przetestować przed użyciem w środowisku produkcyjnym.

Utworzyłem następujący skrypt do równoległego przesyłania wielu folderów ze zdjęciami. Uruchom go najpierw z celem synchronizacji, a następnie ze wszystkimi nazwami folderów do skopiowania.

#!/bin/sh

dest="$1"
shift

if [ "$dest" = "" ]; then
    echo "USAGE: $0 TARGET:/foo/bar <dir1> [dir2] [dir3]"
    exit 1
fi

RCol='\x1B[0m' # Text Reset
BYel='\x1B[1;33m';

for i in "$@"; do
    prefix=`printf "$BYel%50s:$RCol" "$i"`
    echo "$prefix * Starting $i"
    echo "$prefix -> syncing '$i/' to '$dest/$i/'"
    (rsync -rv "$i/" "$dest/$i/") 2>&1 | sed "s/^/$prefix /g" &
    sleep 0.5
done

echo "* Waiting for all to complete"
wait

Poprzedza nazwę folderu na żółto do wszystkich danych wyjściowych konsoli rsync, aby wyglądać ładnie.

Aria2 to dobry program kliencki do pobierania danych przy użyciu wielu połączeń z wielu serwerów lustrzanych. Nie obsługuje SFTP. Więc zainstalowałem serwer FTP - vsftpd . Moje połączenie 3g działa na pełnej mocy z 5 połączeniami z serwerem FTP.