Jak używać inotify i rsync do tworzenia systemu tworzenia kopii zapasowych na żywo

Dlaczego miałbyś używać skryptów bash do wykonywania synchronizacji folderów i kopii zapasowych?

Bash jest zdecydowanie najbardziej popularnym i używanym interpreterą języka poleceń kompatybilnych z SH. Dzisiaj można znaleźć Bash prawie wszędzie, w tym Microsoft Windows z nowym podsystemem Windows dla Linux. Praktycznie cała dystrybucja GNU/Linux jest wyposażona w bash jako domyślną powłokę. To samo dotyczy macOS i niektórych innych systemów operacyjnych podobnych do UNIX.

Bash to nie tylko język dowodzenia; Jak inne powłoki Unix, Bash jest zarówno językiem programowania, jak i tłumacza poleceń. Technicznie rzecz biorąc, strona programowania powłoki daje zdolności użytkownika i funkcje do łączenia systemów lub powłok w pliku. Użytkownik może tworzyć polecenia, łącząc polecenia w pliku tekstowym; Te specjalne typy plików tekstowych, które zawierają zbiór poleceń, nazywane są skontaktami, a gdy te pliki otrzymują zgodę na wykonanie, interpreter powłoki postrzega je jako pojedyncze polecenie.

Zaletą skryptu BASH jest to, że możesz używać narzędzi wiersza polecenia bezpośrednio w nim bez potrzeby importu lub źródła bibliotek zewnętrznych. To narzędzia wiersza poleceń i wbudowane narzędzia są potężne i mogą oddziaływać bezpośrednio z systemem operacyjnym bez kompilacji lub dodatkowych tłumaczy; zwykle podstawowe narzędzia i interfejsy wiersza poleceń, na przykład Awk, Xargs, znajdować, I Grep, może mieć znacznie lepszą wydajność niż korzystanie z skryptów Python i jego bibliotek na przykład. Nie jest trudno znaleźć osoby przeprowadzające zaawansowane analizy danych za pomocą tylko wbudowanych narzędzi Bash i GNU. Inni twierdzą, że tego rodzaju podejście może być 235 x szybciej niż klaster Hadoop - co nie jest tak trudne do uwierzenia, biorąc pod uwagę niektóre monstotacje grupowe, które można znaleźć w dzisiejszych czasach, aby pasowały do ​​złego projektu oprogramowania.

W tej sprawie zawsze pojawia się jedno pytanie: jeśli bash jest tak potężny, dlaczego nie użyć go do automatyzacji wszystkich nudnych rzeczy? Składnia bash jest prosta i pragmatyczna: daje możliwość łączenia programów do automatyzacji wspólnych zadań. Jednak gdy skrypt musi poradzić sobie z wieloma warunkami lub gromadzić zbyt wiele celów, nadszedł czas, aby rozważyć bardziej niezawodny język programowania, taki jak C lub inne języki skryptu, w którym Python i Perl są dobrymi przykładami.

Z drugiej strony, skrypty Bash są bardzo dobre do pojedynczych zadań, takich jak intencja tego artykułu: łączenie narzędzi z możliwościami sprawdzania zmian w określonym folderze, a następnie synchronizacji jego plików. Skrypt bash może doskonale pasować do tego zadania.

Czego potrzebujesz, aby wykonać syncronizację lub autobackups?

Istnieje duża lista różnych metod synchronizacji folderów i plików. Liczba aplikacji, które można wykorzystać do wykonania tego prostego zadania, jest ogromna, a niektóre z nich to rozwiązania stron trzecich. Jednakże, Ten artykuł pokazuje bardziej elegancki sposób na osiągnięcie tego samego za pomocą inotifywait I rsync W skrypcie Bash. Ogólnie rzecz biorąc, to rozwiązanie będzie lekkie, niedrogie i, dlaczego nie powiedzieć, bezpieczniejsze. Zasadniczo do ukończenia tej misji wymagane są tylko narzędzia Inotify, RSYNC i A White Pętla.

Jak używać inotifyWait do autobacków i synchronizacji?

inotifywait Używa API Inotify, aby czekać na zmiany w plikach. To polecenie zostało specjalnie zaprojektowane do użycia w skontlerze. Jedna potężna cecha inotifywait jest ciągłe sprawdzenie zmian; Jak tylko pojawiają się nowe wydarzenia, inotifywait drukuje modyfikacje i wyjścia.

inotifywait Zapewnia dwie opcje, które są bardzo interesujące dla synchronizacji folderów lub kopii zapasowych w czasie rzeczywistym. Pierwszy to -R, -rekurencyjny opcja; Jak sama nazwa wskazuje, ta flaga obserwuje nieograniczoną liczbę głębokości konkretnego katalogu przekazanego jako argumenty inotifywait, z wyłączeniem symbolicznych linków.

-mi, -wydarzenie Flaga zapewnia kolejną interesującą funkcję. Ta opcja wymaga listy predefiniowanych zdarzeń. Dokumentacja Inotify-Tool wymienia więcej niż 15 wydarzeń dla inotifywait; Ale prosty system tworzenia kopii zapasowych i synchronizacji wymaga wyłącznie usuwania, modyfikowania i tworzenia zdarzeń.
Następujące polecenie jest dobrym przykładem scenariusza rzeczywistego:

$ inotifyWait -r -e modyfikuj, utwórz, usuń/dom/userDir/Documents

W takim przypadku polecenie czeka na zmiany - modyfikacje, tworzenie plików lub folderów lub wykluczenia dowolnego rodzaju - w fikcyjnym /home/userdir/dokumenty informator. Jak tylko użytkownik dokonuje jakiejkolwiek zmiany, inotifywait Wyświetla modyfikację i wyjście.

Przypuśćmy, że tworzysz nowy plik o nazwie nowy plik w środku Dokumenty folder podczas inotifywait monitoruje to. Gdy polecenie wykryje tworzenie pliku, wysyła

Dokumenty/ Utwórz NewFile

Innymi słowy, inotifywait Drukuje tam, gdzie następuje modyfikacja, jaki rodzaj zmian, a nazwa pliku lub folderu, który został zmieniony.

Badanie statusu wyjścia inotifywait Kiedy nastąpi zmiana, widzisz status 0-EXIT, który oznacza pomyślne wykonanie. Ta sytuacja jest idealna do skryptu powłoki, ponieważ status wyjścia może być używany jako warunek prawdziwy lub fałszywy.

W związku z tym pierwszy krok skryptu jest zakończony: znaleźć narzędzie, które czeka na zmiany w katalogach. Drugim jest poszukiwanie narzędzia zdolnego do synchronizacji dwóch katalogów i rsync jest idealnym kandydatem.

Jak używać rsync do autobackupów?

rsync to potężna aplikacja. Możesz napisać książkę opisującą wszystko, co możesz zrobić z tym wszechstronnym narzędziem. Z technicznego punktu widzenia, rsync jest niczym więcej niż narzędziem do kopania plików, rodzaj CP polecenie sterydami i specjalnymi uprawnieniami, takimi jak bezpieczne pliki transferowe. Sposób użycia rsync W tym skrypcie jest skromniejsze, ale nie mniej eleganckie.

Głównym celem jest znalezienie sposobu:

• Powtarzaj się w katalogi;
• Skopiuj łącza symboliczne jako linki symboliczne;
• Uprawnienia do zachowania, własność, grupy, czas modyfikacji, urządzenia i pliki specjalne;
• Podaj dodatkowe szczegóły, w pełni wyjście - możliwe jest utworzenie pliku dziennika w razie potrzeby;
• Kompresuj pliki podczas przeniesienia optymalizacji.

rsync Dokumentacja jest dobrze napisana; Sprawdzając podsumowanie dostępnych opcji, możesz łatwo wybrać -Avz Flagi jako lepszy wybór. Proste użycie wygląda następująco:

rsync -Avz /

Ważne jest, aby umieścić cięcie po folderze pochodzenia. Przeciwnie, rsync kopiuje cały folder pochodzenia (w tym sam) do folderu docelowego.

Na przykład, jeśli utworzysz dwa foldery, jeden nazywał Folder Origin i inni folder docelowy, robić rsync Wyślij do drugiej każdej zmiany dokonanej w pierwszej, użyj kolejnego polecenia:

$ rsync -Avz Orygenenfolder/ DestinationFolder

Po utworzeniu nowego pliku nazwanego nowy plik, rsync drukuje coś w stylu:

Wysyłanie przyrostowej listy plików
./
nowy plik
Wysłane 101 bajtów otrzymało 38 bajtów 278.00 bajtów/s
Całkowity rozmiar to 0, przyspieszenie to 0.00

W pierwszym wierszu dyrektywa drukuje rodzaj procesu, kopię przyrostową; to znaczy że rsync używa swoich możliwości uciskania, aby zwiększyć plik i nie zmieniać całego archiwum. Ponieważ po raz pierwszy polecenie jest wykonywane, aplikacja kopiuje cały plik; Po wystąpieniu nowych zmian mają miejsce tylko przyrosty. Kolejne wyjście to lokalizacja, nazwa pliku i dane wydajności. Sprawdzanie statusu wyjścia rsync polecenie, otrzymujesz 0-exit do pomyślnego wykonania.

Istnieją więc dwie ważne aplikacje, które udzielają wsparcia w tym skrypcie: jedna jest w stanie czekać na zmiany, a druga może tworzyć kopie tej modyfikacji w czasie rzeczywistym w czasie rzeczywistym. Tutaj brakuje sposobu na podłączenie obu narzędzi w sposób rsync podejmuje działanie jak najszybciej inotifywait postrzega wszelkie zmiany.

Dlaczego potrzebujemy pętli?

Najprostszym rozwiązaniem powyższego problemu jest pętla. Innymi słowy, za każdym razem inotifywait istnieje skutecznie, skrypt BASH musi zadzwonić rsync wykonać jego przyrost; Zaraz po wystąpieniu kopii skorupa musi wrócić do stanu początkowego i poczekać na nowe wyjście inotifywait Komenda. Właśnie to robi pętla.

Nie potrzebujesz obszernego tła w programowaniu, aby napisać skrypt bash. Bardzo często można znaleźć dobrych administratorów systemów, którzy nie mają lub bardzo ograniczonego doświadczenia w programowaniu. Jednakże, Tworzenie scenariuszy funkcjonalnych jest zawsze ważnym zadaniem administracji systemu. Dobra wiadomość jest taka, że ​​koncepcja za chwilę jest łatwa do zrozumienia.

Poniższy schemat reprezentuje pętlę:

Nieskończony, podczas gdy schemat pętli.

A reprezentuje inotifywait Polecenie omówione powyżej i B, rsync. Za każdym razem A istnieje ze statusem 0-exit, skorupa interpretuje to jako prawdziwe; Zatem pętla while zezwala na wykonanie B; tak szybko B Z powodzeniem wychodzi, polecenie wraca do A Znowu i powtarza pętlę.
W takim przypadku pętla, w którym zawsze ocenia się prawdziwie A. Technicznie generuje nieskończoną pętlę, co jest dobre dla propozycji tego skryptu; inotifywait będzie powtarzanie się, co oznacza, że ​​zawsze będzie czekać na nowe modyfikacje.

Bardziej formalnie składnia dla bash, podczas gdy pętla to:

chwila
Do

zrobione

oznacza listę warunków (A) To musi być prawdziwe; Tak więc pętla While może wykonać , stojąc do bloku poleceń (B). Jeśli pętla przed testem A jest fałszywe, a następnie pyszne wyjście bez wykonywania B.

Oto jak rsync I inotifywait Polecenia pasują do pętli While,

podczas inotifywait -r -e modyfikuj, utwórz, usuń OrygeSenFolder
Do
rsync -Avz Orygenenfolder/ DestinationFolder
zrobione

Łączenie wszystkiego

Teraz nadszedł czas, aby połączyć wszystko omówione powyżej, aby stworzyć skrypt powłoki. Pierwszą rzeczą jest utworzenie pustego pliku i nazwa go; jako przykład, LiveBackup.grzmotnąć reprezentuje dobry wybór. Dobrą praktyką jest umieszczenie skorupy w folderze BIN w katalogu domowym użytkownika, a.k.A. $ Dom/bin.

Następnie możesz edytować plik w wybranym edytorze tekstu. Pierwszy wiersz skryptu Bash jest bardzo ważny; W tym miejscu skrypt definiuje dyrektywę interpretera, na przykład:

#! [Opcje]

Shebang jest tym dziwnym symbolem z hasztem i wykrzyknikiem (#!). Kiedy powłok. Shebang nie jest komentarzem i musi być umieszczony na górze skryptu bez przestrzeni powyżej.

Możesz zostawić pierwszą linię pustą i nie zdefiniować tłumacza. W ten sposób powłoka używa domyślnego interpretera do ładowania i wykonania skryptu, ale nie jest on poparte. Najbardziej przywłaszczonym i bezpiecznym wyborem jest wskazanie dyrektywy tłumacza w następujący sposób:

#!/usr/bin/bash

Dzięki tak wyraźnej dyrektywie tłumacza skorupa szuka interpretera bash w katalogu /usr /bin. Ponieważ zadanie tego skryptu jest proste, nie ma potrzeby określania większej liczby poleceń lub opcji. Bardziej wyrafinowaną możliwością jest wywołanie tłumacza za pomocą polecenia ENV.

#!/usr/bin/env bash

W tym kontekście powłoka przeszukuje domyślne polecenie bash w bieżącym środowisku. Takie porozumienie jest przydatne, gdy środowisko użytkownika ma ważne dostosowania. Może jednak prowadzić do usterki bezpieczeństwa na poziomie przedsiębiorstwa, gdy powłoka nie będzie w stanie wykryć, czy komenda w spersonalizowanym środowisku jest lub nie jest bezpiecznym tłumaczem.

Podczas składania wszystkiego w tym momencie scenariusz wygląda jak:

#!/usr/bin/bash
podczas inotifywait -r -e modyfikuj, utwórz, usuń pochodzenie
Do
rsync -Avz Orygenenfolder/ DestinationFolder
zrobione

Jak używać argumentów w skrypcie Bash?

To, co oddziela ten skrypt od całkowitej funkcjonalności, to sposób, w jaki definiuje pochodzenie i folder docelowy. Na przykład konieczne jest znalezienie sposobu pokazania tych folderów. Szybszy tryb rozwiązania tego pytania jest użycie argumentów i zmiennych.

Oto przykład właściwego sposobu odwołania się do skryptu:

$ ./LiveBackup.bash/home/użytkownik/pochodzenie/dom/użytkownik/docelowe

Powłoka ładuje dowolny z tych argumentów wpisanych po nazwie skryptu i przekazuje je do ładowarki skryptu jako zmienne. Na przykład katalog /dom/użytkownik/pochodzenie jest pierwszym argumentem i możesz uzyskać do niego dostęp do skryptu za pomocą 1 USD. Zatem, 2 USD ma wartość /dom/użytkownik/miejsce docelowe. Do wszystkich tych zmiennych pozycyjnych można uzyskać za pomocą znaku dolara ($) a następnie numer N ($ n), gdzie n jest pozycją argumentu, w której nazywany jest skrypt.

Znak dolara ($) ma bardzo szczególne znaczenie i implikacje w skontaktowaniu skorupy; W innych artykułach zostanie omówione dogłębnie. Na razie puzzle jest prawie rozwiązane.

#!/usr/bin/bash
podczas inotifywait -r -e modyfikuj, utwórz, usuń 1 USD
Do
rsync -Avz 1 USD/ 2 USD
zrobione

Notatka: Aby poradzić sobie ze zbyt wieloma argumentami przy użyciu tylko parametrów pozycyjnych ($ n) może szybko prowadzić do złych projektów i zamieszania w skorupach. Bardziej eleganckim sposobem rozwiązania tego problemu jest użycie getopts Komenda. To polecenie pomaga również tworzyć powiadomienia o niewłaściwym wykorzystaniu, co może być przydatne, gdy inni użytkownicy mają dostęp do skryptu. Szybkie wyszukiwanie w Internecie może wyświetlać różne metody korzystania z getopts, Co może poprawić bieżący skrypt, jeśli potrzebujesz podać więcej opcji użytkowania innych użytkowników.

Czyniąc go wykonywaniem

Należy teraz zrobić tylko jedną rzecz: aby zrobić plik LiveBackup.grzmotnąć wykonywalny. Można go łatwo wykonać z chmod Komenda.

Przejdź do folderu zawierającego skrypt i wpisz:

$ chmod +x na żywo.grzmotnąć

Następnie wpisz znak kropki (./) Przed nazwą skryptu. DOT oznacza, w tym kontekście, bieżący katalog i cięcie definiują względną ścieżkę do pliku w bieżącym katalogu. Mając to na uwadze, musisz również wpisać folder pochodzenia jako pierwszy argument, a następnie folder docelowy jako drugi, taki jak:

$ ./LiveBackup.bash/home/użytkownik/pochodzenie/dom/użytkownik/docelowe

Alternatywnie możesz wywołać skrypty pod jego nazwą, umieszczając jego lokalizację folderu na ścieżce środowiska lub nazywać ją subshellą, na przykład:

$ Bash LiveBackup.bash/home/użytkownik/pochodzenie/dom/użytkownik/docelowe

Pierwsza opcja jest jednak bezpiecznym wyborem.

Przykład prawdziwy

W prawdziwym scenariuszu, ręczne uruchamianie skryptu kopii zapasowej za każdym razem, gdy uruchamiasz system, może być żmudne. Dobrym wyborem jest użycie Cronjob Lub timery/praca jednostki z Systemd. Jeśli masz wiele różnych folderów do tworzenia kopii zapasowych, możesz również stworzyć inny skrypt, który pozwala źródło LiveBackup.grzmotnąć; Zatem polecenie należy wywołać tylko raz w .praca jednostka. W innym artykule tę funkcję można omówić bardziej szczegółowo.

Jeśli używasz podsystemu systemu Windows dla Linux, możliwe jest utworzenie podstawowego zadania, aby uruchomić skrypt za pomocą „harmonogramu zadań”, które jest uruchamiane przez uruchamianie systemowe. Aby użyć pliku wsadowego, aby zadzwonić grzmotnąć.exe z listą poleceń jest dobrym wyborem. Możesz także użyć wizualnego skryptu podstawowego, aby uruchomić plik wsadowy w tle.

Jak wygląda skrypt pro bash

Oto przykład skryptu zaprojektowanego przez autora, który może odczytać bardziej wyrafinowane argumenty wiersza poleceń.

#!/usr/bin/env bash
#
#########################################################. ###########################################
#########################################################. ###########################################
#
# Skrypt: SyncFolder.grzmotnąć
# Autor: Diego Aurino da Silva
# Data: 16 lutego 2018
# Rev: 1.0
# Licencja: MIT (https: // github.com/diegoaurino/bashscripts/blob/master/licencja)
#
# Platforma: WSL lub GNU/Linux
#
# Cel: Mały skrypt do synchronizacji zmian od lewej do prawej z dwóch folderów 
# pod WSL lub GNU/Linux (wymaga narzędzi INOTIFID)
#
#########################################################. ###########################################
#########################################################. ###########################################
###################
# USTAWIENIA GŁÓWNE
###################
Bold = $ (TUPT BOLD)
Normal = $ (tput sgr0)
OUGNEN = ""
miejsce docelowe = ""
###################
# Sekcja opcji
###################
Jeśli [$# -eq 0]
Następnie
printf "\ n%s \ t \ t%s \ n \ n" "Użyj $ Bold -h $ normalne, aby uzyskać pomoc."
Wyjście 1
w przeciwnym razie
podczas getopts „: h”
Do
case $ opcja w
H )
printf "\ n%s \ t \ t%s \ n \ n" "Użycie: ./SyncFolder.bash $ Bold/origen/folder $ normal -o $ bold/destylar/folder $ normal "
Wyjście 0
;;
\? )
printf "\ n%s \ n \ n" "$ bold nieprawidłowa opcja dla $ normal $ (basename $ 0)" 1> i 2
Wyjście 1
;;
esac
zrobione
Shift $ ((optind -1))
OUGNEN = 1 USD
zmiana
podczas getopts ": o:"
Do
case $ opcja w
o)
miejsce docelowe = $ optarg
printf "\ n%s \ n \ n" "Poniższe foldery będą zsynchronizowane lewą prawą:"
printf "\ torigen: \ t \ t \ t%s \ n" "$ bold $ origen $ normalne"
printf "\ tDestination: \ t \ t%s \ n \ n" "$ bold $ docelowe $ normalne"
;;
\? )
printf "\ n%s \ n \ n" "$ bold nieprawidłowa opcja dla $ normal $ (basename $ 0): -$ optarg."1> i 2
Wyjście 1
;;
:)
printf "\ n%s \ n \ n" "$ bold opcja $ normalne -$ optarg wymaga katalogu jako argumentu."1> i 2
Wyjście 1
;;
*)
printf "\ n%s \ n \ n" "$ Bold Unkien Opcja dla $ normal $ (basename $ 0): -$ optarg."1> i 2
Wyjście 1
;;
esac
zrobione
Shift $ ((optind -1))
fi
###################
# Sekcja synchronizacji
###################
podczas inotifywait -r -e modyfikuj, utwórz, usuń $ ORYGEN
Do
rsync -Avz $ ORIGEN/ $ DOCETION - -Delete - -Filter = 'P .git '
zrobione

Wyzwania

Jako wyzwanie, spróbuj zaprojektować dwie kolejne wersje bieżącego skryptu. Pierwszy musi wydrukować plik dziennika, który przechowuje każdą zmianę znalezioną przez inotifywait polecenie i każde przyrost wykonany przez rsync. Drugim wyzwaniem jest utworzenie dwucylwowerowego systemu synchronizacji przy użyciu tylko pewnej pętli jako poprzedniego skryptu. Poradę: jest łatwiejszy niż się wydaje.

Możesz udostępniać swoje ustalenia lub pytania na Twitterze @linuxhint