Creating an HTTP Server from Scratch with Node-addon-api, Libuv, and Milo

Rate this content
Bookmark

Let's explore the magic behind Node.js and create a simple http server! We'll go step-by-step, understanding how libuv makes node asyncronous and how Milo helps our server parse HTTP request. We'll use node-addon-api to create the bridge between c++ and javascript.                                       

This talk has been presented at Node Congress 2024, check out the latest edition of this JavaScript Conference.

FAQ

A native add-on in Node.js is a module written in C++, C, or Rust that extends low-level functionalities of Node.js, such as libuv, V8, and Zlib. These add-ons allow access to system-level features that are not accessible through JavaScript alone.

To create a native add-on in Node.js, you need the following libraries: Node.addon-api, Node.gyp, and bindings. Node.addon-api provides stable header files, Node.gyp is used for building the add-on, and bindings help import the .node add-on into JavaScript files.

In creating an HTTP server, a TCP socket is used to exchange data between the server and the client. It binds to an address and port on the machine, listens for incoming connections, and facilitates data transfer through the socket.

To bind a native add-on module in Node.js, you need to create a binding.gyp file and add the C++ source files inside the sources section. You also specify a target name for the add-on, which will be used when importing the module with bindings in JavaScript.

The Node.addon-api library provides the header files necessary for developing native add-ons in Node.js. It offers stable APIs that ensure compatibility across different Node.js versions, making the development process easier and more reliable.

The .node file is the compiled output of a Node.js native add-on. It can be called from JavaScript, allowing the integration of low-level system functionalities into JavaScript applications.

The 'listen' method in a TCP socket is used to start listening for incoming connections on a specified hostname and port. It involves setting up a callback function that gets invoked whenever new data is received on the socket.

In Node.js, a TCP socket handles incoming data by using a callback function passed to the 'listen' method. This callback is invoked with the data, which can then be read, processed, and used to generate a response that is sent back to the client.

HTTP parsers in an HTTP server are used to parse and validate incoming HTTP requests, transforming raw data into structured objects containing headers, methods, and body content. They ensure the data conforms to HTTP standards and facilitate the generation of valid HTTP responses.

Libuv is important in Node.js because it abstracts the differences between various platforms like Windows and POSIX-compliant systems. It standardizes the APIs for asynchronous I/O operations, making it easier to write code that works across different operating systems.

Marco Ippolito
Marco Ippolito
18 min
04 Apr, 2024

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Today's Talk focuses on creating an HTTP server from scratch using Node.js and native add-ons. The process involves implementing a TCP socket using LibuV for data exchange between the server and client. The Talk also covers invoking callbacks, creating a high-level abstraction for the HTTP server, and parsing HTTP data using an experimental HTTP parser called Milo. The project serves as a proof of concept, showcasing the ease of creating add-ons and interacting with low-level APIs in Node.js.

1. Introduction to Node.js and Native Add-ons

Short description:

Today, we're going to talk about Node.js and specifically how to create an HTTP server from scratch. We will create a native add-on that allows us to access the system that we are using and extend the low-level functionalities of Node.js. To create a native add-on, we need the Node.addon-api and Node.jyp libraries, along with the bindings module. Let's see the project structure.

Welcome, everyone. Today, we're going to talk about Node.js and specifically how to create an HTTP server from scratch. My name is Marco Ippolito. I'm a Senior Developer Experience Engineer at NearForm. I'm also a Node.js core contributor and open-source enthusiast.

So let's get started. What I mean from scratch is literally from scratch. So we will create a native add-on, and we will not use Node.js standard library. So what we will do is call libuv directly and write a bit of C++. But even if you are not a C++ developer, don't be scared because it will be very simple.

So what is a native add-on? A native add-on is a module written in C++ or in C, but it can also be written in Rust that extends some of the low-level functionalities of Node.js, such as libuv. If you don't know what libuv is, we will talk about it later in detail. And also V8, which is the JavaScript engine, Zlib, and many other libraries that compose Node.js. So this native add-on allows us to access the system that we are using, and we could normally not access it in JavaScript.

To create a native add-on, we need a library called Node.addon-api. Node.js has a bunch of APIs that are public and are released. And this package provides the header files to make the development much, much easier. And they are also stable, which means that if you update the Node.js versions, they're not going to break. They're going to be stable. And it's also maintained by the Node.js team. So as you can see, it has quite a few downloads on NPM.

The other library that we need is Node.jyp. So historically, Node.js add-ons have been built with Node.jyp. It was used by Chromium at the beginning, and it was adopted in the early days of Node.js. But you can also use CMake or whatever tool you use for building C++ applications. And with this build system, it will generate a .node file that we can call from JavaScript. And the final one is bindings. This is a very important one because it's a helper module that allows us to import the .node add-on into our JavaScript file, just like you would require or import a JavaScript module. With bindings, you can import a native add-on. So let's see the project structure.

2. Creating a Native Add-on and TCP Socket

Short description:

To create the native add-on, first add in the package.json that you are exporting a .jp file. Set the type module to use ESM. Then, create two scripts for build and clean. Include the three dependencies we talked about. In the source folder, you'll find the C++ files. Declare the add-on module and export the TCP socket inbound class. Bind the source files and use the class with a constructor. The TCP socket is independent from the transport layer.

We will see a bit of code, but it will be quite simple. So to create the native add-on, you first need to add in the package.json that you are exporting a .jp file. So we set .jp file to true, and for this example, we set the type module to use ESM. So this allows NPM to know that this is a native add-on and it will unlock some functionalities like build on during installation, and it's a special mode for NPM.

Then we will need to have two scripts for build and clean. With the clean one, just deletes the build folder. And then we have these three dependencies that we just talked about. In our source folder, we had the C++ files. So we have an add-on file which basically exports our add-on. So please have a look at the export object. It's basically the same thing as doing module.export. It's the same object, just passed in the C++ side. In this talk, you will see a lot of similarities, and there is a lot of C++ code that is just actually JavaScript code. They behave in the same way, and I will show you the one-to-one comparison.

So once we have declared our add-on module, then we have to export our class. So we will export TCP socket inbound, TCP socket class. As I said before, what we are doing in C++ is basically exporting this inbound TCP socket. We will talk about what inbound TCP socket is and why it's important to create an HTTP server.

So now that we have declared our source files, we need to bind them. So we create a binding.gwp file and we add the C++ files inside sources. So we have the add-on C++ and inbound TCP socket C++ file. And then we write as target name, the name of our add-on. In this case, we want to export it as inbound TCP socket. This will be important because when we go to import it with the bindings, we have to write the same name. So we are doing bindings inbound TCP socket. And now we can just use the class that we have created previously and we can instantiate it with a constructor. Don't worry about the code, we will see in detail later.

So let's talk a bit about the TCP socket. So what is our TCP socket? So we know that HTTP is an application layer protocol. So it's technically independent from the transport layer.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

It's a Jungle Out There: What's Really Going on Inside Your Node_Modules Folder
Node Congress 2022Node Congress 2022
26 min
It's a Jungle Out There: What's Really Going on Inside Your Node_Modules Folder
Top Content
The talk discusses the importance of supply chain security in the open source ecosystem, highlighting the risks of relying on open source code without proper code review. It explores the trend of supply chain attacks and the need for a new approach to detect and block malicious dependencies. The talk also introduces Socket, a tool that assesses the security of packages and provides automation and analysis to protect against malware and supply chain attacks. It emphasizes the need to prioritize security in software development and offers insights into potential solutions such as realms and Deno's command line flags.
Towards a Standard Library for JavaScript Runtimes
Node Congress 2022Node Congress 2022
34 min
Towards a Standard Library for JavaScript Runtimes
Top Content
There is a need for a standard library of APIs for JavaScript runtimes, as there are currently multiple ways to perform fundamental tasks like base64 encoding. JavaScript runtimes have historically lacked a standard library, causing friction and difficulty for developers. The idea of a small core has both benefits and drawbacks, with some runtimes abusing it to limit innovation. There is a misalignment between Node and web browsers in terms of functionality and API standards. The proposal is to involve browser developers in conversations about API standardization and to create a common standard library for JavaScript runtimes.
ESM Loaders: Enhancing Module Loading in Node.js
JSNation 2023JSNation 2023
22 min
ESM Loaders: Enhancing Module Loading in Node.js
ESM Loaders enhance module loading in Node.js by resolving URLs and reading files from the disk. Module loaders can override modules and change how they are found. Enhancing the loading phase involves loading directly from HTTP and loading TypeScript code without building it. The loader in the module URL handles URL resolution and uses fetch to fetch the source code. Loaders can be chained together to load from different sources, transform source code, and resolve URLs differently. The future of module loading enhancements is promising and simple to use.
Out of the Box Node.js Diagnostics
Node Congress 2022Node Congress 2022
34 min
Out of the Box Node.js Diagnostics
This talk covers various techniques for getting diagnostics information out of Node.js, including debugging with environment variables, handling warnings and deprecations, tracing uncaught exceptions and process exit, using the v8 inspector and dev tools, and generating diagnostic reports. The speaker also mentions areas for improvement in Node.js diagnostics and provides resources for learning and contributing. Additionally, the responsibilities of the Technical Steering Committee in the TS community are discussed.
Node.js Compatibility in Deno
Node Congress 2022Node Congress 2022
34 min
Node.js Compatibility in Deno
Deno aims to provide Node.js compatibility to make migration smoother and easier. While Deno can run apps and libraries offered for Node.js, not all are supported yet. There are trade-offs to consider, such as incompatible APIs and a less ideal developer experience. Deno is working on improving compatibility and the transition process. Efforts include porting Node.js modules, exploring a superset approach, and transparent package installation from npm.
Multithreaded Logging with Pino
JSNation Live 2021JSNation Live 2021
19 min
Multithreaded Logging with Pino
Top Content
Today's Talk is about logging with Pino, one of the fastest loggers for Node.js. Pino's speed and performance are achieved by avoiding expensive logging and optimizing event loop processing. It offers advanced features like async mode and distributed logging. The use of Worker Threads and Threadstream allows for efficient data processing. Pino.Transport enables log processing in a worker thread with various options for log destinations. The Talk concludes with a demonstration of logging output and an invitation to reach out for job opportunities.

Workshops on related topic

Node.js Masterclass
Node Congress 2023Node Congress 2023
109 min
Node.js Masterclass
Top Content
Workshop
Matteo Collina
Matteo Collina
Have you ever struggled with designing and structuring your Node.js applications? Building applications that are well organised, testable and extendable is not always easy. It can often turn out to be a lot more complicated than you expect it to be. In this live event Matteo will show you how he builds Node.js applications from scratch. You’ll learn how he approaches application design, and the philosophies that he applies to create modular, maintainable and effective applications.

Level: intermediate
Build and Deploy a Backend With Fastify & Platformatic
JSNation 2023JSNation 2023
104 min
Build and Deploy a Backend With Fastify & Platformatic
WorkshopFree
Matteo Collina
Matteo Collina
Platformatic allows you to rapidly develop GraphQL and REST APIs with minimal effort. The best part is that it also allows you to unleash the full potential of Node.js and Fastify whenever you need to. You can fully customise a Platformatic application by writing your own additional features and plugins. In the workshop, we’ll cover both our Open Source modules and our Cloud offering:- Platformatic OSS (open-source software) — Tools and libraries for rapidly building robust applications with Node.js (https://oss.platformatic.dev/).- Platformatic Cloud (currently in beta) — Our hosting platform that includes features such as preview apps, built-in metrics and integration with your Git flow (https://platformatic.dev/). 
In this workshop you'll learn how to develop APIs with Fastify and deploy them to the Platformatic Cloud.
Building a Hyper Fast Web Server with Deno
JSNation Live 2021JSNation Live 2021
156 min
Building a Hyper Fast Web Server with Deno
WorkshopFree
Matt Landers
Will Johnston
2 authors
Deno 1.9 introduced a new web server API that takes advantage of Hyper, a fast and correct HTTP implementation for Rust. Using this API instead of the std/http implementation increases performance and provides support for HTTP2. In this workshop, learn how to create a web server utilizing Hyper under the hood and boost the performance for your web apps.
0 to Auth in an Hour Using NodeJS SDK
Node Congress 2023Node Congress 2023
63 min
0 to Auth in an Hour Using NodeJS SDK
WorkshopFree
Asaf Shen
Asaf Shen
Passwordless authentication may seem complex, but it is simple to add it to any app using the right tool.
We will enhance a full-stack JS application (Node.JS backend + React frontend) to authenticate users with OAuth (social login) and One Time Passwords (email), including:- User authentication - Managing user interactions, returning session / refresh JWTs- Session management and validation - Storing the session for subsequent client requests, validating / refreshing sessions
At the end of the workshop, we will also touch on another approach to code authentication using frontend Descope Flows (drag-and-drop workflows), while keeping only session validation in the backend. With this, we will also show how easy it is to enable biometrics and other passwordless authentication methods.
Table of contents- A quick intro to core authentication concepts- Coding- Why passwordless matters
Prerequisites- IDE for your choice- Node 18 or higher
Mastering Node.js Test Runner
TestJS Summit 2023TestJS Summit 2023
78 min
Mastering Node.js Test Runner
Workshop
Marco Ippolito
Marco Ippolito
Node.js test runner is modern, fast, and doesn't require additional libraries, but understanding and using it well can be tricky. You will learn how to use Node.js test runner to its full potential. We'll show you how it compares to other tools, how to set it up, and how to run your tests effectively. During the workshop, we'll do exercises to help you get comfortable with filtering, using native assertions, running tests in parallel, using CLI, and more. We'll also talk about working with TypeScript, making custom reports, and code coverage.
GraphQL - From Zero to Hero in 3 hours
React Summit 2022React Summit 2022
164 min
GraphQL - From Zero to Hero in 3 hours
Workshop
Pawel Sawicki
Pawel Sawicki
How to build a fullstack GraphQL application (Postgres + NestJs + React) in the shortest time possible.
All beginnings are hard. Even harder than choosing the technology is often developing a suitable architecture. Especially when it comes to GraphQL.
In this workshop, you will get a variety of best practices that you would normally have to work through over a number of projects - all in just three hours.
If you've always wanted to participate in a hackathon to get something up and running in the shortest amount of time - then take an active part in this workshop, and participate in the thought processes of the trainer.