Se sei felice di conservare una copia dei dati sul computer intermedio, puoi semplicemente scrivere uno script che aggiorni la copia locale usando server1 come riferimento, quindi aggiorni il backup su server2 usando la copia locale come riferimento:
#!/bin/sh
rsync user@server1:/path/to/stuff /path/to/loca/copy -a --delete --compress
rsync /path/to/loca/copy user@server2:/path/to/where/stuff/should/go -a --delete --compress
L'uso di un semplice script significa che hai desiderato un singolo comando per fare tutto. Questo ovviamente potrebbe essere un no-no di sicurezza se i dati sono sensibili (tu, o altri nella tua azienda, potresti non volerne una copia fluttuante sul tuo laptop). Se server1 è locale per te, puoi semplicemente eliminare la copia locale in seguito (poiché la prossima volta sarà veloce ricostruire sulla LAN locale).
Costruire un tunnel in modo che i server possano dialogare efficacemente tra loro in modo più diretto dovrebbe essere possibile in questo modo:
- Sul server 2 fare una copia di / bin / sh come / usr / local / bin / shforkeepalive. Utilizzare un collegamento simbolico anziché una copia, quindi non è necessario aggiornarlo dopo gli aggiornamenti di sicurezza che patch / bin / sh.
Sul server 2 crea uno script che non fa altro che dormire in loop per alcuni secondi, poi riecheggia una piccola quantità di testo e usa questo comando "copia" di sh:
#!/usr/local/bin/shforkeepalive
while [ "1" != "0" ]; do
echo Beep!
sleep 5
done
( echoprobabilmente non è necessario, poiché la sessione non sarà inattiva per il tempo necessario per il timeout anche se SSHd è configurato per ignorare i pacchetti keep-alive dal client ssh)
Ora puoi scrivere uno script sul tuo laptop che avvia il tunnel inverso in background, dice a server1 di usare rsync per eseguire l'operazione di copia, quindi uccide il tunnel inverso uccidendo lo script di loop (che chiuderà la sessione SSH):
#!/bin/sh
ssh user@server2 -L2222:127.0.0.1:22 /usr/local/bin/keepalivesctipt &
ssh user@server1 -R2222:127.0.0.1:2222 rsync /path/to/stuff user@127.0.0.1:/destination/path/to/update -a --delete --compress -e 'ssh -p 2222'
ssh user@server2 killall shforkeepalive
Il modo in cui funziona:
- Riga 1: marcatore "comando da utilizzare per interpretare questo script" standard
- Linea 2: avvia una connessione SSH con tunnel inverso ed esegui lo script keepalive tramite esso per tenerlo aperto. Il trailing & dice a bash di eseguire questo in background in modo che le righe successive possano essere eseguite senza aspettare che finisca
- Linea 3: avvia un tunnel che si collegherà al tunnel sopra in modo che server1 possa vedere server2 ed esegui rsync per eseguire la copia / aggiornamento su questa disposizione
- Riga 4: uccidi lo script keep-alive una volta completata l'operazione rsync (e così ritorna la seconda chiamata SSH), che sarà e la prima sessione ssh.
Questo non sembra particolarmente pulito, ma dovrebbe funzionare. Non ho testato quanto sopra, quindi potrebbe essere necessario modificarlo. Rendere il comando rsync uno script a riga singola su server1 può aiutare riducendo l'eventuale necessità di sfuggire a caratteri come il 'sul comando ssh chiamante.
A proposito: dici "non chiedere" perché i due server non possono vedersi direttamente, ma spesso c'è una buona ragione per questo. Il mio server di casa e il server su cui sono conservati i backup online non possono accedere l'uno all'altro (e hanno password + chiavi diverse per tutti gli utenti) - ciò significa che se uno dei due viene violato non può essere utilizzato come percorso facile per hackerare l'altro in modo che i miei backup online siano più sicuri (qualcuno che elimina dal vivo i miei dati non può usare la sua capacità di aggiornare i backup per eliminare tali backup, poiché non ha la possibilità diretta di toccare il sito di backup principale). Entrambi i server possono entrambi connettersi a un server intermedio altrove: il server live è impostato per inviare i suoi backup (tramite rsync) alla macchina intermedia al mattino presto e il server di backup è impostato (un po 'più tardi per consentire il completamento del passaggio 1) per connettersi e raccogliere gli aggiornamenti (di nuovo tramite rsyc seguito da un passaggio di snapshot per mantenere più età del backup). Questa tecnica può essere utilizzabile anche nelle tue circostanze, e in tal caso la consiglierei come un modo molto più pulito di fare le cose.
Modifica: Unendo il mio hack con Aaron per evitare tutto il caos con copie di / bin / sh e uno script keep-alive separato su server2, questo script sul tuo laptop dovrebbe fare tutto il lavoro:
#!/bin/sh
ssh user@server2 -L2222:127.0.0.1:22 sleep 60 &
pid=$!
trap "kill $pid" EXIT
ssh user@server1 -R2222:127.0.0.1:2222 rsync /path/to/stuff user@127.0.0.1:/destination/path/to/update -a --delete --compress -e 'ssh -p 2222'
Come sopra, rsync si sta connettendo a localhost: 2222 che inoltra giù nel tunnel all'host locale del tuo laptop: 2222 che inoltra attraverso l'altro tunnel all'host locale di server2: 22.
Modifica 2: se non ti dispiace che server1 abbia una chiave che gli consente di autenticarsi direttamente con server2 (anche se non riesce a vedere server2 senza un tunnel) puoi semplificare ulteriormente con:
#!/bin/sh
ssh user@server1 -R2222:123.123.123:22 rsync /path/to/stuff user@127.0.0.1:/destination/path/to/update -a --delete --compress -e 'ssh -p 2222'
dove 123.123.123.123 è un indirizzo pubblico per server2, che può essere utilizzato come copia + incolla un solo liner anziché uno script.