Exploring cell-based architecture vs. microservices
Cell-based architecture takes fundamental concepts related to microservices and applies them across the entire software environment to make more fault-tolerant, scalable systems.
On the surface, cell-based architecture and microservices might seem like the same architectural style set in slightly different font sizes.
At their core, both approaches rely on the isolation of independent, separately deployed components to build dynamic and modular distributed systems. But in terms of granularity and level of control, the two architectural styles address distinct organizational and functional concerns.
What is a cell-based architecture?
Cell-based architecture (CBA) is an emergent approach that uses automated provisioning and monitoring to horizontally scale based on demand. Commonly implemented with Kubernetes, the design pattern specifies the separation of logically connected sets of services into self-contained modules, known as cells, with clear mechanisms for intercommunication.
Cells are developed and deployed independently with a distinct piece of the application's overall functionality, such as profiles, products, images, static text files or employee data. In a cell-based system, the capability to roll out new changes to a single, isolated cell mitigates the entire system's risk of regression, as failure in one cell should not bring down the whole application. Deploying multiple cells to support a single tenant can also safeguard against cascading failures by enhancing redundancy. If a monitoring system notices a cell is down or not performing properly, it can be deactivated and respawned while other cells absorb the workload.
What are microservices?
Building off the concepts of service-oriented architecture (SOA), microservices is a distributed architectural style that enables the creation of small, independent software services that align with and support specific business functions. Generally, development teams maintain a series of related microservices, along with any infrastructure, systems, code or databases required to enable the service.
Services typically manage their database and communicate with other services over a network through APIs. As long as contracts and interfaces between services are standardized, the implementation of each service can be in any language. A lack of dependencies between services promotes loose coupling, and when effectively implemented, a microservices application should remain operational even when one service fails.
Cell-based architecture vs. microservices
Microservices provide a way to break down, isolate and enable interoperation between business processes. But they need a plan to scale. Just because services can scale with demand does not mean the underlying database can do the same.
Cell-based architecture potentially addresses certain microservices limitations by offering a methodology for scaling business processes and minimizing failure impact. Essentially, CBA implementation adds a layer to handle any increased demand on the system where the self-contained cells are independently scalable units rather than individual microservices.
When to use cell-based architecture vs. microservices
A cell-based architecture supports the creation of highly available and resilient software systems. For organizations considering a conversion to a distributed system or a migration to the cloud, cell adoption might be an additional step in a larger modernization strategy. But cell-based systems can significantly add to costs through CPU, memory and network demands while creating additional technical challenges such as debugging errors. An observability layer can resolve this issue, but the tradeoff entails even more CPU, memory and network expenses. Legacy systems will likely face more hurdles in pursuing cell-based development than that of newer systems. Even so, the overhead and complexity associated with CBA might outweigh the potential benefits for smaller applications and startups.
Implementing cell-based microservices
When looking for a way to separate business processes and achieve high availability and scalability, a cell-based microservices approach might be an effective but costly and developmentally complex option. Despite these challenges, in the right scenarios, combining both architectural styles offers a compelling way to break down business processes while enabling rapid development and continuous delivery. Large application systems designed to run on the internet and organizations that require elastic demand, high availability and failure isolation can benefit from cell-based microservices. More traditional organizations might face higher costs with fewer benefits.
Matt Heusser is managing director at Excelon Development, where he recruits, trains and conducts software testing and development.
