Hvordan producerer og konsumerer du beskeder i RabbitMQ (grundlæggende brug)?

Question

Accepted Answer

Grundlæggende RabbitMQ-brug involverer **publicering** af beskeder til en exchange/kø og **konsumering** af dem — typisk via et klientbibliotek (ved hjælp af AMQP-protokollen). At forstå den grundlæggende produce/consume-flow er det praktiske indgangspunkt.

## Producing (publicering) af beskeder

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

## Konsumering af beskeder

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

## Vigtige praktiske punkter

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

## Hvorfor det betyder noget

At forstå grundlæggende produce/consume-brug er værdifuldt, fordi det er **det praktiske indgangspunkt til at bruge RabbitMQ**, så det er nødvendig hands-on-viden.

At vide, hvordan man publicerer og konsumerer beskeder, er den grundlæggende færdighed for at bruge RabbitMQ i applikationer.

At forstå **producing messages** — forbindelse, oprettelse af en kanal, erklæring af en kø og publicering af beskeder (med persistens for holdbarhed) — er den grundlæggende skriveoperation.

At forstå **consuming messages** — erklæring af køen, indstilling af prefetch, konsumering af beskeder, behandling af dem og **bekræftelse** efter behandling (med manuelle acks for pålidelighed) — er den grundlæggende læseoperation, der inkluderer de vigtige pålideliges praksisser.

At forstå de **vigtige praktiske punkter** — brug af et klientbibliotek (amqplib, pika osv.), brug af **channels** (lette forbindelser til operationer, genbrug af forbindelsen), **holdbare køer plus persistent beskeder** for at overleve genstarter, **manuelle acks** for pålidelig behandling og **prefetch** for retfærdig arbejdsfordeling, og håndtering af fejl/genoprettelse og brug af exchanges/bindings til routing — afspejler de praktiske overvejelser for faktisk RabbitMQ-brug.

Disse praktiske punkter (channels, durability, manual acks, prefetch) forbinder den begrebsmæssige viden (køer, bekræftelser, holdbarhed) til faktisk kode og afspejler opbygningen af pålidelige RabbitMQ-applikationer.

Da producing og consuming messages er den grundlæggende praktiske færdighed for at bruge RabbitMQ i applikationer, og da forståelsen af den grundlæggende flow og de praktiske punkter (channels, durability, manual acks, prefetch) er nødvendig hands-on-viden, er forståelsen af grundlæggende RabbitMQ produce/consume-brug værdifuld, praktisk relevant viden — det praktiske indgangspunkt til at bruge RabbitMQ, forbinde begreber til kode (med pålideliges praksisser for holdbare køer, persistent beskeder og manuelle acks), og nødvendig for alle, der faktisk opbygger applikationer med RabbitMQ.