This is a high-level overview of the Node.js landscape. The reader will have taken the first steps in using Node.js.
This section comprises the following chapters:
- Title Page
- Copyright and Credits
- Dedication
- About Packt
- Contributors
- Preface
- Section 1: Introduction to Node.js
- About Node.js
- Overview of Node.js
- The capabilities of Node.js
- What are folks doing with Node.js?
- Server-side JavaScript
- Why should you use Node.js?
- Popularity
- JavaScript everywhere
- Leveraging Google's investment in V8
- Leaner, asynchronous, event-driven model
- Microservice architecture
- Node.js is stronger after a major schism and hostile fork
- The Node.js event-driven architecture
- The Node.js answer to complexity
- Asynchronous requests in Node.js
- Performance and utilization
- Is Node.js a cancerous scalability disaster?
- Server utilization, overhead costs, and environmental impact
- Embracing advances in the JavaScript language
- Deploying ES2015/2016/2017/2018 JavaScript code
- TypeScript and Node.js
- Developing microservices or maxiservices with Node.js
- Summary
- Setting Up Node.js
- System requirements
- Installing Node.js using package managers
- Installing Node.js on macOS with MacPorts
- Installing Node.js on macOS with Homebrew
- Installing Node.js on Linux, *BSD, or Windows from package management systems
- Installing Node.js in WSL
- Opening an administrator-privileged PowerShell on Windows
- Installing the Node.js distribution from nodejs.org
- Installing from the source on POSIX-like systems
- Installing prerequisites
- Installing developer tools on macOS
- Installing from the source for all POSIX-like systems
- Installing from the source on Windows
- Installing multiple Node.js instances with nvm
- Installing nvm on Windows
- Requirements for installing native code modules
- Choosing Node.js versions to use and the version policy
- Choosing editors and debuggers for Node.js
- Running and testing commands
- Using Node.js's command-line tools
- Running a simple script with Node.js
- Writing inline async arrow functions
- Converting to async functions and the Promise paradigm
- Launching a server with Node.js
- Using npm, the Node.js package manager
- Using npx to execute Node.js packaged binaries
- Advancing Node.js with ECMAScript 2015, 2016, 2017, and beyond 
- Using Babel to use experimental JavaScript features
- Summary
- Exploring Node.js Modules
- Defining a Node.js module
- Examining the traditional Node.js module format
- Examining the ES6/ES2015 module format
- Injected objects in ES6 modules
- Computing the missing<span> </span>__dirname<span> </span>variable in ES6 modules
- Using CommonJS and ES6 modules together
- Using ES6 modules from CommonJS using import()
- Hiding implementation details with encapsulation in CommonJS and ES6 modules
- <span>Using JSON modules</span>
- Supporting ES6 modules on older Node.js versions
- Finding and loading modules using require and import
- Understanding File modules
- The ES6 import statement takes a URL
- Understanding the Node.js core modules
- Using a directory as a module
- Comparing installed packages and modules
- Finding the installed package in the file system 
- Handling multiple versions of the same installed package
- Searching for globally installed packages
- Reviewing module identifiers and pathnames
- Using deep import module specifiers
- Overriding a deep import module identifier
- Studying an example project directory structure
- Loading modules using require, import, and import()
- Using npm – the Node.js package management system
- The npm package format
- Accessing npm helpful documentation
- Initializing a Node.js package or project with npm init
- Finding npm packages
- The package.json fields that help finding packages
- Installing an npm package
- Installing a package by version number
- Installing packages from outside the npm repository
- Global package installs
- Avoiding global module installation
- <span>Maintaining package dependencies with npm</span>
- Automatically updating package.json dependencies
- Fixing bugs by updating package dependencies
- Explicitly specifying package dependency version numbers
- Packages that install commands
- Configuring the PATH variable to handle locally installed commands
- Configuring the PATH variable on Windows
- Avoiding modifications to the PATH variable
- <span>Updating packages you've installed when they're outdated</span>
- Automating tasks with scripts in package.json
- Declaring Node.js version compatibility
- Publishing an npm package
- The Yarn package management system
- Summary
- HTTP Servers and Clients
- Sending and receiving events with EventEmitter
- JavaScript classes and class <span><span>i</span></span>nheritance
- The EventEmitter class
- The EventEmitter theory
- Understanding HTTP server applications
- ES2015 multiline and template strings
- HTTP Sniffer – listening to the HTTP conversation
- Web application frameworks
- Getting started with Express
- <span>Setting environment variables in the Windows cmd.exe command line</span>
- Walking through the default Express application
- Understanding Express middleware
- Contrasting middleware and request handlers
- Error handling
- Creating an Express application to compute Fibonacci numbers
- Computationally intensive code and the Node.js event loop
- Algorithmic refactoring
- Making HTTPClient requests
- Calling a REST backend service from an Express application
- Implementing a simple REST server with Express
- Refactoring the Fibonacci application to call the REST service
- Some RESTful modules and frameworks
- Summary
- Section 2: Developing the Express Application
- Your First Express Application
- Exploring Promises and async functions in Express router functions
- Promises and error handling in Express router functions
- Integrating async functions with Express router functions
- Architecting an Express application in the MVC paradigm
- Creating the Notes application
- Rewriting the generated router module as an ES6 module
- Creating the Notes application wiring – app.mjs
- Implementing the Notes data storage model
- Data hiding in ES-2015 class definitions
- Implementing an in-memory Notes datastore
- The Notes home page
- Adding a new note – create
- Viewing notes – read
- Editing an existing note – update
- Deleting notes – destroy
- Theming your Express application
- Scaling up – running multiple Notes instances
- Summary
- Implementing the Mobile-First Paradigm
- Understanding the problem – the Notes app isn't mobile-friendly
- Learning the mobile-first paradigm theory
- Using Twitter Bootstrap on the Notes application
- Setting up Bootstrap
- Adding Bootstrap to the Notes application
- Alternative layout frameworks
- Flexbox and CSS Grids
- Mobile-first design for the Notes application
- Laying the Bootstrap grid foundation
- Responsive page structure for the Notes application
- Using icon libraries and improving visual appeal
- Responsive page header navigation bar
- Improving the Notes list on the front page
- Cleaning up the note viewing experience
- Cleaning up the add/edit note form
- Cleaning up the delete-note window
- Customizing a Bootstrap build
- Using third-party custom Bootstrap themes
- Summary
- Data Storage and Retrieval
- Remembering that data storage requires asynchronous code
- Logging and capturing uncaught errors
- Request logging with morgan
- Debugging messages
- Capturing stdout and stderr
- Capturing uncaught exceptions and unhandled rejected Promises
- Storing notes in a filesystem
- Dynamically importing ES6 modules
- Running the Notes application with filesystem storage
- Storing notes with the LevelDB datastore
- Closing database connections when closing the process
- Storing notes in SQL with SQLite3
- The SQLite3 database schema
- The SQLite3 model code
- Running Notes with SQLite3
- Storing notes the ORM way with Sequelize
- Configuring Sequelize and connecting to a database
- Creating a Sequelize model for the Notes application
- Running the Notes application with Sequelize
- Storing notes in MongoDB
- A MongoDB model for the Notes application
- Running the Notes application with MongoDB
- Summary
- Authenticating Users with a Microservice
- Creating a user information microservice
- Developing the user information model
- Creating a REST server for user information
- Creating a command-line tool to test and administer the user authentication server
- Creating a user in the user information database
- Reading user data from the user information service
- Updating user information in the user information service
- Deleting a user record from the user information service
- Checking the user's password in the user information service
- Providing login support for the Notes application
- Accessing the user authentication REST API
- Incorporating login and logout routing functions in the Notes application
- Login/logout changes to app.mjs
- Login/logout changes in routes/index.mjs
- Login/logout changes required in routes/notes.mjs
- Viewing template changes supporting login/logout
- Running the Notes application with user authentication
- Providing Twitter login support for the Notes application
- Registering an application with Twitter
- Storing authentication tokens
- Implementing TwitterStrategy
- Keeping secrets and passwords secure
- Adding password encryption to the user information service
- Implementing encrypted password support in the Notes application
- Running the Notes application stack
- Summary
- Dynamic Client/Server Interaction with Socket.IO
- Introducing Socket.IO
- Initializing Socket.IO with Express
- Real-time updates on the Notes homepage
- Refactoring the NotesStore classes to emit events
- Real-time changes in the Notes home page
- Changing the home page and layout templates
- Adding a Socket.IO client to the Notes home page
- Running Notes with real-time home page updates
- A word on enabling debug tracing in Socket.IO code
- Real-time action while viewing notes
- Changing the note view template for real-time action
- Running Notes with pseudo-real-time updates while viewing a note
- Inter-user chat and commenting for Notes
- Data model for storing messages
- Adding support for messages to the Notes router
- Changing the note view template for messages
- Composing messages on the Note view page
- Showing any existing messages on the Note view page
- Deleting messages on the Notes view page
- Running Notes and passing messages
- Summary
- Section 3: Deployment
- Deploying Node.js Applications to Linux Servers
- Notes application architecture and deployment considerations
- Traditional Linux deployment for Node.js services
- Installing Multipass
- Handling a failure to launch Multipass instances on Windows
- Provisioning a server for the user authentication service
- Testing the deployed user authentication service
- Script execution in PowerShell on Windows
- Provisioning a server for the Notes service
- Adjusting Twitter authentication to work on the server
- Setting up PM2 to manage Node.js processes
- Familiarizing ourselves with PM2
- Scripting the PM2 setup on Multipass
- Integrating the PM2 setup as persistent background processes
- Summary
- Deploying Node.js Microservices with Docker
- Setting up Docker on your laptop or computer
- Installing and starting Docker with Docker for Windows or macOS
- Familiarizing ourselves with Docker
- Setting up the user authentication service in Docker
- Launching a MySQL container in Docker
- The ephemeral nature of Docker containers
- Defining the Docker architecture for the authentication service
- Creating the MySQL container for the authentication service
- Security in the database container
- Dockerizing the authentication service
- Creating the authentication service Dockerfile 
- Building and running the authentication service Docker container
- Exploring<span> </span>AuthNet
- Creating FrontNet for the Notes application
- MySQL container for the<span> </span>Notes application
- Dockerizing the Notes application
- Managing multiple containers with Docker Compose
- Docker Compose file for the Notes stack
- Building and running the Notes application with Docker Compose
- Using Redis for scaling the Notes application stack
- Testing session management with multiple Notes service instances
- Storing Express/Passport<span> </span>session data in a Redis server
- Distributing Socket.IO messages using Redis
- Summary
- Deploying a Docker Swarm to AWS EC2 with Terraform
- Signing up with AWS and configuring the AWS CLI
- Finding your way around the AWS account
- Setting up the AWS CLI using<span> </span>AWS authentication credentials
- Creating an IAM user account, groups, and roles
- Creating an EC2 key pair
- An overview of the AWS infrastructure to be deployed
- Using Terraform to create an AWS infrastructure
- Configuring an AWS VPC with Terraform
- Configuring the AWS gateway and subnet resources
- Deploying the infrastructure to AWS using Terraform
- Setting up a Docker Swarm cluster on AWS EC2
- Deploying a single-node Docker Swarm on a single EC2 instance
- Adding an EC2 instance and configuring Docker
- Launching the EC2 instance on AWS
- Handling the AWS EC2 key-pair file
- Testing the initial Docker Swarm
- Setting up remote control access to a Docker Swarm hosted on EC2
- Setting up ECR repositories for Notes Docker images
- Using environment variables for AWS CLI commands
- Defining a process to build Docker images and push them to the AWS ECR
- Creating a Docker stack file for deployment to Docker Swarm
- Creating a Docker stack file from the Notes Docker compose file
- Placing containers across the swarm
- Configuring secrets in Docker Swarm
- Persisting data in a Docker swarm
- Provisioning EC2 instances for a full Docker swarm
- Configuring EC2 instances and connecting to the swarm
- Implementing semi-automatic initialization of the Docker Swarm
- Preparing the Docker Swarm before deploying the Notes stack
- Deploying the Notes stack file to the swarm
- Preparing to deploy the Notes stack to the swarm
- Deploying the Notes stack to the swarm
- Verifying the correct launch of the Notes application stack
- Diagnosing a failure to launch the database services
- Testing the deployed Notes application
- Logging in with a regular account on Notes
- Diagnosing an inability to log in with Twitter credentials
- Scaling the Notes instances
- Summary
- Unit Testing and Functional Testing
- Assert <span>–</span> the basis of testing methodologies
- Testing a Notes model
- Mocha and Chai <span>–</span> the chosen test tools
- Notes model test suite
- Creating the initial Notes model test case
- Running the first test case
- Adding some tests
- More tests for the Notes model
- Diagnosing test failures
- Testing against databases that require server setup <span>–</span> MySQL and MongoDB
- Using Docker Swarm to manage test infrastructure
- Using Docker Swarm to deploy test infrastructure
- Executing tests under Docker Swarm
- MongoDB setup under Docker and testing Notes against MongoDB
- Testing REST backend services
- Automating test results reporting
- <span>Frontend headless browser testing with Puppeteer</span>
- Setting up a Puppeteer-based testing project directory
- Creating an initial Puppeteer test for the Notes application stack
- Executing the initial Puppeteer test
- Testing login/logout functionality in Notes
- Testing the ability to add Notes
- Implementing negative tests with Puppeteer
- Testing login with a bad user ID
- Testing a response to a bad URL 
- Improving testability in the Notes UI
- Summary
- Security in Node.js Applications
- Implementing HTTPS in Docker for deployed Node.js applications
- Assigning a domain name for an application deployed on AWS EC2
- Updating the Twitter application
- Planning how to use Let's Encrypt
- Using NGINX and Let's Encrypt in Docker to implement HTTPS for Notes
- Adding the Cronginx container to support HTTPS on Notes
- Creating an NGINX configuration to support registering domains with Let's Encrypt
- Adding the required directories on the EC2 host
- Deploying the EC2 cluster and Docker swarm
- Registering a domain with Let's Encrypt
- Implementing an NGINX HTTPS configuration using Let's Encrypt certificates
- Testing HTTPS support for the Notes application
- Using Helmet for across-the-board security in Express applications
- Using Helmet to set the Content-Security-Policy header
- Making the ContentSecurityPolicy configurable
- Using Helmet to set the X-DNS-Prefetch-Control header
- Using Helmet to control enabled browser features using the Feature-Policy header
- Using Helmet to set the X-Frame-Options header
- Using Helmet to remove the X-Powered-By header
- Improving HTTPS with Strict Transport Security
- Mitigating XSS attacks with Helmet
- Addressing Cross-Site Request Forgery (CSRF) attacks
- Denying SQL injection attacks
- Scanning for known vulnerabilities in Node.js packages
- Using good cookie practices
- Hardening the AWS EC2 deployment
- AWS EC2 security best practices
- Summary
- Other Books You May Enjoy
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.