Sign In Start Free Trial

Node Cookbook

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

4.7 (3)

Node Cookbook

4.7 (3)

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

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

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*

Debugging process*

Introduction

Debugging Node with Chrome Devtools

Enhancing stack trace output

Enabling debug logs

Enabling core debug logs

Writing Modules

Writing Modules

Introduction

Scaffolding a module

Installing dependencies

Writing module code

Publishing a module

Using a private repository

Coordinating I/O

Coordinating I/O

Introduction

Interfacing with standard I/O

Working with files

Fetching metadata

Watching files and directories

Communicating over sockets

Using Streams

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

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

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

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

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

Optimizing Performance

Introduction

Benchmarking HTTP

Finding bottlenecks with flamegraphs

Optimizing a synchronous function call

Optimizing asynchronous callbacks

Profiling memory

Building Microservice Systems

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

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

0

2 star

0

1 star

0

Anticipating malicious input

Malicious input can often catch us by surprise. We tend to cater to the common cases, but we can easily neglect more esoteric vulnerabilities resulting from unexpected or forgotten behaviors.

In the main recipe, we'll focus on the parameter pollution case, in the There's More section we'll cover other important, but often unfamiliar areas such as JSON validation and user input driven Buffer creation.

Parameter pollution is quite a subtle form of attack, and if we're not aware of the default way our framework and code handles this form of input validation, we may open ourselves to Denial of Service attacks, and in some cases allow for XSS or CSRF attacks.

In this recipe, we're going to protect a server from HTTP Parameter pollution.

...

Search

Your notes and bookmarks