Glossary of fundamental terms and concepts - ApsaraMQ for RabbitMQ

Look up the key concepts used in ApsaraMQ for RabbitMQ. If you are new to message queuing, start with the message flow overview to see how components fit together. Use the alphabetical reference to look up individual terms.

Message flow overview

A message travels through four stages from producer to consumer:

A producer publishes a message to an exchange with a routing key.
The exchange evaluates its bindings -- rules that map routing keys to queues -- and routes the message to one or more queues.
The message stays in the queue until a consumer retrieves it.
The consumer processes the message and sends an acknowledgment back to the broker.

These components live inside a vhost, which provides logical isolation. Multiple vhosts run on a single instance -- the managed ApsaraMQ for RabbitMQ resource you provision in Alibaba Cloud.

Producer --> Exchange --> Binding --> Queue --> Consumer
              |                        |
              |  (routing key          |  (acknowledgment)
              |   + exchange type      |
              |   determine routing)   |
              |                        |
         +---------+            +-------------+
         |  vhost  |            |   channel   |
         +----+----+            +------+------+
              |                        |
         +----+----+            +------+------+
         |instance |            | connection  |
         +---------+            |   (TCP)     |
                                +-------------+

Alphabetical reference

A

Alternate exchange

A fallback exchange. If no binding matches the routing key, the exchange cannot route the message to any queue. Instead, it forwards the message to its configured alternate exchange (AE).

Arguments

Queue-level configuration parameters. Use arguments to set properties such as message time-to-live (TTL), dead-letter exchange, and dead-letter routing key.

Auto delete

An attribute of exchanges and queues that controls automatic cleanup:

Exchange: Automatically deleted after all queues unbind from it.
Queue: Automatically deleted after all consumers unsubscribe from it.

B

Binding

A routing rule that links an exchange to a queue. The exchange uses bindings to decide which queues receive a given message. Each binding typically includes a binding key or pattern that the exchange matches against the message routing key.

C

Channel

A lightweight, virtual connection that multiplexes over a single TCP connection. Opening a new TCP connection for every operation is expensive, so AMQP uses channels to share one connection across multiple concurrent tasks. A common pattern is to open one channel per thread.

For more information, see Connections and channels.

Connection

A physical TCP connection between a client (producer or consumer) and the ApsaraMQ for RabbitMQ broker. A single connection can carry multiple channels.

For more information, see Connections and channels.

Consumer

An application that subscribes to a queue to receive and process messages.

D

Dead-letter exchange

An exchange that routes dead-letter messages to a dead-letter queue. Any standard exchange type (direct, fanout, topic, or headers) can serve as a dead-letter exchange. Routing is based on the dead-letter routing key and message headers.

For more information, see Dead-letter exchanges.

Dead-letter message

A message that the broker forwards to a dead-letter exchange. A message becomes dead-lettered in any of the following situations:

The consumer rejects the message with basic.reject or basic.nack and the requeue parameter is set to false.
The message fails to be consumed after 16 redelivery attempts. For more information, see Retry policies.
The message exceeds its TTL in the queue. For more information, see Message TTL.

Dead-letter queue

A queue bound to a dead-letter exchange. Dead-letter queues store dead-letter messages for later inspection or reprocessing.

Dead-letter routing key

The routing key used to route a dead-letter message from the dead-letter exchange to the dead-letter queue. If no dead-letter routing key is set, the message's original routing key is used.

Delayed message

A message that the broker holds for a specified delay before delivering it to consumers. Delayed messages are useful for scheduled processing -- for example, sending a reminder 30 minutes after an order is placed.

For more information, see Delayed messages.

Durability

A property of queues, exchanges, and bindings. Durable entities survive broker restarts; non-durable entities are deleted when the broker restarts.

E

Exchange

The routing layer between producers and queues. A producer publishes a message to an exchange, which routes it to one or more queues based on the exchange type, bindings, and routing key.

For more information, see Exchanges.

I

Instance

A managed ApsaraMQ for RabbitMQ resource in Alibaba Cloud. An instance is an independent entity that contains vhosts, exchanges, queues, and other resources.

Instance throttling

Rate limiting that activates when an instance's peak transactions per second (TPS) exceeds the TPS threshold configured at purchase time. When throttling is triggered:

The broker returns an error code and error message.
The broker closes the channel used by the current request. Detect this exception in your code and reopen the channel.

For more information, see Best practices for instance throttling.

Internal

An exchange attribute. An internal exchange cannot receive messages directly from producers -- it can only receive messages from other exchanges through exchange-to-exchange bindings.

M

Message ID

An optional short-string attribute that serves as a unique identifier for a message. Message IDs help trace and deduplicate messages in use cases such as order tracking and ticket processing.

ApsaraMQ for RabbitMQ brokers do not guarantee message idempotence. To achieve idempotent processing, assign a unique identifier to each message and implement deduplication logic in your consumer.

For more information, see Implementing idempotence.

Message TTL

The maximum time a message can remain in a queue before it expires, specified as a non-negative integer in milliseconds. For example, a TTL of 1000 means the message expires after 1 second in the queue. Expired messages are either discarded or routed to a dead-letter exchange if one is configured.

For more information, see Message TTL.

P

Producer

An application that creates and publishes messages to an exchange.

Q

Queue

A buffer that stores messages until consumers retrieve them. Each message can be routed to one or more queues.

R

Routing key

A string that the producer attaches to each message. The exchange uses the routing key -- together with its type and bindings -- to determine which queues receive the message. The exact matching behavior depends on the exchange type.

V

Vhost

A virtual host that provides logical isolation of resources within an instance. Each vhost has its own set of exchanges, queues, and bindings, so applications on different vhosts do not interfere with each other.

An instance can contain multiple vhosts, and each vhost can contain multiple exchanges and queues. Specify a vhost when connecting a producer or consumer to ApsaraMQ for RabbitMQ.