0Pricing
Node.js Backend Development Bootcamp · Lezione

Tipi di exchange: Direct, Topic, Fanout e Headers

Instradi i messaggi verso i consumer corretti scegliendo l’exchange e la strategia di binding appropriati.

Tipi di exchange: Direct, Topic, Fanout e Headers è una lezione Node.js Backend Development Bootcamp gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Node.js Backend Development Bootcamp, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Node.js Backend Development Bootcamp include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Why Exchanges Exist

In RabbitMQ, producers never publish directly to a queue. They publish to an exchange, and the exchange decides which queue(s) receive the message based on bindings and a routing key.

This indirection is the core of event-driven routing. To get messages to the right consumers you must choose the correct exchange type:

  • direct — exact routing-key match
  • topic — pattern match with wildcards
  • fanout — broadcast to all bound queues
  • headers — match on message header attributes

Picking the wrong one means consumers miss messages or get flooded with irrelevant ones.

The Mental Model: Exchange + Binding + Routing Key

Three pieces work together:

  • Routing key: a string the producer attaches to each message (e.g. order.created).
  • Binding: a rule connecting an exchange to a queue, often with a binding key.
  • Exchange type: the algorithm that compares the routing key against the bindings.

The exchange evaluates every binding. A message can land in zero, one, or many queues. If it matches no binding, it is dropped (unless an alternate exchange is configured).

We'll use the amqplib library throughout these examples.

// Establishing a channel with amqplib
const amqp = require('amqplib');

async function connect() {
  const conn = await amqp.connect('amqp://localhost');
  const channel = await conn.createChannel();
  return { conn, channel };
}

module.exports = { connect };

Direct Exchange: Exact Match

A direct exchange delivers a message to queues whose binding key exactly equals the message's routing key.

It is the go-to choice when each message type maps to a specific worker. Classic use case: routing log messages by severity (error, warning, info) to dedicated queues.

  • Routing key error → only the queue bound with error.
  • Multiple queues can share the same binding key — all of them receive a copy.
const amqp = require('amqplib');

async function setupDirect(channel) {
  const ex = 'logs_direct';
  await channel.assertExchange(ex, 'direct', { durable: true });

  const errors = await channel.assertQueue('errors', { durable: true });
  await channel.bindQueue(errors.queue, ex, 'error');

  const allLogs = await channel.assertQueue('all_logs', { durable: true });
  await channel.bindQueue(allLogs.queue, ex, 'error');
  await channel.bindQueue(allLogs.queue, ex, 'warning');
  await channel.bindQueue(allLogs.queue, ex, 'info');
}

module.exports = { setupDirect };

Publishing to a Direct Exchange

The producer passes the routing key as the second argument to channel.publish(exchange, routingKey, content). The exchange does the rest.

Here a message with routing key error reaches both the errors queue and the all_logs queue from the previous scene, while an info message only reaches all_logs.

Notice the body must be a Buffer.

async function publishLog(channel, severity, message) {
  const ex = 'logs_direct';
  channel.publish(
    ex,
    severity, // routing key: 'error' | 'warning' | 'info'
    Buffer.from(JSON.stringify({ message, ts: Date.now() })),
    { persistent: true }
  );
  console.log(`Sent [${severity}] ${message}`);
}

// publishLog(channel, 'error', 'DB connection lost');
module.exports = { publishLog };

Topic Exchange: Pattern Matching

A topic exchange matches routing keys against binding patterns using two wildcards:

  • * (star) matches exactly one word.
  • # (hash) matches zero or more words.

Routing keys are dot-delimited words, e.g. order.eu.created. This is the most flexible exchange and is ideal for hierarchical event names.

  • order.*.created matches order.eu.created but not order.created.
  • order.# matches order.created, order.eu.shipped, etc.
  • *.eu.* matches any region-EU event with three words.

Setting Up Topic Bindings

Consider an order pipeline. Different services care about different slices of the event stream:

  • An audit service wants everything: order.#.
  • A EU compliance service wants only EU events: order.eu.*.
  • A shipping service wants any region's shipped event: order.*.shipped.

One published event can satisfy several patterns at once, fanning out only to the interested consumers.

const amqp = require('amqplib');

async function setupTopic(channel) {
  const ex = 'orders_topic';
  await channel.assertExchange(ex, 'topic', { durable: true });

  const audit = await channel.assertQueue('audit', { durable: true });
  await channel.bindQueue(audit.queue, ex, 'order.#');

  const euCompliance = await channel.assertQueue('eu_compliance', { durable: true });
  await channel.bindQueue(euCompliance.queue, ex, 'order.eu.*');

  const shipping = await channel.assertQueue('shipping', { durable: true });
  await channel.bindQueue(shipping.queue, ex, 'order.*.shipped');
}

module.exports = { setupTopic };

Reasoning About Topic Matches

Let's trace which queues receive each event given the bindings order.# (audit), order.eu.* (EU), order.*.shipped (shipping).

  • order.eu.created → audit + EU
  • order.us.shipped → audit + shipping
  • order.eu.shipped → audit + EU + shipping
  • order.created → audit only (only one word after order, so order.eu.* and order.*.shipped don't match)

This pure-JavaScript helper mimics the topic matching algorithm so you can verify your patterns offline.

function topicMatch(pattern, key) {
  const p = pattern.split('.');
  const k = key.split('.');

  function rec(pi, ki) {
    if (pi === p.length) return ki === k.length;
    if (p[pi] === '#') {
      for (let skip = ki; skip <= k.length; skip++) {
        if (rec(pi + 1, skip)) return true;
      }
      return false;
    }
    if (ki < k.length && (p[pi] === '*' || p[pi] === k[ki])) {
      return rec(pi + 1, ki + 1);
    }
    return false;
  }
  return rec(0, 0);
}

const keys = ['order.eu.created', 'order.us.shipped', 'order.eu.shipped', 'order.created'];
for (const key of keys) {
  console.log(key, {
    audit: topicMatch('order.#', key),
    eu: topicMatch('order.eu.*', key),
    shipping: topicMatch('order.*.shipped', key),
  });
}

Fanout Exchange: Broadcast

A fanout exchange ignores the routing key entirely and delivers every message to all bound queues. It is the simplest and fastest exchange.

Use it for broadcast scenarios: cache invalidation across all app instances, real-time notifications, or pushing updates to many WebSocket gateways.

Each consumer typically declares its own exclusive, auto-deleting queue so it gets a private copy of the broadcast.

const amqp = require('amqplib');

async function subscribeBroadcast(channel, onMessage) {
  const ex = 'cache_invalidations';
  await channel.assertExchange(ex, 'fanout', { durable: true });

  // Exclusive, server-named queue: unique per consumer, auto-deleted on disconnect
  const q = await channel.assertQueue('', { exclusive: true });
  await channel.bindQueue(q.queue, ex, ''); // routing key ignored for fanout

  await channel.consume(q.queue, (msg) => {
    if (msg) {
      onMessage(JSON.parse(msg.content.toString()));
      channel.ack(msg);
    }
  });
}

module.exports = { subscribeBroadcast };

Headers Exchange: Match on Attributes

A headers exchange ignores the routing key and instead matches on the message's headers (key/value pairs). Bindings specify the headers to match plus a special x-match argument:

  • x-match: all — every specified header must match (AND).
  • x-match: any — at least one specified header must match (OR).

This is useful when routing depends on multiple independent dimensions (e.g. format and region) that don't compose cleanly into a single dotted key.

const amqp = require('amqplib');

async function setupHeaders(channel) {
  const ex = 'reports_headers';
  await channel.assertExchange(ex, 'headers', { durable: true });

  const pdfEu = await channel.assertQueue('pdf_eu', { durable: true });
  await channel.bindQueue(pdfEu.queue, ex, '', {
    'x-match': 'all',
    format: 'pdf',
    region: 'eu',
  });

  const anyCsv = await channel.assertQueue('any_csv', { durable: true });
  await channel.bindQueue(anyCsv.queue, ex, '', {
    'x-match': 'any',
    format: 'csv',
    priority: 'high',
  });
}

module.exports = { setupHeaders };

Publishing with Headers

The producer attaches header values via the headers property of the publish options. The empty routing key is conventional for headers exchanges since it is unused.

Given the bindings from the previous scene, a message with { format: 'pdf', region: 'eu' } reaches pdf_eu. A message with { format: 'csv', region: 'us' } reaches any_csv (because x-match: any matched on format).

async function publishReport(channel, payload, headers) {
  const ex = 'reports_headers';
  channel.publish(
    ex,
    '', // routing key unused for headers exchange
    Buffer.from(JSON.stringify(payload)),
    { headers, persistent: true }
  );
}

// publishReport(channel, { id: 42 }, { format: 'pdf', region: 'eu' });
// publishReport(channel, { id: 43 }, { format: 'csv', region: 'us' });
module.exports = { publishReport };

Choosing the Right Exchange

A practical decision guide:

  • Direct — you have a fixed set of categories and want exact routing (severity levels, task types).
  • Topic — event names are hierarchical and consumers subscribe to flexible patterns. The most common choice for microservice event buses.
  • Fanout — every consumer must see every message (broadcast, cache busting).
  • Headers — routing depends on multiple non-hierarchical attributes, or you need AND/OR logic across dimensions.

Rule of thumb: reach for topic by default in event-driven systems; it subsumes direct (a pattern with no wildcards behaves like direct) and is far more extensible than fanout.

Quick Check

Test your understanding of exchange selection.

Recap

You learned how RabbitMQ routes messages through exchanges and bindings:

  • Producers publish to exchanges, never directly to queues; the exchange type is the routing algorithm.
  • Direct — exact routing-key match for fixed categories.
  • Topic — wildcard pattern match (* = one word, # = zero or more) for hierarchical events; the default pick for event buses.
  • Fanout — broadcast to all bound queues, ignoring the routing key.
  • Headers — match on header attributes with x-match: all (AND) or any (OR).

Always declare the exchange and queues with assertExchange/assertQueue and connect them with bindQueue. Choose the exchange that matches how your consumers need to subscribe, and you'll route the right messages to the right places with minimal coupling.

Domande Frequenti

La lezione «Tipi di exchange: Direct, Topic, Fanout e Headers» è gratuita?

Sì — il testo completo di «Tipi di exchange: Direct, Topic, Fanout e Headers» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Node.js Backend Development Bootcamp, passa a CoddyKit PRO. Il corso Node.js Backend Development Bootcamp include 4 lezioni in totale.

Cosa imparerò in «Tipi di exchange: Direct, Topic, Fanout e Headers»?

Instradi i messaggi verso i consumer corretti scegliendo l’exchange e la strategia di binding appropriati. Eserciti Node.js Backend Development Bootcamp con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Node.js Backend Development Bootcamp?

Non è richiesta alcuna esperienza precedente. Node.js Backend Development Bootcamp su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Tipi di exchange: Direct, Topic, Fanout e Headers»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Node.js Backend Development Bootcamp?

Sì. Ogni lezione Node.js Backend Development Bootcamp include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Producer, consumer e modello AMQP
  2. Tipi di exchange: Direct, Topic, Fanout e Headers
  3. Acknowledgement, code di dead-letter e retry
  4. Work queue, prefetch e consumer concorrenti
← Torna a Node.js Backend Development Bootcamp