ActiveMQ distribuição de mensagens

Question

Eu tenho vários servidores que produzem arquivos xml de Python e alguns outros servidores que consomem esses xmls usando Java. Eu só recentemente olhou para JMS e ActiveMQ e decidiu tentar usá-lo para passar os arquivos XML.

Então eu configurar daemons activemq nos servidores de consumo e percebi que eu implementar algum método de ciclismo na produz para distribuir os xmls uniformemente entre os consumidores.

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

Para os testes, eu corri um produtor e um consumidor e olhou para os resultados.

Para minha surpresa, as mensagens do produtor foram distribuídos em todos os servidores do activemq na rede. Desde que eu só correu um consumidor que só recebeu os xmls que tem que o daemon ActiveMQ nessa máquina, eo resto dos xmls estavam esperando pacientemente sobre os outros daemons activemq em outras máquinas.

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

EDIT: Este não é o que realmente aconteceu, me desculpe. Veja abaixo os detalhes

Agora, eu não estou reclamando, pois é isso que eu queria de qualquer maneira, mas eu estou um pouco confuso: o que é a maneira correta de implementar esta fila de muitos-para-muitos que eu sou depois

Devo configurar daemons activemq em minhas máquinas produtores, bem como, enviar os xmls aos ActiveMQs localhost e confiar a descoberta automática para obter os xmls aos consumidores?

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

Devo vara para o meu plano original, e ciclo de mensagens através das máquinas de consumo, apenas para ser seguro?

Ou há uma API que eu deveria usar que esconder os detalhes de meus processos?

BTW, os produtores são processos Python usando STOMP e os consumidores estão java usando JMS.

Eu peço desculpas se os seus olhos estão sofrendo de minha arte ASCII ruim, eu não tinha certeza se estou sendo bastante claro com palavras apenas.

Editar

Aparentemente, quando eu estava correndo "um produtor e um consumidor" Eu não notei que os outros consumidores já estavam em execução. Eles só não estavam fazendo nada de útil com as xmls eles processados. É por isso que eu estava vendo resultados parciais.

Depois de ler um pouco mais e experimentar um pouco, eu descobri o seguinte:

Por padrão, ActiveMQ vai auto-descobrir outras instâncias activemq na rede local, e criar um store-and-forward rede de corretores . Isso significa que o produtor pode postar as xmls a qualquer instância ActiveMQ e eles vão encontrar o seu caminho para os consumidores escutando outras instâncias activemq na mesma rede.

Note que as reivindicações de documentação que auto-descoberta não é recomendado para configurações de produção.

A resposta aceite abaixo ainda é válido, no entanto. A maneira mais simples de usar ActiveMQ é usar apenas um ou dois servidores como "servidores de filas". No entanto, eu escolhi para ir com o meu plano original, porque eu pensar que irá reduzir o tráfego de rede (com um servidor médio, xmls tem que ir para ela e o de fora de novo).

Answer 1

itsadok, eu acho que você provavelmente não está considerando o uso de mensagens corretamente.

Ter uma instância MOM (se ActiveMQ, RabbitMQ, ou qualquer outro corretor MOM) em um caso one-per-consumidor realmente não faz sentido conceitualmente. Pelo contrário, é melhor pensar em seu corretor MOM como um roteador de mensagens.

Nesse caso, você teria uma instância ActiveMQ broker (que podem ser fragmentados ou não escalado se você escalar problemas, ou replicado se você tiver considerações HA), que todos os produtores e todos os consumidores conectar. Então tudo XML vai para a mesma instância do agente, e todos os consumidores ler a partir da mesma instância do agente. Nesse caso, o corretor irá determinar qual o consumidor a mensagem deve ir para a base em qualquer heurística que utiliza.

Isto também significa que você pode adicionar e remover os produtores e consumidores de forma dinâmica, e nada muda:. Todos eles se conectar ao mesmo corretores, para que possa adicionar e remover os produtores e os consumidores como as alterações de carga ou como sistemas falham