Linux – What’s the difference between keepalived and corosync, others

high-availabilitylinux

I'm building a failover firewall for a server cluster and started looking at the various options. I'm more familiar with carp on freebsd, but need to use linux for this project.

Searching google has produced several different projects, but no clear information about features they provide . CARP gave virtual interfaces that failover, I am not really clear on whether that's what corosync does, or is that what pacemaker does?

On the other hand I did get manage to get keepalived working. However, I noted that corosync provides native support for infiniband. This would be useful for me.

Perhaps someone could shed some light on the differences between:

corosync
keepalive
pacemaker
heartbeat

Which product would be the best fit for router failover?

EDIT: So I worked out a little more…

Pacemaker is the bigger project that can use Corosync & Pacemaker.
It seems that Corosync & Heartbeat basically do the same thing. So you choose one or the other.

Heartbeat seems to be an older project but is still being worked on.

Keepalive on the other hand is an entirely different project and implements the VRRP protocol. It has lees features than the others. It appears to still be widely used but is missing recent documentation.

Unfortunately, for firewall/router failover there are very little examples. Has anyone found some nice howto's? I've found one written in Spanish.

Best Answer

Here is the general rule of thumb I have used when deciding between keepalived and heartbeat.

Heartbeat is usually used when you want a true active/standby cluster setup (where only one node is actually "up.") Think NFS. Usually w/ Heartbeat the pre and post script actions are used to start and stop services.

Keepalived is much simpler, and is usually used for hot-standby usage (i.e. To keep a service up in a redundant fashion.)

A good usage example with keepalived that I have had success with is for redundant Nginx load balancers. In that situation, if a node fails, the "floating ip" moves over to the backup node.

Keepalived is simple, but it allows you to create your own check scripts (that would trigger a failover, etc.) Some info: https://tobrunet.ch/2013/07/keepalived-check-and-notify-scripts/

Which is best for you depends on your situation: keepalived is a good fit for router failover.

Related Solutions

Linux – What’s the difference between apt-get and aptitude

aptitude is a wrapper for dpkg just like apt-get/apt-cache, but it is a one-stop-shop tool for searching/installing/removing/querying. A few examples that apt might not supply:

$ aptitude why libc6
i   w64codecs Depends libc6 (>= 2.3.2)
$ aptitude why-not libc6
Unable to find a reason to remove libc6.

$ aptitude show libc6
Package: libc6
State: installed
Automatically installed: no
Version: 2.9-4ubuntu6
Priority: required
Section: libs
Maintainer: Ubuntu Core developers <ubuntu-devel-discuss@lists.ubuntu.com>
Uncompressed Size: 12.1M
Depends: libgcc1, findutils (>= 4.4.0-2ubuntu2)
Suggests: locales, glibc-doc
Conflicts: libterm-readline-gnu-perl (< 1.15-2), 
tzdata (< 2007k-1), tzdata-etch, nscd (< 2.9)
Replaces: belocs-locales-bin
Provides: glibc-2.9-1
Description: GNU C Library: Shared libraries
 Contains the standard libraries that are used by nearly all programs 
 on the system. This package includes shared versions of the standard 
 C library and the standard math library, as well as many others.

Linux – the difference between unlink and rm

Both are a wrapper to the same fundamental function which is an unlink() system call.

To weigh up the differences between the userland utilies.

rm(1):

More options.
More feedback.
Sanity checking.
A bit slower for single calls as a result of the above.
Can be called with multiple arguments at the same time.

unlink(1):

Less sanity checking.
Unable to delete directories.
Unable to recurse.
Can only take one argument at a time.
Marginally leaner for single calls due to it's simplicity.
Slower when compared with giving rm(1) multiple arguments.

You could demonstrate the difference with:

$ touch $(seq 1 100)
$ unlink $(seq 1 100)
unlink: extra operand `2'

$ touch $(seq 1 100)
$ time rm $(seq 1 100)

real    0m0.048s
user    0m0.004s
sys     0m0.008s

$ touch $(seq 1 100)
$ time for i in $(seq 1 100); do rm $i; done

real    0m0.207s
user    0m0.044s
sys     0m0.112s

$ touch $(seq 1 100)
$ time for i in $(seq 1 100); do unlink $i; done

real    0m0.167s
user    0m0.048s
sys     0m0.120s

If however we're talking about an unadulterated call to the system unlink(2) function, which I now realise is probably not what you're accounting for.

You can perform a system unlink() on directories and files alike. But if the directory is a parent to other directories and files, then the link to that parent would be removed, but the children would be left dangling. Which is less than ideal.

Edit:

Sorry, clarified the difference between unlink(1) and unlink(2). Semantics are still going to differ between platform.

Best Answer

Related Solutions

Linux – What’s the difference between apt-get and aptitude

Linux – the difference between unlink and rm

Related Topic