Estamos desarrollando un servicio .Net Core que se hospedará en Azure Service Fabric. Este servicio SF necesita interactuar con 10,000 dispositivos registrados en Azure IoT Hub a través de sus puntos finales AMQP 1.0 SSL TLS. Cada dispositivo IoT Hub tiene sus propios tokens de seguridad y cadena de conexión proporcionados por el servicio IoT Hub.

Para nuestro escenario, necesitamos escuchar todos los mensajes de la nube a los dispositivos que provienen de las 10,000 instancias del dispositivo IoT Hub y "enrutarlos" a un tema central de Bus de servicio al que escuchan las "puertas de enlace" reales en el campo. Básicamente, queremos reenviar mensajes de 10,000 colas de bus de servicio a una cola central.

¿Cuál es el mejor enfoque para manejar estos 10,000 listados de AMQP desde un servicio de SF? ¿Hay alguna manera de reutilizar las conexiones, sesiones o enlaces AMQP para almacenar / compartir recursos? ¿Y cómo podemos distribuir dinámicamente la carga del mantenimiento de la conexión en los 5 nodos en el clúster SF?

Estamos evaluando estos paquetes Nuget para la implementación:Microsoft.Azure.ServiceBus AMQPNetLite Microsoft.Azure.Devices.Client

Estamos haciendo algunas pruebas usando elMicrosoft.Azure.Devices.Client lib, vea un ejemplo de código simplificado a continuación:

using System;
using System.Fabric;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.Devices.Client;
using Microsoft.ServiceFabric.Services.Runtime;

namespace ID.Monitoring.MonServer.ServiceFabric.ServiceBus
{
    /// <summary>
    /// An instance of this class is created for each service instance by the Service Fabric runtime.
    /// </summary>
    internal sealed class ServiceBus : StatelessService
    {
        private readonly DeviceClient _deviceClient;
        private ConnectionStatus _status;

        public ServiceBus(StatelessServiceContext context)
            : base(context)
        {
            _deviceClient = DeviceClient.CreateFromConnectionString("HostName=id-monitoring-dev.azure-devices.net;DeviceId=100;SharedAccessSignature=SharedAccessSignature sr=id-monitoring-dev.azure-devices.net%2Fdevices%2F100&sig={token}&se=1553265888", TransportType.Amqp_Tcp_Only);
        }

        /// <summary>
        /// This is the main entry point for your service instance.
        /// </summary>
        /// <param name="cancellationToken">Canceled when Service Fabric needs to shut down this service instance.</param>
        protected override async Task RunAsync(CancellationToken cancellationToken)
        {
            _deviceClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler);

            while (true)
            {
                if (_status != ConnectionStatus.Connected)
                {
                    await _deviceClient.OpenAsync();
                }
                var receivedMessage = await _deviceClient.ReceiveAsync(TimeSpan.FromSeconds(10)).ConfigureAwait(false);

                if (receivedMessage != null)
                {
                    var messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
                    //TODO: handle incoming message and publish to common 
                    await _deviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false);
                }
            }
        }

        private void ConnectionStatusChangeHandler(ConnectionStatus status, ConnectionStatusChangeReason reason)
        {
            _status = status;
        }
    }
}

Pregunta: ¿Escala bien a 10,000 instancias de servicio de Service Fabric? ¿O hay formas más eficientes de mantener estos tantos AMQP Service Bus Listners desde un entorno de Service Fabric Service? ¿Hay alguna forma de aplicar la multiplexación de conexión AMQP?