Performancing Metrics

December 2010 - Artículos - Return(GiS);

Return(GiS);

December 2010 - Artículos

Leer tablas de un Excel con Open XML y Linq

Hace bastante tiempo escribí un post donde explicaba cómo era posible la creación de un archivo Excel con Open XML utilizando una base de datos como fuente. Esta vez, voy a comentar cómo podemos leer datos de una hoja para poder manipularlos desde C#.

Antes de comenzar, necesitamos utilizar las referencias Windows Base y DocumentFormat.OpenXml. En este ejemplo, vamos a recuperar los siguientes valores:

La información más importante de este archivo para poder recuperar correctamente los datos son el nombre de la hoja y el número de la fila donde comienzan los datos que nos interesan.

El objetivo de nuestro código será recuperar estos datos y almacenarlos en un txt de forma formateada. Creamos un proyecto de consola y comenzamos con el siguiente código:

using System.IO;
using System.Linq;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

namespace ExcelOpenXML
{
    class Program
    {
        static void Main()
        {

            using (var document = SpreadsheetDocument.Open(@"C:\BooksSample.xlsx", true))
            {

                var workbook = document.WorkbookPart.Workbook;
                var workSheets = workbook.Descendants<Sheet>();

                string sheetId = workSheets.First(s => s.Name == @"Hoja1").Id;
                var sheet = (WorksheetPart)document.WorkbookPart.GetPartById(sheetId);

                var sharedStringTable = document.WorkbookPart.SharedStringTablePart.SharedStringTable;
                var books = Library.RetrieveBooks(sheet.Worksheet, sharedStringTable);
                using (var sw = new StreamWriter(@"c:\Books.txt"))
                {
                    foreach (var p in from book in books select book)
                        sw.WriteLine("{0, -40} {1, -20} ", p.Name, p.Price);
                }

            }
        }
    }
}

Si nos fijamos en el código anterior, una vez cargado el archivo tenemos que acceder al objeto workbook, solicitamos todas las hojas en orden descendente y recuperamos el id de aquella que tenga como nombre Hoja1. Con este id podemos recuperar la hoja en cuestión y, por otro lado, recuperamos un elemento llamado SharedStringTable, el cual contiene un conjunto de elementos donde están alojadas todas las cadenas utilizadas en la hoja. Para que os hagáis una idea de lo que estamos recuperando, podemos abrir el archivo con Open XML SDK 2.0 Productivity Tool for Microsoft Office y visualizar su esquema:

¿Cómo recuperamos la información entre tanto XML? :)

using System.Linq;
using System.Collections.Generic;
using System.Globalization;
using DocumentFormat.OpenXml.Spreadsheet;

namespace ExcelOpenXML
{
    public class Library
    {
        static readonly CultureInfo Culture = new CultureInfo("en-US");

        public static List<Book> RetrieveBooks(Worksheet worksheet, SharedStringTable sharedStringTable)
        {
            var result = new List<Book>();

            var dataRows = from row in worksheet.Descendants<Row>()
                           where row.RowIndex > 6 //The table begins on line 5
                           select row;

            foreach (var row in dataRows)
            {
                var textValues = new List<string>();
                foreach (var cell in from cell in row.Descendants<Cell>() where cell.CellValue != null select cell)
                {
                    if (cell.DataType != null && cell.DataType.HasValue && cell.DataType == CellValues.SharedString)
                        textValues.Add(sharedStringTable.ChildElements[int.Parse(cell.CellValue.InnerText)].InnerText);
                    else
                        textValues.Add(cell.CellValue.InnerText);
                }

                var textArray = textValues.ToArray();

                if (textArray.Count() <= 0) continue;

                var book = new Book
                {
                    Name = textArray[0],
                    Price = textArray[1] == "?" ? 0 : float.Parse(textArray[1], NumberStyles.Float, Culture),
                };

                result.Add(book);
            }

            return result;

        }
    }
}

Aunque la tabla comience en la fila 5, realmente nos interesa recuperar solamente los datos y obviar la cabecera. Una vez recuperados todos los registros, recorremos cada uno de ellos para poder almacenar la información en el objeto Book, el cual sólo contiene dos propiedades: Name y Price.

Un dato importante es utilizar la cultura en-US ya que, al recuperar los valores del archivo, el SDK de Open XML recupera los valores con punto en vez de coma. Este sería el resultado con el parseo pero sin la cultura en-US.

Introducing HTML5 (Voices That Matter)   1,756E+16
BLOCKED SCRIPT The Good Parts               1383
CSS: The Missing Manual                  1,756E+16
BLOCKED SCRIPT The Definitive Guide         2371
Programming in Objective-C 2.0           2223

Si ejecutamos la aplicación, abrirá el archivo xlsx y, una vez cargados en memoria, escribirá uno a uno en el archivo Books.txt. El resultado sería el siguiente:

Introducing HTML5 (Voices That Matter)   17,56
BLOCKED SCRIPT The Good Parts               13,83
CSS: The Missing Manual                  17,56
BLOCKED SCRIPT The Definitive Guide         23,71
Programming in Objective-C 2.0           22,23

Adjunto el proyecto por si fuera de utilidad :D

¡Saludos!

Posted: 22/12/2010 17:39 por Gisela | con 2 comment(s)
Archivado en: ,
Windows Azure Connect

Hace un par de días me dieron la oportunidad de participar en la beta de Windows Azure Connect :D . Para quien no haya oído hablar de este futuro servicio, Windows Azure Connect nos dará la posibilidad de conectar servidores on-premise con nuestros roles ubicados en la nube, lo que se conoce como VPN :) .

En este post voy a hacer una demo muy sencilla de cómo configurar este servicio y comprobar la conectividad entre dos máquinas a través de un ping.

Configuración del role en Windows Azure

Accedemos al portal y nos posicionamos en el apartado Virtual Network.

Si es la primera vez que accedemos, deberemos activar la suscripción para Azure Connect.

 Con la suscripción seleccionada, pulsamos en el botón Get Activation Token, el cual nos devolverá un token que deberemos utilizar para que nuestro role en la nube pueda formar parte de un grupo que veremos más adelante.

Para realizar esta demo, crearemos un nuevo proyecto Windows Azure Project  con un web role con el código por defecto. Lo único necesario para poder utilizarlo conjuntamente con Azure Connect es habilitar en el apartado Virtual Network de las propiedades del rol el check y pegar el token recuperado anteriormente.

Por último lo configuraremos para poder acceder a él de manera remota. Una vez realizado el paso anterior, subimos la aplicación al portal y comprobamos que la misma aparece en el aparto de Virtual Network dentro de la suscripción.

Configuración del servidor on-premise

Por parte del servidor on-premise es necesario instalar de forma manual una aplicación proporcionada desde el portal. Desde dicho servidor pulsamos sobre el botón Install Local Endpoint en la parte superior.

Al hacer click sobre este botón nos facilitará una URL para poder descargar el instalador.

Como bien indica el cuadro de diálogo, este software no puede ser guardado para ser ejecutado dentro de un periodo lejano debido a que tiene un tiempo de expiración. Copiamos el link en el explorador y, una vez descargado, ejecutamos la instalación.

Uno de los inconvenientes con los que nos podemos encontrar llegados a este punto es que, con la fase beta, no podamos ejecutar la instalación  si tenemos nuestro sistema operativo en un idioma que no sea inglés :( .

Cuando la instalación finaliza, vemos que aparece un nuevo icono en la barra de tareas, por el momento, sin conexión con la nube.

 A partir de este momento, aparecerán tanto el rol como el servidor on-premise en Activated Endpoints.

Para finalizar la configuración debemos hacer un último paso que es crear el grupo mencionado anteriormente. Para ello pulsamos esta vez sobre Create Group donde deberemos rellenar los siguientes campos:

Como datos obligatorios serán el nombre del grupo, un servidor on-premise en el apartado Connect From y un rol en Connect To.

Lo primero que ocurrirá a partir de ahora será la actualización del web role involucrado.

Y por otro lado el icono del servidor on-premise se tornará al siguiente como señal de conexión con la nube.

 

Si accedemos en remoto al web role (o desde el servidor on-premise) y abrimos una consola de comandos para hacer un ping a nuestro servidor.

 

Voilà! :D ¡Conexión completada!

Si queréis probar cómo sería posible conectar una aplicación en la nube con un SQL Server en un servidor on-premise podéis descargaros el nuevo Windows Azure Training Kit de Diciembre :)

¡Saludos!

Posted: 17/12/2010 19:54 por Gisela | con no comments |
Archivado en:
Trabajando con las queues de Windows Azure Storage

Después de haber repasado los blobs y las tablas, llegó el momento de centrarse en las queues :) . Como comenté en el post introductorio sobre qué es Windows Azure Storage, las queues se utilizan para almacenar mensajes con el objetivo de conseguir la comunicación entre distintas aplicaciones que trabajan conjuntamente. Estas colas de mensajes son FIFO (First In First Out) y son de un único sentido.

 Los mensajes están limitados a 8 KB y deben ser serializables como XML.

Accediendo a través del Storage Client

Si bien podemos realizar todas las operaciones a través de REST, esto puede resultar algo tedioso a la hora de trabajar. Por ello, podemos hacer uso de la API en .NET para facilitarnos el trabajo. Es necesario añadir una referencia a Microsoft.Windows.Azure y Microsoft.Windows.Azure.StorageClient.

¿Por dónde empiezo?

Lo primero que debemos hacer es recuperar la cadena de conexión y crear un CloudQueueClient para poder generar o recuperar las queues.

CloudStorageAccount _account = CloudStorageAccount.DevelopmentStorageAccount;
CloudQueueClient _queueClient = _account.CreateCloudQueueClient();

Crear una Queue

Al igual que en los blobs, para crear una queue necesitamos recuperar una referencia a la misma aunque esta no exista. Una vez creada llamaremos al método CreateIfNotExist.

var queue = _queueClient.GetQueueReference("myqueue");
queue.CreateIfNotExist();

Listar las queues disponibles

Con ListQueues recuperaremos todas las queues disponibles en esa cuenta.

_queueClient.ListQueues();

Eliminar una Queue

 Cuando eliminamos una queue, es recomendable limpiar primero su contenido y posteriormente eliminarla a través del método Delete, así como anular su referencia a cualquier variable.

queue.Clear();
queue.Delete();
queue = null;

Añadir un mensaje

string message = "Hello world!";
queue.AddMessage(new CloudQueueMessage(message));

Procesar un mensaje (Polling)

using System.Diagnostics;
using System.Net;
using System.Threading;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.ServiceRuntime;
using Microsoft.WindowsAzure.StorageClient;

namespace QueueReader_WorkerRole
{
    public class WorkerRole : RoleEntryPoint
    {
        public override void Run()
        {
            var account = CloudStorageAccount.DevelopmentStorageAccount;
            var queueClient = account.CreateCloudQueueClient();
            var queue = queueClient.GetQueueReference("myqueue");
            queue.CreateIfNotExist();

            while (true)
            {
                var message = queue.GetMessage();

                if (message != null)
                {
                    Trace.WriteLine(message.AsString);

                    queue.DeleteMessage(message);
                }
                else
                    Thread.Sleep(2000);
            }
        }

        public override bool OnStart()
        {
            ServicePointManager.DefaultConnectionLimit = 12;

            return base.OnStart();
        }
    }
}

En este proceso, normalmente ejecutado desde un worker role, lo que estamos haciendo es comprobar cada 2 segundos si existe algún mensaje en la queue y de ser así (si el resultado no es nulo) procesarlo. Una vez finalizado el proceso debemos eliminar el mensaje de la queue para que no sea re procesado de nuevo. Cuando un mensaje es recuperado a través de GetMessage permanece invisible durante 30 segundos por defecto, con el objetivo de que no pueda ser recuperado por nadie más. Este tiempo puede ser extensible hasta 2 horas como máximo y, de no ser procesado el message y posteriormente eliminado, volvería a la queue para que fuera recuperado de nuevo por el mismo worker role o cualquiera de sus instancias.

“Ojear” un mensaje (Peek a message)

Existe una alternativa a la hora de conocer el contenido de un mensaje sin la necesidad de sacarlo de la queue. Esta acción es conocida como “peek”, que significa ojear, y puede ser útil para revisar su contenido sin que afecte a su visibilidad. Podemos ojear un mensaje por defecto o indicar a la función PeekMessage el número de mensajes que necesitemos revisar.

var message = queue.PeekMessage();
var messageList = queue.PeekMessage(5);

Connection String

La cadena de conexión sería exactamente la misma que para cualquiera de los otros dos servicios de Windows Azure Storage.

<Setting value="DefaultEndpointsProtocol=http;AccountName=returngis;
AccountKey=KoJ9maUaV29LDdoajvkA....AUVOdb2ehHw5nN21XI2KF7Q==" />

Espero que sea de utilidad :D

¡Saludos!

Posted: 14/12/2010 11:42 por Gisela | con no comments
Archivado en:
Trabajando con las tablas de Windows Azure Storage

Siguiendo la serie de post relacionados con Windows Azure Storage, hoy me gustaría centrarme en las tablas, donde podemos almacenar datos de una forma estructurada pero no relacional.  Este servicio es muy simple, altamente escalable y supone un coste menor que toda una base de datos relacional.

¿Qué no puedo hacer?

Debido a que no se tratan de tablas relacionales, no podremos:

  • Crear foreign keys para las relaciones entre tablas.
  • Realizar joins.
  • Crear índices personalizados en las tablas.

¿Por dónde empiezo?

Antes de comenzar a programar, debemos conocer los tres pasos necesarios para crear nuestra tabla:

  1. Definir la entidad que almacenaremos en ella: Antes de crear una tabla necesitamos alguna forma de describir qué es lo que queremos almacenar.
  2. Definir el contexto: El contexto tratará las acciones que podremos realizar (creación, modificación, eliminación, etcétera), o lo que es lo mismo: Cómo queremos operar con ella.
  3. Creación de la tabla: Una vez que tenemos decidido el qué y el cómo estamos listos para su creación basándonos en los dos puntos anteriores.

Definir la entidad

La definición de la entidad se trata de una clase con sus correspondientes atributos. Para ser capaces de almacenar nuestra clase en una tabla de Windows Azure Storage necesitaremos además tres atributos adicionales que serán heredados de TableServiceEntity: PartitionKey, RowKey y Timestamp. Los dos primeros necesitamos inicializarlos en el momento de la creación de un nuevo objeto (el lugar ideal sería en el constructor) y el  Timestamp será asignado de forma automática. Estas propiedades serán las que nos ayudarán a localizar un registro, y más en concreto PartitionKey será responsable de conseguir una escalabilidad eficiente si lo utilizamos de manera correcta.

Este podría ser un ejemplo de la definición de una entidad:

using System;
using Microsoft.WindowsAzure.StorageClient;

namespace StorageManager_MvcWebRole.Models.Tables
{
    public class Profile : TableServiceEntity
    {

        public Profile()
        {
            PartitionKey = "Users";
            RowKey = Guid.NewGuid().ToString();
        }

        public string UserName { get; set; }
        public string Email { get; set; }
        public int Age { get; set; }
        public string BlogUrl { get; set; }
    }
}

Definir el contexto

Una vez que tenemos el qué, podemos saber cómo vamos a manejarlo :D Creamos una nueva clase que herede de TableServiceContext. Si utilizamos Resharper nos advertirá antes de la compilación de que es necesario importar la librería System.Data.Services.Client.

 

De otro modo, si compilamos la solución, Visual Studio nos informará del mismo error:

Por otro lado, debemos implementar el constructor heredado de TableServiceContext ya que nos avisa de que no existe un constructor sin parámetros para la clase base y es necesario que la nuestra implemente uno. El motivo es que para crear el contexto de la tabla es necesario tener la dirección donde se aloja la misma, así como las credenciales para acceder.

using System.Linq;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.StorageClient;

namespace StorageManager_MvcWebRole.Models.Tables
{
    public class ProfileTableServiceContext : TableServiceContext
    {
        private const string TableName = "Profiles";

        public ProfileTableServiceContext(string baseAddress, StorageCredentials credentials)
            : base(baseAddress, credentials) { }

        public IQueryable<Profile> Profiles
        {
            get { return CreateQuery<Profile>(TableName); }
        }

        public void AddProfile(Profile newProfile)
        {
            AddObject(TableName, newProfile);
            SaveChanges();
        }

        public void RemoveProfile(string rowKey)
        {
            DeleteObject((from item in Profiles
                          where item.PartitionKey == "Users" && item.RowKey == rowKey
                          select item).First());
            SaveChanges();
        }

        public void UpdateProfile(Profile profileUpdated)
        {
            var profile = (from item in Profiles
                           where item.PartitionKey == "Users" && item.RowKey == profileUpdated.RowKey
                           select item).First();

            profile.UserName = profileUpdated.UserName;
            profile.Age = profileUpdated.Age;
            profile.Email = profileUpdated.Email;
            profile.BlogUrl = profileUpdated.BlogUrl;

            UpdateObject(profile);
            SaveChanges();
        }

    }
}

Creación de la tabla

Por último ya podemos crear la tabla tanto en la nube como en local. Si bien es un paso que sólo debemos realizar una vez, podemos utilizar una aplicación externa como Cloud Storage Studio o en mi caso he utilizado la clase WebRole.cs que se genera cuando creamos un proyecto de tipo Windows Azure Project.

using System.Configuration;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.ServiceRuntime;
using Microsoft.WindowsAzure.StorageClient;
using StorageManager_MvcWebRole.Models.Tables;

namespace StorageManager_MvcWebRole
{
    public class WebRole : RoleEntryPoint
    {
        public override bool OnStart()
        {

            CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
            configSetter(ConfigurationManager.ConnectionStrings[configName].ConnectionString));

            var storageAccount = CloudStorageAccount.DevelopmentStorageAccount;
            CloudTableClient.CreateTablesFromModel(typeof(ProfileTableServiceContext), storageAccount.TableEndpoint.AbsoluteUri, storageAccount.Credentials);

            return base.OnStart();
        }
    }
}

Si quisiéramos conectar con una tabla en la nube, la cadena de conexión sería similar a la siguiente:

<Setting name="StorageAccount" value="DefaultEndpointsProtocol=http;AccountName=returngis;
AccountKey=KoJ9maUaV29LDdoajvkAIKzi98CH.....D1PJVpAUVOdb2ehHw5nN21XI2KF7Q==" />

Ya tenemos todos los ingredientes necesarios para trabajar con nuestra nueva tabla :D Lo único que faltaría sería usar el contexto para relacionarnos con la misma. Para realizar este ejemplo he creado un proyecto ASP.NET MVC y en pocas líneas hago uso de cada una de las acciones posibles:

using System;
using System.Linq;
using System.Web.Mvc;
using Microsoft.WindowsAzure;
using StorageManager_MvcWebRole.Models.Tables;

namespace StorageManager_MvcWebRole.Controllers
{
    public class TableController : Controller
    {
        private readonly CloudStorageAccount _account;
        private readonly ProfileTableServiceContext _profileServiceContext;

        public TableController()
        {
            _account = CloudStorageAccount.DevelopmentStorageAccount;
            _profileServiceContext = new ProfileTableServiceContext(_account.TableEndpoint.ToString(), _account.Credentials);
        }

        public ActionResult Index()
        {
            return View(_profileServiceContext.Profiles);
        }

        public ActionResult Create()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Create(Profile newProfile)
        {
            _profileServiceContext.AddProfile(newProfile);

            return RedirectToAction("Index");
        }

        public ActionResult Delete(string rowKey)
        {
            _profileServiceContext.RemoveProfile(rowKey);

            return RedirectToAction("Index");
        }

        public ActionResult Edit(string rowKey)
        {
            return View((from profile in _profileServiceContext.Profiles
                         where profile.PartitionKey == "Users" && profile.RowKey == rowKey
                         select profile).First());

        }

        [HttpPost]
        public ActionResult Edit(Profile profileUpdated)
        {
            _profileServiceContext.UpdateProfile(profileUpdated);

            return RedirectToAction("Index");
        }
    }
}

 

Espero que sea de utilidad :)

¡Saludos!

Posted: 14/12/2010 11:36 por Gisela | con 2 comment(s)
Archivado en:
Trabajando con los blobs de Windows Azure Storage

La palabra Blob se corresponde con las siglas de Binary Large OBject y tiene como objetivo el almacenamiento de archivos de gran tamaño, como por ejemplo:

Cada archivo corresponde a un blob y cada blob está contenido a su vez en un container. Para que os hagáis una idea, un ejemplo podría ser el siguiente: Tengo una cuenta de storage,  a la que puse por nombre MediaStorage, donde quiero almacenar mis archivos de música. A su vez, me gustaría tener un container para separar mis archivos por género pop y rock.

Visto esto, podemos decir que un container se trata de una especie de carpeta, la cual agrupa nuestros blobs.

En este post voy a centrarme en un wrapper disponible a través del SDK de Windows Azure para encapsular las llamadas REST necesarias para cada una de las opciones.
Necesitaremos importar Microsoft.Windows.Azure y Microsoft.Windows.Azure.StorageClient.

¿Tengo entorno de desarrollo?

Si :D A día de hoy se llama Storage Emulator y podemos trabajar con blobs, tablas y colas.

¿Dónde puedo encontrar los archivos almacenados en desarrollo?

La forma más sencilla es a través de Visual Studio 2010. En la ventana Server Explorer podemos ver los archivos almacenados en cada uno de los containers.

Al igual que podemos visualizar nuestro entorno de desarrollo, podríamos adjuntar una cuenta de Storage en la nube y ver su contenido.

¿Cómo conecto con mi cuenta de Storage?

Mientras estamos creando la aplicación, podemos utilizar el entorno de desarrollo local para realizar las pruebas necesarias. El código sería el siguiente:

CloudStorageAccount _account = CloudStorageAccount.DevelopmentStorageAccount;
CloudBlobClient _blobClient = new CloudBlobClient(_account.BlobEndpoint, _account.Credentials);

Una vez finalizado el desarrollo, sería necesario modificar la primera línea para recuperar los valores del archivo de configuración.


CloudStorageAccount.SetConfigurationSettingPublisher((configName,configSetter) => configSetter(RoleEnviroment.GetConfigurationSettingValue(configName)));
CloudStorageAccount _account = CloudStorageAccount.FromConfigurationSetting("StorageAccount");
CloudBlobClient _blobClient = new CloudBlobClient(_account.BlobEndpoint, _account.Credentials);

Un ejemplo de cadena de conexión válida podría ser el siguiente:

<Setting name="StorageAccount" value="DefaultEndpointsProtocol=http;AccountName=returngis;
AccountKey=KoJ9maUaV29LD .... +4D1PJVpAUVOdb2ehHw5nN21XI2KF7Q==" />

Creación de un container

Lo primero que debemos crear es un contenedor donde almacenar nuestros blobs ya que estos últimos no pueden ser creados si no están dentro de alguno.

private CloudBlobContainer GetContainer(string containerName)
{
   var cloudBlobContainer = _blobClient.GetContainerReference(containerName);
if (cloudBlobContainer.CreateIfNotExist())
{
var blobContainerPermissions = cloudBlobContainer.GetPermissions();

         blobContainerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
         cloudBlobContainer.SetPermissions(blobContainerPermissions);
    }

    return cloudBlobContainer;
}

Con el método CreateIfNotExist nos aseguramos de que el mismo sea generado si no fue creado con anterioridad. Si es la primera vez , este método devolverá true y le asignaremos los permisos para que un usuario anónimo pueda acceder al contenido.

Creación de un blob

Para la creación de un blob, únicamente debemos recuperar el container donde queremos que se aloje y "simular" su recuperación a través de GetBlobReference. Llegados a este punto se creará un nuevo objeto del tipo CloudBlob a través del cual podremos subir un nuevo archivo a la nube.

public void SaveBlob(Stream file, string filename)
{
    var blob = GetContainer("myContainer").GetBlobReference(filename);

    blob.UploadFromStream(file);
}

En este caso he utilizado el método UploadFromStream pero es importante saber que tenemos otros métodos para realizar la subida de archivos:

  • UploadByteArray
  • UploadFile
  • UploadFromStream
  • UploadText

Eliminar un blob

Para eliminar un blob debemos, en primer lugar, recuperar el contenedor (he utilizado el método anterior para ello), recuperar el blob y finalmente llamar al método Delete del mismo.

public void Delete(string uri, string containerName)
{
     var container = GetContainer(containerName);
     var blob = container.GetBlobReference(uri);
     blob.Delete();
}

Crear una copia de un blob


public void Copy(string uri, string containerName)
{
    var container = GetContainer(containerName);
    var blob = container.GetBlobReference(uri);
    var newBlob = container.GetBlobReference(string.Format("Copy of {0}", blob.Uri.Segments[blob.Uri.Segments.Length - 1]));

    newBlob.CopyFromBlob(blob);
}

Crear un snapshot de un blob


public void Snapshot(string uri, string containerName)
{
     var container = GetContainer(containerName);
     var blob = container.GetBlobReference(uri);
     blob.CreateSnapshot();
}

¿Qué diferencia hay entre una copia y un snapshot?

Los snapshots proporcionan una versión sólo de lectura de un blob. Esta funcionalidad puede ser útil para restaurar una versión anterior de un blob después de ser modificado. Sin embargo, una copia  es un blob distinto ,creado a partir de otro, el cual se puede modificar.

Añadir metadatos


public void AddMetadata(string uri, string containerName)
{
     var container = GetContainer(containerName);
     var blob = container.GetBlobReference(uri);

     var metadata = new NameValueCollection();
     metadata["Language"] = "es";
     metadata["Date"] = DateTime.Now.ToShortTimeString();

     blob.Metadata.Add(metadata);
}

Espero que sea de utilidad :)

¡Saludos!

Posted: 10/12/2010 19:28 por Gisela | con no comments
Archivado en:
¿Qué es Windows Azure Storage?

Además de poder utilizar la plataforma de Windows Azure para subir nuestras aplicaciones, tenemos un servicio llamado Windows Azure Storage el cual nos permite almacenar datos de tres formas distintas:

  • Blobs: Se utilizan para almacenar archivos de gran tamaño, ya sean música, video, imágenes, binarios, etcétera. Disponemos de un endpoint por cada archivo para poder acceder a ellos. En cuanto a tamaños, exiten dos tipos: Por un lado tenemos los Blocks, los cuales pueden tener un tamaño máximo de 200 GB, y las Pages con un máximo de 1 TB.
  • Tables: En ocasiones es posible que necesitemos almacenar información estructuradas sin llegar a ser relacional. Es por ello que el uso de las tablas puede ser de gran ayuda :) . El objetivo de las mismas es almacenar entidades con hasta un máximo de 252 propiedades por entidad e incluso con la posibilidad de almacenar distintos tipos de estructura dentro de una misma tabla (no muy recomendable :( ).
  • Queues: Uno de los objetivos de almacenar pequeña información puede ser para la comunicación entre aplicaciones a través de las colas de mensajes. Gracias a las Queues podemos manejar estos mensajes de manera sencillas a modo de tickets. El máximo por mensaje son 8 KB.

Para crear una cuenta de Windows Azure Storage, podemos hacerlo a través del portal, posicionándonos en el apartado Storage Accounts (dentro de Hosted Services, Storage Accounts & CDN) y  seleccionando en el menú superior la opción New Storage Account.

Una vez creada podremos ver sus propiedades (direcciones de cada servicio, claves, etcétera) seleccionando la nueva cuenta.

Mi objetivo con esta pequeña introducción es poder profundizar más en estos puntos y conocer la forma de programar y administrar cada uno de estos servicios ofrecidos por la plataforma Azure :)

¡Comencemos!

Posted: 10/12/2010 19:11 por Gisela | con 2 comment(s)
Archivado en:
File upload en ASP.NET MVC

Es posible que tarde o temprano todos aquellos seguidores de ASP.NET MVC tengamos la necesidad de utilizar el típico FileUpload de Web Forms. Si nos fijamos, no existe un helper para este escenario por lo que necesitamos utilizar otra estrategia :D

En primer lugar debemos crear un formulario donde hagamos uso del tag input con el type=”file”. Pero eso no es todo, ya que además necesitaremos especificar a nivel de formulario el atributo enctype. Este atributo indica el tipo de contenido que se va a enviar al servidor. Como nos cuentan en la página oficial de W3, cuando el método utilizado es post el valor por defecto de este atributo es “application/x-www-form-urlencoded”. Sin embargo, si necesitamos hacer uso del elemento input de tipo file debemos modificar este valor por “multipart/form-data”. Dicho esto, nuestro formulario sería de la siguiente manera:

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<dynamic>" %><asp:Content ID="Content1" ContentPlaceHolderID="TitleContent" runat="server">
    Create a blob
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
    <h2>
        Create a new blob
    </h2>
    <div>
        <% using (Html.BeginForm("CreateBlob", "Home", FormMethod.Post, new { enctype = "multipart/form-data" }))
           {%>
        <p>
            <input type="file" id="newFile" name="newFile" size="23" />
        </p>
        <p>
            <input type="submit" value="Upload file" /></p>
        <% } %>
    </div>
</asp:Content>

Por otro lado, para recuperar el archivo en la acción CreateBlob utilizaremos la clase HttpPostedFileBase junto con el name del elemento que recoge el archivo para poder bindearlo.

[HttpPost]
public ActionResult CreateBlob(HttpPostedFileBase newFile)
{
  if (newFile.ContentLength > 0)
  {
   SaveBlob(newFile.InputStream);
  }   return RedirectToAction("Index");
}

Espero que sea de utilidad :)

¡Saludos!

Posted: 9/12/2010 23:55 por Gisela | con 3 comment(s)
Archivado en:
Acceder en remoto a nuestras instancias en Windows Azure

Una de las características más esperadas por los usuarios de la plataforma Windows Azure era la posibilidad de conectarnos en remoto a nuestras instancias. Por defecto, no es una opción que esté habilitada ya que es necesaria una configuración previa.

Configuración

El primer paso que debemos dar para habilitar la opción de conexión remota es configurar el certificado que queremos utilizar y habilitar un check desde Visual Studio 2010 que especifica que esta característica estará disponible. Para ello, pulsamos sobre el proyecto cloud con el botón derecho y seleccionamos la opción Publish...

Acto seguido nos aparecerá un cuadro de diálogo donde se muestra un enlace que nos permitirá configurar las conexiones de acceso remoto.

Al hacer click en este link, aparecerá una nueva ventana donde activaremos la opción Enable connections for all roles para tener acceso a los demás campos.

Ahora bien, es posible que la primera vez que accedamos a esta ventana no tengamos disponible ningún certificado, por lo que deberemos generarlo a través del primer combo seleccionando la opción <Create...>, donde deberemos elegir un nombre para el mismo. Una vez creado, especificaremos las credenciales para el acceso remoto y una fecha de expiración para la cuenta.

Si aceptamos los cambios que hemos realizado y se genera el paquete para su despliegue, en un principio estaríamos listos para realizar el deployment de la aplicación en el portal. Sin embargo, cuando intentamos subir el paquete nos avisa de lo siguiente:

Básicamente nos informa de que el certificado asociado con el paquete que intentamos subir no está disponible en nuestro servicio en la nube y que por lo tanto es necesario instalarlo. ¿Y dónde podemos encontrar dicho certificado?

Si bien en la versión anterior Windows Azure era necesario subir el archivo .cer, en esta nueva versión volvemos a necesitar el archivo .pfx utilizado en una versión anterior. Para conseguir el mismo, podemos hacerlo de la siguiente forma:

  1. Volvemos a seleccionar el proyecto cloud y pulsamos de nuevo en la opción Publish...
  2. Accedemos de nuevo a la configuración de las conexiones de escritorio remoto.
  3. Teniendo el certificado elegido en la subida, pulsamos sobre el botón View...

  4. Aparecerá una ventana nueva con la información del certificado seleccionado. Pulsamos en la segunda correspondiente a los Detalles y hacemos clic sobre el botón Copiar en archivo...

  5. Como opciones en el asistente, seleccionamos Exportar la clave privada, pulsamos siguiente, y dejamos la opción por defecto Intercambio de información personal: PKCS #12 (.PFX). Añadimos una contraseña para proteger la clave privada y por último seleccionamos la ubicación del archivo.
  6. Accedemos al portal de Windows Azure y nos posicionamos en el Hosted Service donde vamos a desplegar la aplicación. Si pulsamos sobre la flecha del servicio, veremos que cuelga del mismo una carpeta llamada Certificates.

  7. Pulsamos en el botón Add Certificate ubicado en el menú superior.

  8. Y por último añadimos el archivo pfx y la contraseña asociada.

A partir de este momento estamos listos para subir sin problemas el paquete del despliegue de nuestra aplicación. Una vez arriba y completado el status hasta el modo Ready. Veremos que aparece una nueva opción habilitada en el menú superior.

Si hacemos clic sobre el icono Connect nos devolverá un archivo del tipo rdp con la configuración necesaria para el acceso de nuestra instancia :)

Espero que sea de utilidad :D

¡Saludos!

Posted: 2/12/2010 23:26 por Gisela | con 4 comment(s)
Archivado en: