Microsoft Azure Docs

Introduction to Azure Storage Queues with Node.js

Azure Storage Queues provide a way to store large numbers of messages that can be accessed from anywhere in the world via HTTP/HTTPS. A queue is a collection of messages. Each message can be up to 64 KB in size. A queue can contain any number of messages, up to the limit of the storage account's capacity.

This guide demonstrates how to use the Azure Storage Queue service with Node.js to perform common operations like creating queues, sending messages, and processing them.

Prerequisites

• An Azure account
• A Storage account created in Azure
• Node.js and npm installed on your development machine

Setting up your Node.js environment

If you don't have a Node.js project set up, create a new directory for your application and initialize it with npm:

mkdir azure-queue-demo
cd azure-queue-demo
npm init -y

Install the Azure Storage Queue SDK

Install the necessary Azure SDK package for queues:

npm install @azure/storage-queue

Connecting to Azure Storage Queue

To connect to your storage account, you'll need your storage account name and its primary access key. You can find these in the Azure portal under your storage account's "Access keys" section.

It's recommended to use environment variables or a secrets management service to store your credentials. For this example, we'll use environment variables.

# Set these environment variables in your terminal or .env file
# export AZURE_STORAGE_ACCOUNT_NAME="your_storage_account_name"
# export AZURE_STORAGE_ACCOUNT_KEY="your_storage_account_key"

Then, in your Node.js code:

const { QueueClient } = require("@azure/storage-queue");

async function getQueueClient() {
    const accountName = process.env.AZURE_STORAGE_ACCOUNT_NAME;
    const accountKey = process.env.AZURE_STORAGE_ACCOUNT_KEY;

    if (!accountName || !accountKey) {
        throw new Error("Please set AZURE_STORAGE_ACCOUNT_NAME and AZURE_STORAGE_ACCOUNT_KEY environment variables.");
    }

    const connectionString = `DefaultEndpointsProtocol=https;AccountName=${accountName};AccountKey=${accountKey};EndpointSuffix=core.windows.net`;
    const queueName = "my-sample-queue"; // Replace with your desired queue name

    const queueClient = new QueueClient(connectionString, queueName);
    await queueClient.createIfNotExists(); // Ensure the queue exists
    console.log(`Queue client created for queue: ${queueName}`);
    return queueClient;
}

// Example usage (call this function to get a client)
// getQueueClient().catch(err => console.error(err));
                

Common Queue Operations

Create a Queue

While the example above uses createIfNotExists(), you can explicitly create a queue:

const { QueueClient } = require("@azure/storage-queue");

async function createMyQueue(connectionString, queueName) {
    const queueClient = new QueueClient(connectionString, queueName);
    const createResponse = await queueClient.create();
    console.log(`Queue ${queueName} created successfully.`);
    return createResponse;
}
                

Send a Message

Add a message to the queue:

const { QueueClient } = require("@azure/storage-queue");

async function sendMessageToQueue(queueClient, messageText) {
    const response = await queueClient.sendMessage(messageText);
    console.log(`Message sent. Message ID: ${response.messageId}`);
    return response;
}

// Example:
// const queueClient = await getQueueClient();
// sendMessageToQueue(queueClient, "Hello from Node.js!").catch(err => console.error(err));
                

Receive a Message

Retrieve and remove the next message from the queue. The message is invisible for a specified timeout period (visibilitytimeout in seconds).

const { QueueClient } = require("@azure/storage-queue");

async function receiveMessageFromQueue(queueClient, visibilityTimeoutSeconds = 60) {
    const receiveResponse = await queueClient.receiveMessage({
        numberOfMessages: 1,
        visibilityTimeout: visibilityTimeoutSeconds
    });

    if (receiveResponse.receivedMessages.length > 0) {
        const message = receiveResponse.receivedMessages[0];
        console.log(`Received message: ${message.messageText}`);
        console.log(`Pop receipt: ${message.popReceipt}`);
        console.log(`Message ID: ${message.messageId}`);
        return message;
    } else {
        console.log("No messages in the queue.");
        return null;
    }
}

// Example:
// const queueClient = await getQueueClient();
// const message = await receiveMessageFromQueue(queueClient);
// if (message) {
//     // Process the message...
//     // Then delete it
//     await deleteMessageFromQueue(queueClient, message.messageId, message.popReceipt);
// }
                

Peek at a Message

Retrieve the next message from the queue without making it invisible. This is useful for inspecting messages without changing their state.

const { QueueClient } = require("@azure/storage-queue");

async function peekMessageFromQueue(queueClient) {
    const peekResponse = await queueClient.peekMessages({
        numberOfMessages: 1
    });

    if (peekResponse.peekedMessages.length > 0) {
        const message = peekResponse.peekedMessages[0];
        console.log(`Peeked message: ${message.messageText}`);
        console.log(`Message ID: ${message.messageId}`);
        return message;
    } else {
        console.log("No messages to peek at.");
        return null;
    }
}
                

Delete a Message

Once a message has been processed, it must be explicitly deleted from the queue using its messageId and popReceipt.

const { QueueClient } = require("@azure/storage-queue");

async function deleteMessageFromQueue(queueClient, messageId, popReceipt) {
    await queueClient.deleteMessage(messageId, popReceipt);
    console.log(`Message ${messageId} deleted successfully.`);
}

// Example (after receiving a message):
// await deleteMessageFromQueue(queueClient, receivedMessage.messageId, receivedMessage.popReceipt);
                

Clear a Queue

Remove all messages from the queue.

const { QueueClient } = require("@azure/storage-queue");

async function clearQueue(queueClient) {
    await queueClient.clearMessages();
    console.log(`Queue ${queueClient.name} cleared successfully.`);
}

// Example:
// const queueClient = await getQueueClient();
// clearQueue(queueClient).catch(err => console.error(err));
                

Get Queue Metadata

Retrieve metadata about the queue, such as the approximate number of messages.

const { QueueClient } = require("@azure/storage-queue");

async function getQueueMetadata(queueClient) {
    const response = await queueClient.getProperties();
    console.log(`Queue Name: ${queueClient.name}`);
    console.log(`Approximate Message Count: ${response.approximateMessagesCount}`);
    return response;
}

// Example:
// const queueClient = await getQueueClient();
// getQueueMetadata(queueClient).catch(err => console.error(err));
                

Delete a Queue

Delete the entire queue.

const { QueueClient } = require("@azure/storage-queue");

async function deleteQueue(queueClient) {
    await queueClient.delete();
    console.log(`Queue ${queueClient.name} deleted successfully.`);
}

// Example:
// const queueClient = await getQueueClient();
// deleteQueue(queueClient).catch(err => console.error(err));
                

Advanced Topics

Explore more advanced features:

• Message Time-to-Live (TTL)
• Message Visibility Timeout
• Handling Poison Messages
• Using Service Bus Queues for more complex scenarios

Conclusion

You've now learned how to perform basic queue operations using Azure Storage Queues and Node.js. This service is ideal for decoupling application components, asynchronous processing, and managing workloads efficiently.