Node.js Proven for Microservices Architecture: 1 Optimal Duo

Reading time: 5 minutes

Let’s talk about Microservices Architecture

We could go over node.js, but there’s a plethora of info, tips and code for you to explore in our previous blogs. You can even click on the tag node.js to filter the posts.

So, let’s delve a bit into microservices acrchitecture. It’s an architectural style that structures an app as a collection of small, loosely coupled, and independently deployable services.

This approach, divides an application into multiple self-contained services, each responsible for a specific business capability or functionality.

Each service operates as a separate entity and communicates with other services through well-defined APIs.

Key characteristics include:

Service independence: each microservice can be developed, deployed, and scaled without impacting other services. This enables teams to work on different services simultaneously, fostering parallel development and deployment.
Decentralized data management: it manages its own data storage, choosing the most suitable system. This avoids the need for a monolithic database and allows each service to use the most appropriate data storage technology for its requirements.
API-based communication: Microservices interact with each other through lightweight and well-defined APIs. This promotes loose coupling, as services are isolated from the underlying implementation details of other services.
Fault isolation: If one microservice fails or has issues, it doesn’t impact the entire application. It’s designed to be resilient. Other services can continue to operate if dependencies are properly handled.
Scalability: Microservices architecture enables horizontal scaling. This allows organizations to allocate resources efficiently and handle varying loads effectively.
Technology diversity: It enables you to use different technologies, languages, frameworks, and databases. Hence, promoting innovation and leveraging existing expertise.

Microservices architecture is commonly used in complex and large-scale applications, as it offers lots of benefits that will be covered later on. Are you looking for expert-devs to work? Click here!

A caveat, it also introduces challenges in the architecture of microservices related to service coordination, data consistency, and distributed system complexity. It needs painstaking attention in the design and implementation.

In contrast to microservices, a monolithic architecture is an older and more traditional approach to building applications. Hence, moving from monolithic to microservices architecture is a must.

Let’s not forget the Frontend: A React.js overview

Microservices and monolithic architectures are not directly related to React.js. It is a tool that can be used in both monolithic and microservices architectures, as it focuses on the front-end layer of an application rather than the architectural approach.

We count with a back up of high-quality content about React.js, there’re tags you can look for in our blog, click here! You’ll find some 101 posts and comparative ones, too.

Here you’ll also find posts about: Hermes and React.js, a comparative chart that takes you to see the differences between Angular and React, some tools as react table bootstrap, a glimpse into its framework, and a react.js 101 JIC you need a quick-recap.

If you need more info, you are always invited to give us a call (+1) 832 460 4149!

Benefits of Microservices Architecture

Microservices are designed to be perform specific tasks efficiently. They can be developed, deployed, and scaled independently, allowing for flexibility and faster development cycles.

Scalability: it allows for independent scaling of different services based on their specific needs. Node.js, with its event-driven, non-blocking I/O model, is well-suited for handling a large number of concurrent connections.

Modularity and Maintainability: they promote modularity by breaking down a complex application into smaller, loosely coupled services. Node.js, with its module-based architecture and npm, encourages code organization and reusability.

Developer Productivity: Node.js, being based on JavaScript, allows for full-stack JavaScript development. This means that developers can use the same programming language (JavaScript) on both the front-end (React.js) and back-end (Node.js).

Rapid Prototyping and Iteration: Node.js, with its lightweight and fast startup, is ideal for rapid prototyping and iterative development. It provides a quick feedback loop for making changes and testing new features.

Ecosystem and Tooling: Node.js has a rich ecosystem with a wide range of open-source modules and tools available through npm. This extensive ecosystem simplifies development by providing libraries, frameworks, and utilities for common tasks such as API development, database integration, testing, and more. It also encourages collaboration and knowledge sharing within the developer community.

Cloud-Native and DevOps Adoption: combined with Node.js, align well with cloud-native principles and DevOps practices. Node.js’s lightweight and container-friendly nature makes it easy to deploy and manage microservices in cloud environments.

Its compatibility with containerization platforms like Docker and orchestration tools like Kubernetes enables efficient deployment, scaling, and management of microservices-based applications.

It’s important to note that while microservices and Node.js offer these benefits, they also come with certain challenges which will be addressed later.

Luckily, there’s plenty of expertise within our Effectus Team. Our Semi-senior full-stack developer Natalia Catalá offers a glimpse into her coding skills to take as a kick-start example.

She presents an example of two microservices which are used of user management and also, to take care of users expenses.

Go to the directory under which you’d like to create the project and create two projects in node.js: 1 user-manager and 2- expenses-manager.

Initialize the npm project inside ./user-manager directory and install necessary dependencies by executing the following command instructions:

npm install express cors nodemon uuid

It’s now time to implement the service, si set up index.js:

const express = require('express');
const cors = require("cors");

const router = require('./router');

const app = express();

app.use(express.json());
app.use(router);
app.use(
 cors({
  origin: '*',
 })
);

const port = process.env.PORT || 3002;

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

Now it’s time to create the controllers, go on!

const uuid = require("uuid");

const users = [];
// Example UserDto 
const userExample = {
 name: "Test",
 email: "test@mail.com"
}

module.exports.register = async (req, res) => {
 const userDto = req.body;
 const id = uuid.v4();
 const userToAdd = { ...userDto, id };
 users.push(userToAdd);
 res.status(201).send({ user: userToAdd });
};

module.exports.getUsers = async (req, res) => {
 res.status(200).send({ users });
};

module.exports.getUserById = async (req, res) => {
 const user = users.find((user) => user.id === req.params.id);
 if (!user) return res.status(404).send({ message: "User not found" });
 res.status(200).send({ user });
};

Ready to create the router? Let’s get it rolling.

const express = require("express");

const controller = require("./controller")

const router = new express.Router();

router.post('/users', controller.register);
router.get('/users', controller.getUsers);
// endpoint accessed by expenses-manager
router.get('/users/:id', controller.getUserById);

module.exports = router;

Initialize the npm project inside ./expense-manager directory and install necessary dependencies by executing the following command instructions

npm install express axios nodemon uuid

Let’s start implementing the service, set up index.js:

const express = require('express');
const router = require('./router');

const app = express();

app.use(express.json());
app.use(router);

const port = process.env.PORT || 3001;

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

Similar as the previous steps, create the controllers:

const uuid = require("uuid");

const usersService = require("./user-service");

const expenses = [];
// Example ExpenseDto 
const expenseExample = {
 amount: 50,
 category: "Food",
 createdBy: "7185abd9-da46-4be3-8e65-e4df2e80089e",
 date: "2021-09-01T00:00:00.000Z",
};
module.exports.create = async (req, res) => {
 const expenseDto = req.body;
 const id = uuid.v4();
 const expenseToAdd = { ...expenseDto, id };
 expenses.push(expenseToAdd);
 res.status(201).send({ expense: expenseToAdd });
};

module.exports.get = async (req, res) => {
  const expensesDto = await Promise.all(
    expenses.map(async (expense) => ({
    ...expense,
   createdBy: await usersService.getUserById({ id: expense.createdBy }),
  }))
 );
 res.status(200).send({ expenses: expensesDto });
};

module.exports.getById = async (req, res) => {
 const expense = expenses.find((expense) => expense.id === req.params.id);
 if (!expense) return res.status(404).send({ message: "Expense not found" });
 const user = await usersService.getUserById({ id: expense?.createdBy });
 res.status(200).send({ ...expense, createdBy: user });
};

Ta-da! Create the router:

const express = require('express');

const expenseController = require('./controller');

const router = new express.Router();

router.post('/expenses', expenseController.create);
router.get('/expenses', expenseController.get);
router.get('/expenses/:id', expenseController.getById);

module.exports = router;

Create the user-service, this is the one that accesses through axios to the other microservice like explained before in the blogpost.

const axios = require("axios");

const HOST = {
   Host: process.env.USERS_API_BASE_URL || "http://localhost:3002",
};

const api = axios.create({
  baseURL: HOST.Host,
});

module.exports.getUserById = async ({ id }) => {
  return api
    .get(`users/${id}`)
    .then(({ data }) => {
       return data.user;
    })
    .catch(({ response }) => {
       console.log("Error: ", response);
    });
};

Natalia is showing a basic possible way to connect microservices, but for a real life use you should add a data base and autentification.

Improving Development Efficiency with Microservices

Latest framework and toolkits updates have surpassed expectations. Allowing developers not to write as much code as they needed before. Some examples:

Next.js: build your entire web app in one framework and get SSR out of the box.
Using tRPC, don’t need to worry about defining the API either in RESTful or GraqphQL. You really have exactly the same experience of calling the local function when actually initialing the API call.
Using Prisma, focus on building the application logic instead of dealing with database queries and migrations.

Challenges of Using Node.js in Microservices

Microservices introduce additional complexity in terms of service coordination, data consistency, and inter-service communication.

Hence, node.js, being single-threaded, may not be the perfect match for CPU-intensive tasks or applications with extensive synchronous processing.

You need a keen eye for application requirements, architecture design, and performance characteristics is crucial to leveraging the benefits effectively.

Real-World Examples: Apps

An example of microservices architecture:

Netflix employs it to handle its vast catalog and user base. React components are used across various microservices, ensuring a consistent UX while microservices handle specific functionalities, such as: search, recommendations, or user profiles.
Spotify: the React components are used within different microservices responsible for playlist management, song recommendations, user preferences, and more. This modular approach allows Spotify to evolve and scale different parts of their application independently.
Uber has shifted towards it. Different microservices handle various aspects of the Uber ecosystem, such as: ride requests, location tracking, payment, and trip history.
Airbnb: react is used in their front-end stack, enabling hosts and guests to browse listings, make reservations, and interact with the platform. Microservices handle property management, booking transactions, and user reviews.

These examples demonstrate how React and microservices work together to build scalable, modular, and user-friendly applications.

React’s component-based nature allows for efficient UI development and integration with microservices’ APIs, while the microservices architecture provides flexibility, scalability, and independent deployment of various application components.

Let’s delve into Netflix example, particularly Analysis and Monitoring:

Analytics Microservice: Create a separate microservice dedicated to handling analytics data. This microservice collects and processes data related to user interactions, system performance, and operational metrics.

It could use technologies like Kafka or RabbitMQ for data ingestion, and a database or data storage system like Elasticsearch or MongoDB for storing the analytics data.

APIs and Event Tracking: Instrument your React.js components with event tracking code to capture UI.

Whenever a significant event occurs, the React component would emit an event that is sent to the Analytics Microservice via an API call. You can use libraries like ReactGA or custom tracking code to send events.

Dashboard: Build a React.js-based analytics dashboard where you can visualize and analyze the collected data.

This dashboard component would communicate with the Analytics Microservice’s API to fetch the necessary data for display. You can use visualization libraries like Chart.js or D3.js to create charts, graphs, and other data visualizations.

Real-time Monitoring: Develop a real-time monitoring component using React.js to track system health and performance.

It collects and aggregates system metrics such as CPU usage, memory consumption, and network traffic. You can use libraries like Socket.io or WebSocket to establish a real-time connection and receive continuous updates.

Alerts and Notifications: Implement an alerting system within the React.js application to notify administrators or engineers when certain predefined thresholds or anomalies are detected in the monitored metrics.

This can be achieved by integrating with notification services like Slack or sending emails through an email service provider.

Authentication and Authorization: Ensure that only authorized users have access to the analytics and monitoring features.

Secure access to the analytics dashboard and monitoring components. You can use authentication libraries like Firebase Authentication or implement a custom solution.

Here’s a high-level overview of the starting point. You need to adapt and expand to fit your specific project requirements. Here’s a rough outline:

Analytics Microservice (Node.js/Express.js):
- Set up an Express.js server to handle API requests.
- Define routes for receiving analytics events from the React.js frontend.
- Process and store the received data in a database or data storage system.
- Implement APIs to fetch analytics data for the dashboard.

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

// Define routes to receive analytics events
app.post('/api/analytics', (req, res) => {
  // Process and store the received analytics event data
});

// Implement APIs to fetch analytics data for the dashboard
app.get('/api/analytics', (req, res) => {
  // Retrieve analytics data from the database and send it to the dashboard
});

// Start the server
app.listen(3000, () => {
  console.log('Analytics microservice running on port 3000');
});

React.js Analytics Dashboard:
- Create React components to display charts, graphs, and visualizations.
- Fetch analytics data from the Analytics Microservice’s API endpoints.
- Use a data visualization library like Chart.js to render the data.

import React, { useEffect, useState } from 'react';
import axios from 'axios';
import { Line } from 'react-chartjs-2';

const AnalyticsDashboard = () => {
 const [analyticsData, setAnalyticsData] = useState([]);

 useEffect(() => {
  // Fetch analytics data from the API
  axios.get('/api/analytics')
   .then(response => {
    setAnalyticsData(response.data);
   })
   .catch(error => {
    console.error('Error fetching analytics data:', error);
   });
 }, []);

 // Render the analytics data using Chart.js
 return (
  <div>
   <h2>Analytics Dashboard</h2>
   <Line data={analyticsData} />
  </div>
  );
};

export default AnalyticsDashboard;

React.js Real-time Monitoring Component:
- Establish a WebSocket connection with the monitoring microservice.
- Receive real-time updates and display system metrics.

import React, { useEffect, useState } from 'react';
import io from 'socket.io-client';

const MonitoringComponent = () => {
 const [metrics, setMetrics] = useState({});

 useEffect(() => {
  // Establish a WebSocket connection with the monitoring microservice
  const socket = io('http://localhost:4000');

  // Receive real-time updates and update the metrics state
  socket.on('metrics', (data) => {
   setMetrics(data);
  });

  // Clean up the socket connection on component unmount
  return () => {
   socket.disconnect();
  };
}, []);

// Render the received system metrics
 return (
    <div>
    <h2>Real-time Monitoring</h2>
    <pre>{JSON.stringify(metrics, null, 2)}</pre>
  </div>
 );
};

export default MonitoringComponent;

These code snippets provide a starting point for building an analytics and monitoring system with microservices and React.js.

Please, DO remember to install the necessary dependencies (express, axios, react-chartjs-2, socket.io-client, and else.)

Future Trends

Microservices architecture keep on becoming a driving force in app modernization. By breaking down monolithic apps into modular independently deployable services, organizations get only benefits.

2023 promises innovation and transformation. Advocating cutting-edge technologies like AI-driven development, low-code/no-code platforms, and the like become a must.

Taken from “The Impact of Microservices on Cybersecurity” by Kedarnath Mundluru May 29, 2023:

“According to research, the Microservices Architecture market will rise from 5.49 billion USD in 2022 to 21.61 billion USD by 2023″ [Munde, 2023].

Other trends that are expected to impact the development of microservices include the following:

- improved observability and enhanced insight into microservices’ actions and ability to control communication through the service mesh reconfigurable infrastructure.
- automated and optimized monitoring, incident response, capacity planning, and other operations through AI techniques to manage software more effectively.
- better reliability than single-source software development through the use of multi-cloud strategies that implement a microservices architecture (Garvit, 2023).

Let’s round it up!

When combined with Node.js, microservices architecture enhances efficiency and productivity.

Node.js’s event-driven, non-blocking I/O model is well-suited for handling a large number of concurrent connections.

However, it’s important to note that it also introduces challenges related to service coordination, data consistency, and distributed system complexity.

So, along with technologies like Node.js, provides a powerful approach for building robust, scalable, and flexible applications that can adapt to the evolving needs of modern businesses.

Want to improve your project? Start working with us!