0Pricing
Node.js Backend Development Bootcamp · Pelajaran

Tipe Exchange: Direct, Topic, Fanout, dan Headers

Rutekan pesan ke consumer yang tepat dengan memilih exchange dan strategi binding yang sesuai.

Tipe Exchange: Direct, Topic, Fanout, dan Headers adalah pelajaran Node.js Backend Development Bootcamp gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Node.js Backend Development Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Node.js Backend Development Bootcamp mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tipe Exchange: Direct, Topic, Fanout, dan Headers” gratis?

Ya — teks lengkap “Tipe Exchange: Direct, Topic, Fanout, dan Headers” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Node.js Backend Development Bootcamp, upgrade ke CoddyKit PRO. Kursus Node.js Backend Development Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Tipe Exchange: Direct, Topic, Fanout, dan Headers”?

Rutekan pesan ke consumer yang tepat dengan memilih exchange dan strategi binding yang sesuai. Kamu berlatih Node.js Backend Development Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Node.js Backend Development Bootcamp?

Tidak diperlukan pengalaman sebelumnya. Node.js Backend Development Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Tipe Exchange: Direct, Topic, Fanout, dan Headers” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Node.js Backend Development Bootcamp ini?

Ya. Setiap pelajaran Node.js Backend Development Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Producer, Consumer, dan Model AMQP
  2. Tipe Exchange: Direct, Topic, Fanout, dan Headers
  3. Acknowledgement, Dead-Letter Queue, dan Percobaan Ulang
  4. Antrean Kerja, Prefetch, dan Consumer yang Bersaing
← Kembali ke Node.js Backend Development Bootcamp