How to build microservices with Node.js

Understanding microservices architecture and how they work

Benefits of microservice architecture

• Scalability is easy, as you can think of the whole system as a collection of services, each interfacing with other microservices. This allows you to scale up, down, or out based on the resources needed by individual microservices instead of the entire application (i.e., monolithic architecture).
• Simplified developer experience so that a new developer joining the team does not have to understand the entire system but only the context of the service they are working on. This improves productivity as they can focus on a single code base and its functionality.
• Platform independence and flexibility so that developers can choose the best tools for the job when building services for the system.

Drawbacks of microservice architecture

• If not architected correctly, there is a risk of getting an overly fragmented system where developers need to spend time and effort gluing together services and tools.
• Monitoring microservice-based architectures is more complex since there are multiple points of failure across the system. This also increases testing complexity.
• Orchestration, which is the integration of the multiple services into a full-fledged application, and discovery, which is how applications and microservices locate each other on a network, must be architected from the get-go.

How to build microservices with Node.js

• Improved execution time - The V8 JavaScript engine that powers Node.js compiles functions written in JavaScript to native machine code. This makes Node.js a popular choice for building microservices that carry out low-latency CPU and IO-intensive operations.
• Event-driven architecture - Most of the objects in Node.js provide a way to emit and listen to events making it highly beneficial in building event-driven apps.
• Asynchronous and non-batch - Most Node.js libraries support non-blocking calls which continue execution without waiting for the previous call to return. Additionally, data is returned as-is, streamed as chunks, and not batched in a buffer.
• Scalable technology - The Node.js execution model supports scaling by delegating request handling to other worker threads.

Building Microservices with Node.js

Prerequisites and initialization

Setting up the server

const express = require('express');
const app = express();

app.use(express.json());

const routes = require('./api_routes/routes');
routes(app);
const port = process.env.PORT || 3000;

app.listen(port, () => {
  console.log(`Listening to port http://localhost:${port}`);
});

Specifying the routes

'use strict';

const controller = require('../controllers/appController');

module.exports = (app) => {
  app.route('/about').get(controller.about);
  app.route('/distance/:zipcode1/:zipcode2').get(controller.getDistance);
}

Building the controller

'use strict';

const properties = require('../package.json');
const distance = require('../service/distance');

const controllers = {
    about: (req, res) => {
        const aboutInfo = {
            name: properties.name,
            version: properties.version,
        }
        res.json(aboutInfo);
    },

    getDistance: (req, res) => {
        distance.find(req, res, (err, dist) => {
            if (err)
                res.send(err);
            res.json(dist);
        });
    },
};

module.exports = controllers;

Establishing the call

const request = require('request');

const apiKey = process.env.ZIPCODE_API_KEY ||
    "hkCt1nW1wF1rppaEmoor7T9G4ta7R5wFSu8l1dokNz8y53gGZHDneWWVosbEYirC";

const zipCodeURL = process.env.ZIPCODE_API_URL;

var distance = {
    find: (req, res, next) => {
        request(zipCodeURL + apiKey +
            '/distance.json/' + req.params.zipcode1 + '/' +
            req.params.zipcode2 + '/mile',
            (error, response, body) => {
                if (!error && response.statusCode == 200) {
                    response = JSON.parse(body);
                    res.send(response);
                } else {
                    console.log(response.statusCode + response.body);
                    res.send({
                        distance: -1
                    });
                }
            });
    }
};

module.exports = distance;

Execution

Incorporating a database into your architecture

$ npm i faunadb --save

'use strict';

const controller = require('../controllers/appController');

module.exports = (app) => {
  app.route('/about').get(controller.about);
  app.route('/distance/:zipcode1/:zipcode2').get(controller.getDistance);
  app.route('/address').post(controller.saveAddress);
}

// controllers/appController.js
'use strict';

const fauna = require('faunadb');
// ..

const q = fauna.query;
const client = new fauna.Client({ secret: 'fnAE1qQKtHACT5avyKsGp3YQcZVDrYEzQ3KCSyiG' })

const controllers = {
  about: (req, res) => {
    // ...
  },

  getDistance: (req, res) => {
    // ...
  },

  saveAddress: async (req, res) => {
    const { address, zip, city } = req.body;
    const newAddress = await client.query(
      q.Create(q.Collection('Address'), { data: { address, zip, city } })
    )
    res.json({
      message: 'Address saved successfully',
      data: newAddress.data
    });
  }

};

module.exports = controllers;

curl --location --request POST 'http://localhost:3000/address' \
--header 'Content-Type: application/json' \
--data-raw '{
    "address": "14 Stobo Lane",
    "city": "San Mateo",
    "zip": 87211
}'

Try Fauna for Free

Sign-up for free

Quick start guide