¿Cómo sincronizar archivos entre dos controles remotos?

Me gustaría transferir archivos entre dos hosts remotos utilizando un shell local, pero parece que rsync no admite la sincronización si se especifican dos controles remotos de la siguiente manera:

$ rsync -vuar host1:/var/www host2:/var/www
The source and destination cannot both be remote.

¿Qué otras soluciones / comandos podría usar para lograr resultados similares?

Como ha descubierto, no puede usar rsync con una fuente remota y un destino remoto. Suponiendo que los dos servidores no pueden comunicarse directamente entre sí, es posible usar ssh para hacer un túnel a través de su máquina local.

En lugar de

rsync -vuar host1:/var/www host2:/var/www

puedes usar esto

ssh -R localhost:50000:host2:22 host1 'rsync -e "ssh -p 50000" -vuar /var/www localhost:/var/www'

En caso de que se lo pregunte, la -Ropción configura un canal inverso desde el puerto 50000 en el host1 que se asigna (a través de su máquina local) al puerto 22 en el host2. No hay conexión directa de host1 a host2.

No dijiste por qué no querías iniciar sesión en un host y luego copiar al otro, así que compartiré una de mis razones y soluciones.

No pude iniciar sesión en una máquina y luego sincronizar con la otra porque ninguno de los hosts tenía una clave SSH que podía iniciar sesión en la otra. Resolví esto usando el reenvío de agente SSH para permitir que el primer host use mi clave SSH mientras estaba conectado.

ADVERTENCIA: el reenvío SSH permite que el host use su clave SSH durante la duración de su inicio de sesión. Si bien no pueden copiar su clave, pueden iniciar sesión en otras máquinas con ella. Asegúrese de comprender los riesgos y no utilice el reenvío de agentes para máquinas en las que no confía.

El siguiente comando utilizará el reenvío del agente SSH para abrir una conexión directa desde host1hasta host2. Esto tiene la ventaja de que la máquina que ejecuta el comando no está bloqueando la transferencia.

ssh -A host1 rsync -vuar /var/www host2:/var/www

Me gusta la respuesta de Roaima, pero los caminos son los mismos en ambos ejemplos, oscureciendo cuál es cuál. Hemos establecido que lo siguiente no funciona:

rsync -vuar host1:/host1/path host2:/host2/path

Pero esto sí (omití la dirección explícita de enlace de localhost de la -Ropción, ya que ese es el valor predeterminado):

ssh -R 50000:host2:22 host1 'rsync -e "ssh -p 50000" -vuar /host1/path localhost:/host2/path'

Tenga en cuenta que deberá tener las claves ssh configuradas correctamente entre los dos hosts remotos, con la clave privada en host1 y la clave pública en host2.

Para depurar la conexión, divídalo en dos partes y agregue el estado detallado:

localhost$ ssh -v -R 50000:host2:22 host1

Si esto funciona, tendrás un shell en host1. Ahora prueba el comando rsync de host1. Recomiendo hacer esto en una ventana diferente para que la información detallada de ssh no se mezcle con la información de estado de rsync:

host1$ rsync -e "ssh -p 50000" -vuar /host1/path localhost:/host2/path

Reformateando la respuesta de roaima en la sintaxis de script bash (y agregando caracteres de continuación de línea '\' para mayor claridad) Elegí al azar el puerto 22000 ...

SOURCE_USER=user1
SOURCE_HOST=hostname1
SOURCE_PATH=path1

TARGET_USER=user2
TARGET_HOST=host2
TARGET_PATH=path2

ssh -l $TARGET_USER -A -R localhost:22000:$TARGET_HOST:22 \
$SOURCE_USER@$SOURCE_HOST "rsync -e 'ssh -p 22000' -vuar $SOURCE_PATH \
$TARGET_USER@localhost:$TARGET_PATH"

La forma ideal sería ejecutar rsyncuno de esos servidores. Pero si no desea ejecutar un script en el servidor remoto. Puede ejecutar un script en su sistema local y hacer un ssh y ejecutar el rsync allí.

ssh user@$host1 <<ENDSSH >> /tmp/rsync.out 2>&1 rsync -vuar /var/www host2:/var/www ENDSSH

Además, como ya sabrá, rysnc realiza una sincronización unidireccional. Si desea una sincronización bidireccional, puede consultar osync ( https://github.com/deajan/osync ). Lo uso y me pareció útil.

Solo como información adicional:

Si usa un host de salto para conectar las otras dos máquinas pero no pueden comunicarse entre sí directamente, puede usar sshfs como medio entre estas dos máquinas de la siguiente manera (en el host de salto):

$ mkdir ~/sourcepath ~/destpath
$ sshfs sourcehost:/target/dir ~/sourcepath
$ sshfs desthost:/target/dir ~/destpath
$ rsync -vua ~/sourcepath ~/desthpath

SSHFS proporciona las dos rutas en el host de salto y rsync gestiona la sincronización de los archivos como siempre (solo con la diferencia de que prácticamente se hace localmente).

Puede ejecutar un rsyncd (servidor) en una de las computadoras.

Este es el enfoque que estoy tomando, ya que no quiero usar ssh para permitir que el acceso 'fuente' (en redacción rsync) al 'destino' como root sin contraseña (como se requiere para usar el túnel SSH con rsync en un guión)

En mi caso, simplemente configuré un servidor rsyncd en la computadora de destino con un solo usuario permitido desde la PC fuente y usé rsync desde el lado fuente.

Funciona genial.

Intenta usar esto. Esto funciona para mi.

ssh src_user@src_host 'rsync -av /src/dir/location/ dest_user@dest_host:/dest/dir/loc/'

Un guión fácil de usar

A lo largo de los años, he hecho esto muchas veces con más o menos los mismos trucos que en cualquier otra respuesta aquí. Sin embargo, debido a que es muy fácil equivocarse en algunos detalles y pasar mucho tiempo resolviendo el problema, se me ocurrió el siguiente script:

1. Facilita la especificación de todos los detalles (origen, destino, opciones)
2. Prueba de forma incremental cada paso y brinda retroalimentación si algo sale mal, para que sepa qué solucionar.
3. Funciona en casos donde ssh -Ano se propagan los datos de autenticación (no sé por qué sucede esto a veces, ya que la solución fue más fácil que encontrar la causa raíz)
4. Finalmente hace el trabajo.

Cómo usar el guión

1. Asegúrese de que puede enviar ssh a ambos hosts desde localhost sin escribir una contraseña.
2. Establezca las variables en las primeras líneas del guión.
3. Ejecutalo.

Cómo funciona

Como dije, usa los mismos trucos que en cualquier otra respuesta aquí:

• La -Ropción de ssh para ssh de localhost a host1 mientras que al mismo tiempo configura un reenvío de puertos que luego permite que host1 se conecte a través de localhost a host2 ( -R localhost:$FREE_PORT:$TARGET_ADDR_PORT)
• -AOpción de ssh para permitir la autenticación fácil del segundo canal ssh

¡Esto es complicado! ¿Hay alguna manera más fácil?

Al copiar todos o la mayoría de los bytes del origen al destino, es MUCHO más fácil de usar tar:

ssh $SOURCE_HOST "tar czf - $SOURCE_PATH" \
    | ssh $TARGET_HOST "tar xzf - -C $TARGET_PATH/"

La secuencia de comandos

#!/bin/bash
#-------------------SET EVERYTHING BELOW-------------------
# whatever you type after ssh to connect to SOURCE/TARGE host 
# (e.g. 1.2.3.4:22, user@host:22000, ssh_config_alias, etc)
# So if you use "ssh foo" to connect to SOURCE then 
# you must set SOURCE_HOST=foo
SOURCE_HOST=host1 
TARGET_HOST=host2 
# The IP address or hostname and ssh port of TARGET AS SEEN FROM LOCALHOST
# So if ssh -p 5678 someuser@1.2.3.4 will connect you to TARGET then
# you must set TARGET_ADDR_PORT=1.2.3.4:5678 and
# you must set TARGET_USER=someuser
TARGET_ADDR_PORT=1.2.3.4:5678
TARGET_USER=someuser

SOURCE_PATH=/mnt/foo  # Path to rsync FROM
TARGET_PATH=/mnt/bar  # Path to rsync TO

RSYNC_OPTS="-av --bwlimit=14M --progress" # rsync options
FREE_PORT=54321 # just a free TCP port on localhost
#---------------------------------------------------------

echo -n "Test: ssh to $TARGET_HOST: "
ssh $TARGET_HOST echo PASSED| grep PASSED || exit 2

echo -n "Test: ssh to $SOURCE_HOST: "
ssh $SOURCE_HOST echo PASSED| grep PASSED || exit 3

echo -n "Verifying path in $SOURCE_HOST "
ssh $SOURCE_HOST stat $SOURCE_PATH | grep "File:" || exit 5

echo -n "Verifying path in $TARGET_HOST "
ssh $TARGET_HOST stat $TARGET_PATH | grep "File:" || exit 5

echo "configuring ssh from $SOURCE_HOST to $TARGET_HOST via locahost"
ssh $SOURCE_HOST "echo \"Host tmpsshrs; ControlMaster auto; ControlPath /tmp/%u_%r@%h:%p; hostname localhost; port $FREE_PORT; user $TARGET_USER\" | tr ';' '\n'  > /tmp/tmpsshrs"

# The ssh options that will setup the tunnel
TUNNEL="-R localhost:$FREE_PORT:$TARGET_ADDR_PORT"

echo 
echo -n "Test: ssh to $SOURCE_HOST then to $TARGET_HOST: "
if ! ssh -A $TUNNEL $SOURCE_HOST "ssh -A -F /tmp/tmpsshrs tmpsshrs echo PASSED" | grep PASSED ; then
        echo
        echo "Direct authentication failed, will use plan #B:"
        echo "Please open another terminal, execute the following command"
        echo "and leave the session running until rsync finishes"
        echo "(if you're asked for password use the one for $TARGET_USER@$TARGET_HOST)"
        echo "   ssh -t -A $TUNNEL $SOURCE_HOST ssh -F /tmp/tmpsshrs tmpsshrs"
        read -p "Press [Enter] when done..."
fi

echo "Starting rsync"
ssh -A $TUNNEL $SOURCE_HOST "rsync -e 'ssh -F /tmp/tmpsshrs' $RSYNC_OPTS $SOURCE_PATH tmpsshrs:$TARGET_PATH"

echo
echo "Cleaning up"
ssh $SOURCE_HOST "rm /tmp/tmpsshrs"

Es posible usar tarvia sshpara transferir los archivos:

ssh -n user1@host1 'tar jcf - -C /var/www .' | ssh user2@host2 'tar jxvf - -C /var/www'

^{Cambie el jparámetro (for tar) a zdos lugares si desea comprimir el archivo con gzip, en lugar de bzip2. Por lo general, bzip2tiene la compresión más alta que gzip, pero es más lenta, así que cámbiela según sus necesidades (consulte: bzip2 vs gzip ).}

Relacionado: ¿Cómo copiar entre dos hosts remotos usando tar entubado en SSH desde un servidor remoto cuando está detrás de un firewall?

Alternativamente (para proteger el ancho de banda, debido a la compresión transparente) es posible usarlo sshfspara montar el sistema de archivos remoto como local y usarlo rsynccomo de costumbre, p. Ej.

$ sshfs user1@host1:/var/www /mnt
$ rsync -vuar /mnt user2@host2:/var/www