RABBIT

Învață RabbitMQ: comenzi explicate cu exemple

76 de comenzi 24 de categorii Comunitate & Q&A

RabbitMQ este cel mai larg adoptat și de încredere broker tradițional de mesagerie (Message Broker) open-source din lume, implementând standardul industrial AMQP (Advanced Message Queuing Protocol). Spre deosebire de Kafka (care funcționează ca un jurnal de streaming continuu), RabbitMQ este un broker inteligent cu consumatori simpli: este conceput special pentru rutarea flexibilă și granulară a fiecărui mesaj individual, garanții stricte de confirmare și sarcini de fundal distribuite (Background Task Queues).

De la microservicii asincrone care procesează plăți, transcodare media sau trimitere de email-uri, până la sisteme critice din telecomunicații și sănătate, RabbitMQ oferă o flexibilitate de rutare inegalabilă prin intermediul Exchange-urilor, a cozilor de mare rezistență Quorum Queues (bazate pe consens Raft) și a mecanismelor de Dead Lettering (DLX).

Arhitectura AMQP în RabbitMQ: Exchange -> Binding -> Queue

# Producător (Publisher)
#        │ (Trimite mesaj cu Routing Key: 'order.created')
#        ▼
# ┌─────────────────────────────────────────────────────────────┐
# │ Exchange (ex: 'orders_exchange' - Tip Topic)                │
# └──────┬──────────────────────────────────────────────┬───────┘
#        │ (Binding: 'order.*')                         │ (Binding: '*.critical')
#        ▼                                              ▼
# ┌───────────────────────────┐                ┌───────────────────────────┐
# │ Queue: 'billing_service'  │                │ Queue: 'audit_logger'     │
# └─────────────┬─────────────┘                └─────────────┬─────────────┘
#               ▼                                            ▼
#      Consumator Billing                           Consumator Audit

Pilonii Tehnologici ai RabbitMQ

Concept AMQP	Mecanism Tehnic	Rol în Producție
Direct Exchange	Rutează mesajul doar către coada al cărei Binding Key este identic cu Routing Key-ul.	Procesare dedicată de sarcini țintite către un anumit tip de worker.
Fanout Exchange	Ignoră Routing Key-ul și transmite mesajul în paralel către toate cozile legate.	Modele Publish/Subscribe (broadcast de evenimente către multiple subsisteme).
Topic Exchange	Rutează pe baza potrivirilor de tipar cu wildcard: `*` (un cuvânt) sau `#` (zero sau mai multe).	Rutare contextuală sofisticată (ex: `eu.orders.payments.urgent`).
Quorum Queues	Cozi replicate distribuit pe multiple noduri de cluster folosind algoritmul Raft.	Înlocuiește vechile Mirrored Queues, garantând zero pierderi de mesaje și recuperare automată.

Exemplu Concret: Trimitere și Consum Mesaj în Python (pika)

import pika

# 1. Conectare la brokerul RabbitMQ:
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# 2. Declararea unei cozi durabile (rezistentă la restart server):
channel.queue_declare(queue='task_queue', durable=True)

# 3. Publicarea unui mesaj cu persistență pe disc:
channel.basic_publish(
    exchange='',
    routing_key='task_queue',
    body='Procesează factura #90812',
    properties=pika.BasicProperties(
        delivery_mode=pika.DeliveryMode.Persistent
    )
)
print(" [x] Mesaj expediat cu succes!")
connection.close()

AMQP & Rutare 1 comandă

Arhitectura AMQP în RabbitMQ: Cum Funcționează Exchange-urile (Direct, Fanout, Topic, Headers) și Routing Keys channel.exchange_declare(exchange='events', exchange_type='topic'); Ghid complet pentru modelul de rutare AMQP: diferențele între cele 4 tipuri de exchange-uri, mecanica binding-urilor și construirea de topologii flexibile de mesagerie decuplată.

cli 4 comenzi

Erori & Dead Lettering 1 comandă

Gestiunea Avansată a Eșecurilor în RabbitMQ: Dead Letter Exchanges (DLX), TTL pe Mesaje și Retry Queues args = {'x-dead-letter-exchange': 'retry_dlx', 'x-message-ttl': 60000} Ghid enterprise pentru reziliența mesajelor în RabbitMQ: configurarea x-dead-letter-exchange, expirarea automată a mesajelor (TTL), gestionarea mesajelor respinse (nack/reject) și reîncercări exponențiale.

Clustering & Quorum Queues 1 comandă

Quorum Queues în RabbitMQ: Replicare Bazată pe Consens Raft și Disponibilitate Înaltă Fără Pierderi de Date channel.queue_declare(queue='critical_orders', arguments={'x-queue-type': 'quorum'}); Ghid tehnic pentru Quorum Queues: înlocuirea vechiului mecanism HA Mirrored Queues, consensul distribuit Raft, configurarea lungimii maxime și consistența datelor în producție.

Performanță & Tuning 1 comandă

Optimizarea Debitul de Mesaje în RabbitMQ: Consumer Prefetch (QoS), Acknowledgment Manual și Backpressure channel.basic_qos(prefetch_count=50); channel.basic_ack(delivery_tag=tag); Ghid complet de tuning și performanță în RabbitMQ: de ce basic.qos prefetch_count este critic pentru prevenirea epuizării memoriei consumatorilor, confirmări manuale (basic_ack) și evitarea congestionării brokerului.

amqp 8 comenzi

Performanță și Streaming 1 comandă

RabbitMQ Streams: Procesare de Mare Debit cu Loguri Append-Only și Offset-uri rabbitmq-plugins enable rabbitmq_stream; queue_declare(queue, arguments={"x-queue-type": "stream"}) Ghid complet pentru RabbitMQ Streams: noul motor de mare performanță (milioane de mesaje/sec), persistență append-only, citire nelimitată cu offset-uri și compararea cu Apache Kafka.

Fiabilitate și Tranzacții 1 comandă

Confirmări de la Producător în RabbitMQ: Publisher Confirms vs Tranzacții AMQP channel.confirm_delivery(); channel.basic_publish(...) Ghid complet pentru Publisher Confirms în RabbitMQ: confirmarea asincronă a persistării mesajelor pe disc cu confirm_select, prevenirea pierderii de mesaje la scriere și comparație cu tranzacțiile.

Scalabilitate și Sharding 1 comandă

Exchange-uri cu Hash Consistent în RabbitMQ: Sharding și Partiționare de Cozi exchange_declare(exchange="hash-ex", type="x-consistent-hash") Ghid complet pentru Consistent Hash Exchange în RabbitMQ: distribuirea uniformă a milioanelor de mesaje pe mai multe cozi paralele pe baza hash-ului cheii de rutare (sharding).

Programare Mesaje 1 comandă

Mesaje Întârziate și Planificate în RabbitMQ: Plugin-ul Delayed Message Exchange headers={"x-delay": 60000} ; amână livrarea cu 60 de secunde Ghid complet pentru programarea livrării mesajelor în RabbitMQ: utilizarea plugin-ului x-delayed-message pentru remindere și plăți amânate fără crearea de cozi temporare cu TTL.

Administrare și Sănătate Cluster 1 comandă

Alarme de Resurse și Flow Control în RabbitMQ: Memory Watermark și Disk Free Limit rabbitmqctl set_vm_memory_high_watermark 0.4; rabbitmqctl status Ghid complet pentru prevenirea blocării nodurilor RabbitMQ: configurarea vm_memory_high_watermark, disk_free_limit, starea blocked a conexiunilor și paginarea mesajelor pe disc.

Arhitectură WAN și Multi-Cloud 1 comandă

Federarea Cozilor și Modulul Shovel în RabbitMQ: Migrare și Conexiuni WAN rabbitmq-plugins enable rabbitmq_shovel rabbitmq_federation Ghid complet pentru conectarea instanțelor RabbitMQ peste conexiuni de internet (WAN): transfer continuu cu Shovel și distribuirea mesajelor la cerere cu RabbitMQ Federation.

Gestiunea Cozilor 1 comandă

Cozi cu Prioritate în RabbitMQ: Parametrul x-max-priority și Header-ul Priority queue_declare(..., arguments={"x-max-priority": 10}); BasicProperties(priority=9) Ghid complet pentru gestionarea cozilor cu prioritate în RabbitMQ: configurarea x-max-priority la declarare, trimiterea mesajelor cu priority și servirea urgentă a sarcinilor critice.

Protocoale și IoT 1 comandă

Integrarea IoT și WebSockets în RabbitMQ: Protocoalele MQTT și Web-STOMP rabbitmq-plugins enable rabbitmq_mqtt rabbitmq_web_stomp Ghid complet pentru conectarea dispozitivelor IoT și aplicațiilor de browser la RabbitMQ: utilizarea plugin-urilor rabbitmq_mqtt și rabbitmq_web_stomp pentru mesagerie în timp real.

Comenzi Esențiale CLI rabbitmqctl și Gestiune Nod 6 comenzi

Management, Diagnosticare și Utilitare CLI 4 comenzi

Tipuri de Exchange-uri AMQP și Strategii de Rutare 6 comenzi

Tipuri de Cozi și Arhitecturi de Stocare 4 comenzi

Metode Protocolare AMQP: Topologie și Resurse 4 comenzi

Metode Protocolare AMQP: Publicare, Consum și Confirmări 3 comenzi

Calitatea Serviciului (QoS) și Garanții de Livrare 5 comenzi

Proprietăți și Metadate Mesaj AMQP 8 comenzi

Politici și Argumente Avansate pentru Cozi (x-arguments) 9 comenzi

Replicare, Topologii Distribuite și Plugin-uri 3 comenzi

Toate comenzile, conceptele și metodele RabbitMQ

Ghidul complet și structurat pentru ecosistemul de mesagerie distribuită RabbitMQ: comenzi CLI de administrare și clustering (rabbitmqctl, rabbitmq-diagnostics, rabbitmqadmin), tipuri de Exchange-uri și strategii de rutare, tipuri de cozi (Quorum, Stream, Classic), metode de canal AMQP (declarare, publicare, consum, confirmări), garanții de livrare QoS, proprietăți de mesaje și politici avansate x-arguments.

Comenzi Esențiale CLI rabbitmqctl și Gestiune Nod (8)

Comandă CLI	Ce face
`rabbitmqctl status`	Afișează starea detaliată a nodului RabbitMQ curent, versiunea brokerului, versiunea mașinii virtuale Erlang/OTP, consumul de memorie și fișiere deschise. `rabbitmqctl status`
`rabbitmqctl cluster_status`	Inspectează topologia clusterului, nodurile membre active (Disc vs RAM), nodurile offline, starea alarmelor de resurse și eventualele partiții de rețea. `rabbitmqctl cluster_status`
`rabbitmqctl stop_app && start_app`	Oprește sau pornește aplicația RabbitMQ lăsând procesul Erlang VM activ; esențial în procedurile de mentenanță și alăturare la cluster. `rabbitmqctl stop_app && rabbitmqctl reset && rabbitmqctl start_app`
`rabbitmqctl join_cluster`	Conectează nodul local (oprit cu stop_app) la un cluster RabbitMQ existent prin intermediul unui nod de contact specificat. `rabbitmqctl join_cluster rabbit@master-node-01`
`rabbitmqctl list_queues`	Listează cozile dintr-un vhost cu atribute specifice: număr de mesaje, mesaje neconfirmate, consumatori activi și tipul cozii. `rabbitmqctl list_queues name messages consumers type`
`rabbitmqctl list_exchanges`	Afișează toate punctele de schimb (Exchanges) configurate pe broker, tipul lor (direct, fanout, topic, headers) și durabilitatea. `rabbitmqctl list_exchanges name type durable`
`rabbitmqctl list_bindings`	Afișează toate asocierile (legăturile) stabilite între Exchange-uri și Cozi, inclusiv cheia de rutare (binding key). `rabbitmqctl list_bindings source_name destination_name routing_key`
`rabbitmqctl set_policy`	Aplică dinamic o politică bazată pe regex asupra resurselor (ex: comutare pe Quorum Queues, configurare TTL automat sau limite de capacitate). `rabbitmqctl set_policy ha-all "^orders\." '{"ha-mode":"all"}' --apply-to queues`

Management, Diagnosticare și Utilitare CLI (6)

Utilitar / Comandă	Ce face
`rabbitmq-plugins enable`	Activează un plugin intern RabbitMQ, cum ar fi interfața web de administrare (rabbitmq_management) sau exportatorul Prometheus. `rabbitmq-plugins enable rabbitmq_management`
`rabbitmq-plugins list`	Afișează catalogul complet de module și extensii disponibile în distribuția RabbitMQ și starea lor de activare. `rabbitmq-plugins list`
`rabbitmq-diagnostics check_running`	Healthcheck rapid de liveness/readiness pentru containere și Kubernetes: confirmă că procesul brokerului este activ și acceptă conexiuni. `rabbitmq-diagnostics check_running`
`rabbitmq-diagnostics memory_breakdown`	Analizează în detaliu structura memoriei RAM ocupate: cozi, procese Erlang, cache-uri de conexiuni și tabele Mnesia. `rabbitmq-diagnostics memory_breakdown`
`rabbitmqadmin declare queue`	Utilitar Python CLI integrat în plugin-ul de management pentru administrarea facilă a resurselor prin linia de comandă fără cod de aplicație. `rabbitmqadmin declare queue name=audit_log durable=true`
`rabbitmqadmin publish & get`	Publică manual un mesaj sau inspectează conținutul unei cozi direct din terminal pentru depanare. `rabbitmqadmin publish exchange=amq.default routing_key=audit_log payload="Ping test"`

Tipuri de Exchange-uri AMQP și Strategii de Rutare (7)

Tip Exchange / Rutare	Ce face
`Direct Exchange`	Rutează mesajele exclusiv către cozile al căror Binding Key este identic punct cu punct cu Routing Key-ul furnizat de producător. `channel.exchange_declare(exchange='direct_logs', exchange_type='direct')`
`Fanout Exchange`	Ignoră cheia de rutare și transmite mesajul în paralel către toate cozile asociate (model clasic Publish/Subscribe – broadcast). `channel.exchange_declare(exchange='broadcast_events', exchange_type='fanout')`
`Topic Exchange`	Rutează pe baza potrivirilor de tipar cu wildcard-uri: * (exact un cuvânt) și # (zero sau mai multe cuvinte separate prin punct). `channel.queue_bind(queue='eu_orders', exchange='topics', routing_key='orders.eu.*')`
`Headers Exchange`	Ignoră cheia de rutare și direcționează mesajul pe baza tabelei de antete (headers); suportă potrivire completă (x-match: all) sau parțială (x-match: any). `channel.queue_bind(queue='pdf_q', exchange='hdr_ex', arguments={'x-match': 'all', 'format': 'pdf'})`
`Default (Nameless) Exchange`	Exchange predefinit de tip direct oferit de broker; leagă automat fiecare coadă creată cu o cheie de rutare egală cu numele cozii. `channel.basic_publish(exchange='', routing_key='my_queue', body=b'Hello!')`
`Dead Letter Exchange (DLX)`	Exchange de securitate către care sunt re-rutate automat mesajele respinse prin NACK/Reject, expirate prin TTL sau eliminate la depășirea cozii. `arguments={'x-dead-letter-exchange': 'retry_dlx', 'x-dead-letter-routing-key': 'dead_tasks'}`
`Alternate Exchange (AE)`	Exchange secundar asociat unui exchange principal, care preia automat toate mesajele ce nu au putut fi rutate către nicio coadă. `channel.exchange_declare('main_ex', 'direct', arguments={'alternate-exchange': 'unrouted_ae'})`

Tipuri de Cozi și Arhitecturi de Stocare (7)

Tip Coadă / Mod	Ce face
`Classic Queues`	Coada tradițională AMQP din RabbitMQ; oferă debit extrem pe un singur nod și comportament FIFO clasic. `channel.queue_declare(queue='jobs', arguments={'x-queue-type': 'classic'})`
`Quorum Queues`	Cozi distribuite de înaltă disponibilitate bazate pe algoritmul de consens Raft; protejează împotriva pierderii de date și a scenariilor de split-brain. `channel.queue_declare(queue='critical_orders', durable=True, arguments={'x-queue-type': 'quorum'})`
`Stream Queues`	Cozi de mare debit de tip jurnal numai-adăugare (append-only log); permit re-citirea istorică prin offset și consum non-destructiv. `channel.queue_declare(queue='telemetry_stream', durable=True, arguments={'x-queue-type': 'stream'})`
`Auto-delete Queues`	Cozi efemere care sunt șterse automat de broker imediat ce ultimul consumator activ își închide conexiunea sau canalul. `channel.queue_declare(queue='temp_worker_q', auto_delete=True)`
`Exclusive Queues`	Cozi accesibile doar pe durata conexiunii curente; la deconectarea clientului, coada este eliminată (esențiale în modele RPC). `result = channel.queue_declare(queue='', exclusive=True)`
`Priority Queues`	Cozi cu suport nativ de prioritizare (valori tipice între 1 și 10); mesajele cu prioritate mare sunt distribuite înaintea celorlalte. `channel.queue_declare(queue='priority_tasks', arguments={'x-max-priority': 10})`
`Lazy Queues`	Scrie mesajele direct pe disc pe măsură ce sosesc, menținând un consum minim de RAM chiar și în prezența milioanelor de mesaje în așteptare. `channel.queue_declare(queue='bulk_q', arguments={'x-queue-mode': 'lazy'})`

Metode Protocolare AMQP: Topologie și Resurse (7)

Metodă AMQP	Ce face
`channel.queue_declare`	Declară o coadă în broker; operațiunea este idempotentă dacă parametrii furnizați sunt identici cu cei existenți. `channel.queue_declare(queue='payments', durable=True)`
`channel.exchange_declare`	Creează un Exchange; parametrul internal=True interzice publicarea directă din aplicații, permițând doar alimentarea prin legături între exchange-uri. `channel.exchange_declare(exchange='events', exchange_type='topic', durable=True)`
`channel.queue_bind`	Asociază o coadă cu un punct de schimb (Exchange) folosind o cheie de legătură (routing key). `channel.queue_bind(queue='invoices', exchange='billing', routing_key='invoice.*')`
`channel.exchange_bind`	Stabilește o legătură directă între două Exchange-uri, permițând compunerea unor topologii de rutare arborescente. `channel.exchange_bind(destination='archive_ex', source='main_ex', routing_key='#')`
`channel.queue_unbind`	Dizolvă legătura dintre o coadă și un Exchange, oprind redirecționarea viitoarelor mesaje. `channel.queue_unbind(queue='invoices', exchange='billing', routing_key='invoice.*')`
`channel.queue_purge`	Golește instantaneu toate mesajele aflate în așteptare dintr-o coadă, fără a șterge definiția acesteia. `channel.queue_purge(queue='obsolete_tasks')`
`channel.queue_delete`	Elimină complet o coadă de pe broker; poate valida opțional dacă este neutilizată sau dacă este deja goală. `channel.queue_delete(queue='temp_q', if_empty=True)`

Metode Protocolare AMQP: Publicare, Consum și Confirmări (8)

Metodă AMQP	Ce face
`channel.basic_publish`	Publică un mesaj către un Exchange; flag-ul mandatory=True returnează mesajul expeditorului dacă nu poate fi rutat la nicio coadă. `channel.basic_publish(exchange='direct_logs', routing_key='error', body=b'Disk full!')`
`channel.basic_consume`	Înregistrează un consumator asincron (mecanism push) pe o coadă, primind mesaje de îndată ce sunt disponibile. `channel.basic_consume(queue='tasks', on_message_callback=callback_fn, auto_ack=False)`
`channel.basic_get`	Extrage sincron un singur mesaj dintr-o coadă (polling); se utilizează doar în scenarii punctuale datorită overhead-ului de rețea. `method, props, body = channel.basic_get('jobs', auto_ack=False)`
`channel.basic_ack`	Trimite confirmarea de procesare cu succes către broker, permițând brokerului să șteargă mesajul din coadă. `channel.basic_ack(delivery_tag=method.delivery_tag)`
`channel.basic_nack`	Trimite o confirmare negativă; dacă requeue=True mesajul este reintrodus în coadă, iar dacă este False, ajunge în DLX. `channel.basic_nack(delivery_tag=method.delivery_tag, requeue=False)`
`channel.basic_reject`	Respinge un singur mesaj individual (similar cu basic_nack, dar fără opțiunea de confirmare în bloc multiple). `channel.basic_reject(delivery_tag=method.delivery_tag, requeue=False)`
`channel.basic_cancel`	Dezactivează un consumator înregistrat prin basic_consume, oprind primirea de noi mesaje pe canal. `channel.basic_cancel(consumer_tag='worker_alpha')`
`channel.basic_recover`	Cere brokerului să livreze din nou toate mesajele care au fost trimise clientului pe canalul curent dar nu au fost încă confirmate. `channel.basic_recover(requeue=True)`

Calitatea Serviciului (QoS) și Garanții de Livrare (7)

Mecanism / Metodă	Ce face
`channel.basic_qos (prefetch_count)`	Limitează numărul de mesaje neconfirmate alocate simultan unui worker; previne congestionarea consumatorilor lenți (Fair Dispatch). `channel.basic_qos(prefetch_count=1)`
`Publisher Confirms`	Activează confirmările asincrone din partea brokerului către producător la scrierea pe disc sau replicarea mesajului (ACK/NACK). `channel.confirm_delivery()`
`waitForConfirms`	Blochează execuția până la primirea confirmării că toate mesajele trimise în lotul curent au fost acceptate și persistate. `if not channel.wait_for_confirms(): raise Exception("Publicare esuata!")`
`Tranzacții AMQP (txSelect/txCommit)`	Oferă tranzacționalitate ACID pe canal; asigură consistență dar scade sever debitul comparativ cu Publisher Confirms. `channel.tx_select(); channel.basic_publish(...); channel.tx_commit()`
`Return Callback (mandatory)`	Callback apelat pe client când un mesaj publicat cu mandatory=True este respins de broker din lipsa unei cozi legate. `channel.add_on_return_callback(lambda ch, m, p, b: print("Mesaj nerutat!"))`
`Consumer Cancel Notification`	Notificare trimisă de broker când o coadă pe care consumatorul o asculta este ștearsă sau nodul de găzduire devine indisponibil. `channel.add_on_cancel_callback(lambda frame: print("Coada a fost stearsa!"))`
`Heartbeats AMQP`	Transmite frame-uri periodice de tip keep-alive pentru a detecta rapid conexiunile TCP întrerupte sau serverele blocate. `pika.ConnectionParameters(host='localhost', heartbeat=30)`

Proprietăți și Metadate Mesaj AMQP (8)

Proprietate Mesaj	Ce face
`delivery_mode`	Specifică dacă mesajul trebuie scris pe disc (2 – Persistent) pentru a supraviețui repornirii brokerului sau păstrat doar în RAM (1 – Transient). `properties=pika.BasicProperties(delivery_mode=2)`
`correlation_id`	ID unic folosit în arhitecturile RPC pentru a corela răspunsul sosit din coada temporară cu cererea inițială a apelantului. `properties=pika.BasicProperties(correlation_id=str(uuid.uuid4()))`
`reply_to`	Numele cozii (adesea exclusivă sau direct amq.rabbitmq.reply-to) unde consumatorul trebuie să expedieze răspunsul RPC. `properties=pika.BasicProperties(reply_to='amq.rabbitmq.reply-to')`
`message_id`	Identificator de unicitate al mesajului generat de producător, indispensabil în procesarea idempotentă (deduplicare). `properties=pika.BasicProperties(message_id='order-89210')`
`expiration (TTL mesaj)`	Timpul maxim de așteptare al mesajului în coadă în milisecunde; la expirare mesajul este redirecționat către DLX sau eliminat. `properties=pika.BasicProperties(expiration='30000')`
`content_type & content_encoding`	Specifică formatul MIME și codarea corpului mesajului, permițând deserializarea sigură în sisteme eterogene. `properties=pika.BasicProperties(content_type='application/json', content_encoding='utf-8')`
`priority (mesaj)`	Nivelul de prioritate al mesajului curent într-o coadă configurată cu argumentul x-max-priority. `properties=pika.BasicProperties(priority=8)`
`headers (metadate)`	Tabelă flexibilă de metadate tip cheie-valoare pentru rutare prin Headers Exchange sau transmitere de context de tracing (OpenTelemetry). `properties=pika.BasicProperties(headers={'trace_id': '4bf92f3577b34da6'})`

Politici și Argumente Avansate pentru Cozi (x-arguments) (9)

Argument Coadă	Ce face
`x-dead-letter-exchange`	Numele Exchange-ului către care sunt dirijate mesajele respinse prin NACK/Reject sau expirate prin TTL. `arguments={'x-dead-letter-exchange': 'dead_letter_ex'}`
`x-dead-letter-routing-key`	Cheia de rutare utilizată la transmiterea mesajului către DLX; dacă lipsește, se păstrează Routing Key-ul inițial. `arguments={'x-dead-letter-routing-key': 'failed_orders'}`
`x-message-ttl`	Durata maximă de viață (în ms) aplicată automat tuturor mesajelor din coadă înainte de a fi trimise în DLX sau șterse. `arguments={'x-message-ttl': 86400000} # 24 ore`
`x-expires`	Timpul de inactivitate completă (fără mesaje, fără conexiuni active) după care coada este ștearsă automat de pe broker. `arguments={'x-expires': 1800000} # 30 min`
`x-max-length`	Numărul maxim de mesaje permise simultan în coadă; depășirea declanșează politica de overflow aleasă. `arguments={'x-max-length': 5000}`
`x-overflow`	Comportamentul la atingerea limitei maxime de mesaje: șterge cele mai vechi mesaje (drop-head) sau respinge noile publicări (reject-publish). `arguments={'x-overflow': 'reject-publish'}`
`x-delivery-limit`	Specific Quorum Queues: numărul maxim de încercări de re-livrare (requeue) a unui mesaj eronat înainte de rutarea automată către DLX. `arguments={'x-delivery-limit': 5}`
`x-single-active-consumer`	Asigură că un singur consumator procesează mesaje la un moment dat (pentru ordine strictă), ceilalți rămânând în standby pentru failover. `arguments={'x-single-active-consumer': True}`
`x-queue-type`	Specifică arhitectura internă a cozii la momentul creării: quorum (Raft HA), classic sau stream. `arguments={'x-queue-type': 'quorum'}`

Replicare, Topologii Distribuite și Plugin-uri (7)

Plugin / Mecanism	Ce face
`Shovel Plugin`	Preluare și reexpediere continuă și sigură a mesajelor între cozi sau exchange-uri din brokeri complet separați fizic sau geografic. `rabbitmqctl set_parameter shovel my-shovel '{"src-uri": "amqp://nod1", "src-queue": "q1", "dest-uri": "amqp://nod2", "dest-queue": "q2"}'`
`Federation Plugin`	Federație la nivel de Exchange sau Coadă pentru distribuirea mesajelor prin conexiuni WAN cu latență ridicată între clustere independente. `rabbitmqctl set_parameter federation-upstream my-up '{"uri":"amqp://remote-cluster"}'`
`Prometheus Exporter`	Expune automat toate metricile native de performanță, conexiuni și cozi în format Prometheus pe portul 15692 (/metrics). `curl -s http://localhost:15692/metrics`
`Tracing & Firehose`	Activează capturarea în scop de diagnostic a fiecărui mesaj publicat și livrat în broker, publicându-le pe un topic dedicat de inspecție. `rabbitmqctl trace_on -p /`
`MQTT Plugin`	Transformă RabbitMQ într-un broker scalabil pentru dispozitive IoT prin suportul protocoalelor standardizate MQTT v3.1.1 și MQTT v5 pe portul 1883. `rabbitmq-plugins enable rabbitmq_mqtt`
`STOMP Plugin`	Permite clienților web din browsere să transmită și să primească mesaje asincrone în timp real direct prin WebSocket. `rabbitmq-plugins enable rabbitmq_web_stomp`
`Virtual Hosts & Permisiuni`	Izolează logic mediile (ex: dev, staging, prod) în spații complet segregate, administrând granular drepturile de configurare, scriere și citire per utilizator. `rabbitmqctl add_vhost /production && rabbitmqctl set_permissions -p /production app_user "." "." ".*"`

Comunitate & Schimb de cunoștințe

Discuții, Întrebări & Coduri RabbitMQ

Ai o întrebare legată de RabbitMQ, cauți o soluție sau vrei să împărtășești un fragment util de cod? Trimite mai jos contribuția ta.

💬

Fii primul care pune o întrebare sau distribuie un fragment de cod / prompt!

Nu au fost adăugate încă întrebări sau exemple de cod pentru această pagină. Dacă ai întâlnit o problemă sau ai un snippet util, adaugă-l mai jos pentru a-i ajuta pe ceilalți.

Comunitate Adaugă o întrebare sau distribuie un cod Anulează răspunsul

Alege ce dorești să transmiți:

Titlu scurt (opțional)

Întrebarea ta *

Moderare & Siguranță:

Pentru a menține calitatea și securitatea informațiilor, fiecare întrebare sau fragment de cod/prompt este analizat (manual sau prin moderare asistată de AI) înainte de publicare.

Nume sau Pseudonim *

Adresă de Email * (nu va fi publicată)