Hoe produceer en consumeer je berichten in RabbitMQ (basisgebruik)?

Question

Accepted Answer

Basisgebruik van RabbitMQ omvat het **publiceren** van berichten naar een exchange/queue en het **consumeren** ervan — doorgaans via een clientbibliotheek (met gebruik van het AMQP-protocol). Inzicht in de basisstroom voor produceren/consumeren is het praktische startpunt.

## Berichten produceren (publiceren)

```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)
```

## Berichten consumeren

```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)
```

## Belangrijke praktische punten

```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)
```

## Waarom het belangrijk is

Inzicht in basisgebruik van produceren/consumeren is waardevol omdat het het **praktische startpunt voor het gebruik van RabbitMQ** is, dus het is noodzakelijke praktische kennis.

Weten hoe je berichten publiceert en consumeert, is de fundamentele vaardigheid voor het gebruik van RabbitMQ in applicaties.

Inzicht in het **produceren van berichten** — verbinding maken, een channel aanmaken, een queue declareren en berichten publiceren (met persistentie voor duurzaamheid) — is de basisschrijfbewerking.

Inzicht in het **consumeren van berichten** — de queue declareren, prefetch instellen, berichten consumeren, verwerken en **bevestigen** na verwerking (met handmatige acks voor betrouwbaarheid) — is de basisleesbewerking die de belangrijke betrouwbaarheidspraktijken omvat.

Inzicht in de **belangrijke praktische punten** — het gebruik van een clientbibliotheek (amqplib, pika, enz.), het gebruik van **channels** (lichte verbindingen voor bewerkingen, hergebruik van de verbinding), **durable queues plus persistent messages** voor het overleven van herstart, **handmatige acks** voor betrouwbare verwerking en **prefetch** voor eerlijke werkdistributie, en het afhandelen van fouten/herverbinding en het gebruik van exchanges/bindings voor routering — weerspiegelt de praktische overwegingen voor daadwerkelijk RabbitMQ-gebruik.

Deze praktische punten (channels, duurzaamheid, handmatige acks, prefetch) verbinden de conceptuele kennis (queues, bevestigingen, duurzaamheid) met daadwerkelijke code en weerspiegelen het bouwen van betrouwbare RabbitMQ-applicaties.

Daardat het produceren en consumeren van berichten de fundamentele praktische vaardigheid is voor het gebruik van RabbitMQ in applicaties, en omdat inzicht in de basisstroom en de praktische punten (channels, duurzaamheid, handmatige acks, prefetch) noodzakelijke praktische kennis is, is inzicht in basisgebruik van RabbitMQ produceren/consumeren waardevol, praktisch relevant kennis — het praktische startpunt voor het gebruik van RabbitMQ, het verbinden van concepten met code (met de betrouwbaarheidspraktijken van durable queues, persistent messages en handmatige acks), en noodzakelijk voor iedereen die daadwerkelijk applicaties met RabbitMQ bouwt.