舉報(bào) 
會(huì)員
Building Serverless Web Applications
Diego Zanon 著
更新時(shí)間：2021-07-15 17:32:24
開(kāi)會(huì)員，本書(shū)免費(fèi)讀 >
最新章節(jié)：
Summary
Ifyou’relookingtolearnmoreaboutscalableandcost-efficientarchitectures,thisbookisforyou.BasicknowledgeofNode.jsskillsorfamiliaritywithcloudservicesisrequired.Forothertopics,wecoverthebasics.
最新章節(jié)
- Summary
- Monitoring efficiency
- Monitoring performance
- Handling errors
- Streaming Lambda logs
- Retrieving metrics with the Serverless Framework
品牌：中圖公司
上架時(shí)間：2021-07-15 17:00:37
出版社：Packt Publishing
本書(shū)數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Summary 更新時(shí)間：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 更新時(shí)間：2021-07-15 17:32:24
