Amazon MQ vs RabbitMQ: Managed vs Self-Hosted, Limits and Costs
Amazon MQ is AWS's managed message broker service, and RabbitMQ is one of the two open-source brokers it runs; the other is ActiveMQ Classic. Choose the RabbitMQ engine and your applications talk to real RabbitMQ, through the same AMQP client libraries, exchanges, bindings and queues. So the Amazon MQ vs RabbitMQ question comes down to who runs RabbitMQ: AWS, through Amazon MQ, or you, on EC2 or Kubernetes, or a hosting company such as CloudAMQP.
On Amazon MQ, AWS provisions and patches the servers, keeps a cluster spread over three Availability Zones, and puts a stable endpoint in front of it. It also adds CloudWatch metrics, IAM and LDAP sign-in and a Lambda trigger. In return you accept AWS's choice of versions, plugins and settings. In November 2026 that means RabbitMQ 4.3 while the open-source project is on 4.4, no streams, MQTT or STOMP, default limits such as a 512 KiB maximum message size, and an instance-hour price 3.35 times what the same m7g instance costs on EC2. As a rule of thumb, a team that uses RabbitMQ as an AMQP broker and doesn't want to operate it should start on Amazon MQ. A team that depends on streams, other protocols, extra plugins or the newest release, or that runs RabbitMQ at a size where the markup adds up, should run it or rent it from a specialist.
Redisson is our product, and we sell neither Amazon MQ nor RabbitMQ. Redisson PRO, which can stand in for a broker when every service is written in Java, has its own section near the end. Amazon MQ facts and prices were checked against AWS's documentation and price lists for US East (N. Virginia) on November 17, 2026, and RabbitMQ facts against RabbitMQ 4.4.1, released on November 16, 2026.
Amazon MQ vs RabbitMQ at a Glance
| Amazon MQ for RabbitMQ | RabbitMQ you run (EC2 or Kubernetes) | |
|---|---|---|
| What it is | AWS's managed broker service running the RabbitMQ engine; it also offers ActiveMQ Classic | The open-source broker, under the Mozilla Public License 2.0, on servers you manage |
| Who patches and replaces nodes | AWS; patches go in during a weekly maintenance window of up to two hours | You |
| Versions | 4.3 (recommended), 4.2 and 3.13 | Any; the newest is 4.4.1 |
| Topology | One node, or a three-node cluster across three Availability Zones, behind a Network Load Balancer | Any number of nodes, placed where you choose |
| Replication | On a cluster, quorum queues, the default type on 4.x, always with three replicas; classic queues are not replicated, and a single instance has nothing to replicate to | Quorum queues with the replica count you set, and streams |
| Protocols | AMQP 0-9-1 and AMQP 1.0 over TLS on port 5671; JMS through the RabbitMQ JMS client | The same, plus MQTT, STOMP, WebSocket and the stream protocol through plugins |
| Plugins | 11 that AWS supports: management, shovel, federation, consistent hash exchange, Prometheus, JMS topic exchange and five for authentication and credentials | Any, community plugins included |
| Configuration | A short list of keys, applied through a configuration revision and a reboot | All of rabbitmq.conf and advanced.config |
| Default limits on 4.x | 512 KiB per message, 10 consumers per channel, and caps on connections, channels, queues and exchanges | 16 MiB per message; no cap on connections, queues or consumers per channel until you set one |
| Disk | EBS: 200 GB on a single instance; 15 GB per node on an mq.m7g.large cluster, up to 75 GB | Whatever volumes you attach |
| Upgrades | In place, one version step at a time; the step from 3.13 to 4.2 blocks all connections while it runs | Node by node, or blue-green to a new cluster, when you choose |
| Monitoring | Broker metrics in CloudWatch, Prometheus endpoints and the management UI; no per-queue CloudWatch metrics on 4.x | Prometheus and Grafana, the management UI and the command-line tools on each node |
| Sign-in | Internal users, OAuth 2.0, IAM, LDAP, an HTTP service or X.509 certificates; no guest user | The same backends, configured and patched by you |
| AWS integrations | Lambda event source, EventBridge Pipes source, KMS encryption at rest, CloudFormation and Terraform resources | Whatever you build |
| SLA | 99.9 percent monthly uptime for clusters; none for single instances | None for the broker |
| Price, US East | Instance-hours plus EBS; about $603 a month for an mq.m7g.large cluster | EC2 and EBS; about $191 a month for three m7g.large instances, plus traffic between zones and your time |
What Amazon MQ for RabbitMQ Gives You
An Amazon MQ broker is either a single instance in one Availability Zone or a cluster of three nodes, one per zone. Both sit behind a Network Load Balancer, so the endpoint doesn't change when AWS replaces an instance. RabbitMQ 4.2 and 4.3 run only on mq.m7g instances, Graviton3 machines from mq.m7g.medium (1 vCPU, 4 GiB) to mq.m7g.16xlarge (64 vCPU, 256 GiB). AWS labels medium for evaluation and recommends large or bigger for production. RabbitMQ 3.13 also runs on the older mq.m5 family, and the small mq.t3.micro reached end of support on October 1, 2026.
Clients connect over TLS only. Port 5671 accepts AMQP 0-9-1 and, on RabbitMQ 4, AMQP 1.0, while ports 443 and 15671 serve the management UI and its HTTP API. There is no plain-text listener, and Amazon MQ deletes any user called guest, including one you create later. A broker is either public or private to your VPC, and a private broker keeps the subnets and security groups it was created with.
AWS also applies defaults of its own. On RabbitMQ 4 brokers, a queue declared without a type becomes a quorum queue, and the documentation recommends quorum queues for anything that must survive a failure, because "classic queues are not guaranteed to be durable in all cases". Classic queues still work but are no longer replicated. AWS's default policies apply to the default / virtual host only. On a cluster they cap every queue's length, at 8 million messages on mq.m7g.large, and refuse new publishes once a queue is full, which is why AWS asks publishers to turn on confirms. You can change or delete these policies.
If the decision in front of you is which engine to pick inside Amazon MQ, it turns on your clients. The ActiveMQ engine runs ActiveMQ Classic 5.19 or 5.18 and is the one for JMS 1.1 code that uses XA or queue selectors, and for MQTT or STOMP clients, which the RabbitMQ engine doesn't accept. ActiveMQ vs RabbitMQ compares the two brokers in depth. The rest of this page is about the RabbitMQ engine.
Versions, Upgrades and Maintenance Windows
Amazon MQ supports three RabbitMQ versions: 4.3, which it recommends and added on September 9, 2026; 4.2, its first 4.x release, added in November 2025; and 3.13. You choose the major and minor version. AWS chooses the patch level and applies it in the broker's weekly maintenance window, which can last up to two hours. Meanwhile the RabbitMQ project shipped 4.4.0 on October 20, 2026, and 4.4.1 on November 16.
RabbitMQ's community support and Amazon MQ's support follow separate calendars. According to RabbitMQ's release information, community support for 4.4 runs to July 31, 2027, and for 4.3 to January 31, 2027. For 4.2 it ended on July 31, 2026, and for 3.13 on September 30, 2024; after those dates, fixes come with a commercial license from Broadcom. Amazon MQ's own calendar gives no end-of-support date for any of its three versions. When it sets one, AWS promises at least 90 days' notice, stops new brokers on that version 30 days before the date, and moves the remaining brokers to the next version within 45 days after it. A version can therefore stay available on Amazon MQ long after its free community fixes have stopped.
Version upgrades run in place, one step at a time: 3.13 to 4.2, then 4.2 to 4.3. The step from 3 to 4 needs mq.m7g instances and no classic mirrored queues, and AWS provides a migration tool that converts them to quorum queues. While it runs, "Amazon MQ blocks all connections to the broker", for a time that grows with the number and depth of queues, and a 3.13 broker with Khepri enabled can't take the in-place path at all. AWS offers no managed blue-green deployment, so avoiding that downtime means building a second broker and moving clients yourself. Every other upgrade, and every reboot, takes a single instance offline and restarts a cluster one node at a time.
Running RabbitMQ yourself reverses these trade-offs. You can be on 4.4 the week it ships, apply a fix the day a security advisory appears, upgrade a cluster node by node while quorum queues keep their majority, or stand up a new cluster beside the old one. You also have to follow the community calendar, which gives each release series about nine months of free fixes, and the risk of falling behind it is yours.
What the Managed Service Leaves Out
Amazon MQ runs unmodified RabbitMQ code, but some features are missing or switched off. These are the gaps AWS documents, measured against a RabbitMQ 4.4 cluster you run:
| Feature | RabbitMQ you run | Amazon MQ for RabbitMQ |
|---|---|---|
| Streams and super streams | Streams since 3.9, super streams since 3.11 | Not supported; AWS warns that creating a stream "will result in data loss" |
| MQTT, STOMP, Web MQTT and Web STOMP | Plugins shipped with the server | Not available; MQTT clients need the ActiveMQ engine or AWS IoT Core |
Delays set by the producer (x-opt-delivery-time) | Quorum queues, since 4.4 | Not until AWS offers 4.4 |
| Deferred messages | Quorum queues over AMQP 1.0, since 4.4 | Not until AWS offers 4.4 |
| Plugins | Any, including community plugins | The 11 that AWS supports |
| Shovels | Static and dynamic | Dynamic only |
| Local random exchanges and message interceptors | Supported | Not supported |
| Configuration | Every key | Keys such as consumer_timeout, heartbeat, resource limits and authentication settings |
| Cluster size and replicas | Any node count; replicas per quorum queue | Three nodes, three replicas |
| Per-queue metrics | Every Prometheus endpoint, /metrics/per-object included | None in CloudWatch on 4.x, and no /metrics/per-object endpoint |
JSON logs, and command-line tools such as rabbitmqctl run on the nodes | Yes | No |
With exactly three nodes in three zones and three replicas per quorum queue, every queue already has a member in each zone, so the zone-aware member placement added in 4.4 matters only on larger clusters you run.
On Amazon MQ's 4.3, a consumer can push a failed message back for a later retry, since delayed retry arrived in that release, but a producer can't schedule a message for a later time. The workarounds are a queue per delay length whose message TTL expires into a dead-letter exchange that routes back to the work queue, or a scheduler in the application. The old delayed-message exchange plugin is no way out: it isn't on AWS's list, and the RabbitMQ team archived it in April 2026, citing its limitations and its dependence on Mnesia, the metadata store that 4.3 removed.
Default Limits to Check Before You Move
Since RabbitMQ 4.2, Amazon MQ applies default resource limits to every broker, which it describes as guardrails for availability. Open-source RabbitMQ sets almost none of them by default, as its limits guide shows, so a workload that runs comfortably on your own cluster can hit them on its first day on Amazon MQ. For an mq.m7g.large broker:
| Limit | Open-source default | Amazon MQ, single instance | Amazon MQ, cluster | Highest allowed, cluster |
|---|---|---|---|---|
| Message size | 16 MiB (up to 512 MiB) | 512 KiB | 512 KiB | 128 MiB |
| Consumers per channel | Unlimited | 10 | 10 | 1,000 |
| Connections per node | Unlimited | 1,500 | 500 | 5,000 |
| Channels per node | Unlimited | 4,500 | 1,500 | 15,000 |
| Queues | Unlimited | 1,000 | 1,000 | 10,000 |
| Exchanges | Unlimited | 1,000 | 1,000 | 50,000 |
| Virtual hosts | Unlimited | 50 | 50 | 1,500 |
| Disk | Your volume; publishers blocked below 50 MB free | 200 GB; blocked below 10 GiB free | 15 GB per node; blocked below 2 GiB free | 75 GB per node |
| Memory alarm | 60 percent of RAM | 4.3 GiB of 8 GiB | 4.3 GiB of 8 GiB | Fixed by AWS |
To raise a limit, you create a configuration revision with keys such as max_message_size or consumer_max_per_channel, associate it with the broker and reboot. A configuration can hold sections for each instance type and deployment mode, so one file can serve brokers of several sizes. Do it before cutover, because clients fail loudly at these limits: a message of 513 KiB closes its channel with PRECONDITION_FAILED, and a connection beyond the per-node cap is refused. The in-place upgrade from 3.13 to 4.2 sets the same trap. RabbitMQ 3 brokers ran with the maximum limits, and the upgrade applies the lower 4.x defaults.
A cluster node's EBS volume starts at 15 GB on mq.m7g.large, and since July 2026 it can grow in 5 GB steps on 4.x clusters, while a single instance gets 200 GB. The ceiling depends on the instance size: 75 GB per node on mq.m7g.large, 250 GB on mq.m7g.4xlarge, and 500 GB at most, from mq.m7g.12xlarge up. When free space on any node drops below the limit, a disk alarm blocks publishers across the whole cluster. A backlog you would park on a cheap 500 GB volume of your own therefore needs the largest Amazon MQ instances, so on Amazon MQ the safer plan is consumers that keep up.
Availability and Durability
A cluster deployment puts one node in each of three Availability Zones. Quorum queues replicate every message to all three with Raft, so a queue keeps accepting and delivering messages while any one node is down, and Amazon MQ keeps that replica count at three even if a client asks for another with x-quorum-initial-group-size. If a zone fails, Amazon MQ tries to move the affected node to another zone and rebalances once the zone is back. Maintenance takes nodes down one at a time and keeps at least two running. Each restart closes the connections on that node, so clients have to reconnect by themselves. AWS's SLA promises at least 99.9 percent monthly uptime for clustered brokers. Single-instance brokers have no SLA and are offline whenever they reboot or take maintenance.
Brokers still on 3.13 behave differently. Their clusters mirror classic queues to every node through a policy AWS manages, and when a node rejoins after maintenance, queue synchronization "blocks all other queue operations" until it finishes, which is why AWS tells 3.13 users to keep queues short. Moving to 4.x and quorum queues removes that pause.
A cluster you run gives you choices Amazon MQ doesn't. You can run five nodes and keep five replicas of a critical queue so that it survives two failures, spread replicas across zones by node tag on clusters bigger than three nodes since 4.4, size disks independently of instance types, and deploy on EKS with the open-source RabbitMQ Cluster Operator. You also own the failure handling: replacing a dead node, rebalancing queue leaders, renewing certificates, patching the operating system and the Erlang runtime, and watching memory and disk alarms around the clock.
Security, Networking and AWS Integrations
Amazon MQ's security defaults are strict. Every connection is encrypted, there is no guest account, and data at rest is encrypted with KMS, under an AWS-owned key unless you choose your own. Users can be stored in RabbitMQ or come from external sources: OAuth 2.0 since September 2025, LDAP since November 2025, and an HTTP service or X.509 client certificates over mutual TLS since January 2026, the last two on 4.x only. IAM sign-in builds on the OAuth 2.0 support: an application exchanges its IAM credentials for a token from AWS STS, and scope aliases in the broker's configuration map IAM roles to RabbitMQ permissions. A cluster of your own can use the same backends, since they are RabbitMQ plugins, but you configure and patch them yourself.
On its own, an Amazon MQ broker can't shovel messages to a private broker or federate from one. Since June 2026, private networking carries those links, and connections to private identity providers, through Amazon VPC Lattice and AWS PrivateLink to other Amazon MQ brokers or to RabbitMQ running in your VPC. That matters during a migration in either direction. Traffic over it costs $0.01 per GB processed, plus VPC Lattice charges.
Amazon MQ also connects to AWS services that can't reach a broker you run. Lambda can consume a RabbitMQ queue on Amazon MQ through an event source mapping, and EventBridge Pipes can read from one; neither offers a source for RabbitMQ outside Amazon MQ. The Lambda integration has limits to know before you design around it:
- By default, it runs one concurrent execution environment per RabbitMQ mapping, which AWS Support can raise for a mapping on request.
- It reads queues only and signs in with PLAIN credentials kept in AWS Secrets Manager.
- Functions can run for at most 14 minutes, and an error on any message retries the whole batch.
- On a single-instance broker, Lambda processes nothing during the maintenance window.
Monitoring and Day-to-Day Operations
Amazon MQ pushes broker metrics to CloudWatch every minute: connections, channels, consumers, queue and message counts, publish, confirm and acknowledgment rates, CPU, memory and disk. On RabbitMQ 4 brokers it no longer publishes per-queue metrics there. Since April 2026, brokers on 4.2 and later also expose RabbitMQ's Prometheus endpoints, /metrics, /metrics/detailed and /metrics/memory-breakdown but not /metrics/per-object, and AWS now recommends them over the management plugin for monitoring. For numbers on a single queue, AWS points to the management API and suggests polling it no more than once a minute.
On Amazon MQ you still choose the instance size, set alarms on memory, disk and queue depth, size prefetch and queue counts, write clients that reconnect after maintenance restarts, and schedule version upgrades. When Detectify moved its RabbitMQ from EKS to Amazon MQ in 2025, the team reported easier day-to-day operations while noting that instance sizing, disk and alerts still needed watching. What goes away is the work on the nodes: provisioning, operating system and Erlang patches, replacing failed instances, and the load balancer in front of the cluster.
The Same Client Code, Pointed at Amazon MQ
Moving a Java service from a cluster you run to Amazon MQ changes how it connects, and the messaging code stays the same. The sample below uses the RabbitMQ Java client 5.38.0, and the comments mark what Amazon MQ changes. It connects over TLS, declares a quorum queue with a delivery limit and a dead-letter exchange, publishes with confirms, and consumes with manual acknowledgments:
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.MessageProperties;
import java.nio.charset.StandardCharsets;
import java.util.Map;
ConnectionFactory factory = new ConnectionFactory();
// 5671 with TLS is the only AMQP listener. From amqp-client 5.33.0 an
// amqps URI also checks the broker's certificate and host name; older
// clients accept any certificate unless you give them an SSLContext
factory.setUri("amqps://b-1234abcd-56ef-78ab-90cd-ef1234567890"
+ ".mq.us-east-1.on.aws:5671");
factory.setUsername(System.getenv("MQ_USER"));
factory.setPassword(System.getenv("MQ_PASSWORD"));
// Maintenance restarts cluster nodes one at a time. Automatic recovery,
// on by default, reconnects and redeclares queues and consumers
factory.setNetworkRecoveryInterval(5_000);
Connection connection = factory.newConnection("orders-service");
Channel setup = connection.createChannel();
setup.exchangeDeclare("orders.dlx", BuiltinExchangeType.FANOUT, true);
setup.queueDeclare("orders.dead", true, false, false, null);
setup.queueBind("orders.dead", "orders.dlx", "");
// Quorum is the default type on Amazon MQ 4.x but not on a broker you
// run, so name it. Five deliveries, then the dead-letter exchange;
// without one, the fifth failure drops the message
setup.queueDeclare("orders", true, false, false, Map.of(
"x-queue-type", "quorum",
"x-delivery-limit", 4,
"x-dead-letter-exchange", "orders.dlx"));
// A cluster's default policy refuses publishes to a queue at its
// max-length, which arrives as a negative confirm. A message over the
// 512 KiB default size limit closes the channel instead
Channel publisher = connection.createChannel();
publisher.confirmSelect();
publisher.basicPublish("", "orders", MessageProperties.PERSISTENT_BASIC,
"order-1042".getBytes(StandardCharsets.UTF_8));
publisher.waitForConfirmsOrDie(5_000);
Channel consumer = connection.createChannel();
// Prefetch per consumer: RabbitMQ 4.3 rejects global QoS
consumer.basicQos(50);
DeliverCallback onDelivery = (tag, delivery) -> {
long deliveryTag = delivery.getEnvelope().getDeliveryTag();
try {
process(delivery.getBody());
consumer.basicAck(deliveryTag, false);
} catch (RuntimeException e) {
// Reject, not nack: since RabbitMQ 4.3 a nack doesn't count
// toward the delivery limit
consumer.basicReject(deliveryTag, true);
}
};
consumer.basicConsume("orders", false, onDelivery, tag -> { });
On Amazon MQ, recovery has to work, because AWS restarts nodes during maintenance; the client's automatic recovery, on by default, reconnects and re-registers queues, bindings and consumers. The way a consumer hands a message back also decides whether the delivery limit ever fires. Since RabbitMQ 4.3, only failed deliveries count toward it: basic.reject and dropped connections do, but basic.nack doesn't, so a consumer that nacks a poison message with requeue keeps getting it back. Amazon MQ treats the move from 4.2 to 4.3 as a minor upgrade, and its list of 4.3 breaking changes doesn't mention this one.
What Each Costs
Amazon MQ bills per broker instance-hour, three instances for a cluster, plus EBS storage at $0.10 per GB-month, and its pricing page lists on-demand hourly rates only. EC2 instances you run can be discounted with Savings Plans or Reserved Instances. List prices in US East (N. Virginia) for a 730-hour month, on November 17, 2026:
| Option | Configuration | Per month |
|---|---|---|
| Amazon MQ, single instance | mq.m7g.medium, for evaluation, with 200 GB | About $120 |
| Amazon MQ, single instance | mq.m7g.large with 200 GB | About $220 |
| Amazon MQ, cluster | Three mq.m7g.large nodes with 15 GB each | About $603 |
| Amazon MQ, cluster | Three mq.m7g.xlarge nodes with 25 GB each | About $1,205 |
| RabbitMQ on EC2 | Three m7g.large instances on demand with 50 GB of gp3 each | About $191, plus replication traffic |
| RabbitMQ on EC2 | Three m7g.xlarge instances on demand with 50 GB of gp3 each | About $369, plus replication traffic |
| CloudAMQP, dedicated cluster | Three nodes, "Big Bunny" plan | $297 |
| CloudAMQP, dedicated cluster | Three nodes, "Happy Hare" plan | $597 |
| CloudAMQP, dedicated cluster | Three nodes, "Roaring Rabbit" plan | $897 |
Per instance-hour, Amazon MQ costs 3.35 times the same m7g instance on EC2 at every size we compared, from medium to 4xlarge. The markup also covers traffic between the nodes of a cluster, which Amazon MQ doesn't bill. A cluster you run across three zones pays the standard $0.01 per GB in each direction for it, and a quorum queue's leader sends every message to two followers in other zones, so each GB published costs about $0.04 in replication alone. It costs more when a client connects to a node that doesn't host the queue's leader, because that node forwards the traffic. At 1,000 messages a second of 1 KiB, replication alone comes to about $108 a month. The premium of an mq.m7g.large cluster over three EC2 instances, about $412 a month, is used up at roughly 10 TB of published messages a month, about 3,800 of those messages a second around the clock. Traffic between clients and the broker crosses zones at the same rate on both.
For a small cluster, the difference comes to a few hundred dollars a month, which is a few hours of an engineer's time, and patching, replacing nodes, upgrading and being on call for a broker take most teams longer than that. The gap grows with instance size, to about $3,400 a month on mq.m7g.4xlarge nodes, and that is where running RabbitMQ yourself starts to pay for the people who do it. CloudAMQP sits between the two: it runs dedicated RabbitMQ clusters on AWS and other clouds, publishes one price per plan, and charges $99 a month extra for VPC peering or PrivateLink. Check its supported versions and plugins against your list as you would AWS's.
Moving Between Self-Hosted RabbitMQ and Amazon MQ
Because both sides run RabbitMQ, a move in either direction migrates the broker and leaves the application code alone. Exchanges, queues, bindings and policies travel as definitions: AWS's own queue migration guide exports them with rabbitmqadmin, edits the file and imports it again. Before moving to Amazon MQ, check five things:
- Version and clients. Target 4.2 or 4.3 on mq.m7g. Every client needs TLS on port 5671, and RabbitMQ 4 refuses Node.js clients on amqplib older than 0.10.7, or any client that negotiates a
frame_maxbelow 8,192. - Queue types. Classic mirrored queues don't exist on 4.x, and a declaration without a type becomes a quorum queue. On 4.3, declaring a transient queue that isn't exclusive, or asking for global QoS, fails.
- Limits. Compare your largest messages, consumers per channel, connections and channels per node, and queue counts with the defaults above, and raise them before the first client connects.
- Features. Streams, MQTT, STOMP, producer-set delays and plugins beyond AWS's 11 have to go, or move to something else, first.
- Disk. Compare your worst backlog with 15 to 75 GB per node on an mq.m7g.large cluster.
For the cutover, drain rather than copy. Create the topology on Amazon MQ, move consumers first, then producers, and let a dynamic shovel carry whatever is left in the old queues. Detectify moved more than 50 services in that order, with shovels between the old queues and the new ones. Amazon MQ runs dynamic shovels only, 30 of them by default on an mq.m7g.large cluster, and the cluster on your side has to be reachable from the broker, publicly or through private networking.
Leaving Amazon MQ works the same way in reverse: export the definitions, build the new cluster with anything you were missing, such as streams or plugins, shovel the remaining messages to it, and switch clients over. Budget for the operations work Amazon MQ was doing, which comes back with the cluster.
Where Amazon SQS Fits
Amazon SQS and SNS come up in the same searches, but they are a different trade. They are serverless, priced per request and need no capacity planning. They also replace AMQP with AWS's own API, have no exchanges or bindings, cap delays at 15 minutes and offer no message priority. Amazon MQ is the AWS service for keeping RabbitMQ's protocol and routing; SQS is the one for teams willing to change their messaging code to stop paying for brokers that sit idle. Amazon SQS vs Reliable Queue compares SQS feature by feature, and RabbitMQ alternatives covers SQS and SNS as a way off RabbitMQ.
A Third Option for Java Services on AWS
Some teams weighing Amazon MQ against RabbitMQ on EC2 need neither. All their services run on the JVM, and Amazon ElastiCache or MemoryDB already holds their cache or session data. Redisson PRO, the paid edition of Redisson, our Valkey and Redis client for Java, keeps queues and topics in that same store, so AWS still operates the servers and no broker is added. Reliable Queue covers work queues, Reliable PubSub covers topics with subscriptions, and Reliable Fanout sends one message to many queues. A JMS provider and a Spring Cloud Stream binder sit on top. The RabbitMQ features you would use on Amazon MQ map like this:
| RabbitMQ on Amazon MQ | Redisson PRO on ElastiCache or MemoryDB |
|---|---|
| Quorum queue | Reliable Queue |
| Delivery limit, 20 by default | deliveryLimit, 10 by default |
| Dead-letter exchange; without one, the message is dropped | deadLetterQueueName; without one, the message is deleted |
| Consumer timeout, 30 minutes, which closes the channel | Visibility timeout, 30 seconds by default, after which the message is available again |
basic.reject with requeue, or delayed retry on 4.3 | Negative acknowledgment as failed, with an optional redelivery delay |
basic.reject without requeue | Negative acknowledgment as rejected, straight to the dead-letter queue |
| Producer-set delay, 4.4 only, not on Amazon MQ | A delay on each message |
| Priorities, up to 32 levels on quorum queues since 4.3 | Priorities from 0 to 9 |
| Fanout exchange | Reliable Fanout, with filters |
| Topic exchange with a queue per consuming service | Reliable PubSub topic with a subscription per service; no routing-key patterns |
| RabbitMQ JMS client, without delivery delay | Redisson PRO's JMS provider, delivery delay included |
The sample sends a reminder with a 15-minute delay and the top priority, then processes it with the same limits as the RabbitMQ sample above. Here redisson is a RedissonClient connected to ElastiCache and Order is the application's message class:
import java.time.Duration;
import org.redisson.api.Message;
import org.redisson.api.MessageArgs;
import org.redisson.api.RReliableQueue;
import org.redisson.api.SyncFailureMode;
import org.redisson.api.SyncMode;
import org.redisson.api.queue.AcknowledgeMode;
import org.redisson.api.queue.QueueAckArgs;
import org.redisson.api.queue.QueueAddArgs;
import org.redisson.api.queue.QueueConfig;
import org.redisson.api.queue.QueueNegativeAckArgs;
import org.redisson.api.queue.QueuePollArgs;
RReliableQueue<Order> orders = redisson.getReliableQueue("orders");
// Five deliveries, then the dead-letter queue. Without a name, a
// message that runs out of attempts is deleted
orders.setConfigIfAbsent(QueueConfig.defaults()
.deliveryLimit(5)
.deadLetterQueueName("orders.dead")
.visibility(Duration.ofMinutes(2)));
// A delay set by the producer: on RabbitMQ that needs 4.4, which
// Amazon MQ doesn't offer yet
orders.add(QueueAddArgs.messages(MessageArgs.payload(order)
.delay(Duration.ofMinutes(15))
.priority(9))
// ElastiCache has no append-only file, so wait for the replica,
// and fail the call rather than log a warning if it misses
.syncMode(SyncMode.ACK)
.syncFailureMode(SyncFailureMode.THROW_EXCEPTION));
Message<Order> msg = orders.poll(QueuePollArgs.defaults()
.acknowledgeMode(AcknowledgeMode.MANUAL)
.timeout(Duration.ofSeconds(30)));
if (msg != null) {
try {
handle(msg.getPayload());
orders.acknowledge(QueueAckArgs.ids(msg.getId()));
} catch (RuntimeException e) {
// Back in 30 seconds; every delivery counts toward the limit
orders.negativeAcknowledge(QueueNegativeAckArgs
.failed(msg.getId())
.delay(Duration.ofSeconds(30)));
}
}
Weigh these limits first:
- Only JVM code can use it. A Python or Node.js service, or a device that speaks MQTT, keeps needing a broker.
- Queued messages occupy RAM in the cache. Give each queue a
maxSize, provision memory for the worst backlog, and set thenoevictioneviction policy so Valkey or Redis never drops a message to free space. - Durability comes from the AWS service. ElastiCache for Valkey 9.0 or later can log each write in more than one zone before acknowledging it, in its synchronous durability mode, which adds 18 percent to the node-hour price; without it, replication is asynchronous and a failover can lose acknowledged writes. MemoryDB logs every write before acknowledging it. The durability section of our Kinesis comparison and JMS on AWS cover the settings.
- There is no exchange-and-binding routing. Fanout with filters and topics with subscriptions cover most uses, but routing-key patterns and header exchanges have no direct equivalent.
- It needs a Redisson PRO license, which comes with round-the-clock support under an SLA for the client library. You can try it for free on your own ElastiCache or MemoryDB first.
How to Choose
Work down the table and take the first row that describes you. A row further down can still apply, so read it before deciding.
| If this is true | Choose |
|---|---|
| You depend on streams, MQTT, STOMP, a plugin AWS doesn't support, or a 4.4 feature such as producer-set delays | RabbitMQ you run on EC2 or EKS, or a hosting company that offers what you need |
| Lambda or EventBridge Pipes has to consume your queues directly | Amazon MQ for RabbitMQ, the only RabbitMQ they read from; plan around one execution environment per Lambda mapping |
| Every client runs on the JVM, ElastiCache or MemoryDB is already in the stack, and you route without routing-key patterns or header exchanges | Redisson PRO on that store, with synchronous durability |
| You can change the messaging code, and you need neither AMQP nor exchange routing | Amazon SQS with SNS |
| Your clusters run on large instances or move many terabytes a month, and your team runs RabbitMQ well | RabbitMQ you run; weigh the markup against your replication traffic and staff time |
| You want to keep RabbitMQ and have AWS run it, and your messages, connections and backlog fit Amazon MQ's limits once raised | Amazon MQ for RabbitMQ, as a cluster in production |
Amazon MQ vs RabbitMQ: Frequently Asked Questions
Is Amazon MQ the Same as RabbitMQ?
Not quite. Amazon MQ is AWS's managed message broker service, and RabbitMQ is one of the two engines it runs, next to ActiveMQ Classic. With the RabbitMQ engine, applications connect to real RabbitMQ, version 4.3, 4.2 or 3.13, with the usual client libraries over AMQP 0-9-1 or AMQP 1.0. What differs is what AWS controls: the versions and patch levels, the plugins, most configuration, the default resource limits and a cluster size fixed at three nodes.
Which RabbitMQ Versions Does Amazon MQ Support?
4.3, which AWS recommends, 4.2 and 3.13, as of November 2026, with 4.x only on mq.m7g instances. AWS applies patch versions itself during the maintenance window, upgrades brokers in place one step at a time, from 3.13 to 4.2 and then to 4.3, and lists no end-of-support date for any of the three. RabbitMQ's newest release is 4.4.1, from November 16, 2026, so 4.4 features such as delayed messages set by the producer aren't available on Amazon MQ yet.
Can Amazon MQ Run RabbitMQ Streams or MQTT?
No. AWS's documentation says Amazon MQ does not support streams and that creating one results in data loss, and the RabbitMQ engine accepts AMQP 0-9-1, AMQP 1.0 and JMS through the RabbitMQ JMS client, so MQTT, STOMP and WebSocket clients can't connect. For MQTT on AWS, Amazon MQ's ActiveMQ engine accepts MQTT 3.1.1 and AWS IoT Core serves device fleets. For streams, run RabbitMQ yourself or look at Amazon Kinesis Data Streams or Amazon MSK.
What Is the Maximum Message Size on Amazon MQ for RabbitMQ?
512 KiB by default on RabbitMQ 4 brokers, compared with 16 MiB on open-source RabbitMQ. You can raise it to 128 MiB with the max_message_size key in a broker configuration, which takes effect after a reboot. A larger message closes the publisher's channel with a PRECONDITION_FAILED error, so check your largest payloads before moving, or keep big payloads in S3 and send a reference.
Is Amazon MQ Cheaper Than Running RabbitMQ on EC2?
Not in instance-hours. In US East, an Amazon MQ instance costs 3.35 times the same m7g instance on EC2, so a three-node mq.m7g.large cluster is about $603 a month against about $191 for three EC2 instances with gp3 storage. Amazon MQ doesn't bill the traffic between its nodes, which a cluster you run across three zones pays at about $0.04 per GB published to quorum queues, and it takes over patching, node replacement and most upgrade work. For small and medium clusters that work usually costs more than the markup; for large ones the markup can pay for the people who run RabbitMQ.
Can AWS Lambda Consume From Amazon MQ for RabbitMQ?
Yes, through an event source mapping that reads a queue over AMQP 0-9-1 and invokes the function with batches of messages, and EventBridge Pipes can read the same queues. By default Lambda runs one concurrent execution environment per RabbitMQ mapping, which AWS Support can raise for each mapping. Credentials come from Secrets Manager with PLAIN authentication, functions are limited to 14 minutes, a failure retries the whole batch, and a single-instance broker delivers nothing to Lambda during maintenance. Lambda has no event source for RabbitMQ that you run yourself.
Can You Move From Amazon MQ Back to Self-Hosted RabbitMQ?
Yes. Both run RabbitMQ, so exporting the definitions from Amazon MQ's management API and importing them into a new cluster recreates the exchanges, queues, bindings and policies. You then move consumers, shovel the remaining messages across and move producers. Amazon MQ runs dynamic shovels only, and reaching a private cluster needs its private networking feature. Plan for what Amazon MQ didn't give you, such as streams or plugins, and for the operations work it was doing.
Similar articles
- RabbitMQ Alternatives: Seven Options, and What Each One Breaks
- ActiveMQ vs RabbitMQ: Key Differences, JMS Support and How to Choose
- Amazon SQS vs. Reliable Queue for Valkey and Redis
- Amazon Kinesis vs Valkey & Redis Based Reliable PubSub and Queue
- Redis vs. RabbitMQ: Choosing the Right Message Broker
- ActiveMQ Alternatives: Seven Options and What Happens to Your JMS Code
- How to Replace RabbitMQ With Valkey & Redis in Spring Cloud Stream Framework
- Redis Java client for AWS ElastiCache
- Redis Java Client for Amazon MemoryDB