Node Cookbook - Third Edition

By : David Mark Clements, Mathias Buus Madsen, Peter Elger, Matteo Collina

Node Cookbook - Third Edition

By: David Mark Clements, Mathias Buus Madsen, Peter Elger, Matteo Collina

Overview of this book

Today's web demands efficient real-time applications and scalability. Asynchronous event-driven programming is ideal for this, and this is where Node.js comes in. Server-side JavaScript has been here since the 90s, but Node got it right. With Node for tooling and server-side logic, and a browser-based client-side UI, everything is JavaScript. This leads to rapid, fluid development cycles. The full-stack, single language experience means less context-switching between languages for developers, architects and whole teams. This book shows you how to build fast, efficient, and scalable client-server solutions using the latest versions of Node. The book begins with debugging tips and tricks of the trade, and how to write your own modules. Then you'll learn the fundamentals of streams in Node.js, discover I/O control, and how to implement the different web protocols. You'll find recipes for integrating databases such as MongoDB, MySQL/MariaDB, Postgres, Redis, and LevelDB. We also cover the options for building web application with Express, Hapi and Koa. You will then learn about security essentials in Node.js and advanced optimization tools and techniques. By the end of the book you will have acquired the level of expertise to build production-ready and scalable Node.js systems. The techniques and skills you will learn in this book are based on the best practices developed by nearForm, one of the leaders in Node implementations, who supported the work of the authors on this book.

Preface

What this book covers

What you need for this book

Free Chapter

Debugging process*

Introduction

Debugging Node with Chrome Devtools

Enhancing stack trace output

Enabling debug logs

Enabling core debug logs

Writing Modules

Introduction

Scaffolding a module

Installing dependencies

Writing module code

Publishing a module

Using a private repository

Coordinating I/O

Introduction

Interfacing with standard I/O

Working with files

Fetching metadata

Watching files and directories

Communicating over sockets

Using Streams

Introduction

Processing Big Data

Using the pipe method

Piping streams in production

Creating transform streams

Creating readable and writable streams

Decoupling I/O

Wielding Web Protocols

Introduction

Creating an HTTP server

Receiving POST data

Handling file uploads

Making an HTTP POST request

Communicating with WebSockets

Creating an SMTP server

Persisting to Databases

Introduction

Connecting and sending SQL to a MySQL server

Connecting and sending SQL to a Postgres server

Storing and retrieving data with MongoDB

Storing and retrieving data with Redis

Embedded persistence with LevelDB

Working with Web Frameworks

Introduction

Creating an express web app

Creating a Hapi web app

Creating a Koa web app

Adding a view layer

Adding logging

Implementing authentication

Dealing with Security

Introduction

Detecting dependency vulnerabilities

Hardening headers in web frameworks

Anticipating malicious input

Guarding against Cross Site Scripting (XSS)

Preventing Cross Site Request Forgery

Optimizing Performance

Introduction

Benchmarking HTTP

Finding bottlenecks with flamegraphs

Optimizing a synchronous function call

Optimizing asynchronous callbacks

Profiling memory

Building Microservice Systems

Introduction

Consuming a service

Setting up a development environment

Standardizing service boilerplate

Using containerized infrastructure

Service discovery with DNS

Adding a Queue Based Service

Deploying Node.js

Introduction

Building a container for a Node.js process

Running a Docker registry

Storing images on DockerHub

Deploying a container to Kubernetes

Creating a deployment pipeline

Deploying a full system

Deploying to the cloud

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Introduction

JavaScript runs in a single threaded event-loop. Node.js is a runtime platform built for evented I/O where multiple execution flows are processed concurrently, but not in parallel. An example of this could be an HTTP server, tens of thousands of requests can be processed per second, but only one instruction is being executed at any given time.

The performance of our application is tied to how fast we can process an individual execution flow prior to performing the next I/O operation.

Through several recipes, this chapter demonstrates the Optimization Workflow, as shown in the following figure:

bdd-flowchart

We'll be referencing this workflow throughout this chapter.

This chapter is about making our JavaScript code as fast as possible in order to increase I/O handling capacity, thus decreasing costs and improving user experience.

Upcoming changes to Node.js performance...

Node Cookbook - Third Edition

By : David Mark Clements, Mathias Buus Madsen, Peter Elger, Matteo Collina

Node Cookbook - Third Edition

By: David Mark Clements, Mathias Buus Madsen, Peter Elger, Matteo Collina

Overview of this book

Related Content you might be interested in

Current Title:

Node Cookbook - Third Edition

Node Cookbook

Mastering Node.js

Server Side development with Node.js and Koa.js Quick Start Guide