redis - node - rabbitmq

¿Cómo puedo implementar esta única cola distribuida de simultaneidad en cualquier plataforma MQ?

Question

Actualmente me cuesta encontrar una solución para implementar un tipo específico de cola, que requieren los siguientes rasgos:

1. Todas las colas deben respetar el orden en que se agregaron los trabajos.
2. Toda la cola tendrá una concurrencia de 1, lo que significa que solo se ejecutará un trabajo a la vez por cola , no por trabajador.
3. Habrá más de unos miles de filas como esta.
4. Necesita ser distribuido y poder escalar (ejemplo si agrego un trabajador)

Básicamente es una cola FIFO de proceso único, y esto es exactamente lo que quiero cuando pruebo diferentes programas de colas de mensajes como ActiveMQ o RabbitMQ, pero tan pronto como lo escalo a 2 trabajadores, simplemente no funciona, porque en este caso lo quiero para escalar y mantener exactamente la misma característica de cola de proceso único. A continuación, adjunto la descripción de cómo debería funcionar en un entorno distribuido con múltiples trabajadores.

Ejemplo de cómo se ve la topología: (tenga en cuenta que se trata de una relación de muchos a muchos entre la cola y los trabajadores )

Ejemplo de cómo se ejecutaría:

+------+-----------------+-----------------+-----------------+
| Step | Worker 1        | Worker 2        | Worker 3        |
+------+-----------------+-----------------+-----------------+
| 1    | Fetch Q/1/Job/1 | Fetch Q/2/Job/1 | Waiting         |
+------+-----------------+-----------------+-----------------+
| 2    | Running         | Running         | Waiting         |
+------+-----------------+-----------------+-----------------+
| 3    | Running         | Done Q/2/Job/1  | Fetch Q/2/Job/2 |
+------+-----------------+-----------------+-----------------+
| 4    | Done Q/1/Job/1  | Fetch Q/1/Job/2 | Running         |
+------+-----------------+-----------------+-----------------+
| 5    | Waiting         | Running         | Running         |
+------+-----------------+-----------------+-----------------+

Probablemente esta no sea la mejor representación, pero muestra que, incluso en la Cola 1 y la Cola 2 , hay más trabajos, pero el Trabajador 3 no comienza a buscar el siguiente trabajo hasta que termine el anterior.

Esto es lo que me cuesta encontrar una buena solución.

He intentado muchas otras soluciones como rabbitMQ, activeMQ, apollo ... Esto me permite crear miles de colas, pero todas ellas, al probar, usaré el worker 3 para ejecutar el siguiente trabajo en la cola. Y la concurrencia es por trabajador

¿Existe alguna solución que pueda hacer esto posible en cualquier plataforma de MQ, por ejemplo, ActiveMQ, RabbitMQ, ZeroMQ, etc.?

Gracias :)

Answer 1

Puede lograr esto utilizando listas de Redis con una cola de "despacho" adicional que todos los trabajadores BRPOP para sus trabajos. Cada trabajo en la cola de envío está etiquetado con la ID de cola original, y cuando el trabajador ha completado el trabajo va a esta cola original y realiza RPOPLPUSH en la cola de envío para que el próximo trabajo esté disponible para cualquier otro trabajador. La cola de envío tendrá un máximo de num_queues elementos.

Una cosa que tendrá que manejar es la población inicial de la cola de envío cuando la cola de origen está vacía. Esto podría ser simplemente un control hecho por el editor contra un indicador "vacío" para cada cola que se establece inicialmente, y también establecido por el trabajador cuando no queda nada en la cola original para enviar. Si se establece este indicador, el editor puede simplemente LPUSH el primer trabajo directamente en la cola de envío.