Scaling

Four standard steps for system design interview. However, I would think about them wider: as about four initial steps to design the software.

• Step 1. Understand the problem and establish design scope
• Step 2. Propose high-level design and get buy-in
• Step 3. Design deep dive
• Step 4. Wrap up

The chapter 3 of the book discovers details about each step, good questions to ask (to think about), DO’s and DONT’s. It also shows good example of the process of designing a news feed system.

The 4th pattern to build microservices is to use Lightweight Frameworks.

Lightweight Frameworks provide similar functionality to Heavyweight Frameworks, but they heavily rely on:

• the event broker
• the container management system (CMS)

In many cases they exceed Heavyweight Frameworks.

Different apps can use any/different resources from the cluster which are better fit their needs. While still provide Scaling and Recovering from Failures (again by heavily relying on event broker and CMS).

Heavyweight Stream Processing Frameworks are another foundation/pattern to build your microservices.

These frameworks are highly scalable and allow you to efficiently solve many analytical tasks. But they are not always good for stateful event-driven microservice application patterns.

Heavyweight frameworks operate using centralized resource clusters, which may require additional operational overhead, monitoring, and coordination to integrate successfully into a microservice framework. However, recent innovations move these frameworks toward container management solutions (CMS) such as Kubernetes that should reduce your efforts.

Function-as-a-Service (FaaS) is an area of cloud computing that is growing rapidly.

There are following issues to conside here:

• Principles of FaaS
• Open source and 3rd party FaaS providers
• 4 components to consider when building microservices as functions
• Cold Start vs Warm Start
• Different Triggers that can start FaaS: Triggering Based on New Events, Triggering Based on Consumer Group Lag, Triggering on a Schedule, Triggering Using Webhooks, Triggering on Resource Events
• Maintaining State
• Two patterns of functions calling other functions: Event-driven and Direct-call
• Termination and Shutdown
• Tuning and Scaling

All of these is disclosed in the Chapter 9 of the book we are currently studying:

Event-Driven Microservices need to materialize states. And it comes with the important things to think about. Two approaches to choose from:

• Internal state store
• or External state store

Both have pros and cons. Both have important scalability and recovery considerations.

Two approaches for changing data structures:

• Bebuilding
• and Migration

Transactions and how to emulate them in order to implement Effectively Once processing.

All of these is disclosed in the Chapter 7 of the book we are currently studying: