Introduction to the Shared-Free Architecture Guide
Why do companies like Google and Facebook use Shared Nothing Architecture, and how is it different from other models?
Read on to find out what shared-nothing architecture is, how it compares to others, and its advantages and disadvantages.
What is a shared-nothing architecture?
Shared Nothing Architecture (SNA) is a distributed computing architecture that consists of multiple independent nodes that do not share resources. Nodes are independent and self-sufficient because they have their own disk space and memory.
In such a system, the dataset/workload is divided into smaller sets (nodes) that are distributed across different parts of the system. Each node has its own memory, storage, and independent input/output interfaces. It communicates and synchronizes with other nodes through a high-speed interconnection network. Such connectivity ensures low latency, high bandwidth, and high availability (backup interconnects can be used in the event of a primary node failure).
Since the data is horizontally partitioned, the system supports incremental growth. You can add new nodes to scale out the distributed system and increase the transfer capacity.
No shared architecture diagrams
Shared-nothing schema explained: The best way to understand a shared-nothing model architecture is to look at it side-by-side with other types of schemas.
Below you’ll see the differences between shared and non-shared components in different models – Shared Everything, Shared Storage, and Shared Nothing.
Unlike the others, SNA does not share resources. The only thing that connects the nodes is the network layer, which manages the communication between the system and the nodes.
Descriptions of other shared schema types
What is a shared-nothing architecture? The concept of “shareless” was first coined by Michael Stonebraker in a 1986 research paper in which he compared shared disk and shared memory architectures. When comparing these two options, Stonebraker considered the possibility of creating a system that shared neither memory nor storage.
When deciding if SNA is right for your use case, it’s a good idea to compare it to other cluster types. Alternative options include:
- Shared disk architecture
- Shared memory architecture
- Share the architecture of everything
Shared-nothing architecture guide: Shared disk architecture
A shared disk is a distributed computing architecture in which all nodes in the system are linked to the same disk device but have their own private memory. Shared data is accessible from all cluster nodes, typically representing shared disks (such as databases) or shared file systems (such as storage area networks or network-attached storage). The shared disk architecture is best suited for use cases where data partitioning is not possible. It is much less scalable as compared to SNA.
Shared memory architecture
Shared-no architecture explained: Shared memory is an architectural model in which nodes within a system use a shared memory resource. This setup provides simplicity and load balancing, as it includes a point-to-point connection between the device and the main storage. Fast and efficient communication between processors is key to ensuring efficient data transfer and avoiding redundancy. This communication takes place over an interconnected network and is managed by a single operating system.
Note: Load balancing is a method of distributing network traffic across multiple servers in a pool to improve performance and prevent bottlenecks. Learn more about load balancing and the different types of load balancers.
Share the architecture of everything
On the other side of the spectrum, there’s the shared architecture of everything. The architecture model consists of nodes that share all the resources within the system. Each node has access to the same computing resources and shared storage. The main idea behind such a system is to maximize the use of resources. The downside is that shared resources can also degrade performance due to contention.
Shared-nothing architecture guide: Advantages and disadvantages of shared-nothing architecture
The Shared Nothing architecture clearly has a lot of benefits over the different shared architectures mentioned above. Take a look at some of the advantages and disadvantages of this model.
Advantage
SNA has many advantages, the main ones being scalability, fault tolerance, and less downtime.
It’s easier to scale
There are no limits when scaling in a shared-nothing model. Unlimited scalability is one of the best features of this type of architecture. Because nodes are independent and don’t share resources, scaling an application doesn’t disrupt the entire system or cause resource contention.
Eliminate single points of failure
If one node in the application fails, it doesn’t affect the functionality of the other nodes because each node is independent. Although a node failure can affect performance, it does not disrupt the overall behavior of the entire application.
Simplify upgrades and prevent downtime
Shared-nothing architecture explained: There is no need to shut down the system when processing or upgrading individual nodes. Due to redundancy, upgrading one node at a time does not affect the efficiency of the other nodes. In addition, having redundant copies of data on different nodes prevents unplanned downtime due to disk failure or data loss.
Shortcoming
Once you’ve considered the benefits of SNA, look at some of the drawbacks that can help you determine if it’s the best option for you.
Cost
A node is made up of its individual processors, memory, and disks. When setting up a system, having dedicated resources inherently means higher costs. In addition, it is more expensive to transfer data that requires software interaction than architectures that share disk space and/or memory.
Reduced performance
If the cross-communication layer is not set up correctly, scaling the system will ultimately affect the overall performance.
Conclusion of the Shareless Architecture Guide
What is a shared-nothing architecture? After reading this article, you should have a better understanding of Shared Nothing Architecture and how it works. Before deciding on an architecture for your application, consider all the advantages and disadvantages of the model.
