Best compression for ZFS send/recv

Question

I'm sending incremental ZFS snapshots over a point-to-point T1 line and we're to a point where a day's worth of snapshots can barely make it over the wire before the next backup starts. Our send/recv command is:

zfs send -i tank/vm@2009-10-10 tank/vm@2009-10-12 | bzip2 -c | \
ssh offsite-backup "bzcat | zfs recv -F tank/vm"

I have plenty of CPU cycles to spare. Is there a better compression algorithm or alternative method I can use to push less data over the line?

Answer 1

It sounds like you've tried all of the best compression mechanisms and are still being limited by the line speed. Assuming running a faster line is out of the question, have you considered just running the backups less frequently so that they have more time to run?

Short of that, is there some kind of way to lower the amount of data being written? Without knowing your application stack its hard to say how, but just doing things like making sure apps are overwriting existing files instead of creating new ones might help. And making sure you arent saving backups of temp/cache files that you wont need.

Answer 2

This is an answer to your specific question:

You can try rzip, but it works in ways that are a bit different from compress/bzip/gzip:

rzip expects to be able to read over the whole file, so it can't be run in a pipeline. This will greatly increase your local storage requirements and you won't be able to run a backup and send the backup over the wire in one single pipe. That said, the resulting files, at least according to this test, are quite a bit smaller.

If your resource constraint is your pipe, you'll be running backups 24x7 anyhow so you'll need to just be copying snapshots constantly and hoping you keep up anyhow.

Your new command would be:

remotedir=/big/filesystem/on/remote/machine/
while 
  snaploc=/some/big/filesystem/
  now=$(date +%s)
  snap=snapshot.$now.zfssnap
  test -f $snaploc/$snap
do
  sleep 1
done

zfs send -i tank/vm@2009-10-10 tank/vm@2009-10-12 > $snaploc/$snap &&
rzip $snaploc/$snap &&
ssh offsite-backup "
        cat > $remotedir/$snap.rzip && 
        rzip -d $remotedir/$snap.rzip && 
        zfs recv -F tank/vm < $remotedir/$snap &&
        rm $remotedir/$snap " < $snaploc/$snap &&
rm $snaploc/$snap

You will want to put better error correction in, and you'll want to consider using something like rsync to transfer the compressed files so if the transfer fails in the middle you can pick up where you left off.

Answer 3

I'm assuming you simply can't increase the raw bandwidth of your site...

You may see benefit from not using compression on the host.

If you use something like a wan optimizer, it will be able to optimize the transfer much better if you don't compress the file before you send it, ie you do exactly what you're doing but remove the bzip2 from the pipe. After a couple runs of your backup, the wan optimizer will have cached a very large fraction of the stuff it sees in the transfer and you'll see huge improvements in transfer speeds.

If you're on a limited budge, you may be able to see a similar improvement by using rsync and rsyncing the uncompressed snapshot, ie:

zfs send -i tank/vm@2009-10-10 tank/vm@2009-10-12 > /path/to/snapshotdir/snapshotfile
rsync /path/to/snapshotdir/snapshotfile offsite-backup:/remote/path/to/snapshotfile
ssh offsite-backup 'zfs recv -F tank/vm < /remote/path/to/snapshotfile'

This would be faster because rsync would only transfer the differences between yesterday's snapshot and today's. Depending on how the snapshotting process works, there may still be lots of redundancy between the two even if they're not really the same file at all.

The wan optimizer is by far a more likely way to fix this problem (well, metro ethernet is the most likely way to solve this problem, but we'll leave that off the table). The rsync is just a wild shot in the dark that's worth testing (locally; rsync will tell you how much time it saved over a straight copy) on your local data before writing the big check for fiber or a riverbed install.

Answer 4

For what it's worth. I would not do a direct send | compress | decompress | receive this can lead to problems at the receiving end if the transfer line snaps and your pools will be offline for a long time during the receive. We send to a local file then gzip the snapshot and transfer using rsync (with riverbed), then we receive from the file. The riverbed doesn't optimize the traffic BUT if there is a problem with the transfer and it needs to be restarted the riverbed speeds the resend up.

We have looked at not compressing the incremental snapshot, using Rsync compression and not using any compression other than the riverbed. It's difficult to say which is best but when we are transferring archivelogs from oracle with rsync compression the transfer rate is roughly twice that of plain files and riverbed (with RSync).

If you have a riverbed then use rsync not ssh as the riverbed understands rsync and will try to optimize it and will add the data to the cache (see above, re restarting transfers).

Answer 5

Here is what I've learned doing the exact same thing you are doing. I suggest using mbuffer. When testing in my environment it only helped on the receiving end, without it at all the send would slow down while the receive caught up.

Some examples: http://blogs.everycity.co.uk/alasdair/2010/07/using-mbuffer-to-speed-up-slow-zfs-send-zfs-receive/

Homepage with options and syntax http://www.maier-komor.de/mbuffer.html

The send command from my replication script: zfs send -i tank/pool@oldsnap tank/pool@newsnap | ssh -c arcfour remotehostip "mbuffer -s 128k -m 1G | zfs receive -F tank/pool"

this runs mbuffer on the remote host as a receive buffer so the sending runs as fast as possible. I run a 20mbit line and found that having mbuffer on the sending side as well didn't help, also my main zfs box is using all of it's ram as cache so giving even 1g to mbuffer would require me to reduce some cache sizes.

Also, and this isnt really my area of expertise, I think it's best to just let ssh do the compression. In your example I think you are using bzip and then using ssh which by default uses compression. So SSH is trying to compress a compressed stream. I ended up using arcfour as the cypher as it's the least cpu intensive and that was important for me. You may have better results with another cypher, but I'd definately suggest letting SSH do the compression (or turn off ssh compression if you really want to use something it doesn't support)

Whats really interesting is that using mbuffer when sending and receiving on localhost speeds things up as well: zfs send tank/pool@snapshot | mbuffer -s 128k -m 4G -o -| zfs receive -F tank2/pool

I found that 4g for localhost transfers seems to be the sweetspot for me. It just goes to show that zfs send/receive doesn't really like latency or any other pauses in the stream to work best.

Just my experience, hope this helps. It took me awhile to figure all this out.

Answer 6

You can pick up a faster cipher for ssh maybe blowfish-cbc, also try the -123456789 switches

-1 (or --fast) to -9 (or -best)

Answer 7

The "best" compression algorithm depends on what type of data you have - if you are pushing a MP3 collection compression will probably slow the process down, while text/logfiles can be significantly compressed with gzip -9.

How much data are you pushing each day?

Answer 8

You will need to test with your data. Just send it to a file and compress it with each method.

For us, gzip made a huge difference and we run everything through that, but there wasn't even a 1% difference between gzip and bzip or 7z.

If you're on a slow T1, you will need to store it to a file and rsync it over.

For those (not you) who are limited a bit more by CPU than bandwidth, like lstvan said a different cipher like arcfour128 speeds things up. We use that internally when moving things around.

Answer 9

Experiment with turning on dedup for zfs send with -D. Savings depends on how much duplication there is in your data, of course.