Node.js Apps Using Distributed Cache

Node.js is a very popular runtime environment. Its popularity stems from its efficiency when building network applications and the flexibility it offers as a cross-platform, open-source JavaScript framework. However, all enterprise-level applications can further boost their performance and scalability to meet today’s demanding digital landscape. This is where distributed caching solutions like NCache come in. This article delves into the significance of distributed caching, its benefits, practical use cases, and how NCache seamlessly integrates with Node.js applications.

Understanding Distributed Caching

Distributed caching lets users store data across multiple servers or nodes in an in-memory data store. Therefore, distributed caching guarantees that any frequently accessed data is readily available in-memory, alleviating primary database load.

Distributed Caching Benefits

Distributed caching is a substantial enhancement to any such application, this section discusses a few of the reasons why below:

Enhanced Performance: In-memory data storage facilitates rapid data retrieval, reducing response times significantly.
Scalability: Distributed caches can scale horizontally by adding more nodes, ensuring consistent performance as application demands grow.
Reliability: Data replication across multiple nodes, ensures high availability preventing any issues as a result of node failure.
Efficient Resource Utilization: Distributed caching reduces the strain on backend resources by offloading frequent read operations from the primary database.

Figure: Distributed cache.

Distributed Caching Use Cases

Clearly, it is essential for read-intensive applications that require high availability, low latency, and scalability to utilize distributed caching. Some common use cases include:

Data Caching
Session Management
API Response Caching
E-commerce Applications
Real-Time Analytics
Content Delivery
Rate Limiting and Access Control

Setting Up NCache for Node.js Applications

The following section highlights how to use NCache in Node.js Applications:

Step 1: Installing NCache

NCache is available on both Windows and Linux, providing flexibility for various deployment environments. Below are two common scenarios for installing the NCache server using Docker on Linux.

Installing Cache Server on a Development Workstation

Run the following command to set up an NCache server locally for application development and testing:

1	docker pull alachisoft/ncache:latest

This deploys a standalone NCache server on your local machine.

Installing a 2-Node Cache Cluster in Dedicated Servers

For production or large-scale testing environments, a multi-node cache cluster is a better option. Run the following commands on two separate dedicated servers:

On Server 1:

1	docker pull alachisoft/ncache:latest

On Server 2:

1	docker run -d --name ncache-node2 -p 8250:8250 -p 9800:9800 alachisoft/ncache

Step 2: Creating a Clustered Cache

Once both instances are running, configure them as a clustered cache using the NCache Management Center or the New-Cache cmdlet. Then, add previously configured cache nodes and use the monitoring tools available in NCache to check cache synchronization and node availability.

Step 3: Installing & Configuring the Node.js Client

After installing NCache, configure the Node.js client by importing the necessary modules and establishing a connection to the cache:

const ncache = require('ncache-client');

async function initializeCache() {

const cache = await ncache.CacheManager.getCache('demoCache');

await cache.connect();

return cache;

}

Basic Cache Operations in Node.js

The following section explains how to populate and manage the cache.

Adding Data to the Cache

Implementing a cache-aside pattern ensures that applications check the cache before fetching data from the database. This reduces database load and improves response times.

async function getProduct(productId) {

const cacheKey = `Product:${productId}`;

let product = await cache.get(cacheKey);

if (!product) {

// Fetch from database if not in cache

product = await fetchProductFromDB(productId);

// Create a CacheItem with absolute expiration

const cacheItem = new ncache.CacheItem(product);

const expiration =

new ncache.Expiration(ncache.ExpirationType.Absolute,

new ncache.TimeSpan(0, 10, 0));

cacheItem.setExpiration(expiration);

await cache.add(cacheKey, cacheItem);

}

return product;

}

Updating/Inserting Data in the Cache

Implementing a cache-aside pattern ensures that applications update data in the database first and then also update the cache to keep it consistent.

async function updateProduct(productId, updatedData) {

// Update the product in the database

await updateProductInDB(productId, updatedData);

// Create a CacheItem with absolute expiration

const cacheKey = `Product:${productId}`;

const updatedCacheItem = new ncache.CacheItem(updatedData);

const expiration = new ncache.Expiration(ncache.ExpirationType.Absolute, new ncache.TimeSpan(0, 10, 0));

updatedCacheItem.setExpiration(expiration);

// Update the cache

await cache.insert(cacheKey, updatedCacheItem);

}

Retrieving Data from the Cache

Fetch multiple cached items at once using the getBulk method to optimize performance:

1 2	const productKeys = ['Product:1001', 'Product:1002', 'Product:1003']; const cachedProducts = await cache.getBulk(productKeys);

Removing Data from the Cache

Remove multiple cached items at once using the removeBulk method to optimize performance:

1 2	const productKeys = ['Product:1001', 'Product:1002', 'Product:1003']; await cache.removeBulk(productKeys);

Advanced Caching Features

NCache provides advanced caching features to enhance application performance and scalability:

Groups: Manage related cache items together for efficient retrieval and removal.
Tags and Named Tags: Categorize data with labels for easy searching and filtering.
SQL Queries: Perform structured queries on cached data to retrieve relevant information.
Expiration and Eviction Policies: Automatically remove outdated data and manage memory efficiently.
Event Notifications: Receive real-time alerts when cache items change.

Conclusion

Integrating NCache with Node.js applications empower developers to build high-performance, scalable, and reliable systems. By leveraging distributed caching, applications can handle increased loads, reduce latency, and provide a seamless user experience. Explore NCache’s comprehensive features to optimize your Node.js applications today.

2 Comments

jhanvi mehta says:

January 18, 2022 at 1:25 pm

Thanks for providing the information about Node.js in NCache that was very helpful for me. A lot of information can be useful for node.js developers. My Appreciation to you! Keep posting more content.
Avinash Sharma says:

November 13, 2021 at 6:48 am

Your blog was absolutely fantastic! A great deal of great information and this can be useful some or maybe the other way. Keep updating your information.

Comments are closed.