Performance Tales of Serverless

Function-as-a-Service serverless cloud offerings provide us with an easy way to run custom code in response to events. One promise of the FaaS model is the ability to scale without limits, up or down, whenever needed.

But how does that work in practice? Can AWS Lambda handle thousands of messages per second? How fast can Azure Functions scale up under sudden heavy load? What kind of latency can you expect from Google Cloud Functions?

This session is a set of short tales, each one of them teaching us a lesson about the practical scalability of serverless applications. I will also suggest steps to evaluate whether your application profile is suitable for serverless today.

Transcript

1. Performance Tales of Serverless Serverless Computing London | November 12 | 2018
2. Control Trust
3. м
6. Application Overview
7. What do we want? 7 $
8. Function-as-a-Service Cloud Offerings
9. Application Overview
10. Ideal Scalability: Throughput
11. Ideal Scalability: Latency
12. OCCASIONAL USERS: Early stages, several visitors per hour
13. Visitors during sample 5 hours
14. Dependency Call Duration (ms)
15. Target End-to-End Latency (ms)
16. AWS Lambda Latency (ms)
17. Google Cloud Functions Latency (ms)
18. Azure Functions Latency (ms)
19. Cold Start
20. Warm Start
21. Subsequent Cold Starts after quiet periods
22. When Does Cold Start Happen? Azure:
23. When Does Cold Start Happen? GCP:
24. When Does Cold Start Happen? AWS:
25. Cold Starts: Language Comparison
26. Dependecies Add to Cold Start
27. Fighting Cold Starts { "type": "timerTrigger", "schedule": "0 */15 * * * *", "name": "warmer" }
28. COLD STARTS ARE SLOW(-ER) …and depend on language and package size 1. Lesson Learnt
29. PROJECTED LOAD: Simulated at the target amount of users
30. Load Testing Setup
31. Load Testing Setup
32. Load Testing Setup
33. Serverless Artillery
34. Requests/sec during 5 hours of load test
35. End-to-End Latency (ms)
36. End-to-End Latency (ms)
37. SERVERLESS APPLICATION CAN DDOS ANY MERE MORTAL SERVICE 2. Lesson Learnt
38. Limit on Trigger Level
39. AWS: Reserved Concurrency 39
40. Azure: Max Scaleout s40
41. SERVERLESS SCALABILITY IS LIMITED BY NON-SERVERLESS DEPENDENCIES 3. Lesson Learnt
42. ETL: Asynchronous data processing
43. How to improve our app
44. Serverless ETL
45. Scaling AWS Lambda
46. Scaling AWS Lambda
47. I/O-intensive workload on AWS Lambda
48. CPU-intensive workload on AWS Lambda
49. AWS Processing Speed per Reserved RAM
50. I/O-intensive workload on Google Cloud Functions
51. CPU-intensive workload on Google Cloud Functions
52. GCF Processing Speed per Reserved RAM
53. Scaling Azure Function
54. Scaling Azure Function
55. I/O-intensive workload on Azure Functions
56. CPU-intensive workload on Azure Functions
57. LEARN THE RESOURCE MODEL: LIMITS, SCALING MODE, RAM & CPU ALLOCATION 4. Lesson Learnt
58. TV EFFECT: We are going to be live on TV!!!
59. Requests/sec during the load test
60. Google Cloud Functions, Run 1: Throttled
61. Resource Pooling: Persist Connections const http = require('http'); const agent = new http.Agent({keepAlive: true}); exports.mycloudfunction = (req, res) => { req = http.get({ host: '...', port: 80, path: '...', agent: agent }, // ...
63. Reuse HTTP Connections in C# private static HttpClient Client = new HttpClient(); [FunctionName("MyFunc")] public static async Task Run([QueueTrigger(“q")] string message) { var response = await Client.GetAsync("https://mikhail.io"); // ... the rest goes here }
64. Managing MySQL at Serverless Scale
65. REUSE CONNECTIONS, POOL & CACHE 5. Lesson Learnt
66. Google Functions, Run 2: Response Percentiles (ms)
67. Azure Functions Response Percentiles (ms)
68. Azure Functions Response 99th Percentile (ms)
69. AWS Lambda Response Percentiles (ms)
70. SERVERLESS IS UNIQUELY SUITABLE FOR SPIKY LOAD… BUT KNOW THE LIMITS 6. Lesson Learnt
71. RUNNING IN PRODUCTION
72. Actual Outcome • • • • 
73. Is Serverless Good for My Next Project?
74. • • • • Is Serverless Good for My Next Project?
75. Perfect Scenarios for Serverless • • • •