Why the fuzz about serverless (with CompassDigital)

Slides from my talk at CompassDigital

Transcript

1. Why the fuzz about serverless?
2. 1. What is serverless and why you should care 2. Who’s using serverless? 3. Serverless- fi rst, not serverless-only 4. Patterns & Anti-Patterns 5. The case for GraphQL & AppSync 6. Q&A
3. Yan Cui http://theburningmonk.com @theburningmonk AWS user since 2010
4. Yan Cui http://theburningmonk.com @theburningmonk running serverless in production since 2016
5. Yan Cui http://theburningmonk.com @theburningmonk independent consultant
6. “What is serverless?”
8. Gojko Adzic It is serverless the same way WiFi is wireless. http://bit.ly/2yQgwwb
9. Serverless means… don’t need to worry about scaling don’t need to provision and manage servers
10. Serverless means… don’t need to worry about scaling don’t need to provision and manage servers don’t pay for it if no-one uses it
11. Lambda
12. Lambda S3 DynamoDB
13. Lambda S3 API Gateway DynamoDB AppSync
14. Lambda S3 API Gateway DynamoDB AppSync Cognito
15. Lambda S3 SQS SNS API Gateway DynamoDB AppSync EventBridge Cognito
16. Lambda S3 SQS SNS Step Functions API Gateway DynamoDB AppSync EventBridge Cognito
17. Lambda S3 SQS SNS Step Functions API Gateway DynamoDB AppSync Kinesis EventBridge Cognito
18. Lambda S3 SQS SNS Step Functions API Gateway DynamoDB AppSync Kinesis EventBridge Cognito You can build pretty much everything with serverless.
19. SCALABLE
20. https://www.vladionescu.me/posts/scaling-containers-on-aws-in-2022 Lambda
21. https://www.vladionescu.me/posts/scaling-containers-on-aws-in-2022 Lambda OUT-DATED!
23. Every function can scale by 1,000 concurrent executions every 10 seconds, independently of each other.
24. RESILIENT
25. DynamoDB replicates data to 3 AZs
26. S3 has 99.999999999% (11 9s) durability
28. Lambda, API Gateway, AppSync, etc. all provide built-in multi-AZ redundancy out-of-the-box
29. Lambda Workers (microVMs) don’t share memory
30. Lambda Workers (microVMs) process one invocation request at a time
31. Lambda Failures are isolated, no more system crash!
32. Lambda Workers are garbage collected every x hours
33. Lambda No more memory leaks and memory fragmentation issues
34. SECURE
35. Lambda Your code Your dependencies The OS EC2 instance Networking Physical infrastructure
37. COST-EFFICIENT
38. User Tra ff i c Cost Serverless Cost per transaction is highly predictable Cost tracks usage closely
39. WASTE User Tra ff i c Cost Serverless Serverful Cost can be predictable, but you overpay Cost per transaction is highly predictable Cost tracks usage closely
40. aws.amazon.com/solutions/case-studies/finra-data-validation
41. “FinDev”
42. $0.0000035 $0.0000004083 $0.00000125 cost per transaction: $0.0000051583 Lambda API Gateway DynamoDB
43. Donald Knuth We should forget about small ef fi ciencies, say about 97% of the time: premature optimization is the root of all evil.
44. input output engineering time lower operational cost
46. cost of the conversation: ~$50 per dev per hour x 8 = $400 potential saving: $10/month
47. cost of the conversation: ~$50 per dev per hour x 8 = $400 potential saving: $10/month break-even time for conversation: $400 ÷ $10/month = 40 months!!!
48. Donald Knuth We should forget about small ef fi ciencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.
50. this is pretty $$$ input output engineering time lower operational cost
51. Knowing the cost of individual functions lets us optimise the right parts of our application
56. “I just want to get from A to B I don’t care how ”
57. Ownership Fuel Navigate To get there! Focus on getting there! uber
58. HW Ownership OS Runtime & Scale Code Physical Servers
59. HW Ownership OS Runtime & Scale Code Physical Servers Virtual Machines
60. HW Ownership OS Runtime & Scale Code Physical Servers Virtual Machines Containers
61. HW Ownership OS Runtime & Scale Code Focus on getting there! Physical Servers Virtual Machines Containers Serverless
62. leverage: do more with less
63. https://bit.ly/2Im61VK “Unless you’re an infrastructure company, infrastructure is basically overhead.” Matt Klein
64. bit.ly/social-network-in-4-weeks
65. leverage: do more with less
66. “Is serverless right for { insert industry }?”
68. Streaming live sporting events 2 million+ concurrent users at peak
69. Streaming live sporting events 2 million+ concurrent users at peak Mix of containers and serverless Serverless for APIs, event processing, etc.
70. www.youtube.com/watch?v=C0pA5eZkmFk
71. aws.amazon.com/solutions/case-studies/bustle
72. twitter.com/ben11kehoe/status/1187027628152115200
73. https://www.infoq.com/news/2021/01/bbc-serverless-scale
74. Workloads transcend industry boundaries
75. “Serverless-First”
76. Start with serverless Move to container when it makes more sense
78. “Amazon has abandoned serverless!”
79. “Amazon has abandoned serverless!” It’s one service, by one team, within one business area…
80. Evolution Architecture "an approach to building software that's designed to evolve over time as business priorities change, customer demands shift, and new technologies emerge."
81. serverless Fast time-to-market
82. serverless Fast time-to-market Gains traction
83. Gains traction serverless Fast time-to-market Optimize for efficiency
84. services that charge by uptime are order of magnitude cheaper when running at scale
85. container Optimize for efficiency Gains traction serverless Fast time-to-market
87. “We can solve any problem by introducing an extra level of indirection.” Fundamental Theorem of Software Engineering
88. Anti-Patterns Patterns &
93. Synchronous Lambda-to-Lambda are almost always a sign of bad design.
95. Service Boundary
96. Service Boundary
97. Service Boundary
98. AWS Lambda function !== lambda function in programming
99. ?
100. ? ?
104. Service Boundary Service Boundary
105. Service Boundary Service Boundary
106. Implementation detail Service Boundary Service Boundary
107. Not a stable interface Service Boundary Service Boundary Implementation detail
109. container Optimize for efficiency Gains traction serverless Fast time-to-market
110. container Optimize for efficiency Gains traction serverless Fast time-to-market Caller shouldn’t have to rewrite their app when you change an implementation detail
111. Service Boundary Service Boundary
112. Service Boundary Service Boundary
113. Service Boundary Service Boundary
114. “Use Lambda functions to transform data, NOT transport data.”
116. Basic CRUD operation No business logic
119. “But why you go functionless?”
120. No Lambda = no cold starts
121. No Lambda = no Lambda-related costs
122. EventBridge Pipes
123. EventBridge Pipes
124. 3rd party API EventBridge Pipes
125. 3rd party API EventBridge Pipes Transform
126. OpenSearch
127. No-Code ETL OpenSearch
128. AppSync EventBridge OpenSearch
129. Step Functions EventBridge OpenSearch
130. Consider the ROI on every moving part in your architecture
133. ?
134. ?
136. Function URL
137. Function URL Lambdalith
138. “Lambdalith”
139. Lambdalith: run web app (e.g. express.js) inside Lambda
140. https://github.com/awslabs/aws-lambda-web-adapter
141. https://github.com/CodeGenieApp/serverless-express
142. https://bref.sh
143. https://github.com/zappa/Zappa
144. “Is it a good idea?”
145. If you’re not using API Gateway features (e.g. Cognito authoriser, request models, direct integration)
146. or, if you’re facing API Gateway limits (e.g. 29s timeout, no response streaming)
147. No API Gateway = no API Gateway costs
148. No API Gateway = no API Gateway latency overhead
149. Lambdalith Pros & Cons
150. Lambdalith Pros & Cons Familiar web framework
151. Lambdalith Pros & Cons Familiar web framework Testing is easier
152. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert
153. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control
154. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control Limited auth support
155. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control Limited auth support Large frameworks affect performance
156. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control Limited auth support Large frameworks affect performance Custom app metric with EMF
157. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control Limited auth support Large frameworks affect performance Custom app metric with EMF In-function authentication
159. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control No per-endpoint auth Large frameworks affect performance Custom app metric with EMF In-function authentication YOU pay for unauthorised requests
160. Knowing the cost of individual functions lets us optimise the right parts of our application
161. Lambdalith Pros & Cons Familiar web framework Testing is easier No per-endpoint metric & alert Less fine-grained access control No per-endpoint auth Large frameworks affect performance Harder to tune performance & cost
162. “Is it a good idea?”
163. Consider the trade-offs before you go Lambdalith
164. Caching
165. Caching is a cheat code
166. Route53 CloudFront API Gateway Lambda DynamoDB
167. Route53 CloudFront API Gateway Lambda DynamoDB client-side caching
168. Route53 CloudFront API Gateway Lambda DynamoDB client-side caching edge caching
169. Route53 CloudFront API Gateway Lambda DynamoDB client-side caching edge caching application-level caching
170. Route53 CloudFront API Gateway Lambda DynamoDB client-side caching edge caching application-level caching ElastiCache
171. Route53 CloudFront API Gateway Lambda DynamoDB client-side caching edge caching application-level caching Momento
172. bit.ly/social-network-in-4-weeks
173. average 99% cache hit rate
175. Lambda DynamoDB AppSync
176. A Query Language for your APIs + runtime for fulfilling queries with your data
177. schema
178. schema server AppSync
179. Client Server
180. Client Server Validates the request
181. schema { query: Query mutation: Mutation }
182. schema { query: Query mutation: Mutation } type Query { getProfile(id: ID!): Profile }
183. schema { query: Query mutation: Mutation } type Query { getProfile(id: ID!): Profile } ! = required ID is a built-in type
184. Profile is a type schema { query: Query mutation: Mutation } type Query { getProfile(id: ID!): Profile }
185. schema { query: Query mutation: Mutation } type Query { getProfile(id: ID!): Profile } type Profile { id: ID! firstName: String! lastName: String! }
186. schema { query: Query mutation: Mutation } type Query { getProfile(id: ID!): Profile @aws_lambda } type Profile { id: ID! firstName: String! lastName: String! } type Mutation { createProfile( firstName: String! lastName: String! ): Profile }
187. schema server AppSync
188. schema server data sources DynamoDB RDS ElasticSearch AppSync
189. GET https://myapp.com/user/1234 REST API { “id”: “1234”, “firstName”: “Yan”, “lastName”: “Cui”, “dob”: “…”, … }
190. GET https://myapp.com/user/1234 REST API { “id”: “1234”, “firstName”: “Yan”, “lastName”: “Cui”, “dob”: “…”, … } Returns data we don’t need
191. GET https://myapp.com/user/1234 REST API { “id”: “1234”, “firstName”: “Yan”, “lastName”: “Cui”, “dob”: “…”, … } Returns data we don’t need Overfetching
192. GET https://myapp.com/user/1234 REST API { “id”: “1234”, “firstName”: “Yan”, “lastName”: “Cui”, “dob”: “…”, … } Doesn’t have everything we need
193. GET https://myapp.com/sports/football GET https://myapp.com/sports/squash … GET https://myapp.com/user/1234/activities REST API GET https://myapp.com/user/1234
194. GET https://myapp.com/sports/football GET https://myapp.com/sports/squash GET https://myapp.com/user/1234/activities REST API GET https://myapp.com/user/1234 …
195. n+1 requests GET https://myapp.com/sports/football GET https://myapp.com/sports/squash GET https://myapp.com/user/1234/activities REST API GET https://myapp.com/user/1234 Underfetching …
196. GraphQL API POST https://myapp.com/graphql { getProfile (id: “1234”) { firstName lastName } }
197. GraphQL API POST https://myapp.com/graphql { getProfile (id: “1234”) { firstName lastName } } { “firstName”: “Yan”, “lastName”: “Cui” }
198. GraphQL API POST https://myapp.com/graphql { getProfile (id: “1234”) { friends { firstName lastName } } } { “friends”: [{ “firstName”: “Gerard”, “lastName”: “Sans” }, { “firstName”: “Ant”, “lastName”: “Stanley” }] }
199. GraphQL solves overfetching and underfetching
200. Strongly typed contract between client and server
201. Strongly typed contract between client and server Built-in request & response validation
202. Strongly typed contract between client and server Built-in request & response validation Mitigates data exfiltration risks
203. Implement “joins” with DynamoDB effortlessly
205. AppSync
206. AppSync Pro fi le
207. AppSync Pro fi le
208. Pro fi le
209. Pro fi le Sport
210. Pro fi le Sport
211. AppSync Pro fi le Sport
212. AppSync Pro fi le Sport
213. Activity
214. Activity
215. AppSync Pro fi le Sport Activity
216. Enables rapid product iterations on the frontend
217. AppSync has built-in caching support
218. aws.amazon.com/appsync/pricing
219. AppSync full request caching
220. AppSync full request caching $context.arguments & $context.identity
221. AppSync full request caching Shared, static data are fetched multiple times $context.arguments & $context.identity
222. Full-request caching is kinda meh…
223. AppSync per-resolver caching
224. AppSync per-resolver caching Shared data is fetched once and cached
225. AppSync per-resolver caching Can specify different TTL & cache key for each resolver Shared data is fetched once and cached
226. average 99% cache hit rate
227. average p99 latency of < 250ms
228. Caching is a cheat code!
229. AppSync Subscriptions simplifies real-time applications
231. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! }
232. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost: Post @aws_subscribe(mutations: [“addPost"]) }
233. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost: Post @aws_subscribe(mutations: [“addPost“]) }
234. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost: Post @aws_subscribe(mutations: [“addPost“]) } subscriber publisher subscriber subscriber
235. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost: Post @aws_subscribe(mutations: [“addPost“]) } publisher subscriber subscriber subscriber
236. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost: Post @aws_subscribe(mutations: [“addPost“]) } publisher subscriber subscriber subscriber
238. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost(author: String, title: String, publishYear: Int, publishMonth: Int) : Post @aws_subscribe(mutations: [“addPost“]) }
239. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost(author: String, title: String, publishYear: Int, publishMonth: Int) : Post @aws_subscribe(mutations: [“addPost“]) } subscriber subscriber subscriber
240. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost(author: String, title: String, publishYear: Int, publishMonth: Int) : Post @aws_subscribe(mutations: [“addPost“]) } subscriber publisher subscriber subscriber
241. type Mutation { addPost(id: ID! author: String! title: String content: String url: String): Post! } type Subscription { addedPost(author: String, title: String, publishYear: Int, publishMonth: Int) : Post @aws_subscribe(mutations: [“addPost“]) } subscriber publisher subscriber subscriber
242. AppSync + Lambda + DynamoDB is the most efficient way to build data-driven applications
243. Summary
244. Synchronous Lambda-to-Lambda calls
245. 🤔 Synchronous Lambda-to-Lambda calls Lambdalith
246. 🤔 Synchronous Lambda-to-Lambda calls Lambdalith Functionless
247. 🤔 Synchronous Lambda-to-Lambda calls Lambdalith Functionless GraphQL & AppSync
248. 🤔 Synchronous Lambda-to-Lambda calls Lambdalith Functionless GraphQL & AppSync Caching
249. Questions?