How do you produce and consume messages in RabbitMQ (basic usage)?

Question

Accepted Answer

Basic RabbitMQ usage involves **publishing** messages to an exchange/queue and **consuming** them — typically via a client library (using the AMQP protocol). Understanding the basic produce/consume flow is the practical entry point.

## Producing (publishing) messages

```js
// connect, create a channel, declare a queue, publish
const channel = await connection.createChannel();
await channel.assertQueue('tasks', { durable: true });   // ensure the queue exists
channel.sendToQueue('tasks',
  Buffer.from(JSON.stringify({ task: 'send-email' })),
  { persistent: true }                                    // persistent message (survives restart)
);
// → publishes a message (here directly to a queue via the default exchange)
```

## Consuming messages

```js
await channel.assertQueue('tasks', { durable: true });
channel.prefetch(1);   // process one at a time (fair dispatch)
channel.consume('tasks', (msg) => {
  const data = JSON.parse(msg.content.toString());
  // process the task...
  channel.ack(msg);     // ACKNOWLEDGE after processing (reliable)
}, { noAck: false });   // manual acks (reliable)
```

## Key practical points

```text
✓ Use a CLIENT LIBRARY (amqplib for Node, pika for Python, Java client, etc.)
✓ CHANNELS → lightweight connections for operations (reuse the connection, use channels)
✓ DURABLE queues + PERSISTENT messages → survive broker restart (durability)
✓ MANUAL acks → reliable processing; PREFETCH → fair work distribution
✓ Handle errors, reconnection; use exchanges/bindings for routing (beyond the default exchange)
```

## Why it matters

Understanding basic produce/consume usage is valuable because it's the **practical entry point to using RabbitMQ**, so it's necessary hands-on knowledge.

Knowing how to publish and consume messages is the fundamental skill for using RabbitMQ in applications.

Understanding **producing messages** — connecting, creating a channel, declaring a queue, and publishing messages (with persistence for durability) — is the basic write operation.

Understanding **consuming messages** — declaring the queue, setting prefetch, consuming messages, processing them, and **acknowledging** after processing (with manual acks for reliability) — is the basic read operation that includes the important reliability practices.

Understanding the **key practical points** — using a client library (amqplib, pika, etc.), using **channels** (lightweight connections for operations, reusing the connection), **durable queues plus persistent messages** for surviving restarts, **manual acks** for reliable processing and **prefetch** for fair work distribution, and handling errors/reconnection and using exchanges/bindings for routing — reflects the practical considerations for real RabbitMQ usage.

These practical points (channels, durability, manual acks, prefetch) connect the conceptual knowledge (queues, acknowledgments, durability) to actual code and reflect building reliable RabbitMQ applications.

Since producing and consuming messages is the fundamental practical skill for using RabbitMQ in applications, and since understanding the basic flow and the practical points (channels, durability, manual acks, prefetch) is necessary hands-on knowledge, understanding basic RabbitMQ produce/consume usage is valuable, practically-relevant knowledge — the practical entry point to using RabbitMQ, connecting concepts to code (with the reliability practices of durable queues, persistent messages, and manual acks), and necessary for anyone actually building applications with RabbitMQ.