最新章節

• Summary
• Monitoring efficiency
• Monitoring performance
• Handling errors
• Streaming Lambda logs
• Retrieving metrics with the Serverless Framework

• Summary 更新時間：2021-07-15 17:32:24
• Monitoring efficiency
• Monitoring performance
• Handling errors
• Streaming Lambda logs
• Retrieving metrics with the Serverless Framework
• Monitoring errors
• Monitoring costs
• Monitoring the operation
• Keeping your functions warm
• Test data
• Being careful with the production environment
• Creating staging environments
• Rollback a deployment
• Dropping a table or column
• Renaming a table or column
• Creating a new table or column
• Deploying new versions with a different database model
• Blue-green deployment
• Development workflow
• Deploying your application
• Simulating AWS services locally
• Testing the frontend
• Using Sinon.JS for mocking
• Mocking external services
• Unit testing Lambda functions
• Testing your solution
• Testing Deploying and Monitoring
• Summary
• Sending IoT messages with Lambda
• Passing the Cognito Identity to the Lambda function
• Attaching an IoT policy and connecting
• Creating an IoT policy
• Updating the logout feature
• Using credentials of an authenticated user
• Private notifications
• Triggering a Lambda function with IoT
• Sending and receiving new comments
• Creating a new instance of the IoT SDK
• Updating the list of comments
• Adding a comment box
• Public notifications
• Implementing serverless notifications
• AWS IoT SDK
• Finding the IoT endpoint
• Protocols
• AWS IoT
• Handling Serverless Notifications
• Summary
• Handling authentication in Lambda functions
• Logging out
• Persisting the user token
• The Login page
• The Signup page
• Using Cognito in our serverless store
• Creating an identity pool
• Creating a user pool
• Amazon Cognito
• Handling authentication and authorization
• MFA
• AWS CloudTrail
• Pen testing
• The Trusted Advisor tool
• Shared responsibility model
• Security on AWS
• Availability
• Non-repudiation
• Integrity
• Confidentiality
• Authorization
• Authentication
• Information security
• Security basics
• Securing the Serverless Application
• Summary
• Using S3 versioning
• Backing up and restoring data
• Enabling CORS
• Uploading and downloading files
• Amazon S3 (for media files)
• Processing the checkout
• Saving the user's shopping cart
• Retrieving the user's shopping cart
• Retrieving all products
• Improving the serverless store
• Controlling user access
• Backing up and restoring data
• Auto scaling
• Provisioned throughput
• Managing the database
• Performance and concurrency
• The query method
• The scan method
• Querying data
• The Document Client API
• Inserting data
• Inserting and querying data
• Limits
• Creating a table
• Modeling the database
• DynamoDB
• Controlling user access
• Backing up and restoring data
• Managing the database
• Performance and concurrency
• Inserting and querying data
• Limits
• Creating a domain
• Handling dates
• Handling Booleans
• Handling numbers
• Handling one-to-many relations
• Modeling the database
• Amazon SimpleDB
• Managing a Serverless Database
• Summary
• Checking out
• Saving the Shopping Cart
• Retrieving all products
• Implementing the Lambda functions
• Handling HTTP responses
• Routing the HTTP verbs
• RESTful APIs
• Setting the endpoints
• Using multiple services
• Referencing Lambda functions in other folders
• Organizing the code
• Defining the functionalities
• Developing the backend
• Naming differences
• Graph
• Monolith
• Microservices
• Nanoservices
• Monolith versus Microservices
• Defining the project architecture
• Developing the Backend
• Summary
• The error pages
• The Login and Signup pages
• The Shopping Cart page
• The product details page
• The Home page
• The Navbar component
• Building an online store
• Rendering on the fly
• Using the Lambda functions for prerendering
• Using PhantomJS
• Prerendering pages
• Considerations
• Cons
• Pros
• Pros and cons of Single-Page Applications
• Single-Page Applications
• Using the query parameters
• Linking pages
• Handling the page routes
• Sending data to the server
• Retrieving data from the server
• Making Ajax requests
• Publishing our demo
• The Cart Item component
• The Shopping Cart component
• The Product component
• The Product List component
• The App component
• Implementing a component
• Composing components
• Organizing the solution
• Preparing the development environment
• Building a shopping cart
• React hello-world
• The Flux pattern
• React principles
• Getting started with React
• Building the Frontend
• Summary
• Configuring CloudFront to support HTTPS connections
• Requesting free certificates with AWS Certificate Manager
• Creating a mail exchange record
• Supporting HTTPS
• Updating Route 53 to use CloudFront
• Invalidating client-side cache
• Invalidating server-side cache
• Handling CloudFront caching
• Creating a distribution
• Setting up CloudFront
• Creating record sets
• Creating a hosted zone
• Setting up Route 53
• Serving gzip files
• Automating website publishing
• Uploading static files
• Supporting www anchors
• Prerendering pages
• Delegating to CloudFront
• Using an error document
• Using redirection rules
• Handling errors
• Enabling web hosting
• Creating a bucket
• Serving static files with Amazon S3
• Hosting the Website
• Summary
• Scaffolding
• Showing deployment information
• Plugins
• Using configuration variables
• Serving HTML pages with Lambda
• Schedule events
• The S3 event
• Events
• Accessing other AWS resources
• Using npm packages
• Going beyond the basics
• Removing a service
• Cross-Origin Resource Sharing
• Adding endpoints
• Retrieving logs
• Invoking a function
• Deploying a service
• Configuring the Lambda limits
• The serverless.yml file
• The handler.js file
• Creating a new project
• Managing permissions in a team
• Configuring the framework
• Installing the framework
• Other frameworks
• Understanding the Serverless Framework
• Serverless Framework
• Using the Serverless Framework
• Summary
• Total pricing
• DynamoDB
• SimpleDB pricing
• Lambda pricing
• API Gateway pricing
• CloudWatch pricing
• SNS pricing
• IoT pricing
• Cognito pricing
• IAM pricing
• Certificate Manager pricing
• CloudFront pricing
• S3 pricing
• Route 53 pricing
• Assumptions
• Estimating costs
• The serverless architecture of our online store
• Amazon DynamoDB
• Amazon SimpleDB
• Database services
• Expose your Lambda function using API Gateway
• Amazon API Gateway
• Creating a Lambda function
• AWS Lambda
• Backend services
• AWS IoT
• Amazon SNS
• Messaging and notifications
• AWS Certificate Manager
• Amazon CloudFront
• Amazon Route 53
• Using S3 with the CLI
• Amazon S3
• Frontend services
• Amazon CloudWatch
• AWS CloudFormation
• AWS CLI
• AWS SDKs
• AWS Management Console
• Managing AWS resources
• Amazon Cognito
• Sign in with a non-root user account
• Creating users and groups
• AWS IAM
• Handling user accounts and security
• Amazon Web Services
• Getting Started with AWS
• Summary
• What you should avoid
• Big Data
• Scheduled events
• IoT backends
• Chatbots
• Triggered processing
• Temporary websites
• Small e-commerce websites
• Lean websites
• Static websites
• Use cases
• Uncertainties
• Atomic deploys
• Debugging difficulties
• Vendor dependency
• Hidden inefficiencies
• Constraints
• Higher latency
• Cons
• Cost model
• Microservices friendly
• Continuous delivery
• System security
• Focus on business
• Reduced operational costs
• Pros
• The pros and cons of serverless
• Cost efficiency
• Availability
• Scalability
• The main goals of serverless
• IaaS and On-Premises
• Serverless and PaaS
• Thinking serverless
• Introducing serverless
• Understanding the Serverless Model
• Questions
• Piracy
• Errata
• Downloading the color images of this book
• Downloading the example code
• Customer support
• Reader feedback
• Conventions
• Who this book is for
• What you need for this book
• What this book covers
• Preface
• Customer Feedback
• Why subscribe?
• www.PacktPub.com
• About the Reviewer
• About the Author
• Credits
• Building Serverless Web Applications
• Copyright
• Title Page
• cover

• cover
• 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 更新時間：2021-07-15 17:32:24