Server Fault is a question and answer site for system and network administrators. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I've recently setup a loadbalanced solution for our websites. We host about 200 sites, most run of our custom application, but some are running wordpress blogs (in which files can be uploaded/deleted). The setup is basic:

          |-------------------> Apache1
 HAProxy -|
          |-------------------> Apache2

I've set up Apache1 as a 'master', so that most of the changes made on it are rsync'd over to Apache2 every minute using the following command:

rsync -av --delete apache1:/var/www/html/ /var/www/html/

The problem is, as mentioned earlier, in some cases files are added/removed on Apache2. The only solution I've come up with so far is to have Apache1 rsync all files in certain directories (wp-content, for instance) to itself (not delete), then push everything back to Apache2.

This has it's flaws, the main ones being:

  • The two servers will eventually get extra files that have been deleted on Apache2
  • As I add more servers, the rsync script will take longer to complete.

Are there any ways to keep 2+ web servers synched, taking into account that both servers can have files added, updated and deleted?

share|improve this question
this setup cries for some shared storage. – pfo Aug 23 '11 at 14:21
Or for storage on a git ! – Antoine Benkemoun Aug 23 '11 at 14:27

I'm using OCFS2 with DRBD.

A DRBD resource /etc/drbd.d/r0.res:

resource r0 {
    syncer { rate 1000M; }
    net {
        after-sb-0pri discard-zero-changes;
        after-sb-1pri discard-secondary;
        after-sb-2pri disconnect;
    startup { become-primary-on both; }

    on s1 {
        device      /dev/drbd1;
        disk        /dev/sdc;
        address     ip1:7789;
        meta-disk   internal;
    on s2 {
        device      /dev/drbd1;
        disk        /dev/xvdb2;
        address     ip2:7789;
        meta-disk   internal;

/dev/drbd1 is formatted as ocfs2 filesystem:

/dev/drbd1   ocfs2   100660180   7427076  93233104   8% /data/webroot

Configuration for OCFS2 without Pacemaker /etc/ocfs2/cluster.conf:

    ip_port = 7777
    ip_address = ip1
    number = 0
    name = s1
    cluster = ocfs2

    ip_port = 7777
    ip_address = ip2
    number = 1
    name = s2
    cluster = ocfs2

    node_count = 2
    name = ocfs2

DRBD status can be looked at with drbd-overview utility:

# drbd-overview 
  1:r0  Connected Primary/Primary UpToDate/UpToDate C r---- /data/webroot ocfs2 96G 9.8G 87G 11% 

or from /proc/drbd:

cat /proc/drbd 
version: 8.3.8 (api:88/proto:86-94)
GIT-hash: d78846e52224fd00562f7c225bcc25b2d422321d build by, 2010-06-04 08:04:09

 1: cs:Connected ro:Primary/Primary ds:UpToDate/UpToDate C r----
    ns:953133955 nr:42207234 dw:1185526354 dr:62396241 al:230084 bm:5853 lo:0 pe:0 ua:0 ap:0 ep:1 wo:b oos:0
share|improve this answer

I have not used it in a server setup, but you might try Unison. It deals with changes on either side and will automatically sync things that aren't conflicting. I believe it is limited to 2 hosts, so it wouldn't scale past your current solution.

The only way I know how to scale past 2 hosts would be to set up NFS, or some other shared/distributed filesystem.

share|improve this answer
+1 since this sounds like the path I'd look at. If you want it scripted, something like Unison. A better solution, depending on network interconnect and speed, would be something like DRDB filesystem that would sync the two filesystems automatically. The popular way to deal with it is a shared storage SAN with RAID but that can introduce a single point of failure. – Bart Silverstrim Aug 23 '11 at 14:21
I am definitely a fan of NFS but keep in mind that while it consolidates everything in place, it does mean that all of your front-facing sites are dependent on that one shared copy as both a single point of failure and a single set of resources if performance is an issue. – damorg Aug 23 '11 at 14:30
You can use unison on more than 2 hosts. Mesh topology; have hostA sync with hostB, then hostC, then have hostB sync with hostC. Not the prettiest, but it works just fine. – Patrick Nov 4 '11 at 1:03

Another option would be to build an "authoritative" replica of the content apart from the front-facing webservers and make sure all updates and changes are made on that replica.

Then, you deploy from that server to any number of front-facing servers on a set schedule.

Yes, it's an extra copy of the content but it does give you some potential benefits:

1) Control of when the updates go live

2) Less complexity in handling multi-direction sync between any number of servers

3) The ability to make changes and preview them without impact your front-facing production.

Other options are some type of shared storage spread across as much hardware as you need for reliability, performance, and scalability.

share|improve this answer

We are currently using rsync also, but I'm not crazy about it.

We have been experimenting with , which not only will sync between two servers, but we can also sync up with S3, Cloudfiles or other cloud storage. This will obviously provide us a lot more flexibility.

I don't have any config setups to share at this moment, but we are liking what we see.

share|improve this answer

I've been having this same conundrum and have come across a few solutions depending on the specifics of the application in question.

NFS: While NFS, or some sort of shared drive would certainly work, in my case, I wanted to avoid it because it creates a bottleneck of one computer that can bring down the whole system. A strong part of my reason for load balancing is redundancy, and NFS takes this out of the equation. Although, if all other options fail, this might be the only one left.

DB Files: Most of what I try to do is build the application to store it's files in a database. That way I don't have to worry about any of the clustered web servers having to write any data. This seems by far the best solution, but is often times not an option if you are not developing the software.

DNS control: For some sites or applications that have an "admin" section that only a few users use (like a wordpress blog), I sometimes use a seperate dns pointing to the master server to ensure that the admin only creates writes on the correct server. With a few modifications, you can redirect wp-admin to use the admin dns. The downside here is that while the front face of the blog remains load balanced and redundent, the admin section is reliant on one system. For most bloggers, this is probably ok, though.

Two-way rsync: The last option, which I try to avoid, is multiple direction rsyncing. Deleting becomes the biggest problem here where it's hard for rsync to know if a file is a new file (and thus only showing up on one server), or a deleted file (and thus only showing up on one server). Generally, if I have to do multi-direction rsyncing, I target a specific folder where the data is stored and remove it from the rest of the structure using a symlink, then rsync it both ways without delete. Most applications don't ever need to delete a file, unless they are creating temp files, which should probably be stored outside of your sites structure, anyway. This can still work with deleting files, but I'd still try to target your specific directories that you store files.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.