Building Serverless Web Applications电子书

Title Page

Copyright

Building Serverless Web Applications

Credits

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Understanding the Serverless Model

Introducing serverless

Thinking serverless

Serverless and PaaS

IaaS and On-Premises

The main goals of serverless

Scalability

Availability

Cost efficiency

The pros and cons of serverless

Pros

Reduced operational costs

Focus on business

System security

Continuous delivery

Microservices friendly

Cost model

Cons

Higher latency

Constraints

Hidden inefficiencies

Vendor dependency

Debugging difficulties

Atomic deploys

Uncertainties

Use cases

Static websites

Lean websites

Small e-commerce websites

Temporary websites

Triggered processing

Chatbots

IoT backends

Scheduled events

Big Data

What you should avoid

Summary

Getting Started with AWS

Amazon Web Services

Handling user accounts and security

AWS IAM

Creating users and groups

Sign in with a non-root user account

Amazon Cognito

Managing AWS resources

AWS Management Console

AWS SDKs

AWS CLI

AWS CloudFormation

Amazon CloudWatch

Frontend services

Amazon S3

Using S3 with the CLI

Amazon Route 53

Amazon CloudFront

AWS Certificate Manager

Messaging and notifications

Amazon SNS

AWS IoT

Backend services

AWS Lambda

Creating a Lambda function

Amazon API Gateway

Expose your Lambda function using API Gateway

Database services

Amazon SimpleDB

Amazon DynamoDB

The serverless architecture of our online store

Estimating costs

Assumptions

Route 53 pricing

S3 pricing

CloudFront pricing

Certificate Manager pricing

IAM pricing

Cognito pricing

IoT pricing

SNS pricing

CloudWatch pricing

API Gateway pricing

Lambda pricing

SimpleDB pricing

DynamoDB

Total pricing

Summary

Using the Serverless Framework

Serverless Framework

Understanding the Serverless Framework

Other frameworks

Installing the framework

Configuring the framework

Managing permissions in a team

Creating a new project

The handler.js file

The serverless.yml file

Configuring the Lambda limits

Deploying a service

Invoking a function

Retrieving logs

Adding endpoints

Cross-Origin Resource Sharing

Removing a service

Going beyond the basics

Using npm packages

Accessing other AWS resources

Events

The S3 event

Schedule events

Serving HTML pages with Lambda

Using configuration variables

Plugins

Showing deployment information

Scaffolding

Summary

Hosting the Website

Serving static files with Amazon S3

Creating a bucket

Enabling web hosting

Handling errors

Using redirection rules

Using an error document

Delegating to CloudFront

Prerendering pages

Supporting www anchors

Uploading static files

Automating website publishing

Serving gzip files

Setting up Route 53

Creating a hosted zone

Creating record sets

Setting up CloudFront

Creating a distribution

Handling CloudFront caching

Invalidating server-side cache

Invalidating client-side cache

Updating Route 53 to use CloudFront

Supporting HTTPS

Creating a mail exchange record

Requesting free certificates with AWS Certificate Manager

Configuring CloudFront to support HTTPS connections

Summary

Building the Frontend

Getting started with React

React principles

The Flux pattern

React hello-world

Building a shopping cart

Preparing the development environment

Organizing the solution

Composing components

Implementing a component

The App component

The Product List component

The Product component

The Shopping Cart component

The Cart Item component

Publishing our demo

Making Ajax requests

Retrieving data from the server

Sending data to the server

Handling the page routes

Linking pages

Using the query parameters

Single-Page Applications

Pros and cons of Single-Page Applications

Pros

Cons

Considerations

Prerendering pages

Using PhantomJS

Using the Lambda functions for prerendering

Rendering on the fly

Building an online store

The Navbar component

The Home page

The product details page

The Shopping Cart page

The Login and Signup pages

The error pages

Summary

Developing the Backend

Defining the project architecture

Monolith versus Microservices

Nanoservices

Microservices

Monolith

Graph

Naming differences

Developing the backend

Defining the functionalities

Organizing the code

Referencing Lambda functions in other folders

Using multiple services

Setting the endpoints

RESTful APIs

Routing the HTTP verbs

Handling HTTP responses

Implementing the Lambda functions

Retrieving all products

Saving the Shopping Cart

Checking out

Summary

Managing a Serverless Database

Amazon SimpleDB

Modeling the database

Handling one-to-many relations

Handling numbers

Handling Booleans

Handling dates

Creating a domain

Limits

Inserting and querying data

Performance and concurrency

Managing the database

Backing up and restoring data

Controlling user access

DynamoDB

Modeling the database

Creating a table

Limits

Inserting and querying data

Inserting data

The Document Client API

Querying data

The scan method

The query method

Performance and concurrency

Managing the database

Provisioned throughput

Auto scaling

Backing up and restoring data

Controlling user access

Improving the serverless store

Retrieving all products

Retrieving the user's shopping cart

Saving the user's shopping cart

Processing the checkout

Amazon S3 (for media files)

Uploading and downloading files

Enabling CORS

Backing up and restoring data

Using S3 versioning

Summary

Securing the Serverless Application

Security basics

Information security

Authentication

Authorization

Confidentiality

Integrity

Non-repudiation

Availability

Security on AWS

Shared responsibility model

The Trusted Advisor tool

Pen testing

AWS CloudTrail

MFA

Handling authentication and authorization

Amazon Cognito

Creating a user pool

Creating an identity pool

Using Cognito in our serverless store

The Signup page

The Login page

Persisting the user token

Logging out

Handling authentication in Lambda functions

Summary

Handling Serverless Notifications

AWS IoT

Protocols

Finding the IoT endpoint

AWS IoT SDK

Implementing serverless notifications

Public notifications

Adding a comment box

Updating the list of comments

Creating a new instance of the IoT SDK

Sending and receiving new comments

Triggering a Lambda function with IoT

Private notifications

Using credentials of an authenticated user

Updating the logout feature

Creating an IoT policy

Attaching an IoT policy and connecting

Passing the Cognito Identity to the Lambda function

Sending IoT messages with Lambda

Summary

Testing, Deploying, and Monitoring

Testing your solution

Unit testing Lambda functions

Mocking external services

Using Sinon.JS for mocking

Testing the frontend

Simulating AWS services locally

Deploying your application

Development workflow

Blue-green deployment

Deploying new versions with a different database model

Creating a new table or column

Renaming a table or column

Dropping a table or column

Rollback a deployment

Creating staging environments

Being careful with the production environment

Test data

Keeping your functions warm

Monitoring the operation

Monitoring costs

Monitoring errors

Retrieving metrics with the Serverless Framework

Streaming Lambda logs

Handling errors

Monitoring performance

Monitoring efficiency

Summary