Skip to main content

3 Dimensions to Scaling: The scaling cube

Source: https://thenewstack.io/from-monolith-to-microservices/

 X-axis scaling

Running multiple copies of an application behind a load balancer. Each copy can handle 1/N of the load. Where N is the number of running copies.
This is simple and commonly used approach to scale.

Cons

* Each copy accesses all the data, cache size will be higher.
* Doesn't solve increasing development and application complexity.

Y-axis scaling

Splitting the application into multiple, different services. Then more infra resources can be added to only the micro-service which is bottleneck in the architecture.
Here cached can be utilized efficiently, only where it is needed.

Z-axis scaling

Each server runs same copy similar to X-axis scaling. The big difference is that each server. Some component of the system is responsible for routing each request to the appropriate server.
This is commonly used to scale databases where data is partitioned(a.k.a sharded)

Pros

* Each server deals with a subset of data
* Improved cached utilization
* improved fault isolation

Cons

* Increased application complexity
* Partitioned schema is tricky to repartition data
* Doesn't solve increasing development and application complexity.

Comments

  1. AnonymousMay 15, 2019 at 10:08 AM

    Hey great article on scaling across the 3 axes. Especially love the pros and cons section on each. I actually work for the guy that came up with the Scale Cube, Marty Abbott. Here is an article of his about it.

    https://akfpartners.com/growth-blog/scale-cube

    You might want to include it in your resources. Up to you.

    Thanks again,

    Eric

    ReplyDelete

Post a Comment

Popular posts from this blog

Reactive Microservices with Vert.x(Vertx.io)

Vert.x is an event driven and non blocking “Platform” where we can develop our application on. Vert.x is like Node.JS, but the biggest difference is that it runs on the JVM, it’s scalable, concurrent, non-blocking, distributed and polyglot. Following four key properties of Vert.x helps us in developing reactive applications. Async and non-blocking model Elastic Resilient Responsive Async and non-blocking model None of the Vert.x APIs block the calling thread(with few exceptions). If the result can be found quickly, It will be returned; Otherwise it will be handled by a handler to receive event sometime later. vertx      .createHttpServer()      .requestHandler(r -> {            r.response()            .end("<h1>Hello from my first " + "Vert.x 3 application</h1>"); })            .listen(8080, result -> {                 if (result.succeeded()) {                      fut.complete();                 } else {      
Post a Comment
Read more

Validating Nested Models

What is validation ? Validations are required for ensuring that the received data is correct and valid. If the received data is valid then we do the further processing with the data. Nested Model Validation Nested model is sometimes tricky when you have complex associations. Here I'm explaining how we can do nested model validation. We use nested form to save associations through its parent model. Generally we do: class Album < ActiveRecord::Base   has_many :songs   accepts_nested_attributes_for :songs end When we are using nested form we want to save a new or edit an existing album with songs. Now suppose we want all the songs to be removed on removal of the album. class Album < ActiveRecord::Base   has_many :songs   accepts_nested_attributes_for :songs, :allow_destroy => true end At this point we can detect and reject empty association entries class Album < ActiveRecord::Base   has_many :songs   accepts_n
Post a Comment
Read more