Questo tutorial mostra come eseguire il mirroring del tuo sito Web dal server Web principale a un server di backup che può subentrare in caso di guasto del server principale. Usiamo lo strumento rsync per questo e lo facciamo eseguire attraverso un cron job che controlla ogni x minuti se c'è qualcosa da aggiornare sul mirror. Pertanto, il tuo server di backup di solito dovrebbe essere aggiornato se deve prendere il controllo.
rsync aggiorna solo i file che sono stati modificati, quindi non è necessario trasferire 5 GB di dati ogni volta che esegui rsync. Rispecchia solo i file nuovi/modificati e può anche eliminare i file dal mirror che sono stati eliminati sul server principale. In aggiunta a ciò, può preservare le autorizzazioni e le proprietà di file e directory con mirroring; per preservare le proprietà, dobbiamo eseguire rsync come root, che è ciò che facciamo qui. Se le autorizzazioni e/o le proprietà cambiano sul server principale, rsync le modificherà anche sul server di backup.
In questo tutorial eseguiremo il tunneling di rsync tramite SSH che è più sicuro; significa anche che non è necessario aprire un'altra porta nel firewall per rsync:è sufficiente se la porta 22 (SSH) è aperta. Il problema è che SSH richiede una password per l'accesso che non va bene se si desidera eseguire rsync come cron job. La necessità di una password richiede l'interazione umana che non è ciò che vogliamo.
Ma per fortuna c'è una soluzione:l'uso di chiavi pubbliche . Creiamo una coppia di chiavi (sul nostro server di backup mirror.example.com ), uno dei quali viene salvato in un file sul sistema remoto (server1.example.com ). Successivamente non ci verrà più richiesta una password quando eseguiamo rsync. Questo include anche i lavori cron che è esattamente quello che vogliamo.
Come avrai già intuito da quanto ho scritto finora, il concetto è che avviamo il mirroring di server1.example.com direttamente da mirror.example.com; server1.example.com non deve fare nulla per ottenere il mirroring.
Userò la seguente configurazione qui:
- Server principale:server1.example.com (server1) - Indirizzo IP:192.168.0.100
- Server mirror/backup:mirror.example.com (mirror) - Indirizzo IP:192.168.0.175
- Il sito Web di cui eseguire il mirroring si trova in /var/www su server1.example.com.
rsync è solo per il mirroring di file e directory; se vuoi eseguire il mirroring del tuo database MySQL, usa invece il mirroring/replica MySQL.
Voglio dire in primo luogo che questo non è l'unico modo per impostare un tale sistema. Ci sono molti modi per raggiungere questo obiettivo, ma questo è il modo in cui prendo.
1 Installa rsync
Innanzitutto, dobbiamo installare rsync sia su server1.example.com che su mirror.example.com. Per i sistemi Debian e Ubuntu, questo è simile a questo:
server1/mirror:
(Lo facciamo come root!)
apt-get install rsync
Su altre distribuzioni Linux, useresti yum (Fedora/CentOS) o yast (SuSE) per installare rsync.
2 Crea un utente senza privilegi su server1.example.com
Ora creiamo un utente senza privilegi chiamato someuser su server1.example.com che verrà utilizzato da rsync su mirror.example.com per eseguire il mirroring della directory /var/www (ovviamente, someuser deve avere i permessi di lettura su /var/www su server1 .esempio.com).
server1:
(Lo facciamo come root!)
useradd -d /home/someuser -m -s /bin/bash someuser
Questo creerà l'utente someuser con la directory home /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 qualche utente una password:
passwd someuser
3 Test rsync
Successivamente, testiamo rsync su mirror.example.com. Come root facciamo questo:
specchio:
rsync -avz -e ssh [email protected]:/var/www/ /var/www/
Dovresti vedere qualcosa del genere. Rispondi con sì:
The authenticity of host 'server1.example.com (192.168.0.100)' can't be established.
RSA key fingerprint is 32:e5:79:8e:5f:5a:25:a9:f1:0d:ef:be:5b:a6:a6:23.
Are you sure you want to continue connecting (yes/no)?
<-- yes
Quindi inserisci la password di un utente e dovresti vedere che la directory /var/www di server1.example.com è rispecchiata in /var/www su mirror.example.com.
Puoi verificarlo in questo modo su entrambi i server:
server1/mirror:
ls -la /var/www
Dovresti vedere che tutti i file e le directory sono stati sottoposti a mirroring su mirror.example.com e che i file e le directory dovrebbero avere le stesse autorizzazioni/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:
specchio:
(Lo facciamo come root!)
mkdir /root/rsync
ssh-keygen -t dsa -b 1024 -f /root/rsync/mirror-rsync-key
Vedrai qualcosa del genere:
Generating public/private dsa key pair.
Enter passphrase (empty for no passphrase): [press enter here]
Enter same passphrase again: [press enter here]
Your identification has been saved in /root/cron/mirror-rsync-key.
Your public key has been saved in /root/cron/mirror-rsync-key.pub.
The key fingerprint is:
68:95:35:44:91:f1:45:a4:af:3f:69:2a:ea:c5:4e:d7 [email protected]
È importante non inserire una passphrase, altrimenti il mirroring non funzionerà senza l'interazione umana, quindi premi semplicemente invio !
Quindi, copiamo la nostra chiave pubblica su server1.example.com:
specchio:
(Tuttavia, 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 utente (non root!) e fai questo:
server1:
(Per favore, fallo come un utente!)
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
In questo modo, abbiamo aggiunto il contenuto di mirror-rsync-key.pub al file /home/someuser/.ssh/authorized_keys. /home/someuser/.ssh/authorized_keys dovrebbe essere simile a questo:
server1:
(Sempre come un utente!)
vi /home/someuser/.ssh/authorized_keys
ssh-dss AAAAB3NzaC1kc3MAAA[...]lSUom [email protected]
mirror
Ora vogliamo consentire le connessioni solo da mirror.example.com e l'utente che si connette dovrebbe essere autorizzato a utilizzare 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:
(Sempre come un utente!)
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 [email protected]
mirror
È importante utilizzare 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 utente!)
mkdir ~/rsync
vi ~/rsync/checkrsync
#!/bin/sh
case "$SSH_ORIGINAL_COMMAND" in
*\&*)
echo "Rejected"
;;
*\(*)
echo "Rejected"
;;
*\{*)
echo "Rejected"
;;
*\;*)
echo "Rejected"
;;
*\<*)
echo "Rejected"
;;
*\`*)
echo "Rejected"
;;
rsync\ --server*)
$SSH_ORIGINAL_COMMAND
;;
*)
echo "Rejected"
;;
esac
chmod 700 ~/rsync/checkrsync
6 Prova rsync su mirror.example.com
Ora dobbiamo testare su mirror.example.com se possiamo eseguire il mirroring di server1.example.com senza che venga richiesta la password di qualche utente. Facciamo questo:
specchio:
(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 devono essere eliminati anche su mirror.example.com. L'opzione --exclude significa che questi file/directory non devono essere sottoposti a mirroring; es. --exclude =**/error significa "non eseguire il mirroring di /var/www/error". Puoi utilizzare 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.)
Ora dovresti vedere che il mirroring ha luogo:
receiving file list ... done
sent 71 bytes received 643 bytes 476.00 bytes/sec
total size is 64657 speedup is 90.56
senza che venga richiesta una password! Questo è ciò che volevamo.
7 Crea un lavoro Cron
Vogliamo automatizzare il mirroring, ecco perché creiamo un cron job su mirror.example.com. Esegui crontab -e come root:
specchio:
(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]com:/var/www/ /var/www/
Ciò 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 assicurarmi che cron sappia dove trovare rsync. La tua posizione di rsync potrebbe differire. Corri
specchio:
(Lo facciamo come root!)
which rsync
per scoprire dove si trova il tuo.
8 link
- rsync: https://rsync.samba.org/