Serverless stateful
Download as PPTX, PDF0 likes140 views
This document describes a reactive platform architecture designed for scalability. It advocates for a shift in priorities from consistency to availability to enable responsiveness under load. The architecture uses microservices and serverless functions to improve scalability but notes serverless is not yet good for managing state. It also discusses challenges around infrastructure complexity and operational costs that increase with microservices compared to monolithic architectures.
](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-11-320.jpg)
![ Sometime services have to handle a state, so in order to elaborate a
computation: they need to know the current state and they will also
produce an output state.
type StatefulService[S, Input, Output] = Service[(S, Input), (S, Output)]
class Service[In, Out](name: String, f: In => Out)
type In = (S, Input) type Out = (S, Output)](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-12-320.jpg)
f: (S, I) => (S, O)
f: I => S => (S, O) // Currying: I => (S => (S, O))
f: I => State[S, O] // S => (S, O) = State[S, O]
class StatefulService[S, I, O](name: String, f: I => State[S, O])](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-13-320.jpg)
type ReactiveService[I, O] = Service[I, Future[O]]
val f: I => Future[O]
type ReactiveStatefulService[S, I, E] = StatefulService[I, Future[State[S, E]]]
val f: I => Future[State[S, E]]
O = State[S, E]](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-17-320.jpg)
![f: (S, Command) => (S, Event)
val f: Command => State[S, Event]
type Cmd[S] = StatefulService[S, Command, Event]
f: (S, Event) => (S, Event)
val f: Event => State[S, Event]
type Evt[S] = StatefulService[S, Event, Event]
f: (S, Request) => (_, Response)
val f: Request => State[S, Response]
type Ask[S] = StatefulService[S, Request, Response]
(Wallet(id=123, balance=5), DepositCmd(walletId=123, amount=10)) => (Wallet(id=123, balance=15), DepositEvt(walletId=123, amount=10))
(Wallet(id=123, balance=15), SettleWinEvt(walletId=123, amount=10)) => (Wallet(id=123, balance=25), WinSettledEvt(walletId=123, amount=1
(Wallet(id=123, balance=15), GetBalanceReq(walletId=123)) => (_, GetBalanceResp(walletId=123, amount=25))](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-18-320.jpg)
![val reactors: Set[(S, Event) => (S, Event)]val reactors: Set[StatefulService[S, Event, Event]]
val modifiers: Set[StatefulService[S, Command, Event]]val modifiers: Set[(S, Command) => (S, Event)]
trait Processor[S] {
type RootAggregate = S
}](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-19-320.jpg)
![trait View[S] {
type RootAggregate = S
}
val queries: Set[(S, Request) => Response]val queries: Set[StatefulService[S, Request, Response]]
val reactors: Set[(S, Event) => (S, Event)]val reactors: Set[StatefulService[S, Event, Event]]](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-20-320.jpg)
![Processor Actor
Cmd[Debit(10)]
Evt[Credit(50)]
Evt[Debit(20)]
Evt[Credit(15)]
Evt[Debit(10)]
publish
process
View Actor
request
respond
Client App
notify
Actor
[View1]Actor
[View1]Actor
[View1]
PROCESSORS
(WRITE)
VIEWS
(READ)
(Wallet, Cmd) => (Wallet Evt)
(List[Wallet], Req) => Res
(List[Wallet], Evt) => List[Wallet]](https://image.slidesharecdn.com/serverlessstateful-191104100812/85/Serverless-stateful-21-320.jpg)
Serverless stateful
- 2. Patrick Di Loreto CTO Addison Global (MoPlay) https://github.com/patricknoir http://patricknoir.blogspot.com @patricknoir
- 6. This architecture was designed for system pre smart phone generation Need for customer acquisition => need for SCALABILITY Availability became more important than Consistency (CAP theorem)
- 7. Response in a timely manner Responsive under failure scenariosResponsive under load Enabler for responsiveness
- 9. Average system utilization across organization is 15% to 20% The ideal should be around 80% 20% of IT budgets go to operations “We have created: Large Underutilized Complex Environments which are costly to maintain”
- 10. In => Out In Stateful Out Database In => Out In Stateless FaaS Out
- 11. Has a name Is a function from In to Out Service[-In, +Out](name: String, f: In => Out)
- 12. Sometime services have to handle a state, so in order to elaborate a computation: they need to know the current state and they will also produce an output state. type StatefulService[S, Input, Output] = Service[(S, Input), (S, Output)] class Service[In, Out](name: String, f: In => Out) type In = (S, Input) type Out = (S, Output)
- 13. type In = (S, I) type Out = (S, O) class Service[In, Out](name: String, f: In => Out) f: (S, I) => (S, O) f: I => S => (S, O) // Currying: I => (S => (S, O)) f: I => State[S, O] // S => (S, O) = State[S, O] class StatefulService[S, I, O](name: String, f: I => State[S, O])
- 15. Instruction Time Execute typical instruction 1/1,000,000,000 = 1 nanosec Fetch from L1 cache memory 0.5 nanosec Branch misprediction 5 nanosec Fetch from L2 cache memory 7 nanosec Mutex lock/unlock 25 nanosec Fetch from main memory 100 nanosec Send 2K bytes over 1Gbps network 20,000 nanosec (20µs) Read 1MB sequentially from memory 250,000 nanosec (250µs) Fetch from new disk location (seek) 8,000,000 (8ms) Read 1MB sequentially from disk 20,000,000 nanosec (20ms) Send packet US to Europe and back 150,000,000 nanosec (150ms)
- 16. Instruction Time Execute typical instruction 1 s Fetch from L1 cache memory 0.5 s Branch misprediction 5 s Fetch from L2 cache memory 7 s Mutex lock/unlock ½ s Fetch from main memory 1½ min Send 2K bytes over 1Gbps network 5½ hours Read 1MB sequentially from memory 3 days Fetch from new disk location (seek) 13 weeks Read 1MB sequentially from disk 6½ months Send packet US to Europe and back 5 years
- 17. class Service[In, Out](name: String, f: In => Out) type ReactiveService[I, O] = Service[I, Future[O]] val f: I => Future[O] type ReactiveStatefulService[S, I, E] = StatefulService[I, Future[State[S, E]]] val f: I => Future[State[S, E]] O = State[S, E]
- 18. f: (S, Command) => (S, Event) val f: Command => State[S, Event] type Cmd[S] = StatefulService[S, Command, Event] f: (S, Event) => (S, Event) val f: Event => State[S, Event] type Evt[S] = StatefulService[S, Event, Event] f: (S, Request) => (_, Response) val f: Request => State[S, Response] type Ask[S] = StatefulService[S, Request, Response] (Wallet(id=123, balance=5), DepositCmd(walletId=123, amount=10)) => (Wallet(id=123, balance=15), DepositEvt(walletId=123, amount=10)) (Wallet(id=123, balance=15), SettleWinEvt(walletId=123, amount=10)) => (Wallet(id=123, balance=25), WinSettledEvt(walletId=123, amount=1 (Wallet(id=123, balance=15), GetBalanceReq(walletId=123)) => (_, GetBalanceResp(walletId=123, amount=25))
- 19. val reactors: Set[(S, Event) => (S, Event)]val reactors: Set[StatefulService[S, Event, Event]] val modifiers: Set[StatefulService[S, Command, Event]]val modifiers: Set[(S, Command) => (S, Event)] trait Processor[S] { type RootAggregate = S }
- 20. trait View[S] { type RootAggregate = S } val queries: Set[(S, Request) => Response]val queries: Set[StatefulService[S, Request, Response]] val reactors: Set[(S, Event) => (S, Event)]val reactors: Set[StatefulService[S, Event, Event]]
- 21. Processor Actor Cmd[Debit(10)] Evt[Credit(50)] Evt[Debit(20)] Evt[Credit(15)] Evt[Debit(10)] publish process View Actor request respond Client App notify Actor [View1]Actor [View1]Actor [View1] PROCESSORS (WRITE) VIEWS (READ) (Wallet, Cmd) => (Wallet Evt) (List[Wallet], Req) => Res (List[Wallet], Evt) => List[Wallet]
- 23. Node 1 Node 2 Node 3
- 24. Deployment CI/CD Monitoring Logging Tracing Security Auth/Autz
- 25. MessageFabric APIGateway Pub Int Ext Computation Farm RDS KV GRAPH HDFS/S3 Repository Kubernetes
- 30. Mobile growth changed customer behavior, new needs: SCALABILITY is a must to run your business Shift on priorities: AVAILABILITY over CONSISTENCY (CAP) Infrastructure complexity and operational costs increase with MicroService Architecture vs Monolith Serverless is the way to go but are not yet good enough to manage State https://cloudstate.io/