Ever wondered how to manage connections to SQL databases from serverless applications, or how to rate limit and build serverless state machines? This presentation discusses patterns you can use to build the most complex serverless applications!

1. Square Peg Round Hole
Serverless Solutions For Non-Serverless
Problems

2. My Background
Brought Multi-Touch Input Support To The Linux
Desktop
Technical Architect of New Relic Browser
CTO and Co-founder of Stackery

3. What I’ve Seen
Business Impeded Because Infrastructure/
Processes Couldn’t Scale
Engineering Orgs That Don’t Know What Has Been
Deployed Where

4. Spent Years Figuring Out Best Practices For
Serverless

5. What Are The Most Common Architecture
Challenges For Serverless?

6. Working With SQL Databases
Rate Limiting
State Machines

8. Yesterday!!!

11. Working With SQL Databases

12. But Why?

13. Lots of SQL databases are already in use
Boring…

14. SQL Databases Provide Two Main Features

15. Relationships
Transactions

16. Relationships

17. Delete parent
Find all children
Delete Children

18. So Many Things
Could Go Wrong
Here!

19. What If There Are
Too Many Records?

20. What If We Hit
Throughput Limits
After First N
Records?

21. What If We Hit
Throughput Limits
After First N
Records?

22. SQL Schemas Solve
This Declaratively

23. When Parent Record
Is Deleted,
Automatically Delete
Child Record
No Orphaned
Records

24. Transactions

25. Wait, Didn’t DynamoDB Add Transactions Last
Year?
Yes, But…

26. DynamoDB Transactions Ensure All Queries In A
Batch Are Executed Or None Are Executed
But, All Queries Are Performed At Once

27. DynamoDB-Style Transaction Example
Facilitates Atomicity For Updating
Values Together

28. Temporal Transaction Example
Facilitates Locking For This Build
Record While We Try Starting Build

29. SQL Relationships And Transactions Lower TCO
Less Code
Easier Code

30. SQL Databases Are Cool
But You Mentioned There’s An Issue?

31. Three Scalability Concerns For SQL Databases:
Storage
Compute
Network Connections

32. AWS Aurora Auto-Scales Storage

33. AWS Aurora Serverless Auto-Scales Compute

34. Still Need A Solution For Network Connections

35. Still Need A
Solution For
Network
Connections

36. Most SQL Databases Limit Connections
Each DB connection is handled on an independent thread of
execution
Each thread of execution requires memory set aside for it
Switching execution between threads adds overhead

37. Wait, Didn’t AWS Aurora Add A Data API Last
Year?
Yes, But Data API Only Allows Atomic
Transactions, Not Locking
We Still Need A Persistent Network Connection
Solution

38. https://docs.aws.amazon.com/lambda/latest/dg/vpc-rds-deployment-pkg.html
This Connection Remains Until
The Function Instance Is Terminated
Example Network Connection Scaling Issue

39. Each Function Has A Set
Of Idle Instances With
Open Connections
20/20
20/20
20/20
20/20
20/20 Total Requests: 100
Total Connections: 100

40. 40/40
15/20
15/20
15/20
15/20 Total Requests: 100
Total Connections: 120

41. 15/40
15/20
40/40
15/20
15/20 Total Requests: 100
Total Connections: 140!

43. Solution: Create And Destroy
Connection In Every Invocation

44. Stay Tuned For Even Better Solutions!

45. Connection Pooled Queries Over HTTPS!

46. Transactions Too!

47. Rate Limiting

48. Last Year I Enumerated Three Hacks To Enable
Rate Limiting

49. XX X

50. New Solution!
SQS Queues With Reserved Concurrency

51. SQS Queues With Reserved Concurrency
1. To prevent overloading a system, each minute we add X
number of items to a queue (Here, web pages we intend to
scrape)
2. The Scraper function is limited to only Y concurrent
invocations (Gotcha: Y must be greater than 5 to work right)
3. Each Scraper invocation retrieves one message at a time and
processes it

52. Trivial Enough We’ll Move On For Now
(But We’ll Revisit…)

53. State Management

55. Concurrency Coordination
State Transitions
Any serverless state machine can be built with a
combination of the above

56. Concurrency Coordination Requires
External State

57. Concurrency Coordination Example: Map / Reduce
1. Add a record to a database with count of concurrent invocations
2. Perform invocations
3. At completion, invocations atomically reduce concurrent count
4. If no more concurrent invocations, transition to next state

58. State Transitions Require Local State

59. State Transitions Example: Custom Retry Logic
1. Attempt to execute function
2. On failure, check “retries” property of the input message
3. If retries > MAX_RETRIES, then report failure
4. Otherwise, increment “retries” property in message, then
reinvoke self

60. Can We Make This More General?

61. AWS Step Functions And Azure Logic Apps
But… They’re Expensive For High-Throughput
Apps

62. We Can Build It Ourselves!
(Let’s Go Back To A Rate Limiting Example!)

63. Recently, We Were Hit With A SPAM Bot On Our
Sign-up Form
Real SPAM Values

64. Signups

65. On Every Sign-Up We Send A Welcome Email
We Don’t Want To Do That For SPAM

66. Dealing With The Immediate Situation
AWS WAF

67. But What If They Change IP Addresses?

68. Can’t Rate Limit By
IP Address…

69. What If We Build Our Own State Machine?

70. 1. Signup Invokes enqueueFunction, Enqueues Message To Queue
2. Enqueued Message Is Delayed 1 Minute
3. dequeueFunction Receives Messages; If More Than N Messages In
Queue (Or DeadLetter), Throws An Error To Send Messages To
DeadLetter, Sends Alert
4. Otherwise, dequeueFunction Sends Welcome Email
Normal Signup Process

71. 5. Human Invokes drainDeadLetter To Move All Caught Messages To
Holding, Unblocking dequeueFunction
6. Human Filters Out SPAM From Holding
7. Human Invokes approveAll To Move Messages From Holding To
Approved
8. dequeueFunction Processes All Approved Messages From Approved
Queue
Manual Approval Process

72. Serverless For The Win!

73. The Sky is The Limit!

74. New VS Code Integration!

75. If You Want To Learn How To Serverless With
Confidence…
Sign Up For Free At
stackery.io

76. Thank You!
Chase Douglas
CTO @ Stackery
chase@stackery.io
Link To Slides Will Be Shared By @txase