Specchia il tuo sito web con rsync

Questo tutorial mostra come puoi specchiare il tuo sito web dal tuo server web principale a un server di backup che può subentrare se il server principale fallisce. Utilizziamo lo strumento rsync per questo, e lo facciamo eseguire tramite un cron job che controlla ogni x minuti se c’è qualcosa da aggiornare sul mirror. Così il tuo server di backup dovrebbe essere di solito aggiornato se deve subentrare.

rsync aggiorna solo i file che sono cambiati, quindi non è necessario trasferire 5 GB di dati ogni volta che esegui rsync. Specchia solo i file nuovi/cambiati e può anche eliminare i file dal mirror che sono stati eliminati sul server principale. Inoltre, può preservare permessi e proprietà dei file e delle directory specchiati; per preservare le proprietà, dobbiamo eseguire rsync come root, il che è ciò che facciamo qui. Se i permessi e/o le proprietà cambiano sul server principale, rsync li cambierà anche sul server di backup.

In questo tutorial tunneleremo rsync attraverso SSH, che è più sicuro; significa anche che non devi aprire un altro porto nel tuo firewall per rsync - è sufficiente che il porto 22 (SSH) sia aperto. Il problema è che SSH richiede una password per accedere, il che non è buono se vuoi eseguire rsync come cron job. La necessità di una password richiede interazione umana, che non è ciò che vogliamo.

Ma fortunatamente c’è una soluzione: l’uso di chiavi pubbliche. Creiamo una coppia di chiavi (sul nostro server di backup mirror.example.com), una delle quali è salvata in un file sul sistema remoto (server1.example.com). Successivamente non ci verrà più richiesta una password quando eseguiamo rsync. Questo include anche i cron job, che è esattamente ciò che vogliamo.

Come potresti già aver indovinato da quanto ho scritto finora, il concetto è che iniziamo il mirroring di server1.example.com direttamente da mirror.example.com; server1.example.com non deve fare nulla per essere specchiato.

Utilizzerò la seguente configurazione qui:

• Server principale: server1.example.com (server1) - Indirizzo IP: 192.168.0.100
• Server mirror/di backup: mirror.example.com (mirror) - Indirizzo IP: 192.168.0.175
• Il sito web che deve essere specchiato si trova in /var/www su server1.example.com.

rsync è per specchiare solo file e directory; se vuoi specchiare il tuo database MySQL, usa invece il mirroring/repliazione di MySQL.

Voglio dire prima che questo non è l’unico modo per impostare un tale sistema. Ci sono molti modi per raggiungere questo obiettivo, ma questo è il modo che seguirò.

Il primo passo è accedere o diventare l’utente root sul tuo sistema. Su Debian e centOS, usa:

su -

Se sei connesso come un utente diverso da root. Su Ubuntu, usa:

sudo -s

invece.

1 Installa rsync

Prima di tutto, dobbiamo installare rsync sia su server1.example.com che su mirror.example.com. Per i sistemi Debian e Ubuntu, questo appare così:

server1/mirror:

(Lo facciamo come root!)

apt install rsync

Su altre distribuzioni Linux, utilizzeresti yum / dnf (Fedora/CentOS) o yast (SuSE) per installare rsync.

Su CentOS / Rocky Linux o AlmaLinux, usa:

dnf install rsync

2 Crea un utente non privilegiato su server1.example.com

Ora creiamo un utente non privilegiato chiamato someuser su server1.example.com che sarà utilizzato da rsync su mirror.example.com per specchiare la directory /var/www (ovviamente, someuser deve avere permessi di lettura su /var/www su server1.example.com).

server1:

(Lo facciamo come root!)

sudo useradd -d /home/someuser -m -s /bin/bash someuser

Questo creerà l’utente someuser con la home directory /home/someuser e la shell di login /bin/bash (è importante che someuser abbia una shell di login valida - qualcosa come /bin/false non funziona!). Ora dai a someuser una password:

passwd someuser

3 Testa rsync

Successivamente, testiamo rsync su mirror.example.com. Come root facciamo questo:

mirror:

rsync -avz -e ssh [email protected]:/var/www/ /var/www/

Dovresti vedere qualcosa del genere. Rispondi con sì:

L'autenticità dell'host 'server1.example.com (192.168.0.100)' non può essere stabilita.  
La chiave RSA fingerprint è 32:e5:79:8e:5f:5a:25:a9:f1:0d:ef:be:5b:a6:a6:23.  
Sei sicuro di voler continuare a connetterti (sì/no)?

<-- sì

Quindi inserisci la password di someuser, e dovresti vedere che la directory /var/www di server1.example.com è specchiata in /var/www su mirror.example.com.

Puoi controllarlo in questo modo su entrambi i server:

server1/mirror:

ls -la /var/www

Dovresti vedere che tutti i file e le directory sono stati specchiati su mirror.example.com, e i file e le directory dovrebbero avere gli stessi permessi/proprietà di server1.example.com.

4 Crea le chiavi su mirror.example.com

Ora creiamo la coppia di chiavi privata/pubblica su mirror.example.com:

mirror:

(Lo facciamo come root!)

mkdir /root/rsync  
ssh-keygen -t dsa -b 1024 -f /root/rsync/mirror-rsync-key

Vedrai qualcosa del genere:

Generazione della coppia di chiavi pubblica/privata dsa.  
Inserisci la passphrase (vuoto per nessuna passphrase): [premi invio qui]  
Inserisci la stessa passphrase di nuovo: [premi invio qui]  
La tua identificazione è stata salvata in /root/cron/mirror-rsync-key.  
La tua chiave pubblica è stata salvata in /root/cron/mirror-rsync-key.pub.  
La chiave fingerprint è:  
68:95:35:44:91:f1:45:a4:af:3f:69:2a:ea:c5:4e:d7 root@mirror

È importante che tu non inserisca una passphrase altrimenti il mirroring non funzionerà senza interazione umana, quindi premi semplicemente invio!

Successivamente, copiamo la nostra chiave pubblica su server1.example.com:

mirror:

(Ancora, lo facciamo come root.)

scp /root/rsync/mirror-rsync-key.pub [email protected]:/home/someuser/

La chiave pubblica mirror-rsync-key.pub dovrebbe ora essere disponibile in /home/someuser su server1.example.com.

5 Configura server1.example.com

Ora accedi tramite SSH su server1.example.com come someuser (non come root!) e fai questo:

server1:

(Per favore, fallo come someuser!)

mkdir ~/.ssh  
chmod 700 ~/.ssh  
mv ~/mirror-rsync-key.pub ~/.ssh/  
cd ~/.ssh  
touch authorized_keys  
chmod 600 authorized_keys  
cat mirror-rsync-key.pub >> authorized_keys

Facendo questo, abbiamo aggiunto il contenuto di mirror-rsync-key.pub al file /home/someuser/.ssh/authorized_keys. /home/someuser/.ssh/authorized_keys dovrebbe apparire simile a questo:

server1:

(Ancora come someuser!)

vi /home/someuser/.ssh/authorized_keys

ssh-dss AAAAB3NzaC1kc3MAAA[...]lSUom root@  
mirror

Ora vogliamo consentire connessioni solo da mirror.example.com, e l’utente connesso dovrebbe essere autorizzato a usare solo rsync, quindi aggiungiamo

command="/home/someuser/rsync/checkrsync",from="mirror.example.com",no-port-forwarding,no-X11-forwarding,no-pty

proprio all’inizio di /home/someuser/.ssh/authorized_keys:

server1:

(Ancora come someuser!)

vi /home/someuser/.ssh/authorized_keys

command="/home/someuser/rsync/checkrsync",from="mirror.example.com",no-port-forwarding,no-X11-forwarding,no-pty ssh-dss AAAAB3NzaC1kc3MAAA[...]lSUom root@  
mirror

Devi usare un FQDN come mirror.example.com invece di un indirizzo IP dopo from=, altrimenti il mirroring automatico non funzionerà!

Ora creiamo lo script /home/someuser/rsync/checkrsync che rifiuta tutti i comandi tranne rsync.

server1:

(Lo facciamo ancora come someuser!)

mkdir ~/rsync  
vi ~/rsync/checkrsync

#!/bin/sh  
  
case "$SSH_ORIGINAL_COMMAND" in  
        **)  
                echo "Rifiutato"  
                ;;  
        *(*)  
                echo "Rifiutato"  
                ;;  
        *{*)  
                echo "Rifiutato"  
                ;;  
        *;*)  
                echo "Rifiutato"  
                ;;  
        *<*)  
                echo "Rifiutato"  
                ;;  
        *`*)  
                echo "Rifiutato"  
                ;;  
        rsync   ext--server*)  
                $SSH_ORIGINAL_COMMAND  
                ;;  
        *)  
                echo "Rifiutato"  
                ;;  
esac

chmod 700 ~/rsync/checkrsync

6 Testa rsync su mirror.example.com

Ora dobbiamo testare su mirror.example.com se possiamo specchiare server1.example.com senza essere invitati a inserire la password di someuser. Facciamo questo:

mirror:

(Lo facciamo come root!)

rsync -avz --delete --exclude=/stats --exclude=/error --exclude=/files/pictures -e "ssh -i /root/rsync/mirror-rsync-key" [email protected]:/var/www/ /var/www/

(L’opzione –delete significa che i file che sono stati eliminati su server1.example.com dovrebbero essere eliminati anche su mirror.example.com. L’opzione –exclude significa che questi file/directory non dovrebbero essere specchiati; ad esempio, –exclude=/error significa “non specchiare /var/www/error”. Puoi usare più opzioni –exclude. Ho elencato queste opzioni come esempi; puoi adattare il comando alle tue esigenze. Dai un’occhiata a

man rsync

per ulteriori informazioni.)

Dovresti ora vedere che il mirroring avviene:

receiving file list ... done  
  
sent 71 bytes  received 643 bytes  476.00 bytes/sec  
total size is 64657  speedup is 90.56

senza essere invitato a inserire una password! Questo è ciò che volevamo.

7 Crea un cron job

Vogliamo automatizzare il mirroring, ecco perché creiamo un cron job per esso su mirror.example.com. Esegui crontab -e come root:

mirror:

(Lo facciamo come root!)

crontab -e

e crea un cron job come questo:

*/5 * * * * /usr/bin/rsync -azq --delete --exclude=/stats --exclude=/error --exclude=**/files/pictures -e "ssh -i /root/rsync/mirror-rsync-key" [email protected]:/var/www/ /var/www/ 

Questo eseguirebbe rsync ogni 5 minuti; adattalo alle tue esigenze (vedi

man 5 crontab

). Uso il percorso completo per rsync qui (/usr/bin/rsync) solo per essere sicuro che cron sappia dove trovare rsync. La tua posizione di rsync potrebbe differire. Esegui

mirror:

(Lo facciamo come root!)

which rsync

per scoprire dove si trova il tuo.

8 Link

• rsync: https://rsync.samba.org/