Rsyncing directories through ssh tunnel

Question

I have 3 computers/servers, let's call them as computer A, computer B and computer C.

• Computer A has access via ssh to computer B.
• Only computer B has access via ssh to computer C.
• Computer A doesn't have access to computer C directly.

So, I want to rsync directories from computer A to computer C, using computer B(since only computer B has access via ssh to computer C). I want to use rsync in a simple way, like this:

rsync -options /path_to_local IpComputerC:/path_to_remote

I'm thinking on a ssh tunnel, but I don't know if I have to make a local port forwarding or a remote port forwarding, or if I have to make two tunnels: one from A to B and other from B to C?

Any suggestions?? I'd be really grateful.

**UPDATE: I dit it!! I created an ssh tunnel with local port forwarding, which means that I used a local port from the machine A to connect with a remote port on the machine C through the machine B. The syntax for the command is:

ssh -f -N -L local_port_machineA:ip_machineC:remoteport_machineC user_machineB@ip_machineB

In my case, remoteport_machineC shoul be port 22, because I want to rsync directories through ssh.

After that, we can execute the rsync command from the machine A, in this way:

rsync -avz -e "ssh -p local_port" /source_directory username_machineC@localhost:/target_directory

That's all. Additionally, you can add more options in the part inside the quotes, such as keys or files, etc.**

Answer 1

Much simpler than other suggestions: use rsync's -e | --rsh option:

rsync -azv -e 'ssh -o "ProxyCommand ssh -A proxy -W %h:%p"' foo/ dest:./foo/

Note that I'm using -A (agent forwarding) but it should also work with password authentication if you don't use keys, and, of course, you can replace proxy with B and dest with C in your example.

If by chance you don't have a new enough ssh version (>= 5.3, IIRC), you can use netcat instead of -W option to ssh:

rsync -azv -e 'ssh -o "ProxyCommand ssh -A proxy nc %h %p"' foo/ dest:./foo/

Answer 2

One solution would be a crontab on your "jump node" (Computer B in this scenario).

A --> B (manually initiated, or could also be done via crontab on nodeA)

rsync -avzP --progress /path/to/transfer/ user@nodeB:/transfer/share/

B --> C (create a crontab to run every 15 mins)

sudo crontab -e
*/15 * * * * rsync -avzP --progress /transfer/share/ user@nodeC:/destination/share/

You might wish to further secure this by locking down access via a "service account" (AKA: ProdID) with limited access. Alternately you could use a SSH key to get around a password prompt at login.

http://www.rackspace.com/knowledge_center/article/generating-rsa-keys-with-ssh-puttygen

supplemental information

Have you considered a remote NFS share (offered by nodeC, remotely mounted on nodeB, and targeted by the rsync from nodeA)? In this scenario, the remote NFS share (from NodeC) would be mounted on NodeB (and would appear as a standard file-system from the OS perspective). As such, it would be accessible within the connection scenario you describe, without consuming DISK on NodeB. Thus, you would be able to adapt the 'rsync' syntax above to point at the remote NFS share mounted on NodeB to ultimately "pass-thru" onto NodeC. There may also be security concerns you will wish to consider.

Answer 3

NFS solution

REFERENCE

http://www.tldp.org/HOWTO/NFS-HOWTO/server.html

IMPLEMENTATION

NodeC: enable NFS, create NFS share, set non-root permissions (RHEL 5.x in this example, other distros will be subtly different)

sudo /sbin/chkconfig portmap on
sudo /sbin/chkconfig nfs on
sudo /sbin/service portmap start
sudo /sbin/service nfs start

sudo chown "nobody:users"   /final/destination/share
sudo chmod 775 /final/destination/share

sudo vi /etc/exports
    /final/destination/share    NodeC_IP(rw)    NodeB_IP(rw)    
sudo /usr/sbin/exportfs -ra

NodeB: mount destination share automatically

sudo mkdir -p /transfer/share/name
sudo vi /etc/fstab
    NodeC_IP:/final/destination/share   /transfer/share/name    nfs defaults
sudo mount -a

NodeA: schedule an rsync job (15 min frequency in this example)

# manual method
/usr/bin/rsync -avzP --progress /transfer/share/local/ user@nodeB:/transfer/share/name/

# scheduled method
sudo crontab -e
    */15 * * * * /usr/bin/rsync -avzP --progress /transfer/share/local/ user@nodeB:/transfer/share/name/