Active-Active vs. Active-Passive Storage Controllers: Why Should You Even Care?

If you don’t have a great understanding of storage controller design, you are in excellent company. In fact, many IT veterans have only a basic understanding of the different controller architectures out there. And most everyone’s eyes start to glaze over when the terms active-active and active-passive controllers start getting thrown around. And if you made it that far, the term Asymmetric Logical Unit Access (ALUA) almost certainly challenges your attention span.

But first, what is a storage controller? According to a Storage Switzerland analyst, the storage controller is the compute part of a storage array that runs the storage software. If the storage controller fails, the storage software can’t run and the array goes offline. As a result, redundant storage controllers are critical to maintaining data accessibility.

In this blog, we will explain why storage buyers should care. In short, because it directly relates to the price-performance trade-off of your investment.

Let me illustrate it visually.


To elaborate, here are some basic storage controller design 101 terms:

A storage controller is usually an x86 server that serves the following functions:

  1. Receiving read/write requests from the hosts (over FC or iSCSI)
  2. Data processing: Deduplication, compression, metadata handling etc.
  3. Reading/writing the outcome from/to the disk

Active-Active storage controllers describe an architecture where both controllers are doing the above functions and the load on the storage array is automatically distributed evenly between all the controllers.

Active-Passive storage controllers refer to the approach where only one controller is doing the above functions (that’s the “active” controller) and the second controller is not doing anything (you guessed it, that’s the “passive” controller).

Asymmetric Logical Unit Access or ALUA refers to a hybrid approach. I know that you are thinking, “ALUA is a horrible acronym.” In this approach, both controllers are at work, but Logical Unit Numbers (LUNs) have an affinity to a specific controller and usually, if you access the LUN from a different controller, you’ll pay a performance price. In addition, the performance per LUN is limited to that of a single controller (yes, also in a scale-out architecture). So you need to start manual load balancing of the LUNs between controllers. Did I mention it’s a headache?


O.K. So now for a simplified 201 course in storage controller architecture. For argument’s sake, let’s assume an array with a single pair of controllers. That array can generate 200K input/output operations per second or IOPS.

Design What did you buy? What did you get?
Active-Active 2 controllers, each can deliver 100K IOPS 200K IOPS
Active-Passive 2 controllers, each can deliver 200K IOPS 200K IOPS

Now for an important inequality on the cost of controllers (remember, these are just x86 processors):

cost_of_controller_that_can_deliver_100K_IOPS < cost_of_controller_that_can_deliver_200K_IOPS

That’s why an active-active design is fundamentally more cost effective for a given performance level.

To be fair, there are some advantages to an active-passive design:

  1. You get to be creative in marketing an active-passive design as active-active
  2. Development is easier as the network stack between the controllers is practically non-existent
  3. When you upgrade the controller or the controller is faulty, there is no performance penalty

The third point is the one that gets raised most commonly from proponents of active-passive designs.

To see how big the advantage really is:

  • Check how often a controller fails
  • Check how often your vendor distributes patches and firmware updates and how long it takes to apply them

In both of the cases above, an active-active design would be functioning at only 50% of the maximum. If you calculate the two above, you would realize this advantage is limited (statistically) to less than an hour a year. Let that sink in.

Back to our original question – why should you care about an array’s storage controller design? The answer hasn’t changed – you should care because you’re paying for it.

There are a lot of dimensions that go into evaluating what storage solution is right for you. While different solutions from different vendors may be a better fit for different scenarios, it is critical to be able to see through marketing hype in order to understand exactly what you are paying for. In the case of active-active vs. active-passive controller design, it comes down to price-performance trade offs.

New call-to-action