Se você deseja manter uma cópia dos dados na máquina intermediária, basta escrever um script que atualize a cópia local usando o server1 como referência e atualize o backup no servidor2 usando a cópia local como referência:
#!/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
Usar um script simples significa que ele desejou um único comando para fazer tudo. É claro que isso pode ser um problema de segurança, se os dados forem sensíveis (você ou outras pessoas da sua empresa talvez não desejem uma cópia flutuando no laptop). Se server1 for local para você, você poderá excluir a cópia local posteriormente (pois será rápida a reconstrução na LAN local na próxima vez).
Construir um túnel para que os servidores possam conversar efetivamente mais diretamente entre si deve ser possível da seguinte maneira:
- No servidor 2, faça uma cópia de / bin / sh como / usr / local / bin / shforkeepalive. Use um link simbólico em vez de uma cópia para não precisar atualizá-lo após a atualização de segurança desse patch / bin / sh.
No servidor 2, crie um script que não faça nada além de fazer um loop em suspensão por alguns segundos e, em seguida, fazer eco de uma pequena quantidade de texto, e faça com que isso use a agora "cópia" de sh:
#!/usr/local/bin/shforkeepalive
while [ "1" != "0" ]; do
echo Beep!
sleep 5
done
( echoprovavelmente não é necessário, pois a sessão não ficará inativa por tempo suficiente, mesmo que o SSHd esteja configurado para ignorar pacotes keep-alive do cliente ssh)
Agora você pode escrever um script no seu laptop que inicie o seu túnel reverso em segundo plano, diga ao server1 para usar o rsync para executar a operação de cópia e, em seguida, elimine o túnel reverso matando o script em loop (que fechará a sessão 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
Como isso funciona:
- Linha 1: marcador "comando a ser usado para interpretar esse script" padrão
- Linha 2: inicie uma conexão SSH com túnel reverso e execute o script keepalive por meio dele para mantê-lo aberto. O trailing & diz ao bash para executar isso em segundo plano, para que as próximas linhas possam ser executadas sem esperar pela conclusão
- Linha 3: inicie um túnel que se conectará ao túnel acima para que o servidor1 possa ver o servidor2 e execute o rsync para executar a cópia / atualização sobre esse arranjo
- Linha 4: interrompa o script keep-alive assim que a operação rsync for concluída (e a segunda chamada SSH retornar), o que ocorrerá e a primeira sessão ssh.
Isso não parece particularmente limpo, mas deve funcionar. Eu não testei o acima, então você pode precisar ajustá-lo. Tornar o comando rsync um script de linha única no servidor1 pode ajudar a reduzir qualquer necessidade de escapar caracteres como o 'no comando de chamada ssh.
BTW: você diz "não pergunte" por que os dois servidores não podem se ver diretamente, mas geralmente há uma boa razão para isso. Meu servidor doméstico e o servidor em que seus backups on-line são mantidos não podem se conectar (e possuem senhas + chaves diferentes para todos os usuários) - isso significa que, se um dos dois for invadido, ele não poderá ser usado como uma rota fácil para hackear o outro para que meus backups on-line sejam mais seguros (alguém que deleta meus dados do Live não pode usar sua capacidade de atualizar os backups para excluir os backups, pois não tem capacidade direta de tocar no site principal de backup). Ambos os servidores podem se conectar a um servidor intermediário em outro local - o servidor ativo está configurado para enviar seus backups (via rsync) para a máquina intermediária no início da manhã e o servidor de backup está configurado (um pouco mais tarde para permitir que a etapa 1 seja concluída) para se conectar e colete as atualizações (novamente via rsyc, seguidas de uma etapa de captura instantânea para manter várias idades de backup). Essa técnica também pode ser utilizável em sua circunstância e, nesse caso, eu a recomendaria como uma maneira muito mais limpa de fazer as coisas.
Edit: Mesclando meu hack com o Aaron para evitar toda a confusão com cópias de / bin / sh e um script keep-alive separado no server2, esse script no seu laptop deve fazer todo o trabalho:
#!/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'
Como acima, o rsync está se conectando ao localhost: 2222, que encaminha o túnel ao localhost do seu laptop: 2222, que encaminha o outro túnel ao localhost do servidor2: 22.
Edit 2: Se você não se importa com o server1 com uma chave que permita a autenticação direta com o server2 (mesmo que não consiga ver o server2 sem um túnel), você pode simplificar ainda mais com:
#!/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'
em que 123.123.123.123 é um endereço público do servidor2, que pode ser usado como copiar + colar uma linha em vez de um script.