Distribución de mensajes ActiveMQ

Question

Tengo varios servidores que producen archivos xml de Python y algunos otros servidores que consumen esos xmls usando Java. Recientemente, busqué en JMS y ActiveMQ y decidí intentar usarlo para pasar los archivos xml.

Así que configuré los demonios ActiveMQ en los servidores del consumidor y pensé que implementaría algún método de ciclo en los productos para distribuir los xmls de manera uniforme entre los consumidores.

Python  -----------------------------> ActiveMQ ---> Java
        \                           /
         \                         /
          ---------------------------> ActiveMQ ---> Java
                                 /  /
Python  ----------------------------

Para las pruebas, ejecuté un productor y un consumidor y miré los resultados.

Para mi sorpresa, los mensajes del productor se distribuyeron en todos los servidores ActiveMQ de la red. Como solo ejecuté un consumidor, solo recibió los xmls que llegaron al demonio ActiveMQ en esa máquina, y el resto de los xmls estaban esperando pacientemente en los otros demonios ActiveMQ en otras máquinas.

Python  -----------------------------> ActiveMQ ---> Java (work)
                                          |
                                          |
                                       ActiveMQ (xmls piling up)

EDITAR: Esto no es lo que realmente sucedió, lo siento. Vea a continuación los detalles

Ahora, no me estoy quejando, ya que de todos modos esto es lo que quería, pero estoy un poco confundido: ¿cuál es la forma correcta de implementar esta cola de muchos a muchos que estoy buscando?

¿Debo configurar también los demonios ActiveMQ en mis máquinas productoras, enviar los xmls a los ActiveMQ localeshost y confiar en el descubrimiento automático para llevar los xmls a los consumidores?

Python ---> ActiveMQ ------------------------------ ActiveMQ ---> Java
                |                                      |
                |                                      |
                |                                -- ActiveMQ ---> Java
                |                               |  
Python ---> ActiveMQ----------------------------

¿Debo seguir con mi plan original y pasar los mensajes por las máquinas de consumo, solo para estar seguro?

¿O hay una API que debería usar para ocultar esos detalles de mis procesos?

Por cierto, los productores son procesos python que usan STOMP y los consumidores son java que usan JMS.

Pido disculpas si te duelen los ojos por mi arte ASCII, no estaba seguro de si soy lo suficientemente claro con solo palabras.

EDITAR

Aparentemente, cuando estaba ejecutando "un productor y un consumidor" No me di cuenta de que los otros consumidores ya estaban funcionando. Simplemente no estaban haciendo nada útil con los xmls que procesaron. Es por eso que estaba viendo resultados parciales.

Después de leer un poco más y experimentar un poco, descubrí lo siguiente:

De manera predeterminada, ActiveMQ descubrirá automáticamente otras instancias de ActiveMQ en la red local y creará una tienda de almacenamiento y reenvío red de corredores . Esto significa que el productor puede publicar los xmls en cualquier instancia de ActiveMQ y encontrarán el camino para que los consumidores escuchen en otras instancias de ActiveMQ en la misma red.

Tenga en cuenta que la documentación afirma que el descubrimiento automático no se recomienda para configuraciones de producción.

Sin embargo, la respuesta aceptada a continuación sigue siendo cierta. La forma más sencilla de usar ActiveMQ es usar uno o dos servidores como "Servidores de cola". Sin embargo, elegí seguir mi plan original, porque creo que reducirá el tráfico de red (con un servidor intermedio, xmls tiene que entrar y salir de él nuevamente).

Answer 1

Itsadok, creo que probablemente no estés considerando el uso de mensajes correctamente.

Tener una instancia de MOM (ya sea ActiveMQ, RabbitMQ o cualquier otro agente de MOM) en un caso de uno por consumidor no tiene sentido conceptual. Más bien, es mejor pensar en su agente MOM como un enrutador de mensajes.

En ese caso, tendría una instancia de agente de ActiveMQ (que podría dividirse o escalarse si tiene problemas de escala, o replicarse si tiene consideraciones de HA) a la que se conectan todos los productores y todos los consumidores. Luego, todos los XML van a la misma instancia de agente y todos los consumidores leen desde la misma instancia de agente. En ese caso, el agente determinará a qué consumidor debe dirigirse el mensaje en función de cualquier heurística que utilice.

Esto también significa que puede agregar y eliminar productores y consumidores dinámicamente, y nada cambia: todos se conectan a los mismos intermediarios, por lo que puede agregar y eliminar productores y consumidores a medida que su carga cambia o cuando los sistemas fallan.