Node Cookbook

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

4.7 (3)

Buy this Book

Node Cookbook

4.7 (3)

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

Buy this Book

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

Who this book is for

Conventions

Reader feedback

Customer support

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

4.7 (3)

5 star

66.7%

4 star

33.3%

3 star

2 star

1 star

Using containerized infrastructure

Container technology has recently gained rapid adoption within the industry and for good reason. Containers provide a powerful abstraction and isolation mechanism that can lead to robust and repeatable production deployments.

The container model for software deployment has become synonymous with microservices and distributed systems in general. Largely because the architectural model is a natural fit with the underlying container model. While a full discussion of the merits of containers is outside the scope of this book some of the key benefits to bear in mind are:

Isolation: Containers provide a clean isolated environment for our services to run in. The container brings the correct environment with it so we can be sure that if it runs on my machine it will run on ours.
Immutability: Once a container is built it can be treated as an immutable...