Si está contento de conservar una copia de los datos en la máquina intermedia, simplemente puede escribir un script que actualice la copia local utilizando el servidor1 como referencia y luego actualice la copia de seguridad en el servidor2 utilizando la copia local como referencia:
#!/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
El uso de un script simple significa que ha deseado un solo comando para hacer todo. Por supuesto, esto podría ser un no-no de seguridad si los datos son confidenciales (usted u otras personas de su empresa, puede que no desee una copia flotando en su computadora portátil). Si el servidor1 es local para usted, puede eliminar la copia local después (ya que la próxima vez se reconstruirá rápidamente en la LAN local).
Construir un túnel para que los servidores puedan comunicarse efectivamente entre ellos de manera más directa debería ser posible así:
- En el servidor 2, haga una copia de / bin / sh como / usr / local / bin / shforkeepalive. Use un enlace simbólico en lugar de una copia, entonces no tiene que actualizarlo después de las actualizaciones de seguridad que parchean / bin / sh.
En el servidor 2, cree una secuencia de comandos que no haga nada más que bucle en suspensión durante unos segundos y luego haga eco de una pequeña cantidad de texto, y haga que esto use la ahora "copia" de sh:
#!/usr/local/bin/shforkeepalive
while [ "1" != "0" ]; do
echo Beep!
sleep 5
done
( echoprobablemente no sea necesario, ya que la sesión no estará inactiva durante el tiempo suficiente como para que se agote el tiempo de espera incluso si SSHd está configurado para ignorar los paquetes de mantenimiento del cliente ssh)
Ahora puede escribir un script en su computadora portátil que inicie su túnel inverso en segundo plano, le dice al servidor1 que use rsync para realizar la operación de copia, luego mata el túnel inverso al eliminar el script de bucle (que cerrará la sesión 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
La forma en que esto funciona:
- Línea 1: marcador estándar "comando a utilizar para interpretar este script"
- Línea 2: inicie una conexión SSH con túnel inverso y ejecute el script keepalive a través de él para mantenerlo abierto. Trailing & le dice a bash que ejecute esto en segundo plano para que las siguientes líneas puedan ejecutarse sin esperar a que termine
- Línea 3: inicie un túnel que se conectará al túnel de arriba para que el servidor1 pueda ver el servidor2, y ejecute rsync para realizar la copia / actualización sobre este arreglo
- Línea 4: elimine la secuencia de comandos keep-alive una vez que se complete la operación rsync (y así se devuelve la segunda llamada SSH), que lo hará y la primera sesión ssh.
Esto no se siente particularmente limpio, pero debería funcionar. No he probado lo anterior, por lo que es posible que deba modificarlo. Hacer que el comando rsync sea un script de una sola línea en el servidor1 puede ayudar al reducir la necesidad de escapar de caracteres como el 'en el comando ssh de llamada.
Por cierto: dices "no preguntes" por qué los dos servidores no pueden verse directamente, pero a menudo hay una buena razón para esto. Mi servidor doméstico y el servidor en el que se guardan las copias de seguridad en línea no pueden iniciar sesión entre sí (y tienen diferentes contraseñas + claves para todos los usuarios); esto significa que si uno de los dos es pirateado, no se puede usar como una ruta fácil para piratear el otro para que mis copias de seguridad en línea sean más seguras (alguien que borre maliciosamente mis datos de Live no puede usar su capacidad para actualizar las copias de seguridad para eliminar dichas copias de seguridad, ya que no tiene la capacidad directa de tocar el sitio de copia de seguridad principal). Ambos servidores pueden conectarse a un servidor intermedio en otro lugar: el servidor en vivo está configurado para enviar sus copias de seguridad (a través de rsync) a la máquina intermedia temprano en la mañana y el servidor de copia de seguridad está configurado (un poco más tarde para permitir que se complete el paso uno) para conectarse y recopile las actualizaciones (nuevamente a través de rsyc seguido de un paso de captura de imágenes para mantener varias edades de copia de seguridad). Esta técnica también puede ser útil en su caso, y si es así, la recomendaría como una forma mucho más limpia de hacer las cosas.
Editar: fusionando mi truco con Aaron's para evitar toda la intrusión con copias de / bin / sh y un script de keep-alive separado en server2, este script en su computadora portátil debería hacer todo el trabajo:
#!/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'
Al igual que con lo anterior, rsync se conecta a localhost: 2222 que reenvía por el túnel al localhost de su computadora portátil: 2222 que reenvía a través del otro túnel al localhost del servidor2: 22.
Edición 2: si no le importa que el servidor1 tenga una clave que le permita autenticarse con el servidor2 directamente (aunque no pueda ver el servidor2 sin un túnel), puede simplificar aún más 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'
donde 123.123.123.123 es una dirección pública para server2, que podría usarse como copiar + pegar una línea en lugar de un script.