Book Image

Serverless Design Patterns and Best Practices

By : Brian Zambrano
Book Image

Serverless Design Patterns and Best Practices

By: Brian Zambrano

Overview of this book

Serverless applications handle many problems that developers face when running systems and servers. The serverless pay-per-invocation model can also result in drastic cost savings, contributing to its popularity. While it's simple to create a basic serverless application, it's critical to structure your software correctly to ensure it continues to succeed as it grows. Serverless Design Patterns and Best Practices presents patterns that can be adapted to run in a serverless environment. You will learn how to develop applications that are scalable, fault tolerant, and well-tested. The book begins with an introduction to the different design pattern categories available for serverless applications. You will learn thetrade-offs between GraphQL and REST and how they fare regarding overall application design in a serverless ecosystem. The book will also show you how to migrate an existing API to a serverless backend using AWS API Gateway. You will learn how to build event-driven applications using queuing and streaming systems, such as AWS Simple Queuing Service (SQS) and AWS Kinesis. Patterns for data-intensive serverless application are also explained, including the lambda architecture and MapReduce. This book will equip you with the knowledge and skills you need to develop scalable and resilient serverless applications confidently.

Related Content you might be interested in

Current Title:

Small book image
Serverless Design Patterns and Best Practices
Brian Zambrano
Apr, 2018 | 260 pages
Small book image
Writing API Tests with Karate
Benjamin Bischoff
May, 2023 | 326 pages
Small book image
DevOps for Serverless Applications
Shashikant Bangera
Sep, 2018 | 264 pages
Small book image
JavaScript Cloud Native Development Cookbook
John Gilbert
Sep, 2018 | 352 pages
Table of Contents (18 chapters)
Title Page
Title Page
Copyright and Credits
Copyright and Credits
Dedication
Dedication
Packt Upsell
Packt Upsell
Contributors
Contributors
Preface
Preface
Free Chapter
1
Introduction
Introduction
What is serverless computing?
Design patterns
When to use serverless
Classes of serverless pattern
Serverless frameworks
Summary
2
A Three-Tier Web Application Using REST
A Three-Tier Web Application Using REST
Serverless tooling
System architecture
Logic layer
Presentation layer
Data layer
Writing our logic layer
Deploying the REST API
Deploying the Postgres database
Setting up static assets
Viewing the deployed web application
Running tests
Iteration and deployment
Summary
3
A Three-Tier Web Application Pattern with GraphQL
A Three-Tier Web Application Pattern with GraphQL
Introduction to GraphQL
System architecture
Logic layer
Presentation layer
Writing the logic layer
Deployment
Viewing the deployed application
Iteration and deployment
Summary
4
Integrating Legacy APIs with the Proxy Pattern
Integrating Legacy APIs with the Proxy Pattern
AWS API Gateway introduction
Simple proxy to a legacy API
Transforming responses from a modern API
Complex integration using a Lambda function
Migration techniques
Summary
5
Scaling Out with the Fan-Out Pattern
Scaling Out with the Fan-Out Pattern
System architecture
Resizing images in parallel
Alternate Implementations
Summary
6
Asynchronous Processing with the Messaging Pattern
Asynchronous Processing with the Messaging Pattern
Basics of queuing systems
Asynchronous processing of Twitter streams
Alternate Implementations
Summary
7
Data Processing Using the Lambda Pattern
Data Processing Using the Lambda Pattern
Introducing the lambda architecture
Lambda serverless architecture
Processing cryptocurrency prices using lambda architecture
Results
Summary
8
The MapReduce Pattern
The MapReduce Pattern
Introduction to MapReduce
MapReduce serverless architecture
Processing Enron emails with serverless MapReduce
Understanding the limitations of serverless MapReduce
Exploring alternate implementations
Summary
9
Deployment and CI/CD Patterns
Deployment and CI/CD Patterns
Introduction to CI/CD
Setting up unit tests
Setting up CI with CircleCI
Setting up CD and deployments with CircleCI
Summary
10
Error Handling and Best Practices
Error Handling and Best Practices
Error tracking
Logging
Cold starts
Local development and testing
Managing different environments
Securing sensitive configuration
Trimming AWS Lambda versions
Summary
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

System architecture

Our system architecture, at a high level, will be the same as in the REST API version of our sample application. Requests from the web will hit the CloudFront CDN, which is backed by S3. Our JavaScript code from the served-up HTML files will query the serverless API, which itself will communicate with the RDS-backed data layer:

Thinking through this application from a top-down approach, the steps in fetching data will be the same regardless of how the logic layer is implemented:

  • End-user requests a website
  • Static assets are served to the user from CloudFront and S3
  • Static assets request data via logic layer/web APIs (GraphQL in this case)
  • Logic layer fetches/writes data from/to Postgres database in the data layer

Moving our example web application from a REST design to GraphQL means focusing on the logic layer, as the presentation and data layers won't change much, if at all. Of course, any changes to our API mean that our presentation layer (that is, the client) will need...

Previous Section
End of Section 3
Next Section