Come utilizzare inotify e rsync per creare un sistema di backup live

Perché dovresti usare gli script bash per eseguire sincronizzazioni e backup delle cartelle?

Bash è di gran lunga l'interprete della lingua di comando compatibile più popolare e utilizzata. Oggi puoi trovare Bash quasi ovunque, tra cui Microsoft Windows con il nuovo sottosistema Windows per Linux. Praticamente tutta la distribuzione GNU/Linux viene fornita con Bash come shell predefinita. Lo stesso vale per MacOS e altri sistemi operativi simili a Unix.

Bash non è solo una lingua di comando; Come altri gusci unix, Bash è sia un linguaggio di programmazione che un interprete di comando. Tecnicamente parlando, il lato di programmazione di una shell fornisce le abilità e le funzionalità dell'utente per combinare utilità di sistema o shell in un file. L'utente può creare comandi semplicemente combinando i comandi in un file di testo; Questi tipi speciali di file di testo che includono una raccolta di comandi sono chiamati script shell e, quando tali file ricevono l'autorizzazione per eseguire, l'interprete Shell li vede come un singolo comando.

Il vantaggio di uno script bash è che è possibile utilizzare gli strumenti della riga di comando direttamente al suo interno senza la necessità di importazione o librerie esterne di origine. Questi strumenti di comando e utility integrati sono potenti e possono interagire direttamente con il sistema operativo senza compilation o interpreti aggiuntivi; di solito le utility core e le interfacce della riga di comando, come Awk, Xargs, Trovare, E grep, può avere una prestazione molto migliore rispetto all'utilizzo di script di Python e delle sue librerie, ad esempio. Non è difficile trovare persone che eseguono un'analisi dei dati avanzati utilizzando solo script bash e utility integrate GNU. Altri sostengono che questo tipo di approccio può essere 235 x più veloce di un cluster Hadoop - il che non è così difficile da credere considerando alcune mostruosità clustering che puoi trovare al giorno d'oggi solo per adattarsi ai progetti di cattivi software.

In questa materia, sorge sempre una domanda: se Bash è così potente, perché non usarla per automatizzare tutte le cose noiose? La sintassi di Bash è semplice e pragmatica: ti dà la possibilità di combinare programmi per automatizzare le attività comuni. Tuttavia, quando la sceneggiatura deve affrontare più condizioni o accumulare troppi scopi, è tempo di considerare un linguaggio di programmazione più robusto, come C o altri linguaggi di script, in cui Python e Perl sono buoni esempi.

D'altra parte, gli script bash sono molto buoni per le attività singole come l'intenzione di questo articolo: combinare le utility con le funzionalità per verificare le modifiche in una cartella specifica e quindi sincronizzare i suoi file. Uno script bash può adattarsi perfettamente a questo compito.

Di cosa hai bisogno per eseguire sincronizzazione o autobackup?

Esiste un grande elenco di metodi diversi per sincronizzare cartelle e file. Il numero di applicazioni che possono essere utilizzate per svolgere questo semplice compito è vasto e alcune di queste sono soluzioni di terze parti. Tuttavia, Questo articolo ti mostra un modo più elegante per realizzare lo stesso solo usando inotifywait E rsync In una sceneggiatura di Bash. In generale, questa soluzione sarà leggera, economica e, perché non dire, più sicura. In sostanza, sono necessari solo tool di inotify, rsync e un po 'di tempo per completare questa missione.

Come utilizzare iNotifyWait per autoback e sincronizzazioni?

inotifywait Utilizza API Inotify per attendere le modifiche ai file. Questo comando è stato appositamente progettato per essere utilizzato negli script di shell. Una potente caratteristica di inotifywait è verificare le modifiche continuamente; Non appena si verificano nuovi eventi, inotifywait Stampa le modifiche ed uscite.

inotifywait Fornisce due opzioni molto interessanti per la sincronizzazione delle cartelle o i backup in tempo reale. Il primo è il -R, -ricorsivo opzione; Come suggerisce il nome, questa bandiera osserva le profondità di sottodirectory illimitate di una directory specifica passata come argomenti a inotifywait, esclusi i collegamenti simbolici.

IL -e, -evento Flag fornisce un'altra caratteristica interessante. Questa opzione richiede un elenco di eventi predefiniti. La documentazione di inotify-tool elenca più di 15 eventi per inotifywait; Ma un semplice sistema di backup e sincronizzazione richiede solo elimina e crea eventi.
Il seguente comando è un buon esempio di uno scenario del mondo reale:

$ inotifywait -r -e modifica, crea, elimina/home/userdir/documenti

In questo caso, il comando attende modifiche - modifiche, creazioni di file o cartelle o esclusioni di qualsiasi tipo - nel fittizio /home/userdir/documenti directory. Non appena l'utente apporta qualsiasi modifica, inotifywait emette la modifica e l'uscita.

Supponendo di creare un nuovo file chiamato nuovo file dentro il Documenti cartella mentre il inotifywait lo sta monitorando. Una volta che il comando rileva la creazione del file, emette

Documenti/ crea newfile

In altre parole, inotifywait stampe in cui si verifica la modifica, che tipo di modifiche apportate e il nome del file o della cartella che è stato modificato.

Esaminare lo stato di uscita di inotifywait Quando si verifica una modifica, si vede uno stato di 0-ust che significa un'esecuzione riuscita. Questa situazione è perfetta per uno script di shell perché uno stato di uscita può essere usato come condizione vera o falsa.

Di conseguenza, il primo passo dello script è completo: trovare un'utilità che attende le modifiche nelle directory. Il secondo è cercare un'utilità in grado di sincronizzare due directory e rsync è un candidato perfetto.

Come usare rsync per autobackups?

rsync è un'applicazione potente. Puoi scrivere un libro che descrive tutto ciò che puoi fare con questa versatile utilità. Parlando tecnicamente, rsync non è altro che uno strumento a fari file, una specie di cp Comando con steroidi e poteri speciali come file di trasferimento sicuro. L'impiego di rsync In questo script è più modesto ma non meno elegante.

L'obiettivo principale è trovare un modo per:

• Ricorrere in directory;
• Copia collegamenti simbolici come collegamenti simbolici;
• Preservare le autorizzazioni, la proprietà, i gruppi, i tempi di modifica, i dispositivi e i file speciali;
• Fornire ulteriori dettagli, output verbosio: quindi è possibile creare un file di registro se necessario;
• Comprimi file durante il transfert per l'ottimizzazione.

IL rsync La documentazione è ben scritta; Controllando il riepilogo delle opzioni disponibili, è possibile selezionare facilmente il -Avz bandiere come scelta migliore. Un semplice utilizzo sembra segue:

rsync -avz /

È importante mettere una barra dopo la cartella di origine. Anzi, rsync copia l'intera cartella di origine (incluso se stesso) nella cartella di destinazione.

Ad esempio, se crei due cartelle, una chiamata Originfolder e l'altro la cartella di destinazione, produrre rsync Invia al secondo ogni modifica apportata al primo, usa il comando successivo:

$ rsync -Avz Origenfolder/ DestinationFolder

Una volta creato un nuovo file denominato nuovo file, rsync Stampa qualcosa come:

Invio dell'elenco di file incrementali
./
nuovo file
inviati 101 byte ricevuti 38 byte 278.00 byte/sec
La dimensione totale è 0 SpeedUp è 0.00

Nella prima riga, la direttiva stampa il tipo di processo, una copia incrementale; ciò significa che IL rsync Utilizza le sue capacità di compressione per incrementare solo il file e non modificare l'intero archivio. Come è la prima volta che viene eseguito il comando, l'applicazione copia l'intero file; Una volta che si verificano nuovi cambiamenti, si verificano solo incrementazioni. L'output successivo è la posizione, il nome del file e i dati delle prestazioni. Controllando lo stato di uscita del rsync comando, ricevi un 0-ust per l'esecuzione riuscita.

Quindi, ci sono due importanti applicazioni per fornire supporto in questo script: uno è in grado di aspettare le modifiche e l'altro può creare copie di questa modifica in tempo reale. Qui, ciò che manca è un modo per collegare entrambe le utility in un modo che rsync agire non appena inotifywait percepisce qualsiasi alterazione.

Perché abbiamo bisogno di un ciclo di tempo?

La soluzione più semplice per il problema sopra è un ciclo while. In altre parole, in ogni occasione inotifywait esiste con successo, la sceneggiatura bash deve chiamare rsync per eseguire la sua incrementazione; Immediatamente dopo la copia, la shell deve tornare allo stato iniziale e attendere una nuova uscita del inotifywait comando. Questo è esattamente ciò che fa un giro.

Non hai bisogno di una vasta sfondo nella programmazione per scrivere uno script bash. È molto comune trovare buoni amministratori di sistema che non hanno o molto limitato, esperienza con la programmazione. Tuttavia, La creazione di script funzionali è sempre un compito importante di amministrazione del sistema. La buona notizia è che il concetto dietro un po 'è facile da capire.

Il seguente diagramma rappresenta un ciclo while:

Diagramma di anello infinito.

UN rappresenta il inotifywait comando discusso sopra e B, rsync. Ogni volta UN esiste con uno stato di 0-ust, la shell lo interpreta come vero; Pertanto, il ciclo while consente l'esecuzione di B; Non appena B Inoltre esce correttamente, il comando ritorna a UN di nuovo e ripete il ciclo.
In questo caso, il ciclo while valuta sempre vero per UN. Tecnicamente, genera un ciclo infinito, ciò che è buono per la proposta di questa sceneggiatura; inotifywait sarà eseguito ricorrentemente, il che significa che aspetterà sempre nuove modifiche.

Più formalmente, la sintassi per un bash mentre loop è:

Mentre
Fare

Fatto

significa l'elenco delle condizioni (UN) che deve essere vero; Quindi, il ciclo while può eseguire il , in piedi per il blocco di comandi (B). Se il ciclo pre-test UN è falso, quindi il loop while esce senza eseguire B.

Ecco come rsync E inotifywait I comandi si adattano al ciclo while,

mentre inotifywait -r -e modifica, crea, elimina Origenfolder
Fare
Rsync -Avz Origenfolder/ DestinationFolder
Fatto

Combinando tutto

Ora è il momento di combinare tutto ciò che è discusso sopra per creare uno script di shell. La prima cosa è creare un file vuoto e nominarlo; come esempio, livebackup.Bash rappresenta una buona scelta. È buona pratica posizionare gli script di shell nella cartella del cestino sotto la directory di home utente, a.K.UN. $ Home/cestino.

Successivamente, puoi modificare il file nell'editor di testo di tua scelta. La prima riga di una sceneggiatura di Bash è molto importante; È qui che lo script definisce la direttiva dell'interprete, ad esempio:

#! [opzioni]

Lo shebang è questo strano simbolo con un hash e un marchio esclamativo (##!). Quando la shell carica lo script per la prima volta, cerca questo segno, poiché indica ciò che l'interprete deve essere utilizzato per eseguire il programma. Lo shebang non è un commento e deve essere posizionato nella parte superiore della sceneggiatura senza spazi sopra.

Puoi lasciare la prima riga vuota e non definire l'interprete. In questo modo, la shell utilizza l'interprete predefinito per caricare ed eseguire lo script, tuttavia, non è approvato. La scelta più appropriata e sicura è indicare la direttiva dell'interprete come segue:

#!/usr/bin/bash

Con la direttiva dell'interprete esplicita in quel modo, la shell cerca l'interprete Bash sotto la directory /usr /bin. Poiché il compito di questo script è semplice, non è necessario specificare più comandi o opzioni. Una possibilità più sofisticata è quella di chiamare l'interprete usando il comando Env.

#!/usr/bin/env bash

In questo contesto, la shell cerca il comando bash predefinito nell'ambiente corrente. Tale disposizione è utile quando l'ambiente utente ha importanti personalizzazioni. Tuttavia, può portare a glitch di sicurezza a livello aziendale una volta che la shell non è in grado di rilevare se il comando in un ambiente personalizzato è o non è un interprete sicuro.

Quando mettono tutto insieme a questo punto, la sceneggiatura sembra:

#!/usr/bin/bash
mentre inotifywait -r -e modifica, crea, elimina originefolder
Fare
Rsync -Avz Origenfolder/ DestinationFolder
Fatto

Come usare gli argomenti in uno script bash?

Ciò che separa questo script da una funzionalità totale è come sta definendo l'origine e la cartella di destinazione. Ad esempio, è necessario trovare un modo per mostrare quali sono quelle cartelle. La modalità più veloce per risolvere questa domanda è l'utilizzo di argomenti e variabili.

Ecco un esempio del modo corretto per fare riferimento allo script:

$ ./LiveBackup.Bash/Home/Utente/Origine/Home/Utente/destinazione

La shell carica uno di questi argomenti digitati dopo il nome dello script e li passa al caricatore di script come variabili. Ad esempio, la directory /home/utente/origine è il primo argomento e puoi accedervi all'interno dello script usando il $ 1. Così, $ 2 ha un valore di /home/utente/destinazione. È possibile accedere a tutte queste variabili posizionali utilizzando il segno del dollaro ($) seguito da un numero N ($ n), dove n è la posizione dell'argomento in cui si chiama la sceneggiatura.

Il segno del dollaro ($) ha un significato e implicazioni molto speciali all'interno degli script di shell; In altri articoli, sarà discusso in profondità. Per ora, il puzzle è quasi risolto.

#!/usr/bin/bash
mentre inotifywait -r -e modifica, crea, elimina $ 1
Fare
rsync -avz $ 1/ $ 2
Fatto

Nota: per affrontare troppi argomenti usando solo parametri di posizione ($ n) Può portare rapidamente a cattivi disegni e confusione negli script di shell. Un modo più elegante per risolvere questo problema è usare il getopts comando. Questo comando ti aiuta anche a creare avvisi di disaccordo, cosa può essere utile quando altri utenti hanno accesso allo script. Una ricerca rapida su Internet può mostrare diversi metodi di utilizzo getopts, Cosa può migliorare lo script corrente se è necessario fornire più opzioni di utilizzo ad altri utenti.

Rendendolo eseguibile

Solo un'altra cosa deve essere fatta ora: per creare il file livebackup.Bash eseguibile. Può essere facilmente eseguito con il chmod comando.

Vai alla cartella contenente lo script e il tipo:

$ chmod +x livebackup.Bash

Quindi, digita il segno dot-slash (./) Prima del nome dello script. Il punto significa, in questo contesto, la directory corrente e la barra definiscono un percorso relativo al file nella directory corrente. Con questo in mente, devi anche digitare la cartella di origine come primo argomento, seguita dalla cartella di destinazione come la seconda, come ad esempio:

$ ./LiveBackup.Bash/Home/Utente/Origine/Home/Utente/destinazione

In alternativa, è possibile chiamare gli script con il suo nome posizionando la sua posizione della cartella nel percorso dell'ambiente o chiamarlo sottotitoli, come:

$ Bash LiveBackup.Bash/Home/Utente/Origine/Home/Utente/destinazione

La prima opzione è una scelta sicura però.

Esempio di vita reale

In uno scenario del mondo reale, Eseguire manualmente uno script di backup ogni volta che si avvia il sistema, può essere noioso. Una buona scelta è usare un Cronjob O timer/servizio unità con SystemD. Se hai molte cartelle diverse da eseguire il backup, puoi anche creare un altro script che fonda il livebackup.Bash; Pertanto, il comando deve essere chiamato solo una volta in a .servizio unità. In un altro articolo, questa funzione può essere discussa in modo più dettagliato.

Se si utilizza il sottosistema di Windows per Linux, è possibile creare un'attività di base per eseguire lo script utilizzando il "programma di pianificazione" attivato dall'avvio del sistema. Per utilizzare un file batch per chiamare il Bash.exe con un elenco di comandi è una buona scelta. È inoltre possibile utilizzare uno script Visual Basic per avviare il file batch in background.

Che aspetto ha una sceneggiatura professionista

Ecco un esempio di uno script progettato dall'autore in grado di leggere argomenti di comando più sofisticati.

#!/usr/bin/env bash
#
###Com #############################################
###Com #############################################
#
# Script: SyncFolder.Bash
# Autore: Diego Aurino da Silva
# Data: 16 febbraio 2018
# Rev: 1.0
# Licenza: MIT (https: // github.com/diegoaurino/bashscripts/blob/master/licenza)
#
# Piattaforma: WSL o GNU/Linux
#
# Scopo: piccolo script per sincronizzare le modifiche da sinistra a destra da due cartelle 
# Under WSL o GNU/Linux (richiede iNotify-Tools)
#
###Com #############################################
###Com #############################################
###################
# IMPOSTAZIONI GENERALI
###################
Bold = $ (Tput BOLD)
normale = $ (Tput SGR0)
Origen = ""
destinazione = ""
###################
# Sezione Opzioni
###################
if [$# -eq 0]
Poi
printf "\ n%s \ t \ t%s \ n \ n" "usa $ grassetto -h $ normale per l'aiuto."
Uscita 1
altro
mentre gettopts ": h" opzione
Fare
case $ opzione in
H )
printf "\ n%s \ t \ t%s \ n \ n" "Utilizzo: ./SyncFolder.Bash $ Bold/Origen/Cartella $ Normali -o $ Bold/Destination/Folder $ Normal "
uscita 0
;;
\? )
printf "\ n%s \ n \ n" "$ Bold opzione non valida per $ normale $ (basename $ 0)" 1> & 2
Uscita 1
;;
Esac
Fatto
Shift $ ((optind -1))
Origene = $ 1
spostare
mentre gettopts ": o:" opzione
Fare
case $ opzione in
O)
destinazione = $ optarg
printf "\ n%s \ n \ n" "Le seguenti cartelle saranno sincronizzate a sinistra a destra:"
printf "\ torigen: \ t \ t \ t%s \ n" "$ Bold $ Origen $ Normal"
printf "\ tdestination: \ t \ t%s \ n \ n" "$ grassetto $ destinazione $ normale"
;;
\? )
printf "\ n%s \ n \ n" "$ grassetto opzione non valida per $ normale $ (basename $ 0): -$ optarg."1> & 2
Uscita 1
;;
:)
printf "\ n%s \ n \ n" "$ grassetto L'opzione $ normale -$ optarg richiede una directory come argomento."1> & 2
Uscita 1
;;
*)
printf "\ n%s \ n \ n" "$ grassetto opzione Unkown per $ normale $ (basename $ 0): -$ optarg."1> & 2
Uscita 1
;;
Esac
Fatto
Shift $ ((optind -1))
fi
###################
# Sezione di sincronizzazione
###################
mentre inotifywait -r -e modifica, crea, elimina $ origene
Fare
RSYNC -AVZ $ Origen/ $ Destination -DELETE -Filter = 'P .idiota'
Fatto

Sfide

Come sfida, prova a progettare altre due versioni dello script corrente. Il primo deve stampare un file di log che memorizza ogni modifica trovata dal inotifywait comando e ogni incrementazione fatta da rsync. La seconda sfida è creare un sistema di sincronizzazione a due direzione utilizzando solo un ciclo di tempo come lo script precedente. Un consiglio: è più facile di quanto sembri.

Puoi condividere i tuoi risultati o domande su Twitter @Linuxhint