Synchronizuj migawki LVM z serwerem kopii zapasowej

Mam wiele maszyn wirtualnych Xen działających na wielu serwerach Linux. Te maszyny wirtualne przechowują obrazy dysków w woluminach Linux LVM z nazwami urządzeń wzdłuż linii / dev / xenVG / SERVER001OS i tak dalej. Chciałbym regularnie wykonywać kopie zapasowe tych obrazów dysków, aby w razie potrzeby móc przywrócić maszyny wirtualne (urządzenia LVM są już dublowane za pomocą DRBD między dwoma fizycznymi maszynami, po prostu jestem tutaj wyjątkowo paranoikiem).

Jak mam to zrobić? Oczywiście pierwszym krokiem jest wykonanie migawki urządzenia LVM, ale jak mogę przenieść dane na serwer zapasowy w najbardziej wydajny sposób? Mógłbym po prostu skopiować całe urządzenie, coś w stylu:

dd if=/dev/xenVG/SERVER001OS | ssh administrator@backupserver "dd of=/mnt/largeDisk/SERVER001OS.img"

... ale wymagałoby to dużej przepustowości. Czy istnieje narzędzie podobne do rsync do synchronizowania zawartości bloków całego dysku między zdalnymi serwerami? Coś jak:

rsync /dev/xenVG/SERVER001OS backupServer:/mnt/largeDisk/SERVER001OS.img

Jeśli dobrze rozumiem stronę podręcznika rsync, powyższe polecenie nie zadziała (prawda?), Ale pokazuje, do czego dążę. Rozumiem, że opcja --devices rsync polega na kopiowaniu samych urządzeń, a nie ich zawartości. Utworzenie lokalnej kopii obrazu maszyny wirtualnej przed zsynchronizowaniem go ze zdalnym serwerem nie jest opcją, ponieważ nie ma miejsca na dysku.

Czy istnieje przydatne narzędzie, które może synchronizować między urządzeniami blokowymi i plikiem kopii zapasowej na zdalnym serwerze? Mogę napisać jeden, jeśli będę musiał, ale istniejące rozwiązanie byłoby lepsze. Czy przegapiłem opcję rsync, która robi to dla mnie?

Standardowy rsync nie ma tej funkcji, ale jest łatka do niego w łatce rsync tarball (copy-devices.diff), którą można pobrać ze strony http://rsync.samba.org/ftp/rsync/ Po zastosowaniu i ponownej kompilacji , możesz zsynchronizować urządzenia z opcją --copy-devices.

Chociaż dla RSync istnieją łatki „urządzenie zapisujące” i „urządzenie kopiujące”, działają one dobrze tylko na małych obrazach (1-2 GB). RSync będzie spędzał wieki, szukając pasujących bloków na większych obrazach i jest prawie bezużyteczny dla urządzeń / plików o pojemności 40 GB lub większej.

Używamy następujących danych, aby wykonać porównanie sumy kontrolnej na 1 MB, a następnie po prostu skopiować zawartość, jeśli nie jest zgodna. Używamy tego do tworzenia kopii zapasowych serwerów na wirtualnym hoście w USA do systemu tworzenia kopii zapasowych w Wielkiej Brytanii za pośrednictwem publicznego Internetu. Bardzo mała aktywność procesora i wydajność migawki następuje dopiero po godzinach:

Utwórz migawkę:

lvcreate -i 2 -L 25G /dev/vg_kvm/company-exchange -n company-exchange-snap1

export dev1='/dev/mapper/vg_kvm-company--exchange--snap1';
export dev2='/dev/mapper/vg_kvm-company--exchange';
export remote='[email protected]';

Początkowe wysiewanie:

dd if=$dev1 bs=100M | gzip -c -9 | ssh -i /root/.ssh/rsync_rsa $remote "gzip -dc | dd of=$dev2"

Przyrostowa nocna kopia zapasowa (wysyła tylko zmienione bloki):

ssh -i /root/.ssh/rsync_rsa $remote "
  perl -'MDigest::MD5 md5' -ne 'BEGIN{\$/=\1024};print md5(\$_)' $dev2 | lzop -c" |
  lzop -dc | perl -'MDigest::MD5 md5' -ne 'BEGIN{$/=\1024};$b=md5($_);
    read STDIN,$a,16;if ($a eq $b) {print "s"} else {print "c" . $_}' $dev1 | lzop -c |
ssh -i /root/.ssh/rsync_rsa $remote "lzop -dc |
  perl -ne 'BEGIN{\$/=\1} if (\$_ eq\"s\") {\$s++} else {if (\$s) {
    seek STDOUT,\$s*1024,1; \$s=0}; read ARGV,\$buf,1024; print \$buf}' 1<> $dev2"

Usuń migawkę:

lvremove -f company-exchange-snap1

Osoby zainteresowane zrobieniem tego konkretnie za pomocą migawek LVM mogą polubić moje narzędzie lvmsync , które odczytuje listę zmienionych bloków w migawce i wysyła tylko te zmiany.

Spójrz na Zumastor Linux Storage Project, który implementuje tworzenie kopii zapasowej „migawki” za pomocą binarnego „rsync” za pomocą narzędzia ddsnap .

Ze strony podręcznika:

ddsnap zapewnia replikację urządzenia blokowego, biorąc pod uwagę funkcję migawki na poziomie bloku, zdolną do efektywnego przechowywania wielu jednoczesnych migawek. ddsnap może wygenerować listę porcji migawek, które różnią się między dwiema migawkami, a następnie przesłać tę różnicę przewodowo. Na dalszym serwerze zapisz zaktualizowane dane w migawkowym urządzeniu blokowym.

Istnieje skrypt Pythona o nazwie blockync, który jest prostym sposobem synchronizacji dwóch urządzeń blokowych w sieci za pośrednictwem ssh, przenosząc tylko zmiany.

• Skopiuj blocksync.py do katalogu domowego na hoście zdalnym
• Upewnij się, że zdalny użytkownik może albo sudo, albo sam root
• Upewnij się, że lokalny użytkownik (root?) Może odczytać urządzenie źródłowe i ssh na zdalnym hoście
• Odwołać się: python blocksync.py /dev/source user@remotehost /dev/dest

Niedawno zhakowałem go, aby go wyczyścić i zmienić, aby używał tego samego algorytmu szybkiej sumy kontrolnej, co rsync ( Adler-32 ).

Jeśli próbujesz zminimalizować ilość pustej przestrzeni, którą wyślesz zwykłym drutem dd, czy nie możesz po prostu przesłać go do gzip przed przesłaniem go do ssh?

np. dd if = / dev / xenVG / SERVER001OS | gzip | ssh administrator @ backupserver "dd of = / mnt / largeDisk / SERVER001OS.img.gz"

Uwaga: wydajność systemu z migawkami LVM jest proporcjonalna do liczby migawek.

Na przykład wydajność MySQL z migawkami lvm

Oprócz odpowiedzi Davida Herselmana - poniższy skrypt zostanie zsynchronizowany z urządzeniem lokalnym:

perl -'MDigest::MD5 md5' -ne 'BEGIN{$/=\1024};print md5($_)' $dev2 |
  perl -'MDigest::MD5 md5' -ne 'BEGIN{$/=\1024};$b=md5($_);
    read STDIN,$a,16;if ($a eq $b) {print "s"} else {print "c" . $_}' $dev1 |
   perl -ne 'BEGIN{$/=\1} if ($_ eq"s") {$s++} else {if ($s) {
    seek STDOUT,$s*1024,1; $s=0}; read ARGV,$buf,1024; print $buf}' 1<> $dev2

O ile mi wiadomo oba skrypty zostały po raz pierwszy opublikowane na lists.samba.org .

To stare pytanie, ale nikt nie wspomniał o dwóch bardzo przydatnych narzędziach do wydajnej synchronizacji dwóch urządzeń blokowych:

• bdsync , które wykorzystują podejście diff-transfer-and-patch;

• blockync (tutaj znajdziesz moją ulepszoną wersję ), które wykorzystują podejście przepisywania w miejscu.

Zdecydowanie sugeruję grę obiema narzędziami i wybranie tych, które lepiej dostosują się do zamierzonego zastosowania.

Po kilku latach poszukiwań stworzyłem narzędzie do synchronizacji migawek LVM między serwerami. Zaprojektowano go tak, aby używał minimalnej liczby operacji we / wy i umożliwiał działanie systemów podczas synchronizacji.

Jest podobny do wysyłania / odbierania ZFS, ponieważ synchronizuje różnice między migawkami LVM i wykorzystuje cienkie przydzielanie, aby wpływ na wydajność był minimalny.

Chciałbym poznać opinie, więc proszę spojrzeć.

Skrypt ten miał kilka usprawnień:

1. W moim systemie przynajmniej odczyt bufora perla wynosi 8k, więc użyj rozmiaru bloku 8192.
2. autoflush, więc lokalny koniec nie blokuje się, dopóki zdalny bufor wyjściowy nie jest „pełny”, ponieważ podczas karmienia LZOP buforowanie wydaje się bezcelowe.

ssh -i /root/.ssh/rsync_rsa $ remote "perl -'MDigest :: MD5 md5 '-ne' BEGIN {$ | = 1; \ $ / = \ 892}; print md5 (\ $ ) '$ dev2 | lzop -c "| lzop -dc | perl -'MDigest :: MD5 md5 '-ne' BEGIN {$ | = 1; $ / = \ 8192}; $ b = md5 ($ ); czytaj STDIN, $ a, 16; if ($ a eq $ b) {print "s"} else {print "c". $ _} „$ dev1 | lzop -c | ssh -i /root/.ssh/rsync_rsa $ remote "lzop -dc |
perl -ne 'BEGIN {\ $ / = \ 1} if (\ $ _ eq \" s \ ") {\ $ s ++} else {if (\ $ s) {szukaj STDOUT, \ $ s * 8192,1; \ $ s = 0}; czytaj ARGV, \ $ buf, 8192; print \ $ buf} '1 <> $ dev2 "