The document discusses using mRuby and lightweight APIs for microservices. It introduces mRuby as a lightweight Ruby implementation that can be embedded into applications. It then demonstrates using mRuby with Nginx through the ngx_mruby module to build a simple microservice for handling API requests. Benchmark tests show the mRuby implementation serving requests faster than a standard Rack implementation in Ruby. However, some downsides of mRuby are also noted, such as needing to recompile when adding dependencies and lack of features like require that make code less dry.

1. Lightweight APIs in mRuby
1 / 57

2. Who am I
2 / 57

3. Who am I
Name's Mikhail Bortnyk
3 / 57

4. Who am I
Name's Mikhail Bortnyk
Ruby developer and team leader in R&R Music Ukraine
4 / 57

5. Who am I
Name's Mikhail Bortnyk
Ruby developer and team leader in R&R Music Ukraine
Co-creator of Kottans school
5 / 57

6. Who am I
Name's Mikhail Bortnyk
Ruby developer and team leader in R&R Music Ukraine
Co-creator of Kottans school
Geek, polyglot, software development addict
6 / 57

7. Who am I
Name's Mikhail Bortnyk
Ruby developer and team leader in R&R Music Ukraine
Co-creator of Kottans school
Geek, polyglot, software development addict
github: @vessi
7 / 57

8. Who am I
Name's Mikhail Bortnyk
Ruby developer and team leader in R&R Music Ukraine
Co-creator of Kottans school
Geek, polyglot, software development addict
github: @vessi
twitter: @mikhailbortnyk
8 / 57

9. What is mRuby
9 / 57

10. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
10 / 57

11. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
can be linked and embedded into your application
11 / 57

12. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
can be linked and embedded into your application
can compile your software into bytecode
12 / 57

13. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
can be linked and embedded into your application
can compile your software into bytecode
can generate C code for embedding bytecode
13 / 57

14. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
can be linked and embedded into your application
can compile your software into bytecode
can generate C code for embedding bytecode
author: Yukihiro 'matz' Matsumoto
14 / 57

15. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
can be linked and embedded into your application
can compile your software into bytecode
can generate C code for embedding bytecode
author: Yukihiro 'matz' Matsumoto
github: github://mruby/mruby
15 / 57

16. What is mRuby
mRuby is lightweight implementation of Ruby complying (partially) to
ISO/IEC 30170:2012
can be linked and embedded into your application
can compile your software into bytecode
can generate C code for embedding bytecode
author: Yukihiro 'matz' Matsumoto
github: github://mruby/mruby
latest version: 1.1.0
16 / 57

17. Typical Rails project
17 / 57

18. Typical Rails project (I am so sorry for it,
mom!)
18 / 57

19. Typical Rails project
it's based on Rack
19 / 57

20. Typical Rails project
it's based on Rack
it contains a lot of business processes
20 / 57

21. Typical Rails project
it's based on Rack
it contains a lot of business processes
it responds to many routes
21 / 57

22. Typical Rails project
it's based on Rack
it contains a lot of business processes
it responds to many routes
often too heavy to serve tons of lightweight requests without scaling
22 / 57

23. Typical Rails project
it's based on Rack
it contains a lot of business processes
it responds to many routes
often too heavy to serve tons of lightweight requests without scaling
So, what is the solution?
23 / 57

24. Solutions
24 / 57

25. Solutions
You have a problem and decide to use threads. Two now problems have
you.
25 / 57

26. Solutions
You have a problem and decide to use threads. Two now problems have
you.
You have a problem and decide to use functional languages. Now your
problems are immutable.
26 / 57

27. Solutions
You have a problem and decide to use threads. Two now problems have
you.
You have a problem and decide to use functional languages. Now your
problems are immutable.
You have a problem and decide to use Java. Now you have
ProblemsFactory.
27 / 57

28. Solutions
You have a problem and decide to use threads. Two now problems have
you.
You have a problem and decide to use functional languages. Now your
problems are immutable.
You have a problem and decide to use Java. Now you have
ProblemsFactory.
You have a problem and decide...
28 / 57

29. Kill it with fire!
29 / 57

30. Kill it with fire!
Microservices
30 / 57

31. Microservices
31 / 57

32. Microservices
32 / 57

33. Microservices
The idea is to split big project in bunch of independent lightweight services.
33 / 57

34. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
34 / 57

35. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
35 / 57

36. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
be lightweight
36 / 57

37. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
be lightweight
be stable
37 / 57

38. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
be lightweight
be stable
don't switch technology stack aggresively
38 / 57

39. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
be lightweight
be stable
don't switch technology stack aggresively
So, I decided to use mRuby. What do we have for serving web here?
39 / 57

40. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
be lightweight
be stable
don't switch technology stack aggresively
So, I decided to use mRuby. What do we have for serving web here?
mod_mruby. Apache module that executes mRuby code inside Apache
process.
40 / 57

41. Microservices
The idea is to split big project in bunch of independent lightweight services.
Requirements:
be fast
be lightweight
be stable
don't switch technology stack aggresively
So, I decided to use mRuby. What do we have for serving web here?
mod_mruby. Apache module that executes mRuby code inside Apache
process.
ngx_mruby. Perfectly the same but with Nginx flavour.
41 / 57

42. Little demonstration
Microservice without any service
42 / 57

43. Little demonstration
Used software:
nginx (ALL)
docker (ALL)
docker-compose (ALL)
mongodb (ALL)
ab (ALL)
unicorn gem (rack)
rack gem (rack)
rack-routing gem (rack)
mongo gem (rack)
ngx_mruby (mRuby)
mruby-mongo (mRuby)
43 / 57

44. Rack execution
$> cd testlab/rack
$> docker-compose up
$> ab -n 10000 -c 100 http://192.168.0.100:10080/api/contacts
# and kill docker-compose with ^C
44 / 57

45. Rack stats (page 1)
Document Path: /api/contacts
Document Length: 537 bytes
Concurrency Level: 100
Time taken for tests: 7.897 seconds
Complete requests: 10000
Failed requests: 4399
(Connect: 0, Receive: 0, Length: 4399, Exceptions: 0)
Non-2xx responses: 5601
Total transferred: 5080859 bytes
HTML transferred: 3434440 bytes
Requests per second: 1266.27 [#/sec] (mean)
Time per request: 78.972 [ms] (mean)
Time per request: 0.790 [ms] (mean, across all concurrent requests)
Transfer rate: 628.29 [Kbytes/sec] received
45 / 57

46. Rack stats (page 2)
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 4 4.1 2 34
Processing: 1 74 72.1 23 423
Waiting: 1 74 72.0 22 423
Total: 2 78 72.2 27 426
Percentage of the requests served within a certain time (ms)
50% 27
66% 135
75% 147
80% 154
90% 174
95% 192
98% 216
99% 232
100% 426 (longest request)
46 / 57

47. mRuby execution
$> cd testlab/rack
$> docker-compose up
$> ab -n 10000 -c 100 http://192.168.0.100:10080/api/contacts
# and kill docker-compose with ^C
47 / 57

48. mRuby stats (page 1)
Document Path: /api/contacts
Document Length: 98 bytes
Concurrency Level: 100
Time taken for tests: 6.721 seconds
Complete requests: 10000
Failed requests: 0
Total transferred: 2140000 bytes
HTML transferred: 980000 bytes
Requests per second: 1487.83 [#/sec] (mean)
Time per request: 67.212 [ms] (mean)
Time per request: 0.672 [ms] (mean, across all concurrent requests)
Transfer rate: 310.93 [Kbytes/sec] received
48 / 57

49. mRuby stats (page 2)
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 3 5.9 0 29
Processing: 5 64 27.5 68 132
Waiting: 5 64 27.6 68 131
Total: 14 67 24.4 69 132
Percentage of the requests served within a certain time (ms)
50% 69
66% 78
75% 83
80% 88
90% 102
95% 106
98% 112
99% 120
100% 132 (longest request)
49 / 57

50. Problems
50 / 57

51. Problems
Everything has its price. ngx_mruby and Nginx and mRuby are not exceptions.
51 / 57

52. Problems
Everything has its price. ngx_mruby and Nginx and mRuby are not exceptions.
you have to recompile mRuby each time you add some dependency
52 / 57

53. Problems
Everything has its price. ngx_mruby and Nginx and mRuby are not exceptions.
you have to recompile mRuby each time you add some dependency
oftenly gems are written in pure C
53 / 57

54. Problems
Everything has its price. ngx_mruby and Nginx and mRuby are not exceptions.
you have to recompile mRuby each time you add some dependency
oftenly gems are written in pure C
mRuby has no require keyword, so you code will not be so DRY as you
want
54 / 57

55. Problems
Everything has its price. ngx_mruby and Nginx and mRuby are not exceptions.
you have to recompile mRuby each time you add some dependency
oftenly gems are written in pure C
mRuby has no require keyword, so you code will not be so DRY as you
want
still not so fast as pure C implementation :(
55 / 57

56. Questions?
56 / 57

57. Thank you!
57 / 57