Those are my notes for ServelessDays NZ - Auckland, at 24th May 2024.
Sheen Brisals - Think, Architect, and Build Serverless Applications as Set Pieces
During ServerlessDaysNZ Sheen Brisals gave the talk Think, Architect, Build, Sustain Serverless Application Set Pieces. It was full of important insights to Set Pieces and sustain Serverless Applications.
I particularly liked how he touched on the fact that legacy applications being rewritten to Serverless is a thing, as this is everywhere being part of lots of engineers' lives.
More than that, Brisals highlighted how patterns and pivotal for a maintainable and reliable application, despite the execution model:
- Identify Domains so you can decouple a domain to rewrite it more effectively
- Complexity is better abstracted, becoming simpler, when you know and apply good proven Patterns -- the exception is to invent a new one
- Design Patterns, Architecture Patterns, Execution Model patterns, Software Design, etc, will improve the quality of your Application. As Serverless will likely push you to learn them, you have the opportunity to develop as an Architect
- The Serverless should help you to think in the whole picture, as the settled pieces need communication between them, therefore optimising value to the end-user
Unfortunately, I was not selected to win the book Serverless Development on AWS, but for those who won, I wish they could learn a lot there. What a great indication of how good a fellow is Sheen. Giving away those books is a gigantic contribution to the community!
I am very pleased to know you in person, Sheen.
This presentation talked a lot with Michael Walmsley's. So nice.
Heitor Lessa - Let Them Retry: Idempotency for the Rest of Us
Despite being common to talk or to assess if a given application or infrastructure follows best practices and great architectural patterns, implementing this is a challenge for development teams for different reasons.
Heitor Lessa, in his talk "Let Them Retry: Idempotency for the Rest of Us", demonstrates how a tool that improves the Developer Experience bringing the implementation of the patterns close to the code is powerful to win adoption. PowerTools is a developer toolkit to accelerate development providing interfaces and abstractions to implement Serverless best practices.
Heitor used a sample code, emulating an existent codebase, from an application already working in Production. We had the opportunity to see the appeal of PowerTools. Usually, Idempotency (to handle duplicated transactions) is associated with a good amount of change in the code. Still, PowerTools was designed to introduce no or very few impacts to a code that is very dangerous to change. As building blocks, adding more complex functionalities, such as caching, payload tempering and failure mode.
The existence of tools like PowerTools reinforces how implementing good and proven software (and architectural) patterns is pivotal for a scalable and reliable application. The Serverless execution mode can mislead to relaxed code, but that would weaken the performance and stability of an application. The lesson is that working smarter is applying known solutions for specific problems.
PowerTools provides a wide range of functionalities, not surprisingly being able to match Well-Architected frameworks in their implementation: Secrets/System Manager Parameters, Event Source Data Classes, Validation, Feature Flag, Idempotency, Data Masking, Streaming, Middleware, JMESPath, Batch processing, Metrics, Tracing. We avoid writing boilerplates, repeated code and even the need to create a shared lib of constructs ourselves. The community is improving it.
PowerTools is a helpful tool to implement these features. This is an opportunity to learn and deep dive into best practices and designs. It also enhances how you observe and monitor your application. It is a serious tool to consider if you intend to leverage how your code is executed, deployed, monitored and performed.
In his talk, Heitor implemented, live in the meeting, Idempotency into a legacy code. He enriched it with failure modes, caching, payload tampering and order tolerance. So, PowerTools is also very easy and quick to use.
Best practices for everyone
Michael Walmsley - Unleashing Serverless Scalability on AWS: Practical Strategies and Proven Patterns
Some started Michael Walmsley introduction saying "A fantastic human being...". And I will start from there as well because I have experienced that myself.
I bumped into Michael while walking to the conference venue. I first heard about it from a great friend, Joshua Katz, who was impressed with Michael. It was a very pleasant walk while sharing quick impressions of being AWS Community Builders and excitement about the conference.
It happens that Michael is now an AWS Hero with many years of experience to share. One of the first things he said in his talk was replaying Suzana Melo Moraes (you should listen to this girl - so inspiring), who has three years in tech, when she was saying that, mostly every day, she struggles with something usually starting from having no idea how to fix a particular problem she was assigned to solve. Michael sympathised, saying that, even after 30 years, there are days that things happen to him the same way. This happens in everyone involved in this field and it was so humbling coming from him.
As usual, Michael doesn't keep secrets by himself but shares insightful tips. His presentation was about Unleashing Serverless Scalability on AWS:
- Start the design with the needed scalability in mind (can you see that links to Sheen Brassals talk?)
- Master and understand well the limits, they are there for a reason and as early you design your application to work with them, better design your application and scalable-ready it is
- Events, Messages, and Commands are the way of communication for Serverless and a must-know subject
- Do not ignore Flow Control
- Break your application limits before someone else does -- use performance tests in your favour
- Study and use proven patterns (check https://serverlessland.com)
Brad Jacques - Delivering at pace while evolving a Serverless architecture
Brad Jacques delivered a talk titled "Delivering at pace while evolving a Serverless architecture" at ServerlessDays NZ. Brad covered a challenging project where file manipulation use cases were an important feature.
"Complexity is everywhere". Brad could not help it advise that a successful delivery starts from breaking the complexity into pieces, to plan ahead of time and to do the simple things first. He mentioned that the deadline was short, affirming it was the right strategy to evolve the architecture.
He also stressed the use of established patterns for success, such as breaking down complexity, identifying domains and context boundaries, and understanding limits and messaging.
It was also important how the work was planned with the team. Having a small committed team, fast feedback loops and continuous measurement were key to proving the solution was correct.
The summary is so great that I will copy it here entirely:
- Do the simple thing first
- Small teams with a fast feedback loop (showcase often)
- Identify risk early, shift left, and spike
- Continuously measure performance, and stress test
- Isolate context boundaries
- The solution must prove itself correct
Brad's insights were based on his experience with a new project for a major client at a consultancy company. However, it was clear that the principles and strategies he shared apply to any application, in any industry, and of any size.
His parting advice was to "evolve your architecture, measure, and make decisions throughout the process."