Primeros Pasos con el Service Bus de Azure: Las colas


Muy buenas a todos,

Después de unas semanas sin poder publicar porque he estado ocupado preparando un examen de inglés, vuelvo con una entrada de la que llevaba tiempo detrás. Dentro de mis objetivos del año, además de profundizar en cómo usar las APIs de SharePoint y de Office 365 (de lo que ya he publicado bastantes entradas en el blog), está el empezar a aprender de Azure. Recientemente os expliqué cómo hacer tareas programadas con Azure por medio de los webjobs, aplicados en el caso del post a SharePoint.

Timer Jobs para SharePoint OnLine

Hoy os quiero hablar de otro de los servicios que nos ofrece Azure y que cuando he indagado sobre él, me ha resultado muy interesante, el Service Bus. Este servicio nos proporciona métodos para comunicar nuestras aplicaciones. Estos métodos pueden ser muy diversos, desde una simple cola FIFO, sistema de colas basado en subscripciones o situaciones en las que no se necesitan colas, solo un mecanismo para comunicarse. Todos estos escenarios los proporcionar el Service Bus de Azure. Os dejo algunos enlaces para que indaguéis y leáis más sobre este servicio que tenemos disponible.

https://azure.microsoft.com/en-us/documentation/articles/fundamentals-service-bus-hybrid-solutions/

https://azure.microsoft.com/en-us/documentation/articles/service-bus-dotnet-how-to-use-queues/

En este post, vamos a centrarnos fundamentalmente en las colas FIFO, en las que un productor va a ir colocando mensajes y un consumidor los irá leyendo por estricto orden de llegada.

Untitled

Vamos a ver un ejemplo en el que podremos comprobar como funcionan las colas en Azure Service Bus. El ejemplo constará de dos aplicaciones de consola, una que actuará como productor y otra como consumidor. Vamos a ver también los pasos para poner en marcha este servicio en Azure y cómo usarlo desde nuestras aplicaciones.

Creando el servicio en Azure

Lo primero que tenemos que hacer es entrar en el portal de administración de Azure para crear un nuevo Service Bus.

Captura de pantalla 2015-07-01 a las 20.01.02

Una vez ahí, en el apartado de Service Bus, hacemos click en crear y completamos el formulario

Captura de pantalla 2015-07-01 a las 20.01.19

Seleccionamos el centro de datos que queremos y en nuestro caso, como solo vamos a usar en este ejemplo una cola FIFO, seleccionamos la opción mensajería de tipo Basic.

Esta es la pantalla de opciones de un service bus una vez creado.

Captura de pantalla 2015-07-01 a las 20.07.44

Cómo usarlo desde nuestra aplicación

Vamos a crear una nueva solución con un proyecto de tipo aplicación de consola en Visual Studio 2013. Para poder usar el Service Bus, tendremos en primer lugar, que añadir desde Nuget el paquete Microsoft Azure Service Bus.

Tras este tendremos que añadir la cadena de conexión al app.config de la aplicación de consola. La cadena de conexión la podemos obtener en el portal de azure. Una vez dentro del Service Bus creado, en la parte inferior de la pantalla, hacemos click en Información de conexión. (Como podemos ver en la imagen inmediatamente anterior).

De ahí copiamos la cadena de conexión y la añadimos en la el app.config de la siguiente forma:

<appSettings>
        <!-- Service Bus specific app setings for messaging connections -->
        <add key="Microsoft.ServiceBus.ConnectionString" value="[connectionstringhere]"/>
    </appSettings>

El productor de mensajes

A continuación os dejo el código del productor que he creado a modo de ejemplo:

class Program
    {
        static void Main(string[] args)
        {
            bool exit = false;
            int i = 1;

            do
            {
                switch (menu())
                {
                    case 1:

                        QueueHelper.CreateQueue("TestQueue");
                        break;
                    case 2:

                        BrokeredMessage message = new BrokeredMessage("Example Service Bus Message");
                        message.Properties["Counter"] = i;

                        i += 1;

                        QueueHelper.SendMessage("TestQueue", message);
                        break;
                    default:
                        exit = true;
                        break;
                }
            }
            while (!exit);
        }

        static int menu()
        {
            Console.WriteLine("--- Option Menu ---");
            Console.WriteLine("0.- Exit");
            Console.WriteLine("1.- Create Queue");
            Console.WriteLine("2.- Send Message");
            Console.Write("-->");

            int value = int.Parse(Console.ReadLine());

            return value;
        }
    }

El código del productor implementa un sencillo menú por consola con dos opciones: por un lado crear la cola que vamos a usar (para la primera vez que usamos la aplicación), y por otro lado envía un mensaje a la misma.

Los mensajes se envían usando la clase BrokeredMessage. Esta clase en el constructor, nos permite establecer el cuerpo del mensaje y usando las propiedades de la misma, pasar otros parámetros de interés del mensaje.

Cómo podéis ver, el productor hace uso de un helper que implementa la funcionalidad de interacción con el service bus. Os dejo también a continuación las funciones que se usan.

public static void CreateQueue(string queueName)
        {
            // Configure queue settings
            QueueDescription qd = new QueueDescription(queueName);
            qd.MaxSizeInMegabytes = 5120;
            qd.DefaultMessageTimeToLive = new TimeSpan(0, 1, 0);

            // Create a new queue with custom settings
            string connectionString =
                CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");

            var namespaceManager =
                NamespaceManager.CreateFromConnectionString(connectionString);

            if (!namespaceManager.QueueExists(queueName))
            {
                namespaceManager.CreateQueue(qd);
            }
        }

        public static void SendMessage(string queueName, BrokeredMessage message)
        {
            string connectionString =
                CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");

            QueueClient Client =
                QueueClient.CreateFromConnectionString(connectionString, queueName);

            Client.Send(message);
        }

La función que crea la cola es muy sencilla. En primer lugar establece las propiedades de la cola que vamos a crear, en este caso, tamaño de la misma y el tiempo de vida del mensaje. A continuación obtiene del app.config la cadena de conexión y se conecta con el Service Bus. Por último, comprueba si existe la cola y en caso negativo, la crea.

La función que envía un mensaje es aún más sencilla. Simplemente establece la conexión con la cola del Service Bus donde queramos publicar el mensaje y lo envía.

El consumidor de mensajes

El código del consumidor es el que véis a continuación:

class Program
    {
        static void Main(string[] args)
        {
            while(true)
            {
                BrokeredMessage message = QueueHelper.ReceiveMessage("TestQueue");

                Console.WriteLine("Body: " + message.GetBody<string>());
                Console.WriteLine("MessageID: " + message.MessageId);
                Console.WriteLine("Test Property: " +
                message.Properties["Counter"]);

            }
        }
    }

Este código es muy sencillo. Está continuamente a la escucha de que en la cola haya algún mensaje y en caso de que sea así lo recibe y lo imprime por pantalla.

Al igual que el productor, usa un helper para la conexión con el Service Bus. El código de la función ReceiveMessage es el siguiente:

public static BrokeredMessage ReceiveMessage(string queueName)
        {
            string connectionString =
  CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
            QueueClient Client =
              QueueClient.CreateFromConnectionString(connectionString, queueName);

            BrokeredMessage message = null;

            try
            {
                message = Client.Receive();

                message.Complete();
            }
            catch(Exception ex)
            {
                message.Abandon();
            }

            return message;
        }

La función que recibe un mensaje de la cola funciona de la siguiente manera. En primer lugar se conecta con la cola correspondiente del Service Bus. Tras esto espera a que haya un mensaje en la cola para leer, si se recibe correctamente usa la función Complete() para eliminar el mensaje recibido de la cola. En caso de que haya algún error, usa la función Abandon() para liberarlo de nuevo en la cola.

Cómo funciona el ejemplo

Vamos a ver en una captura como funciona el ejemplo que hemos desarrollado:

Untitled2

Cada vez que se ejecuta la opción enviar mensaje, el productor envía un mensaje y el receptor lo recibe y muestra en pantalla, ya que como vimos en el código, éste está siempre esperando nuevos mensajes para procesarlos.

Y hasta aquí todo lo que os quería enseñar. ¿Cuáles son los siguientes pasos?, pues en próximos post os contaré como funcionan las subscripciones o topics y más adelante mezclaré todo esto con SharePoint OnLine, para como siempre, avanzar en las opciones que tenemos disponibles en Azure y ver cómo las podemos usar con SharePoint, se pueden plantear, como veremos, ejemplos muy interesantes.

Un saludo a todos y hasta la próxima

Anuncios

2 comentarios en “Primeros Pasos con el Service Bus de Azure: Las colas

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s