Reasonable RPC with Remotely
0 likes1,003 views
The document discusses the challenges and trade-offs of existing remote procedure call (RPC) solutions, highlighting issues with scalability, maintenance, and safety. It introduces 'remotely RPC,' a beta project aimed at providing a productive and safe environment for remote function calls using a modular design. Key features include fast binary serialization, pluggable transports, and comprehensive monitoring capabilities, with an emphasis on enhancing productivity and code reuse.
![Remote reference
factorial: Remote[Int => Int]](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-20-320.jpg)
![Applying a remote
function
val x: Remote[Int] =
factorial(9)](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-21-320.jpg)
![Getting a response
val x: Response[Int] =
factorial(9).run(endpoint)](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-22-320.jpg)
![Response monad
type Demo[A] = Kleisli[Response, Endpoint, A]
implicit def remoteToK[A](r: Remote[A]): Demo[A] =
Kleisli.ask[Response, Endpoint].flatMapK(r.run)
def call: Demo[(Movie,List[Actor])] = for {
a <- MovieClient.getMovie("m2")
b <- MovieClient.getActors(a)
} yield (a,b)](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-23-320.jpg)
![Running Responses
val address = new InetSocketAddress("10.1.0.1",8080)
val exe: Task[(Movie,List[Actor])] = for {
transport <- NettyTransport.single(address)
endpoint = Endpoint.single(transport)
output <- call(endpoint)(Context.empty)
_ <- transport.shutdown
} yield output
val (movie, actors) = exe.run](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-24-320.jpg)
![Pluggable transports
type Handler =
Process[Task,BitVector] =>
Process[Task,BitVector]](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-29-320.jpg)
![Endpoints
case class Endpoint(
connections: Process[Task,Handler])](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-30-320.jpg)
![Endpoint combinators
def circuitBroken:
(Duration,Int,Endpoint) => Endpoint
def failoverChain:
(Duration,Process[Task,Endpoint]) => Endpoint](https://image.slidesharecdn.com/remotely-scaladays-2015-150323235323-conversion-gate01/85/Reasonable-RPC-with-Remotely-31-320.jpg)
Reasonable RPC with Remotely
- 1. Reasonable RPC with Remotely ScalaDays, 18th March 2015 Rúnar Bjarnason Tim Perrett
- 3. Existing solutions No panaceas. Just tradeoffs.
- 4. Monolith • All functionality in a single binary • Doesn’t scale • Difficult to evolve and maintain
- 5. Broker pattern • Message bus or broker mediates between services • Single point of failure/integration • If broker goes down, the whole system is down
- 6. Message-passing • Lightweight and inexpensive • Reliable and scales well • Discovery is a pain
- 7. Message passing solutions • Finagle • Thrift • Akka • HTTP*(JSON+XML)/REST
- 8. Finagle • Imperative API • No reuse • Too powerful • No higher-order constructs
- 9. Thrift • All of the problems with Finagle • Tough tooling • Documentation is lacking • No formal spec for wire format
- 10. Akka • Too powerful • Untyped • Actor system API bleeds to the outside • Behavior of complex systems is unreasonable
- 11. HTTP*(JSON+XML)/REST • Unproductive, developer time wasted • Marshalling/unmarshalling • Defining HTTP endpoints and using HTTP clients • Resources wasted on HTTP layer and parsing • Does what we want, but at tremendous cost
- 12. Our Vision Productivity, Safety, Reuse
- 13. Productivity Don’t want to think about: • HTTP protocol specifics • Every possible failure mode • Serialization format • Compatibility
- 14. Safety • Ad-hoc evolution doesn’t scale • Incompatibilities should be compile-time failures • Fail as early as possible
- 15. Reuse • Use an actual programming language • Build protocols from modular primitives • Compose large protocols from small ones
- 16. Remotely RPC for reasonable people
- 17. Remotely RPC for reasonable people BETA
- 18. Remotely • Pilot for Verizon open-source • Taking the time to build exactly what we want to use • You can use it too!
- 19. Remote call val x = factorial(9)
- 20. Remote reference factorial: Remote[Int => Int]
- 21. Applying a remote function val x: Remote[Int] = factorial(9)
- 22. Getting a response val x: Response[Int] = factorial(9).run(endpoint)
- 23. Response monad type Demo[A] = Kleisli[Response, Endpoint, A] implicit def remoteToK[A](r: Remote[A]): Demo[A] = Kleisli.ask[Response, Endpoint].flatMapK(r.run) def call: Demo[(Movie,List[Actor])] = for { a <- MovieClient.getMovie("m2") b <- MovieClient.getActors(a) } yield (a,b)
- 24. Running Responses val address = new InetSocketAddress("10.1.0.1",8080) val exe: Task[(Movie,List[Actor])] = for { transport <- NettyTransport.single(address) endpoint = Endpoint.single(transport) output <- call(endpoint)(Context.empty) _ <- transport.shutdown } yield output val (movie, actors) = exe.run
- 25. Demo
- 26. Feature Pageant
- 27. Binary Codecs • Fast, lightweight binary serialization • Built on scodec • Ships with codecs for standard Scala types • Easy to make codecs for your own types • Future goal: Fully automate codec-creation
- 28. Pluggable transports • Uses Netty 4 out of the box • Akka I/O • Netty 3 • ØMQ
- 29. Pluggable transports type Handler = Process[Task,BitVector] => Process[Task,BitVector]
- 30. Endpoints case class Endpoint( connections: Process[Task,Handler])
- 31. Endpoint combinators def circuitBroken: (Duration,Int,Endpoint) => Endpoint def failoverChain: (Duration,Process[Task,Endpoint]) => Endpoint
- 32. Context-passing • Context provides arbitrary container for experiment propagation. • Every request tagged with a UUID. • Contains stack of request UUIDs. • highlights the “path” through the system request graph when debugging.
- 33. Pluggable monitoring • Report round-trip latency timing. • Trace every request uniquely. • Trace the request stack entirely. • Bring your own by implementing the Monitoring trait. • Uses println out of the box.
- 34. Capability checking • Protocol versioning over time inevitable • Determine client/server compatibility before establishing connection
- 35. How fast is it? • Went from 56 ms to 32 ms (production payload) • In benchmarks on modest hardware • Min: ~400 μs • Mean: ~1.5 ms • Throughput is an issue currently
- 36. Spray I/O Netty 4
- 37. Future work • Prettier API • Drastically improve throughput • Extensible protocol language • More built-ins for e.g. server-side map and flatMap • Remote polymorphic functions
- 38. Summary • Remotely is productive • It’s safe • It promotes code reuse • You can contribute!