A fons dins d'AMQP

Traducció de l’original en anglès. Llegeix-lo en: CastellanoEnglish

Part 3 de 4AMQP i RabbitMQ
  1. AMQP i RabbitMQ [TOC]
  2. Què és AMQP? i l'arquitectura
  3. A fons dins d'AMQP
  4. Hello World fent servir la llibreria 'kombu' i python

A les línies següents descriuré amb més detall les propietats i les funcionalitats dels elements d'AMQP. No serà una descripció exhaustiva però en la meva opinió més que suficient per començar a jugar amb les cues d'AMQP.

Canals

Quan els productors i els consumidors es connecten al broker usant un sòcol TCP, després d'autenticar la connexió, estableixen un canal on s'envien les ordres d'AMQP. El canal és un camí virtual dins d'una connexió TCP, això és molt útil perquè hi pot haver múltiples canals dins de la connexió TCP i cada canal s'identifica amb un ID únic.

Un paràmetre interessant d'un canal és confirmation mode; si això està establert a true, quan els missatges lliurats a un exchange finalment arriben a les seves cues el productor rep un missatge de confirmació amb un UID del missatge. Aquest tipus de missatges són asíncrons i permeten a un productor enviar el següent missatge mentre encara està esperant el missatge ACK. Per descomptat, si el missatge no es pot emmagatzemar i es perd el productor rep un missatge NACK (not acknowledged).

Productors

Potser aquesta és la part més simple del sistema. Els productors només necessiten negociar l'autenticació a través d'una connexió TCP, crear un canal i després publicar tots els missatges que vulguin amb la seva clau d'encaminament corresponent. Per descomptat, els productors poden crear exchanges, cues i després enllaçar-los. Però normalment això no és una bona idea, és molt més segur fer-ho des dels consumidors. Perquè quan un productor intenta enviar un missatge a un broker i no té l'exchange necessari llavors el missatge es perdrà. Normalment els consumidors estan connectats tot el temps i subscrits a les cues i els productors només es connecten als brokers quan necessiten enviar missatges.

Consumidors

Quan un consumidor es connecta a una cua normalment usa una ordre anomenada basic.consume per subscriure el canal a una cua; llavors, cada vegada que la cua subscrita té un missatge nou s'envia al consumidor després que l'últim missatge sigui consumit, o rebutjat.

Si el consumidor només vol rebre un missatge sense una subscripció pot usar l'ordre basic.get. Això és com un mètode de sondeig. De fet, el consumidor només rep un missatge cada vegada que envia l'ordre.

Pots obtenir el millor rendiment usant l'ordre basic.consume perquè és més eficient que sondejar cada vegada que el consumidor vol un altre missatge.

Quan hi ha més d'un consumidor connectat a una cua, els missatges es distribueixen en round-robin. Després que el missatge es lliura a un consumidor aquest envia un missatge de confirmació i llavors la cua envia un altre missatge al següent consumidor. Si el consumidor envia un missatge de rebuig el mateix missatge s'envia al següent consumidor.

Hi ha dos tipus de confirmacions:

  • basic.ack: aquest és el missatge que el consumidor envia a la cua per confirmar la recepció d'un missatge
  • auto_ack: aquest és un paràmetre que podem establir quan el consumidor se subscriu a una cua. El paràmetre assumeix el missatge ACK del consumidor i llavors la cua envia el següent missatge sense esperar el missatge ACK.

El missatge basic.reject s'envia quan el consumidor vol rebutjar un missatge rebut. Aquest missatge descarta el missatge i es perd. Si volem tornar a posar el missatge a la cua podem establir el paràmetre requeue=true quan s'envia un missatge de rebuig.

Quan la cua es crea hi pot haver un paràmetre anomenat dead letter establert a true; llavors, si el consumidor rebutja un missatge amb el paràmetre requeue=false el missatge es posa en cua en una cua nova anomenada * dead letter.* Això és molt útil perquè després de tot podem anar a aquella cua i inspeccionar el motiu del rebuig del missatge.

Cues

Tant els consumidors com els productors poden crear una cua usant l'ordre queue.declare. La manera més natural és crear les cues des dels consumidors i després enllaçar-les a un exchange. Els consumidors necessiten un canal lliure per crear una cua; si un canal està subscrit a una cua, el canal està ocupat i no pot crear cues noves. Quan es crea una cua normalment usem un nom per identificar la cua; si el nom no s'especifica es genera aleatòriament. Això és útil quan es creen cues temporals i anònimes per a RPC-over-AMQP.

Paràmetres que podem establir quan creem una cua nova:

  • exclusive - aquest paràmetre fa que una cua sigui privada i només sigui accessible des de la teva aplicació. Només un consumidor es pot connectar a una cua.
  • auto-delete - quan l'últim consumidor es desubscriu de la cua, la cua s'elimina.
  • passive - quan es crea una cua que existeix el servidor retorna correctament o retorna error si els paràmetres no coincideixen. Si el paràmetre passive està establert i creem una cua que existeix sempre retorna èxit però si la cua no existeix no es crea.
  • durable - la cua pot persistir quan els serveis es reinicien.

Exchange i binding

En el primer article

de la sèrie vam parlar dels diferents tipus d'exchange i com podeu recordar aquests tipus són: direct, fanout i topic. I el paràmetre més important a establir quan el productor envia un missatge és la routing key, aquesta s'usa per encaminar el missatge a una cua.

Un cop hem declarat un exchange aquest es pot relacionar amb una cua usant una ordre de binding: queue_bind. La relació entre ells es fa usant la routing key o un patró basat en la routing key. Quan l'exchange és de tipus fanout la *routing key * o els patrons no són necessaris.

Alguns exemples de patrons poden ser: log.*, *message.* * i #.

Els paràmetres d'exchange més importants són:

  • type: direct, fanout i topic.
  • durable: fa que un exchange sigui persistent als reinicis.

Broker i hosts virtuals

Un broker és un contenidor on es creen els exchanges, els bindings i les cues. Normalment podem definir més d'un broker virtual en el mateix servidor. Els brokers virtuals també s'anomenen hosts virtuals. Els usuaris, els permisos i alguna cosa més relacionada amb un Broker no es poden usar des d'un altre. Això és molt útil perquè podem crear múltiples brokers en el mateix servidor físic com un servidor web multi-domini i quan algun d'aquests hosts virtuals és massa gran es pot migrar a un altre servidor físic i es pot posar en clúster si cal.

Missatges

Un missatge AMQP és un binari sense una mida i un format fixos. Cada aplicació pot establir els seus propis missatges. El broker AMQP només afegirà petites capçaleres per ser encaminat entre diferents cues tan ràpidament com sigui possible.

Els missatges no són persistents dins d'un broker a menys que el productor estableixi el paràmetre persistent=true. D'altra manera els missatges s'han d'emmagatzemar en exchanges durable i cues *durable * per persistir en el broker quan es reinicia. Per descomptat, quan els missatges són persistents aquests s'han d'escriure a disc i el rendiment baixarà. Llavors potser de vegades crear missatges persistents no és una bona idea.

2 comentaris

Els comentaris del blog antic, tal com es van escriure. Els comentaris estan tancats.

  1. Pau Freixes

    Good structured explanation about amqp actors and relationship between thems ... just only one thing

    When you said "After the message is delivered to a consumer this send an acknowledge message and then queue send another message to next consumer", doesn't mean that concurrent processing messages to diferent consumers have been done with ack. Ack is only a way to say this consumer is already again to listen for new messages.

    1. Oriol Rius

      So my explanation is not enough precise, isn't it?