Before OpenStack even had a name, it had its basic design tenets. The wiki history reveals that Rick wrote these down as early as May 2010, two months before OpenStack was officially launched. Let’s take a look at them:
- Scalability and elasticity are our main goals
- Any feature that limits our main goals must be optional
- Everything should be asynchronous
- a) If you can’t do something asynchronously, see #2
- All required components must be horizontally scalable
- Always use shared nothing architecture (SN) or sharding
- a) If you can’t Share nothing/shard, see #2
- Distribute everything
- a) Especially logic. Move logic to where state naturally exists.
- Accept eventual consistency and use it where it is appropriate.
- Test everything.
- a) We require tests with submitted code. (We will help you if you need it)
Now go and look at every single OpenStack diagram of Nova ever presented. Either they look something like this:
Nova diagram
or they’re lying.
Let’s focus our attention for a minute on the little thing in the middle labeled “nova database”. It’s immediately obvious that this is a shared component. That means tenet 5 (“Always use shared nothing architecture (SN) or sharding“) is out the window.
Back in 2010, the shared database was Redis, but since the redisectomy, it’s been MySQL or PostgreSQL (through SQLAlchemy). MySQL and PostgreSQL are ACID compliant, the very opposite of eventually consistent (bye bye, tenet 7). They’re wicked fast and scale very, very well. Vertically. Adios, tenet 4.
Ok, so what’s the score?
Tenet 1: Scalability and elasticity are our main goals.
Tenet 2: Any feature that limits our main goals must be optional
Tenet 3: Everything should be asynchronous
Tenet 4: All required components must be horizontally scalable
Tenet 5: Always use shared nothing architecture or sharding
Tenet 6: Distribute everything (Especially logic. Move logic to where state naturally exists).
Tenet 7: Accept eventual consistency and use it where it is appropriate.
Tenet 8: Test everything.
Is everything synchronous? Hardly. I see 258 instances of RPC call (synchronous RPC methods) vs. 133 instances of RPC cast (asynchronous RPC methods). How often each are called is anybody’s guess, but clearly there’s a fair amount of synchronous stuff going on. Sayonara, tenet 3.
Is everything distributed? No. No, it’s not. Where does the knowledge of individual compute nodes’s capacity for accepting new instances naturally exist? On the compute node itself. Where is the decision made about which compute node should run a new instance? In nova-scheduler. Sure, the scheduler is actually a scale-out internal service in the sense that there could be any number of them, but it’s making decisions on other components’s behalf. Tschüß, tenet 6.
Are we testing everything? Barely. Nova’s most recent test coverage percentage at the time of this writing is 83%. It’s much better than it once was, but there’s still a ways to go up to 100%. Adieu, tenet 8.
We can’t really live without a database, nor a scheduler, so auf wiedersehen tenet 2.
We’re left with:
Tenet 1: Scalability and elasticity are our main goals.
Tenet 2: Any feature that limits our main goals must be optional
Tenet 3: Everything should be asynchronous
Tenet 4: All required components must be horizontally scalable
Tenet 5: Always use shared nothing architecture or sharding
Tenet 6: Distribute everything (Especially logic. Move logic to where state naturally exists).
Tenet 7: Accept eventual consistency and use it where it is appropriate.
Tenet 8: Test everything.
So, the question the remains: With all the above in mind, is scalability and elasticity *really* still our main goals?