Introducción

Windows Azure tiene la característica de balanceador de carga incluido dentro del servicio, no es un cobro extra como en otras soluciones de Nube. Este servicio de balanceo está disponible tanto para aplicaciones Cloud Services (PaaS) como para servicios que corren en máquinas virtuales (Iaas).

El balanceador de Azure tiene el criterio de distribución de carga llamado Round Robin y no soporta sticky session, hasta ahora. Esto produce un reto para las compañías que tienen aplicaciones que no son State Less.

En ese contexto, y no como la primera opción a recomendar, podemos hacer un Walkaround utilizando nuestro propio sistema de balanceo basado en Aplication Request Routing (ARR) de Internet Information Server (IIS). Con esto podemos implementar un escenario donde tenemos ARR corriendo en máquinas virtuales, que balancean la carga hacia servidores Web que se encuentren en otro Cloud Service con la opción de afinidad.

Este es un escenario muy potente porque estamos tomando el control del balanceador, agregando la capacidad de afinidad de sesiones y conectado IaaS con PaaS dentro del mismo sistema. . Aquí, una pieza clave para unir los dos mundos (IaaS con PaaS) son las redes virtuales.El escenario que vamos a implementar se muestra en la figura 1.

Este articulo lo divido en dos partes, para que sea más simple su lectura. La primera parte configura el primer ARR y hace pruebas de balanceo junto con afinidad.

En la segunda parte vamos a completar el escenario de la figura 1.

Paso a paso para implementar ARR con balanceador y afinidad

Primero vamos a implementar un escenario más sencillo que nos permita entender cómo se implementa y configura ARR en Windows Azure. La idea es solo crear un ARR y que este balancee tráfico a dos sitios web de terceros para luego agregarle afinidad. El escenario de prueba inicial lo podemos ver en la figura 2.

1.      Crear una Red Virtual

En la figura 1 se muestra el escenario que buscamos armar en este artículo. Para lograrlo debemos comunicar directamente el Cloud Service que contiene las máquinas virtuales con el que contiene las aplicaciones Web. Esto es conectar IaaS con PaaS, una de las maravillas que nos permite hacer Azure.

La unión des diferentes Cloud Services se logra a través del uso de una red virtual. La red virtual debe ser creada primero, para así estar disponible al momento de crear las máquinas virtuales y aplicaciones Web.

Para crear una red virtual, en el portal se selecciona la opción New, Networks y Custom Create como muestra la figura 3.

Luego, ingresamos el nombre de la red y el grupo de afinidad. Es un requisito tener un grupo de afinidad para tener una red virtual.

El siguiente paso en el asistente es la creación y asignación del espacio de direccionamiento. Para asignar direcciones tenemos dos opciones de nomenclatura, COUNT y CIDR. CDIR es la clásica de los administradores de red, que definen máscaras y con eso determinan la cantidad de direcciones IP del segmento. Por otra parte, COUNT es el método para desarrolladores donde defines el número de direcciones IP que necesitas en el segmento de manera directa y más simpe.

Para nuestro escenario vamos a definir una sub red para los balanceadores (máquinas virtuales con ARR) y otro para las aplicaciones Web (PaaS)

Con esto ya tenemos definida nuestra virtual la cual será utilizada en los próximos pasos.

2.      Crear un Servidor Windows Server 2012

Vamos a crear un servidor con Windows Server 2012 en una Máquina virtual de Windows Azure. Para ello, desde el portal se selecciona la opción de crear una máquina virtual desde la galería. Seleccionamos la imagen de Windows Server 2012 Datacenter y avanzamos en el asistente de creación.

Le asignamos el nombre de ARR1 a la VM y definimos el usuario administrador. La versión del realeas no es importante para nuestros objetivos porque básicamente solo necesitamos IIS.

En el paso 3 debemos definir el DNS name, en este caso demoARRblog. Este es el DNS del Cloud Service y será el mismo que tendrá la segunda máquina virtual con ARR. Muy importante en este paso es seleccionar la red virtual que creamos en el primer paso y la sub net de balanceadores, como se muestra en la siguiente figura.

Por ultimo nos preguntan por el Availability Set, para este demo no lo necesitamos, en producción obvio que sí, lo dejamos en blanco.

Con esto ya hemos creado nuestro primer servidor Virtual en la subnet de balanceadores. Una vez creada la VM, podemos ver en el Dashboard de la red virtual que aparece el recurso ya alocado en la red y sub red definidas.

3.      Configuración de IIS en Windows Server

Lo primero que vamos ha hacer es modificar las configuraciones de seguridad del explorador para poder acceder a internet. Para los administradores seleccionamos OFF.

Luego en Server Manager, agregamos el ROL de Web Server (IIS) y las herramientas de administración.

A continuación en los servicios del rol agregamos los por defecto para luego confirmar la instalación.

4.      Instalación de Aplication Request Routing (ARR)

Ahora, utilizando Internet Information Services (IIS) manager, vamos a instalar ARR. Para ello, al entrar al IIS Manager, nos aparece el siguiente dialogo donde nos preguntan si queremos conectarnos a la plataforma de componentes Web, le decimos que sí.

Esto nos lleva al sitio Web donde podemos bajar e instalar gratuitamente Web Plaform Installer. Lo bajamos e instalamos en nuestro servidor virtual.

Luego buscamos el Web Platform Installer 4.5 por ARR como se muestra en la siguiente figura. Lo agregamos aprontando el botón ADD y luego lo instalamos.

El proceso de instalación termina con la siguiente pantalla de confirmación.

5.      Publicar Puerto 80/http de la Máquina Virtual

Para poder acceder al servidor Web de nuestro servidor Virtual debemos exponer el servicio a través de un EndPoint. Existen los EndPoint externos e internos. Para que un usuario pueda acceder al nuestro servidor Web, tenemos que crear un EndPoint externo en el puerto 80.

Para hacer esto, vamos al portal de Azure y en la máquina virtual buscamos la pestaña que dice ENDPOINTS. Ahí apretamos agregar y se inicia el asistente para crear el EndPoint. Vamos a crear uno con las siguientes características

1. Nombre: WWW
2. Protocolo: TCP
3. Puerto público: 80
4. Puerto Privado: 80

Ahora podemos conectarnos utilizando un Browser a nuestro servidor virtual.

6.      Crear una Server Farm de pruebas con Aplication Request Routing (ARR)

En este punto ya tenemos el primer servidor virtual con ARR instalado y podemos crear ya la primera server FARM para poder probar las características de ARR. Una Server FARM es una granja de servidores que se comportan como un solo servidor lógico que está compuesto por varias instancias de servidores, físicos o virtuales.

El escenario de pruebas que usaremos se ilustra en la siguiente imagen. La idea es que el ARR1 sirva como balanceador de carga que dirige los requerimientos que se envían a http://demoarrblog.cloudapp.net a dos sitios web públicos, www.dell.com y www.amazon.com.

Primero creamos un Server Farm. Para esto vamos a IIS Manager y vamos a ver que ahora aparece dentro del árbol de nuestro servidor una hoja que se llama Server Farm. Esto es lo que nos agregó la instalación de ARR.

Si iniciamos el asistente de crear una nueva Server Farm, lo primero que nos pregunta es el nombre y si está estará Online. En nuestro caso, vamos a llamarla BalanceadorSitiosExternos y estará Online. Como siguiente paso vamos a agregar los servidores que componen la granja, 143.166.224.244 para DELL y 176.32.98.166 para Amazon.

Cuando damos Finalizar al asistente, aparece el siguiente dialogo que nos pregunta si queremos que las reglas de ruteo se creen automáticamente. Le decimos que sí, ya que esas son las reglas que buscamos crear para redirigir los requerimientos hacia los dos sitios externos.

Por último vamos ha configurar el método de distribución de carga. Para ello vamos a nuestra granja y seleccionamos Load Balance.

Vamos a utilizar el criterio de distribución de carga llamada Weigted Round Robin, que distribuye los requerimientos de manera homogénea entre ambos sitios si los configuramos con el mismo peso relativo, como aparece en la siguiente imagen.

Una vez que aplicamos los cambios, podemos cargar varias veces el sitio Web http://demoarrblog.cloudapp.net y vamos a ver el comportamiento del balanceador funcionado. Alternadamente nos muestra el contenido del sitio Web de DELL y Amanzon, en la URL del Cloud Service!

Podemos ver en las dos siguientes capturas de pantalla la prueba de ejecución.

7.      Pruebas de Server Affinity con Aplication Request Routing (ARR)

La última prueba que vamos a realizar es la de afinidad (affinity). La afinidad es la capacidad de mantener al cliente final conectado siempre al mismo servidor de la granja de servidores. Por ejemplo, si un usuario entra en nuestro servicio y el balanceador lo envío la primera vez al sitio Web de Dell, la afinidad hace que todos los siguientes requerimientos de ese cliente sean dirigidos hacia ese servidor hasta que se cumpla un tiempo de inactividad o ese servidor se encuentre fuera de línea.

La opción de affinity se utiliza para que aplicaciones Web que no están preparadas para ser balanceadas porque no son state less. Cuando se trabaja en la nube, especialmente en PaaS, lo ideal es que nuestras aplicaciones Web sean State Less porque eso permite escalar sin ningún problema. El uso de ARR es un Walk Arround para las aplicaciones Web que no cumplen con esta característica de no tener estado.

Para configurar Server Affinity con Aplication Request Routing (ARR) vamos a la opción de Server Affinity de nuestra granja de servidores como muestra la figura.

En esa opción seleccionamos Client Affinity y aplicamos el cambio. Esta característica se basa en el uso de cookies en el cliente, que permite al ARR conocer cuál fue el servidor de la granja que le asigno en el primer requerimiento de ese cliente y continúa enviándolo ahí.

Una vez configurado podemos probar que el cliente siempre será enviado al mismo sevidor. En mi caso, con Explorer  cargue mi sitio y me envió al servidor de Dell. Todos los siguientes requerimientos con ese Browser van al mismo sitio de Dell.

ara comprobar la afinidad, ahora utilizaré otro browser para cargar el sitio. Esto equivale a otro cliente, por lo que me envía a Amazon. Todos los recargar que hago me envían al mismo servidor.

Próximos pasos

En esta primera parte hemos creado y configurado un servidor virtual con Aplication Request Routing (ARR). En el siguiente artículo voy a desarrollar el escenario completo, como se muestra en la figura 1, es decir una aplicación Web corriendo en PaaS, balanceada con ARR con mis propios criterios y con Server Affinity para crear afinidad entre el cliente y el servidor que lo atiende en la Server Farm.

Links relacionados

• Windows Azure: ASP.NET en Cloud Service utilizando MongoDB
• Cómo respaldar Azure SQL Database usando un Worker Role
• Windows Azure Media Services: Publicar videos para IOS y Windows Phone
• ¿Cómo ejecutar Apache SOLR en Windows Azure?

En Channel 9 hay una muy Buena explicación de Windows Azure Active Directory. Por el alcance de nombre, he recibido muchas peguntas sobre el tema. La más preocupante fue «puedo dejar de usar Active directory en mi empresa y reemplazarlo por Windows Azure Active directory?»

Este video es muy fácil de seguir y entender las diferencias entre los dos servicios.

Links relacionados

1. Windows Azure: ASP.NET en Cloud Service utilizando MongoDB
2. Windows Azure Media Services: Publicar videos para IOS y Windows Phone

Introducción

El mundo de las bases de datos está cambiando vertiginosamente, debido a las nuevas necesidades de información y cantidad de datos que se almacenan actualmente en los sistemas de información. Dentro de este contexto ha aparecido Mongo DB que es una base de datos  no relacional, o cómo le gusta al marketing referirse una base de datos NoSql.

MongoDb es una base de datos orientada a documentos en formato Json que permite esquemas dinámicos. Dentro de las principales características de la base de datos podemos encontrar:

1.  Indexación por cualquier atributo, es decir búsqueda rápida por cualquier atributo del documento (registro en el mundo relacional)
2. Soporta Mirror para HA
3. Escalamiento horizontal utilizando Sharding
4. Soporte para Map/Reduce, para procesos de procesamiento y agregación flexible de datos

Pueden encontrar más información de MongoDB aquí.

En este Post vamos a hacer una simple aplicación Web (Azure Cloud Service) con C# que utiliza MongoDB para almacenar Notas ingresadas en la Página Web. Además, permite agrupar las notas en libros para mostrar las capacidades de esquema flexible y agrupación de documentos dentro de otros documentos.

Requerimientos del ejemplo

Para poder desarrollar este ejemplo se necesita:

1. Una Base de datos de MongoDB
2. Instalar el Driver de C# para Mongo
3. Windows Azure SDK

Paso a paso de la implementación

Paso 1: Crear una instancia de MongoDB

Para desarrollar el ejercicio vamos a crear una instancia de MongoDB en Azure utilizando el Add-On que ofrece MongoLAB en windows Azure. Para ello seguimos el asistente que se muestra en la siguiente figura, el cual se inicia utilizando el botón NEW, Store y se busca en la lista la opción de MongoDB.

Una vez creada la base de datos de MongoDB, la cual es provista en el modelo DBaaS, podemos ver el panel de control que se muestra en la figura 2.

Para administrar nuestra base de datos Mongo, tenemos que hacer click en el botón Manage de la botonera al pie de página, donde llegaremos a la consola de administración Web de MongoLab, la cual se muestra en la figura 3.

Con esto ya estamos listos para codificar nuestra aplicación.

Paso 2: Crear el proyecto Cloud Service

Para crear nuestro proyecto Cloud Services utilizaremos Visual Studio, creamos un nuevo proyecto del tipo Cloud Services, sin ningún role dentro, como se muestra en la figura 4.

Ahora, vamos a agregar a la solución un proyecto ASP.NET Empty Web Application utilizando el botón derecho sobre la solución, opción Add new proyect. Usamos un Web vacio para que sea más simple poner foco solo en los aspectos de Mongo en el ejemplo.

Cuando tenemos los dos proyectos, debemos agregar el ROL Web al cloud Services. Para ello, utilizando el botón derecho sobre ROLES, utilizamos la opción Add … Web Project in the Solution y seleccionamos nuestro proyecto Web vacío.

Por úlitmo debemos instalar el driver de C# para Mongo. Esto lo hacemos utilizando el módulo Package Manager Console con el comando Install-Package mongocsharpdriver. La figura 5 muestra la consola después de instalarlo.

En este punto tenemos la solución creada y lista para comenzar a programar.

Paso 3: Crear clase de acceso a datos

Para acceder a Mongo vamos a utilizar una clase de acceso a datos, que nos simplifica y aísla el origen de datos de la aplicación. Para esto, creamos una clase llamada DAC. En esta clase agregamos las referencias que necesitamos para Mongo.

using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.IdGenerators;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.UI.WebControls;

Con Mongo tenemos dos opciones para poder trabajar con los documentos. La primera es al estilo fuertemente tipados, como estamos acostumbrados por ejemplo a trabajar en C# y la otra es utilizar BsonDocumet es decir sin tipos conocidos en tiempo de programación. Aquí, vamos a trabajar primero con objetos con tipos y luego lo haremos son tipos. Obviamente la segunda aproximación da más flexibilidad y potencia para usar las colecciones de documentos de Mongo.

Paso 4: Crear una clase tipo Nota y DAC

Utilizando la primera aproximación de trabajo vamos a crear la siguiente clase

public class DocumentoNota
    {
        public DocumentoNota()
        {
            Date = DateTime.UtcNow;
        }
        private DateTime date;
        [BsonId(IdGenerator = typeof(CombGuidGenerator))]
        public Guid Id { get; set; }
        [BsonElement("Note")]
        public string Text { get; set; }
        [BsonElement("Date")]
        public DateTime Date
        {
            get { return date.ToLocalTime(); }
            set { date = value; }
        }
    }
 

Esta clase representa el documento que vamos a guardar en MongoDb, una nota que tiene un identificador único, una fecha y un texto.

Ahora, vamos a crear la clase Dal que nos ayudará a interactuar MongoDB. El constructor de esta clase recibe la cadena de conexión con Mongo y el nombre de la base de datos.

public class Dal : IDisposable
    {
        private MongoServer mongoServer = null;
        private bool disposed = false;
        private string collectionName = "Notes";
        private string connectionString;
        private string dbName;
        // Default constructor.
        public Dal(string strconnectionString, string strdbName)
        {
            connectionString = strconnectionString;
            dbName = strdbName;
        }
        # region IDisposable
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    if (mongoServer != null)
                    {
                        this.mongoServer.Disconnect();
                    }
                }
            }
            this.disposed = true;
        }
        # endregion
    }

Paso 5: Conexión y consulta a MongoDB con objetos con tipo

La conexión a mongoDB se hace utilizando las clases MongoServer, MongoClient y MongoDatabase. El método ObtenerDB crea un cliente Mongo que se conecta al servidor y obtiene la referencia conectada a la base de datos.

private MongoDatabase ObtenerDB(string strdbName)
        {
            if (mongoServer == null)
            {
                var client = new MongoClient(connectionString);
                mongoServer = client.GetServer();

            }
            return mongoServer.GetDatabase(strdbName);
        }

Al tener la referencia a la base de datos ya conectada podemos comenzar a hacer consultas. El Método GetAllNotes() se conecta a la base de datos, obtiene la colección de documentos y los entrega en una lista. Aquí debemos notar que estamos usando una colección fuertemente tipada ya que la lista es del tipo <DocumentoNota>.

public List<DocumentoNota> GetAllNotes()
        {
            try
            {
                MongoDatabase database = this.ObtenerDB(this.dbName);
                MongoCollection<DocumentoNota> noteCollection =
                    database.GetCollection<DocumentoNota>(this.collectionName);
                return noteCollection.FindAll().ToList<DocumentoNota>();
            }
            catch (MongoConnectionException)
            {
                return new List<DocumentoNota>();
            }
        }

Para realizar la consulta vamos a utilizar un Web Form que llamaremos defaul.aspx. Para crearlo usamos el botón derecho opción Add New Form. Esto nos entrega una forma vacía a la cual agregamos una GridView llamada GridView1. Luego agregamos un botón que llamamos btActualizar.

Vamos a declarar una propiedad privada del tipo Dal llamada xMongo que utilizaremos en todos los métodos de este Web Form para interactuar con MongoDb. En el método Page_Load() creamos una instancia de xMongo leyendo desde la configuración del Cloud Services la cadena de conexión y el nombre de la base de datos de mongo. Por último, realizamos la consulta en el método ActualizarWebForm() que es el evento que se gatilla cuando se hace click en el botón  btActualizar. El siguiente código muestra lo implementado hasta ahora.

private Dal xMongo;
        private void ActualizarWebForm()
        {
            this.GridView1.DataSource = xMongo.GetAllNotes();
            GridView1.DataBind();
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (xMongo == null)
            {
                xMongo =
new Dal(CloudConfigurationManager.GetSetting("mongoDB"), CloudConfigurationManager.GetSetting("dbName"));
            }
        }
        protected void btActualizar_Click(object sender, EventArgs e)
        {
            this.ActualizarWebForm();
        }

Antes de ejecutar nuestra primera consulta debemos ingresar en la configuración los valores de dbName y mongoDB, como se muestra en la siguiente imagen.

Los valores a utilizar los debemos obtener desde el sitio de administración de Mongo LAB. En el panel de control del portal de Azure, en nuestra el ítem de MongoLab creado utilizando el botón de Connection info obtenemos la cadena de conexión de MongoDB. Luego vamos al portal de MongoLab y copiamos el nombre de la base de datos que viene creada por defecto. Para hacer esto, debemos apretar el botón Manage. La siguiente imagen nos muestra el portal de administración.

Si ejecutamos nuestro proyecto, funciona pero no nos trae registros ya que no hemos ingresado dato alguno. Vamos a agregar un método CrearNota() como se muestra a continuación. Aquí recibimos un objeto de tipo Note y lo agregamos a la colección con el método insert.

public void CrearNota(DocumentoNota note)
        {
            MongoCollection<DocumentoNota> collection =this.ObtenerDB(this.dbName).GetCollection<DocumentoNota>(this.collectionName);
            try
            {
                collection.Insert(note, SafeMode.True);
            }
            catch (MongoCommandException ex)
            {
                string msg = ex.Message;
            }
        }

Por último en nuestro formulario Web agregamos un texbox y un botón para ingresar el texto de la nueva nota. Y utilizando el Dal podemos crear nuevas notas.

protected void btNuevaNota_Click(object sender, EventArgs e)
        {
            DocumentoNota valor = new DocumentoNota();
            valor.Date = DateTime.Now;
            valor.Text = tbTexto.Text;
            xMongo.CrearNota(valor);
            tbTexto.Text="";
            this.ActualizarWebForm();
        }

Ahora, ejecutamos nuestro proyecto e ingresamos algunas notas como muestra la siguiente figura.

Paso 6: consulta a MongoDB con objetos sin tipo

Una de las características de Mongo es que puede manejar esquemas dinámicos en los documentos. Para poder aprovechar esta ventaja, no podemos usar objetos con tipos definidos en nuestra aplicación sino que debemos usar un tipo genérico llamado BsonDocument. Ahora, vamos a hacer la misma consulta que hicimos antes para obtener una lista de notas sin tipo, sino que la lista tendrá la lista de documentos en formato de objetos Json. Para esto le agregamos al Dal el siguiente método.

public List<string> GetAllElementosJson( string nombreColeccion)
        {
            var str = new List<string>();

            foreach (var item in this.ObtenerDB().GetCollection<MongoDB.Bson.BsonDocument>(nombreColeccion).FindAll())
            {
                str.Add(item.AsBsonDocument.ToString());
            }
            return str;
        }

Ahora, modificamos nuestro Web Form agregando un checkbox que nos permite seleccionar trabajar con o sin tipo. Actualizamos el método ActualizarWebForm() y podemos ya leer con o sin tipo como se muestra en el código actualizado. Nótese que le entregamos el nombre de la colección de documentos que queremos leer.

        private void ActualizarWebForm()
        {
            if (chbTipo.Checked)
            {
                this.GridView1.DataSource = xMongo.GetAllNotes();
            }
            else
            {
                this.GridView1.DataSource = xMongo.GetAllElementosJson("Notes");
            }
            GridView1.DataBind();
        }

Si desmarcamos el checkbox obtendremos la lista de objetos como muestra la imagen 9.

Paso 7: Actualizar Documentos en Mongo a partir de objetos sin tipo

Para crear una nueva nota en la colección, sin utilizar un objeto con tipo utilizamos nuevamente la clase   BsonDocument como muestra el método del Dal crearBsonDocumentNota().

public void crearBsonDocumentNota (string strTexto, string strColeccion)
{
   MongoDB.Bson.BsonDocument documentoX = new MongoDB.Bson.BsonDocument {
   { "_id", Guid.NewGuid() } ,
   { "Date", DateTime.Now.ToLocalTime() },
   { "Note", strTexto }
             };
    var collection =
        this.ObtenerDB(this.dbName).GetCollection<MongoDB.Bson.BsonDocument>(strColeccion);
    try
    {
      collection.Insert(documentoX);
     }
     catch (MongoCommandException ex)
     {
         string msg = ex.Message;
      }
  }

Ahora, actualizamos el método btNuevaNota_Click() para que dependiendo de la selecciona del checkbox agreguemos notas usando tipos o no.

        protected void btNuevaNota_Click(object sender, EventArgs e)
        {
            if (chbTipo.Checked)
            {
                DocumentoNota valor = new DocumentoNota();
                valor.Date = DateTime.Now;
                valor.Text = tbTexto.Text;
                xMongo.CrearNota(valor);
            }
            else
            {
                xMongo.crearBsonDocumentNota(tbTexto.Text,"Notes");
            }
            tbTexto.Text = "";
            this.ActualizarWebForm();
        }

Paso 8: Borra un documento de la colección

En este punto ya podemos crear y ver documentos de una colección, utilizando o no una clase con tipo. Ahora, vemos a borrar las notas de la colección.

public void borrarAllDocumentos(string strCcoleccion)
        {
            MongoCollection < MongoDB.Bson.BsonDocument > notesCollection =
                this.ObtenerDB(this.dbName).GetCollection <MongoDB.Bson.BsonDocument> (strCcoleccion);
            notesCollection.RemoveAll();
        }

Luego en el formulario Web agregamos un botón para borrar todos los documentos e invocamos este método. Al hacerlo vamos a borrar todos los documentos de la colección.

Paso 9: Representar la colección de documentos como un árbol

El paradigma de las bases de datos documentales como mongoDB es tener colecciones de documentos que a su vez pueden contener colecciones de documentos como un atributo. Esto se representa de manera natural en una estructura de árbol más que en una tabla. Las tablas son la representación natural del paradigma tradicional/relacional por excelencia.

Ahora vamos a implementar el mapeo desde una colección de MongoDB hacia un TreeNode para usarlo como fuente de datos del control Web Treeview. Para esto vamos a utilizar recursividad, que debemos recorrer el árbol desde la raíz hasta las hojas de cada rama.

La raíz del árbol se crea en el método getArbol(string strColeccion)  y obtiene la colección de documentos. Aquí se recorre todos los elementos que tiene en este primer nivel la colección de documentos del tipo BsonDocument. Este documento puede contener un arreglo de documentos, un documento con alguna estructura definida o un elemento dentro del documento.

El método obtnerNodo() es quien discrimina el tipo de documento que se está procesando y determina si es una hoja del árbol por lo cual debe ser procesada, un documento o un arreglo de documentos. Los dos últimos casos, que en el Switch del código son MongoDB.Bson.BsonType.Array y MongoDB.Bson.BsonType.Document,  lo que hacen es llamar de manera recursiva al mismo método obtenerNodo() hasta llegar al nivel de la hoja. En ese momento lo que hace el método es agregarlo como un nodo al TreeNode. Ambos métodos se muestran en el siguiente código.

private TreeNode obtnerNodo(MongoDB.Bson.BsonDocument doc, TreeNode hoja)
        {
            foreach (var item in doc.Elements)
            {
                switch (item.Value.BsonType)
                {
                    case MongoDB.Bson.BsonType.Array:
                        var hojaHijaArray = new TreeNode(item.Name);
                        foreach (var documento in item.Value.AsBsonArray)
                        {
                            this.obtnerNodo(documento.AsBsonDocument, hojaHijaArray);
                        }
                        hoja.ChildNodes.Add(hojaHijaArray);
                        break;
                    case MongoDB.Bson.BsonType.Document:
                        var hojaHijaDoc = new TreeNode(item.Name);
                        this.obtnerNodo(item.Value.AsBsonDocument, hojaHijaDoc);
                        hoja.ChildNodes.Add(hojaHijaDoc);
                        break;
                    default:
                        var etiqueta = string.Format("{0}: {1} [{2}]", item.Name, item.Value.RawValue.ToString(), item.Value.BsonType.ToString());
                        hoja.ChildNodes.Add(new TreeNode(etiqueta));
                        break;
                }
            }
            return hoja;
        }
        public TreeNode getArbol(string strColeccion)
        {
            var arbol = new TreeNode(strColeccion);
            int acc = 0;
            foreach (var item in this.ObtenerDB(this.dbName).GetCollection<MongoDB.Bson.BsonDocument>(strColeccion).FindAll())
            {
                arbol.ChildNodes.Add(this.obtnerNodo(item, new TreeNode(acc.ToString())));
                acc += 1;
            }
            return arbol;
        }

El resultado de llamar a getArbol() es un objeto TreeNode que representa la estructura de la colección en un árbol con ramas y hojas, donde las hojas son los valores de las propiedades de los documentos. Para verlo funcionando, ampliamos el método ActualizarWebForm() para que además de mostrar la tabla con valores de la colección, muestre un árbol con la misma.

private void ActualizarWebForm()
        {
            if (chbTipo.Checked)
            {
                this.GridView1.DataSource = xMongo.GetAllNotes();
            }
            else
            {
                this.GridView1.DataSource = xMongo.GetAllElementosJson("Notes");
            }
            tvArbol.Nodes.Clear();
            tvArbol.Nodes.Add(xMongo.getArbol("Notes"));
            GridView1.DataBind();
        }

Ahora, cuando ejecutamos la aplicación de ejemplo y actualizamos vemos tanto los datos en la tabla como en el árbol. Nótese que no estamos usando el método con objetos con tipo definido, ya que la idea es que el mapeo nos sirva para cualquier colección.

Paso 10: Representar una  colección más compleja de documentos como un árbol

Para hacer más ilustrativo el ejemplo, y representar mejor la potencia de los esquemas dinámicos y la posibilidad de contener documentos dentro de documentos, vamos a implementar una segunda colección que sea una lista de las notas ingresadas en la colección Notes.

En la clase Dal vamos a agregar un método que agrupará las notas de la colección Notes en una nueva colección de documentos, el cual tendrá un par de atributos y un elemento llamado “Notas”. Este será una colección de los documentos de las notas ingresadas. Con esto vamos a ver una colección que tiene un documento (raíz) que tiene a su vez en su contenido una colección de documentos. En Dal agregamos el siguiente método.

  public string AgruparNotas(string strColeccionAgrupacion)
        {
            MongoDB.Bson.BsonArray Libro = new MongoDB.Bson.BsonArray();
            var pagina = new MongoDB.Bson.BsonDocument();
            pagina.Add("_id", Guid.NewGuid());
            pagina.Add("cierre", DateTime.Now.ToLocalTime());
            int acc = 0;

            var notas = new MongoDB.Bson.BsonArray();
            foreach (var item in this.ObtenerDB(this.dbName).GetCollection<MongoDB.Bson.BsonDocument>(this.collectionName).FindAll())
            {
                var nota = new MongoDB.Bson.BsonDocument();
                nota.Add("Registro", acc.ToString());
                nota.Add("Nota", item.AsBsonDocument);
                notas.Add(nota);
                acc += 1;
            }
            pagina.Add("Notas", notas);
            Libro.Add(pagina);
            var collection = this.ObtenerDB(this.dbName).GetCollection<MongoDB.Bson.BsonArray>(strColeccionAgrupacion);
            collection.InsertBatch(Libro);

            return Libro[0].AsBsonDocument.ToString();
        }

Ahora, en la interfaz Web volvemos a modificar el método ActualizarWebForm() para que ahora al momento de actualizar el formulario, cree esta nueva colección y la muestre en el Treeview.

private void ActualizarWebForm()
        {
            if (chbTipo.Checked)
            {
                this.GridView1.DataSource = xMongo.GetAllNotes();
            }
            else
            {
                this.GridView1.DataSource = xMongo.GetAllElementosJson("Notes");
            }
            tvArbol.Nodes.Clear();
            xMongo.borrarAllDocumentos("agrupacion");
            xMongo.AgruparNotas("agrupacion");
            tvArbol.Nodes.Add(xMongo.getArbol("agrupacion"));
            GridView1.DataBind();
        }

Una vez hecho esto, el resultado será que el árbol ahora muestra los diferentes niveles. Los documentos de la colección Notes ahora son parte del documento de la colección agrupación como aparece en la imagen 11.

El código fuente esta aquí.

Conclusión

En este pequeño artículo podemos ver cómo utilizar MongoDb de manera muy básica y comenzar a comprender el paradigma de las bases de datos documentales. Además, vemos como MongoDb está ya disponible en el modelo DBaaS en Windows Azure y como una aplicación Cloud Services del tipo Web puede utilizarla.

Links Relacionados

• Windows Azure Media Services: Publicar videos para IOS y Windows Phone #azure
• Cómo respaldar Azure SQL Database usando un Worker Role
• MongoDB C# / .NET Driver
• Windows Azure SDK