Avoiding Self-Denial

Shared-nothing architecture

We can avoid machine-induced self-denial by building a shared-nothing architecture. Shared-nothing architecture is when each server can run without knowing anything about any other server. The machines don’t share databases, cluster managers, or any other resource. It’s a hypothetical ideal for horizontal scaling.

In reality there’s always some amount of contention and coordination among the servers, but we can sometimes approximate shared-nothing. Where that’s impractical, apply decoupling middleware to reduce the impact of excessive demand, or make the shared resource itself horizontally scalable through redundancy and a backside synchronization protocol. We can also design a fallback mode for the system to use when the shared resource is not available or not responding. For example, if a lock manager that provides pessimistic locking is not available, the application can fall back to using optimistic locking.

Traffic management

If we have a little time to prepare and are using hardware load balancing for traffic management, we can either set aside a portion of our infrastructure or provision new cloud resources to handle the promotion or traffic surge. Of course, this works only if the extraordinary traffic is directed at a portion of the system.