Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
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
← Prev
Back
Next →
← Prev
Back
Next →