Assembling production-ready applications using Serverless App Repository

Serverless computing provided us with many great small mechanisms to build and scale our applications.

AWS Serverless Application Repository extended that even more, by enabling developers to share their serverless application "recipes" and provide serverless solutions out-of-the-box, amplifying the speed of development to a matter of days, not sprints.

However, you need to know how to assemble these solutions together along with your specific business logic and deliver production-ready applications.

In this session, we will show you how to design and combine composite serverless applications using AWS Serverless Application Repository.

Learn about potential problems and caveats you might encounter, how to "combine two pieces of a puzzle that don't fit together" and what can you rely on.

Transcript

1. Frankfurt | 26 & 27 September 2018
2. Serverless made our developer life a whole lot easier
3. Less infrastructure to worry about Less scalability issues, quicker TTL Happier customers
4. Though it has incredibly improved,
 building your own serverless applications, from ground up, is still not that easy.
5. And the way we use some of the serverless services can be incredibly repetitive
6. CRM
7. CRM grew more
8. And More! + a lot more as you grow!
9. What do we do when this is the number of tables we have?
11. A serverless variation of the “Groundhog day” - same functionality and logic, different parameter names / objects - identical serverless component compositions - similar delivery expectations
12. As your serverless application grows Many identical functionalities Common patterns emerge
13. Patterns
14. AWS Serverless Application Repository A warehouse for serverless applications and components developed using AWS SAM. (GA early 2018) - Community built and shared component - Instantly deployable - Searchable - Customizable input parameters - Predefined licensing
18. What is, actually, the Serverless Application Repository? a library of Plug and Play components? Is it a list of Chef’s recipes or
20. Currently on Serverless App Repository: - Complete tools - Applications - Complete microservices - Partial services - Examples
21. So how do you use it?
22. Assembling production-ready applications using Serverless App Repository Aleksandar Simovic | 27.09.2018.
23. Aleksandar Simovic Senior Software Engineer at ScienceExchange co-author of “Serverless Applications with Node.js” AWS Serverless Hero co-organizer of JS Belgrade (>1800 members)
24. What we’ll cover, is a lot of questions, on - Designing applications with App Repo - Combining serverless components - Problems and caveats - Building one Serverless App Repo component by yourself
25. (with AppRepo) Designing serverless applications
26. (could be a talk by itself)
27. Imagine the Node.js world without NPM…
 
 Well, thats where we would live right now, in serverless, 
 if it weren’t for Serverless App Repository.
28. The Design Context - Components consist of AWS resources also, not only code. - Orchestration and deployment - Versioning - Stages - Trust Serverless AppRepo != NPM, Github
29. Design obstacles - Do we fit it within our architecture? - Do we orientate ourselves around the given components?
 - Does its resource composition or folder structure suit us? - What does it mean to deploy the component along with its stack?
 - If so? How do we orchestrate?
30. Design obstacles - Align with your own architecture. - Parametrized NPM approach.
 - Component structure is only important in the context of resources used.
 - At the moment, components are deployed as a separate stack. Will change in the future. (though you can improvise and you should)
31. Design Process - How do we design such systems considering App Repo?
 - How do you plan and develop?
 - How do you estimate them?
32. Design Process 1. Requirements 2. Process Decomposition (SSD, BPMN can help) 3. Translation to AWS Terms (requires AWS Aware*) 4. Assess and use adequate components 5. Develop
33. Process Decomposition 1. Requirement 2. User Story 3. Complex Business Process 4. Simple Business Process 5. AWS AppRepo Component / Custom built component
34. Does one serverless component equal to one simple process? • Mechanical engineering has solved these problems awhile ago. • Components are not constrained by a single purpose. • A component can be both simple and complex. (bolts and water pumps)
35. Architecture design depends greatly on best practices
36. Also known as “some of our previous relationships” Combining serverless components “Two pieces of puzzle that don’t fit together”
37. How do we connect our components? - data formats - resources - avoid duplicating components - use conditional component resources We don’t need to care about resource protocols, but we do need to care about:
38. Scenarios - All services custom built (HERE) - Custom built + single independent serverless component - Custom built + multiple independent serverless components - Custom built + multiple connected serverless components - Building everything from serverless components (Is it possible?)
39. Your combined AppRepo component is deleted. - How are we handling such risk? - Are our services going to collapse? - What happens to our data? - How do you backup?
40. Your combined AppRepo component is deleted. - Deployed stacks are not deletable. 
 - Unpublishing a component, has no effect on your currently deployed apps.
 - If you delete this stack - there are AWS mechanisms to prevent deletion. (S3)
 - Your data is safe.
41. Problems and caveats
42. Performance - What is the performance of a serverless component? - We have no data for different scenarios for a single, average or mass use? - How does it scale? - Does it have limitations and are those handled? (e.g. Kinesis Firehose 2MB/shard)
43. Bills - Resource Consumption - How do we know the cost of a serverless component? - When we scale, how does our cost scale?
 

44. Testing - How do we check if it was properly tested from the beginning? - How do we approach testing other people’s serverless components? - Code? - Infrastructure? - How do we combine testing? - Tools - Frameworks? - Coverage - Different approaches? - CI, CD?
45. Errors - How do we handle errors from such components? - Tracking errors - What if this component produces errors?
46. Metrics and Monitoring - How do we measure if a certain component is behaving as intended? - What are the metrics of a single component? - Tracking its usage?
47. Security - What are the component’s permissions and policies? - Can you deny some? - How do we know if it has a security flaw? - Leaking information?
48. Standardization - Shared issues with NPM and GitHub - There is no certification process, at the moment. (should there be one?) - Trust factor. - AWS ownership brings expected service standardization. (Community)
49. How do we approach and tackle these problems in production - The design process, decompose all business processes - Track components that suit a process - Analyze each potential component candidate, its resources, composition - Analyze the code and tests, run them - Use a test account, with Billing Alerts - Deploy at the application development account
50. Building a Serverless App Repo component by yourself
51. A component’s components - AWS SAM Template (with SAM local) - Any language - Restricted policy list - AWS Resources supported by the policy list - License - Source Code URL
54. Key Takeaways - You don’t need to manually write each and every service, over and over again.
 - App Repo components save an immense amount of time.
 - When designing with AppRepo, decompose everything to a simple process.
 - Though very young, AppRepo is safe and actively in development and you can greatly benefit from it in production. - Analyze each and every component carefully, scalability, its limitations and cost.
55. Thank you!
56. Just for AWS Community Days
 our book discount code:
 
 claudia40
 
 More at:
 effortless-serverless.com 
 
 Twitter:
 @simalexan Q&A