Shiju Varghese's Blog

Scaling Node.js Real-time Apps with Windows Azure Service Bus

shiju — Mon, 10 Jun 2013 16:08:09 GMT

In this post, I will demonstrate how to scale out real-time Socket.IO apps with Windows Azure Service Bus by leveraging the Node.js module Socket.IO-ServiceBus. The Node module Socket.IO-ServiceBus lets the Node.js developers scale out the Socket.IO apps to multiple servers, which will work with Socket.IO store, provided by Windows Azure Service Bus Topic. The only Windows Azure component you need to scale out your Socket.IO apps with Socket.IO-ServiceBus, is Windows Azure Service Bus Topic. You can deploy your Socket.IO apps into any cloud platform or on-premise servers and, the apps deployed in multiples servers, that will be work through the Windows Azure Service Bus. This blog post assumes that you have already worked with Socket.IO apps and will be focused on how to scale out Socket.IO apps with Windows Azure Service Bus.

Socket.IO for Real-time Web Apps

Socket.IO is one of the most popular Node.js modules, which is widely used for building real-time web apps on the Node.js platform. Socket.IO provides cross-browser real-time communication to web browsers which enables bi-directional communication between the server and browser client. Socket.IO leverages HTML 5 WebSocket if the browsers are support it, otherwise, it will use some browser-specific tricks to simulate the behavior provided by WebSockets, regardless of browser versions. Socket.IO can be used for building real-time apps such as Web Chats, Real-time Games, Stock monitoring apps, Push Notification Hubs, Real-time APIs, etc.

Scale Out Socket.IO Apps to multiple Servers with Socket.IO-ServiceBus

Node.js is a single threaded, asynchronous programming model, which enables a non-blocking execution models for developing web apps and networking apps. By default, for Node.js apps, you can’t leverage multi core machines, since Node.js is based on single threaded execution model, which will be leveraged single core of the server machine. But you can leverage multi cores of the server machine by leveraging the Node.js Cluster module. The problem with Socket.IO is that it would be difficult to scale out the Socket.IO server to multiple processes and multiple servers. Socket.IO provides a feature named Store which can be used for scale out Socket.IO apps to multiple processes. The Windows Azure Service Bus extends the Socket.IO store by providing a store option in Windows Azure, which provides greater scalability for scaling the Socket.IO apps to multiple processes and multiple servers regardless of data centers used for the server apps. Socket.IO-ServiceBus is the module developed by Microsoft Windows Azure Team for scale out Socket.IO apps with the help of Windows Azure Service Bus Topics. The beauty of the Socket.IO-ServiceBus is that it is not necessary to deploy your Socket.IO apps in Windows Azure. You can deploy your Socket.IO apps in any cloud platform or your own on-premise server. The only essential component for working with Socket.IO-ServiceBus is Windows Azure Service Bus Topic. Socket.IO-ServiceBus will leverage the Windows Azure Service Bus Topic as the store option for Socket.IO server instances.

The following are the basic steps for configuring Socket.IO store with Windows Azure Service Bus using the Socket.IO-ServiceBus

Step 1 – Create Windows Azure Service Bus Namespace and Topic

In order to working with Socket.IO-ServiceBus, we need to create a Windows Azure Service Bus namespace and Topic to configuring the store for Socket.IO server. To create a Windows Azure Service Bus namespace, go to Windows Azure management portal, select Service Bus from left pane, click Create from lower side of the windows and add a new namespace as shown in the following picture

You can copy the connection string of Service Bus from “Connect Info” button, after the choosing the namespace, which you want to copy the connection string.

We have created a namespace in Windows Azure Service Bus. Let’s create a Windows Azure Service Bus Topic within the namespace we have created in the previous step, for configuring the Service Bus store for Socket.IO server apps. To create a Service Bus Topic, select New from the lower left corner, select App Services, Service Bus, , Topic and click Quick Create and give the Topic Name and choose region and Namespace.

Step 2 – Configure Windows Azure Service Bus Store for Socket.IO Servers

In the step 1, we have created Windows Azure Service Bus namespace and Topic. In this step, let’s configure the Windows Azure Service Bus store for Socket.IO. First, add the npm module socket.io-servicebus to your Socket.IO app.

The code block below configures the socket.io-servicebus module with Windows Azure Service Bus connection string and topic name.

var socketio = require('socket.io')

    ,SbStore = require('socket.io-servicebus');

var io = socketio.listen(server);

//Configure Service Bus Store

io.configure(function () {

  io.set('store', new SbStore({

    topic: topicName,

    connectionString: sbconn

  }));

});

In above code block, the variable name topicName contains the name of Windows Azure Service Bus Topic and the variable name sbconn contains the connection string for Windows Azure Service Bus. You can deploy the Socket.IO apps to any number of servers and the only piece of code you need to do is configure the socket.io-servicebus module with above code block.

Summary

The npm module socket.io-servicebus, developed by Windows Azure team, is an excellent framework which lets the Node.js developers to build highly scalable real-time Node.js apps by simply leveraging Windows Azure Service Bus. The socket.io-servicebus does not restrict you to deploying your Node.js server apps only with Windows Azure. You can deploy your Socket.IO apps to any kind of servers and the only Windows Azure component you required is the Windows Azure Service Bus subscription. The socket.io-servicebus is an open source framework that available in github from here. I would greatly appreciate the Windows Azure team for their openness and contributions to OSS systems. I hope that socket.io-servicebus will enable better performance in future releases which will enable us to building mission critical real-time Node.js apps with Windows Azure Service Bus.

You can follow me on twitter at @shijucv

Edge.js - Running Node.js and .NET in One Process

shiju — Wed, 29 May 2013 08:56:47 GMT

C# is the most powerful static type programming language which can be used for developing wide variety of applications. Node.js is a server-side JavaScript platform which can be used for building high performance scalable applications on the V8 JavaScript engine. .NET provides more than 11,000 packages via NuGet and Node.js provides more than 30,000 modules via NPM. It would be great if we could use both .NET and Node.js platforms in one place. Edge.js is a Node.js npm module that lets the developers to run .NET and Node.js code in one process, where you can call .NET functions from Node.js and Node.js functions from .NET. With Edge.js, you can call C# async lambda from node.js. Both .NET and Node.js are using different threading models, but Edge does handle the threading models of single threaded V8 and multi-threaded CLR. Currently Edge.js supports to use JavaScript with C#, F#, Python, and PowerShell. Edge.js was developed by Tomasz Janczuk. The Edge.js framework hosted on Github at https://github.com/tjanczuk/edge

The following components required for working with Edge.js framework:

Windows
Node.js 0.6.x or later
.NET 4.5
Edge NPM Module

Working with Edge.js

You first install to Edge.js using npm in order to working Edge.js framework

Calling C# class from Node.js

The code block below provides a sample Node.js program which is using C# code for converting images from one image format to another image format

   1:  var edge = require('edge');

   2:  var convertImage = edge.func(function() {/*

   3:  #r "System.Drawing.dll"

4:

   5:   using System;

   6:   using System.Threading.Tasks;

   7:   using System.Collections.Generic;

   8:   using System.Drawing;

   9:   using System.Drawing.Imaging;

10:

  11:   class Startup

  12:  {

  13:    static IDictionary<string, ImageFormat> formats

  14:              = new Dictionary<string, ImageFormat>

  15:          {

  16:              { "jpg", ImageFormat.Jpeg },

  17:              { "bmp", ImageFormat.Bmp },

  18:              { "gif", ImageFormat.Gif },

  19:              { "tiff", ImageFormat.Tiff },

  20:              { "png", ImageFormat.Png }

  21:          };

22:

  23:  public async Task<object> Invoke(

  24:                  IDictionary<string,object> input)

  25:   {

  26:         await Task.Run(async () => {

  27:            using (Image image = Image.FromFile(

  28:                    (string)input["source"]))

  29:     {

  30:            image.Save((string)input["destination"],

  31:                   formats[(string)input["toType"]]);

  32:         }

  33:     });

34:

  35:              return null;

  36:          }

  37:      }

  38:  */});

39:

  40:  var params = {

  41:      source: '.\\shiju.png',

  42:      destination: '.\\shiju.jpg',

  43:      toType: 'jpg'

  44:  };

45:

  46:  convertImage(params, function (error) {

  47:      if (error) throw error;

  48: console.log('The image shiju.png has been asynchronously converted to shiju.jpg');

  49:  });

In the above code block, we are using the C# code using the edge.func where you can put C# async lambdas. In the above code block, we are using a C# class, which can be specified using the class name Startup with an Invoke method that matches the Func<object,Task<object>> delegate signature. We can add reference to the .Net assemblies using #r. The above program will convert the image to jpg format from png format where conversion logic was written in C# and called it from Node.js

You can run the above program as a normal node.js program as shown in the below command prompt:

Consuming Windows Azure Mobile Services REST API from ASP.NET Web API App

shiju — Sun, 12 May 2013 09:59:18 GMT

Windows Azure Mobile Services lets the developers to use structured storage, user authentication and push notifications to Android, iOS, HTML, Windows Store, or Windows Phone 8 apps by leveraging the Windows Azure Cloud platform. Using with Windows Azure Mobile Services, you can enjoy the scalability power of Cloud to your Mobile apps. In this blog post, I will demonstrate how to persist data on Windows Azure Mobile Services Table from a ASP.NET Web API app by leveraging the Windows Azure Mobile Services REST API, and finally provides a generic type helper class for performing CRUD operations on the Windows Azure Mobile Services Table.

Consuming Windows Azure Mobile Services REST API from a ASP.NET Web API App

Windows Azure Mobile Services provides native API for Android, iOS, HTML, Windows Store, or Windows Phone 8 apps so that you can directly consume the Windows Azure Mobile Services from your native Mobile apps. In this post, we will be consume the Windows Azure Mobile Services from a ASP.NET Web API app. Windows Azure Mobile Services provides REST API so that we can easily consume it form our ASP.NET Web API app. This use case is based on a real world app I have recently worked, where iOS clients are consuming a REST API written in ASP.NET Web API and for some persistence over the REST API, we need to send push notifications to the iOS clients. So we are consuming the Windows Azure Mobile Services REST API from ASP.NET Web API app where we need to send push notifications. In this post, I am directly consuming the REST API from my app instead of using any REST API wrapper for .Net clients so that we can explore the Windows Azure Mobile Services REST API.

A Generic CRUD Helper Class for Windows Azure Mobile Services Table

Let’s create a generic type class for CRUD operations on the Windows Azure Mobile Services Table by consuming the REST API of Windows Azure Mobile Services. This generic type helper class can work with any type of Model object.

 public class MobileServiceRequestHelper<T> where T : class
    {
        private string tableEndpoint;
        private string applicationKey;
        private HttpClient client;
        public MobileServiceRequestHelper(string tableName)
        {
            tableEndpoint = ConfigurationManager
                .AppSettings["TableEndpoint"] + tableName ;
            applicationKey = ConfigurationManager
                .AppSettings["X-ZUMO-APPLICATION"];
            client = new HttpClient();
            client.DefaultRequestHeaders.
                Add("X-ZUMO-APPLICATION", applicationKey);
            client.DefaultRequestHeaders.Accept
                .Add(new MediaTypeWithQualityHeaderValue("application/json"));
        }
    }
 

We are taking the application key and Mobile Services URI from the web.config table and we will pass the Windows Azure Table name in the constructor method of our generic type helper class.

Insert Operation

The API documentation for Insert record operation available from here. The code block below provides the implementation of HTTP Post for inserting a new record onto Windows Azure Mobile Services Table. We are serializing the model object as JSON format and executing the HTTP request by calling the SendAsync method of HTTPClient class.

 public bool Post(T requestData)
{
    var obj = JsonConvert.SerializeObject(requestData,
        new JsonSerializerSettings()
        {
            NullValueHandling = NullValueHandling.Ignore
        });
    var request = new HttpRequestMessage(HttpMethod.Post,
        tableEndpoint);
    request.Content = new StringContent(obj, Encoding.UTF8,
        "application/json");
    var data = client.SendAsync(request).Result;
    if (data.IsSuccessStatusCode)
        return true;
    else
        throw new HttpResponseException(data.StatusCode);
}
 

Update Operation

The API documentation for Update record operation available from here. The code block below provides the implementation of HTTP Put for updating an existing record onto Windows Azure Mobile Services Table.

 public bool Put(T requestData, int id)
{
            
        var request = new HttpRequestMessage(new HttpMethod("PATCH"), 
            tableEndpoint + id);
        var obj = JsonConvert.SerializeObject(requestData);
        request.Content = new StringContent(obj, Encoding.UTF8, 
            "application/json");
        var data = client.SendAsync(request).Result;
        if (data.IsSuccessStatusCode)
            return true;
        else
            throw new HttpResponseException(data.StatusCode);     
}
 

Please note that Windows Azure Mobile Services used HTTP Verb “PATCH” for updating an existing record.

Delete Operation

The API documentation for Delete record operation available from here. The code block below provides the implementation of HTTP Delete for deleting an existing record from the Windows Azure Mobile Services Table.

 public void Delete(int id)
{
    var request = new HttpRequestMessage(HttpMethod.Delete, 
        tableEndpoint + id.ToString());
    var data = client.SendAsync(request).Result;
    if (!data.IsSuccessStatusCode)
        throw new HttpResponseException(data.StatusCode);
}
 

Query Operation

The API documentation for Query record operation available from here. The code block below provides the implementation of querying all records and filtering with id value from the Windows Azure Mobile Services Table.

 public IEnumerable<T> GetAll()
{
    var result = client.GetStringAsync(tableEndpoint).Result;
    var data = JsonConvert.DeserializeObject<IEnumerable<T>>(result);
    return data; 
}
public T Get(int id)
{
    var result = client.GetStringAsync(tableEndpoint +
        "?$filter=Id eq " + id).Result;
    var data = JsonConvert.DeserializeObject<IEnumerable<T>>(result);
    return data.FirstOrDefault();
} 
 

Windows Azure Mobile Services supports the Open Data Protocol (OData) so that you can query the data from Windows Azure Mobile Services Table by using the query option parameters provided by the OData.

The complete implementation of the MobileServiceRequestHelper class is available on Gist at https://gist.github.com/shijuvar/5562928

Consuming the REST API from ASP.NET Web API App

In the previous steps, we have created a generic type helper class for executing requests against Windows Azure Mobile Services REST API. The code block below provides the HTTP Post operation of our ASP.NET Web API where we inserting a new record onto Windows Azure Mobile Services table named “tokens”

 public HttpResponseMessage Post(Token token)
{
    if (ModelState.IsValid)
    {
        var req = new MobileServiceRequestHelper<Token>("tokens");
        var isSuccess = req.Post(token);
        if (isSuccess)
        {
            HttpResponseMessage response = Request.CreateResponse(
                HttpStatusCode.Created, token);
            return response;
        }
        throw new HttpResponseException(HttpStatusCode.BadRequest);
    }
    else
    {
        return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
    }
}
 

In the above code block, we are creating an object of MobileServiceRequestHelper with generic type Token and inserting a new record on Windows Azure Mobile Services table “tokens”.

Windows Azure SDK 2.0 for .NET Released

shiju — Wed, 01 May 2013 07:11:42 GMT

The Windows Azure Cloud Computing platform has been in the big news after the platform exceeded the annual revenue of $1 billion. Today, Microsoft has been released the Windows Azure SDK 2.0 for .NET update that lets the .NET developers to build Windows Azure apps from Visual Studio with an easy and more elegant manner. The new update provides the lot of improvements within Visual Studio, for developing, deploying and managing Windows Azure apps. You can download and install the Windows Azure SDK 2.0 for .NET from the Windows Azure .NET developer center. The Windows Azure SDK for .NET is a open source project hosted on GitHub.

Improvement in Windows Azure SDK 2.0 for .NET

The information below provides the summary of the improvements provided by Windows Azure SDK 2.0 for .NET.

Windows Azure Web Sites:

Improved tooling support in Visual Studio for publishing apps
Management Support within the Visual Studio Server Explorer
Enable Live Streaming of Diagnostic Logs within the Visual Studio

Windows Azure Cloud Services:

Support for choosing High Memory VM Instances within Visual Studio
Application Deployment Support with Simultaneous Update Option
Improved Diagnostics Support

Windows Azure Storage:

Table Storage Explorer within the Visual Studio Server Explore

Windows Azure Service Bus

Enhanced client library with support for browsing messages, message pump programming model and auto delete for Idle messaging Entities

Windows Azure PowerShell Automation

Enhanced version with new Automation Commands

You can see the detailed information on the Windows Azure SDK 2.0 for .NET from ScottGu’s blog post Announcing the release of Windows Azure SDK 2.0 for .NET.

Sending and Receiving Messages in Windows Azure Storage Queue with JavaScript Serializer

shiju — Tue, 30 Apr 2013 17:06:34 GMT

In this blog post, I will demonstrate sample code for sending and receiving messages in Windows Azure Storage Queue with JavaScript Serializer for serializing and de-serializing messages. We are adding a custom type to Windows Azure Queue where we are using JavaScriptSerializer Class provided by System.Web.Script.Serialization namespace, for the serialization.

Creating a Windows Azure Storage Queue

The below method creates a Windows Azure Storage Queue

 public static CloudQueue GetAzureQueue(string queueName)
{
    var storageAccount = Microsoft.WindowsAzure.Storage
        .CloudStorageAccount.Parse(
        RoleEnvironment.GetConfigurationSettingValue
        ("StorageConnectionString"));
    var queueClient = storageAccount.CreateCloudQueueClient();
    CloudQueue queue = queueClient.GetQueueReference(queueName);
    return queue;
}
 

Adding Messages to Windows Azure Storage Queue

The below code block in the ASP.NET MVC Action Method, creates a Windows Azure Storage Queue and adding messages to the Queue. For adding a custom type to the Queue, we are serialize the model as a string message using JavaScript Serializer

 [HttpPost]
public ActionResult Create(CustomerFormModel form)
{
    if (ModelState.IsValid)
    {
        //maps to domain object from view model
        var command = Mapper.Map<CustomerFormModel,
            NewCustomerCommand>(form);
        var serializer = new JavaScriptSerializer();
        var modelAsString = serializer.Serialize(command);
        var queueClient = AzureStorageHelper.GetAzureQueue(QueueName);
        queueClient.CreateIfNotExists();
        //Add messages to the Azure Queue
        queueClient.AddMessage(new CloudQueueMessage(modelAsString));               
        return RedirectToAction("Index");
    }
return View(form);
}
 

Receiving Messages from Windows Azure Storage Queue

The code block below provides the implementation in a Worker Role for retrieving messages from Windows Azure Storage Queue and de-serializing the message string as a custom type. Finally, we creates a Windows Azure Table entity from the values of de-serialized type and inserting to Windows Azure Table.

 CloudTable customerTable = AzureStorageHelper.GetAzureTable(TableName);
    customerTable.CreateIfNotExists();
    CloudQueue customerQueue = AzureStorageHelper.GetAzureQueue(QueueName);
    customerQueue.CreateIfNotExists();
    var receivedMessage=customerQueue.GetMessage();
    if (receivedMessage != null)
    {
        // Process the message
        var serializer = new JavaScriptSerializer();
        var command = serializer.Deserialize<NewCustomerCommand>(receivedMessage.AsString);
                        
        // Create a new Azure Table entity.
        Customer customer=new Customer{
            Id=Guid.NewGuid().ToString(),
            PartitionKey = command.LastName,
            RowKey = command.FirstName,
            FirstName=command.FirstName,
            LastName=command.LastName,
            Address=command.Address,
            Email=command.Email,
            Phone=command.Phone                                
        };
 
        // Create the TableOperation that inserts the customer entity.
        TableOperation insertOperation = TableOperation.Insert(customer);
 
        // Execute the insert operation.
        customerTable.Execute(insertOperation);
        customerQueue.DeleteMessage(receivedMessage);
    }
 

Slides and Code from My Global Windows Azure Bootcamp Presentation

shiju — Sat, 27 Apr 2013 15:07:42 GMT

I did a presentation on Windows Azure Cloud Services at Global Windows Azure Bootcamp in Kochi, India. The title of the session was “Windows Azure Cloud Services – Web Roles and Worker Roles”. In this session, I have demonstrated how to building multi-tier Windows Azure Cloud Services application using with Web Role, Worker Role, Table Storage and Service Bus Queue. You can download the source code from my github repository https://github.com/shijuvar/AzureCloudServices. The code walkthrough demonstrated in the blog post Building Windows Azure Cloud Services App with Web Role, Worker Role, Table Storage and Service Bus. The slides used for the talk can download from here.

Global Windows Azure Bootcamp in Kochi, Kerala

shiju — Thu, 25 Apr 2013 05:58:41 GMT

On April 27, a global Windows Azure bootcamp is organizing across the world. This event is a free, one-day training program for Windows Azure and delivering variety of topics on the Cloud and Windows Azure platform. You can visit the global Windows Azure bootcamp website from here.

In Kerala, India, global Windows Azure bootcamp is conducting at Kochi, organized by Kerala Microsoft Users Group and sponsored by Marlabs and Orion. Visit the Kochi Windows Azure bootcamp website from here and you can register for the event from here

Deploying Windows Azure Cloud Services Apps

shiju — Wed, 24 Apr 2013 13:20:36 GMT

In my previous post Building Windows Azure Cloud Services App with Web Role, Worker Role, Table Storage and Service Bus, I have demonstrated how to build a multi-tier cloud application using Windows Azure Cloud Service. In this post, I will demonstrate how to deploy our Cloud Service application on Windows Azure using Visual Studio 2012. You can create a Cloud Service from Visual Studio itself and can deploy the Cloud Service to Windows Azure without using the Windows Azure management portal.

Publishing the Cloud Service App

Let’s publish our cloud service app from Visual Studio. Right-click the Cloud Service project, and click Publish as shown in the below picture

The Publish wizard will ask you for the Windows Azure Subscription as shown in the below picture. If you have not imported any Windows Azure subscription, you can download it by clicking “Sign in to download credentials” which will download a .publishsettings file from Windows Azure management portal and later you can import the .publishsettings by clicking the Import button.

The wizard will ask you for choose a Cloud Service in the Windows Azure Publish Settings window. You can choose an existing Cloud Service which you have created from Management Portal. You can also create the Cloud Service from Visual Studio itself. Let’s create a Cloud Service from Visual Studio where you can specify the name of the service and location of the data center.

In the Windows Azure Publish Settings window, we can specify the environment, Build configuration and Service configuration. Windows Azure provides two environment for running apps: staging and production, where staging is used for testing and validating our cloud service app and production is used for running live applications.

We can also enable Remote Desktop for roles which lets access to the roles hosted on the virtual machines by using remote desktop. The screenshot below provides the Remote Desktop Window.

The next windows in the wizard shows the summary of Windows Azure Publish configuration. We can edit these configurations in our future publish and can also modify it from Windows Azure management portal

In the Windows Azure Publish Summary window, click the publish button which will deploy the Cloud services app to Windows Azure.

The screenshot below shows the Windows Azure Activity log that shows the success of the deployment.

The screenshots below provides the Windows Azure management portal where we can see that our newly created Cloud Service is running in the product environment.

The screenshots below show that our application running successfully on the Windows Azure cloud

Summary

In this post, we have created a Windows Azure Cloud Service from Visual Studio and deployed the Cloud Service app on the Windows Azure VM from Visual Studio. Using Visual Studio, we can easily create and deploy cloud services without accessing the Windows Azure management portal. I will discuss more about the Cloud Services in my future blog post.

You can follow me on twitter at @shijucv

Building Windows Azure Cloud Services App with Web Role, Worker Role, Table Storage and Service Bus

shiju — Mon, 22 Apr 2013 16:52:54 GMT

Windows Azure Cloud Services, provides a Platform as a Service (PaaS) offering for building multi-tier, highly scalable, reliable cloud applications on the Windows Azure Cloud platform. In this blog post, I will demonstrate how to build a multi-tier Windows Azure Cloud Services application using with Web Role, Worker Role, Table Storage and Service Bus Queue. This demo application will also demonstrates the usages of Service Bus Queue, Table Storage and how to communicate between the Web Role and Worker Role.

Source Code

The source code of the demo Windows Azure Cloud Services app available on GitHub at https://github.com/shijuvar/AzureCloudServices

About the Demo App

The Cloud Services app will have two roles: a Web Role and a Worker Role. Windows Azure Service Bus Queue will be used for communicating between the Web Role and a Worker Role. Table storage is used for the persistence of data. A user can a register a Customer entity from the Web Role where a message will be send to Windows Azure Service Bus Queue. The Worker Role will be polling the Queue messages, and finally persist the data into a Windows Azure Table storage.

The following Windows Azure services will be used for the demo app:

Web Role
Worker Role
Windows Azure Table
Windows Azure Service Bus

The Web Role app is built with ASP.NET MVC 4 web application and the Worker Role uses the Worker Role with Service Bus Queue template.

The following NuGet packages for Windows Azure, have been used in this app

Windows Azure Configuration Manager - Microsoft.WindowsAzure.ConfigurationManager
Windows Azure Storage - WindowsAzure.Storage
Windows Azure Service Bus - WindowsAzure.ServiceBus

Write Command of the App

The code block below provides the entity class which represents for creating a new customer entity

   1:  public class NewCustomerCommand

   2:  {

   3:      public string FirstName { get; set; }

   4:      public string LastName { get; set; }

   5:      public string Address { get; set; }

   6:      public string Phone { get; set; }

   7:      public string Email { get; set; }

   8:  }

Read Model of the App

The code block below provides the read model of the app

   1:  public class Customer : TableEntity

   2:  {

   3:      public string Id { get; set; }

   4:      public string FirstName { get; set; }

   5:      public string LastName { get; set; }

   6:      public string Address { get; set; }

   7:      public string Phone { get; set; }

   8:      public string Email { get; set; }

   9:  }

In this demo app, Windows Azure Table storage is used for persistence and read operations will be performed against the Table storage. The Customer class represents the Windows Azure Table entity so that it is inherited from the class TableEntity.

Building the Cloud Services App with Visual Studio

Let’s create a Windows Azure Cloud Services projects from Visual Studio 2012. The Windows Azure Cloud Service project available from the Cloud template.

Let’s add ASP.NET MVC 4 Web Role and Worker Role with Service Bus Queue onto the Windows Cloud service as shown in the following picture.

The Windows Azure Cloud Service project has the two Roles: a Web Role and a Worker Role

Let’s add the necessary NuGet packages to the corresponding projects. In this demo app, we are using Windows Azure Storage and Windows Azure Service Bus so that we have to add the connection string for both Windows Azure Storage and Windows Azure Service Bus. To add the connection string, right click the corresponding Role from the Roles folder of the Cloud Service project, choose properties.

From the properties windows, choose the settings tab, add Settings. Let’s add names StorageConnectionString and Microsoft.ServiceBus.ConnectionString for Windows Azure Storage and Service Bus. If you want to use local Storage Emulator for the development cycle, you can give the value “UseDevelopmentStorage=true” for the connection string.

Helpers for Table Storage and Service Bus Queue

Let’s add helper classes for Windows Azure Table and Service Bus Queue in order to working these services.

AzureStorageHelper.cs

   1:  public static class AzureStorageHelper

   2:  {

   3:  public static void InitializeAzureTable(string tableName)

   4:  {

   5:      CloudTable table = GetAzureTable(tableName);

   6:      //Create table if it doesn't exists

   7:      table.CreateIfNotExists();

   8:  }

9:

  10:  public static CloudTable GetAzureTable(string tableName)

  11:  {

  12:      var storageAccount = Microsoft.WindowsAzure.Storage

  13:          .CloudStorageAccount.Parse(

  14:          RoleEnvironment.GetConfigurationSettingValue

  15:          ("StorageConnectionString"));

  16:      // Get table for working with tables.

  17:      var tableClient = storageAccount.CreateCloudTableClient();

  18:      CloudTable table = tableClient.GetTableReference(tableName);

  19:      return table;

  20:  }

  21:  }

In the above code block, the method GetAzureTable returns CloudTable and the InitializeAzureTable method creates the Azure Table if it does not exists.

The code block below provides the helper class for working with Windows Azure Service Bus

ServiceBusQueueHelper.cs

   1:  public static class ServiceBusQueueHelper

   2:  {

   3:  //// Recommended that you cache QueueClient

   4:  //// rather than recreating it on every request.

   5:  public static public static QueueClient CustomersQueueClient;

   6:  // The name of the queue

   7:  public const string QueueName = "CustomerQueue";

8:

   9:  public static NamespaceManager CreateNamespaceManager()

  10:  {

  11:      string connectionString =

  12:      CloudConfigurationManager.GetSetting(

  13:      "Microsoft.ServiceBus.ConnectionString");

  14:      var namespaceManager = NamespaceManager.

  15:        CreateFromConnectionString(connectionString);

  16:      return namespaceManager;

  17:  }

  18:  public static void Initialize()

  19:  {

  20:      // Using Http to be friendly with outbound firewalls

  21:      ServiceBusEnvironment.SystemConnectivity.Mode =

  22:          ConnectivityMode.Http;

  23:      string connectionString =

  24:          CloudConfigurationManager.GetSetting

  25:          ("Microsoft.ServiceBus.ConnectionString");

  26:      NamespaceManager namespaceManager = CreateNamespaceManager();

  27:      if (!(namespaceManager.QueueExists(QueueName)))

  28:      {

  29:          namespaceManager.CreateQueue(QueueName);

  30:      }

31:

  32:      // Initialize the connection to Service Bus Queue

  33:      CustomersQueueClient = QueueClient.

  34:          CreateFromConnectionString(connectionString, QueueName);

  35:  }

  36:  }

The code block below calls from Global.asax.cs for creating Table and initializing the Service Bus Queue.

   1:  //Create Azure Table

   2:  AzureStorageHelper.InitializeAzureTable("Customer");

   3:  //Initialize Service Bus Queue

   4:  ServiceBusQueueHelper.Initialize();

Sending Messages to Service Bus Queue in Web Role App

The web role app lets the users to create Customer entity, where a message will be send to Windows Azure Service Bus Queue and the worker role will be polling the queue messages.

The code bock below provides to send customer message to Windows Azure Service Bus Queue, from Create action method of CustomerController

   1:  [HttpPost]

   2:  public ActionResult Create(CustomerFormModel form)

   3:  {

   4:  if (ModelState.IsValid)

   5:  {

   6:      //maps to domain object from view model

   7:      var command = Mapper.Map<CustomerFormModel,

   8:          NewCustomerCommand>(form);

   9:      var message = new BrokeredMessage(command);

  10:      // Send customer message to Service Bus Queue

  11:      ServiceBusQueueHelper.CustomersQueueClient.

  12:                       Send(message);

  13:      return RedirectToAction("Index");

  14:  }

  15:  return View(form);

  16:  }

We create the object of BrokeredMessage with the NewCustomerCommand object and send the message to Windows Azure Queue. BrokeredMessage represents the unit of communication between Service Bus clients.

The screen shot below provides the UI for creating a new Customer

Receiving Messages from Service Bus Queue in Worker Role App

The Worker Role app will be polling on the Windows Azure Service Bus Queue and persist data into Table storage.

The code block below provides the implementation of Worker Role

   1:  public class WorkerRole : RoleEntryPoint

   2:  {

   3:  // The name of your queue

   4:  const string QueueName = "CustomerQueue";

   5:  public static QueueClient Client;

   6:  bool IsStopped;

7:

   8:  public override void Run()

   9:  {

10:

  11:  var storageAccount = CloudStorageAccount.Parse

  12:     (RoleEnvironment.GetConfigurationSettingValue

  13:     ("StorageConnectionString"));

14:

  15:      while (!IsStopped)

  16:      {

  17:      try

  18:      {

  19:      // Receive the message

  20:      BrokeredMessage receivedMessage = null;

  21:      receivedMessage = Client.Receive();

22:

  23:      if (receivedMessage != null)

  24:      {

  25:      // Process the message

  26:      Trace.WriteLine("Processing",

  27:          receivedMessage.SequenceNumber.ToString());

  28:      NewCustomerCommand command = receivedMessage.

  29:          GetBody<NewCustomerCommand>();

  30:     // Create the table client.

  31:     CloudTableClient tableClient = storageAccount.

  32:         CreateCloudTableClient();

33:

  34:      // Create the CloudTable object for "Customer" table.

  35:      CloudTable table = tableClient.GetTableReference("Customer");

36:

  37:      // Create a new customer entity.

  38:      Customer customer=new Customer{

  39:          Id=Guid.NewGuid().ToString(),

  40:          PartitionKey = command.LastName,

  41:          RowKey = command.FirstName,

  42:          FirstName=command.FirstName,

  43:          LastName=command.LastName,

  44:          Address=command.Address,

  45:          Email=command.Email,

  46:          Phone=command.Phone

  47:      };

48:

  49:      // Create the TableOperation that inserts the customer entity.

  50:      TableOperation insertOperation = TableOperation.Insert(customer);

51:

  52:      // Execute the insert operation.

  53:      table.Execute(insertOperation);

  54:      receivedMessage.Complete();

  55:      }

  56:    }

  57:          catch (MessagingException e)

  58:          {

  59:              if (!e.IsTransient)

  60:              {

  61:                  Trace.WriteLine(e.Message);

  62:                  throw;

  63:              }

64:

  65:              Thread.Sleep(10000);

  66:          }

  67:          catch (OperationCanceledException e)

  68:          {

  69:              if (!IsStopped)

  70:              {

  71:                  Trace.WriteLine(e.Message);

  72:                  throw;

  73:              }

  74:          }

  75:      }

  76:  }

77:

  78:  public override bool OnStart()

  79:  {

  80:      // Set the maximum number of concurrent connections

  81:      ServicePointManager.DefaultConnectionLimit = 12;

82:

  83:      // Create the queue if it does not exist already

  84:      string connectionString = CloudConfigurationManager.

  85:          GetSetting("Microsoft.ServiceBus.ConnectionString");

  86:      var namespaceManager = NamespaceManager.

  87:          CreateFromConnectionString(connectionString);

  88:      if (!namespaceManager.QueueExists(QueueName))

  89:      {

  90:          namespaceManager.CreateQueue(QueueName);

  91:      }

92:

  93:      // Initialize the connection to Service Bus Queue

  94:      Client = QueueClient.CreateFromConnectionString

  95:          (connectionString, QueueName);

  96:      IsStopped = false;

  97:      return base.OnStart();

  98:  }

99:

 100:  public override void OnStop()

 101:  {

 102:      // Close the connection to Service Bus Queue

 103:      IsStopped = true;

 104:      Client.Close();

 105:      base.OnStop();

 106:  }

 107:  }

Receives Messages from Queue

The code block below receives message from Service Bus Queue

   1:  BrokeredMessage receivedMessage = null;

   2:      receivedMessage = Client.Receive();

Process Queue Message and Insert Data to Windows Azure Table

The code block below processes the queue message and insert data to Windows Azure Table

   1:  if (receivedMessage != null)

   2:  {

   3:  // Process the message

   4:  Trace.WriteLine("Processing",

   5:      receivedMessage.SequenceNumber.ToString());

   6:  NewCustomerCommand command = receivedMessage.

   7:      GetBody<NewCustomerCommand>();

   8:  // Create the table client.

   9:  CloudTableClient tableClient = storageAccount.

  10:      CreateCloudTableClient();

11:

  12:  // Create the CloudTable object for "Customer" table.

  13:  CloudTable table = tableClient.

  14:      GetTableReference("Customer");

15:

  16:      // Create a new customer entity.

  17:      Customer customer=new Customer{

  18:          Id=Guid.NewGuid().ToString(),

  19:          PartitionKey = command.LastName,

  20:          RowKey = command.FirstName,

  21:          FirstName=command.FirstName,

  22:          LastName=command.LastName,

  23:          Address=command.Address,

  24:          Email=command.Email,

  25:          Phone=command.Phone

  26:      };

27:

  28:  // Create the TableOperation that inserts the customer entity.

  29:TableOperation insertOperation = TableOperation.Insert(customer);

30:

  31:  // Execute the insert operation.

  32:  table.Execute(insertOperation);

  33:  receivedMessage.Complete();

  34:  }

The messages in the Service Bus Queue contains the type NewCustomerCommand so that we are receiving the message from Queue as type NewCustomerCommand by using the generic type method GetBody of the BrokeredMessage class. The BrokeredMessage class represents the unit of communication between Service Bus clients. We create an instance of Customer object by copying the value of NewCustomerCommand object for insert a new Table entity. We create a TableOperation insert using the Insert method of TableOperation class and finally executes the insert operation using the execute method of CloudTable.

Reading Data from Windows Azure Table in Web Role App

The code block below provides the implementation of Index action method in the CustomerController of Web Role app.

   1:  public ActionResult Index()

   2:  {

   3:  CloudTable table = AzureStorageHelper.

   4:      GetAzureTable("Customer");

   5:  TableQuery<Customer> query = new TableQuery<Customer>();

   6:  var customers = table.ExecuteQuery(query);

   7:  if (Request.IsAjaxRequest())

   8:  {

   9:      return PartialView("_List", customers);

  10:  }

  11:  return View(customers);

  12:  }

In the above code block, we are query the all customer data from the Windows Azure Table named Customer. We use the ExecuteQuery method of the CloudTable object for executing the query against the Table storage.

The code block below provides the complete implementation of ASP.NET MVC Controller class CustomerController, which is used for sending messages to Windows Azure Queue and reading data from Windows Azure Table Storage.

   1:  public class CustomerController : Controller

   2:  {

   3:  public ActionResult Index()

   4:  {

   5:  CloudTable table = AzureStorageHelper.

   6:      GetAzureTable("Customer");

   7:  TableQuery<Customer> query = new TableQuery<Customer>();

   8:  var customers = table.ExecuteQuery(query);

   9:  if (Request.IsAjaxRequest())

  10:  {

  11:      return PartialView("_List", customers);

  12:  }

  13:  return View(customers);

  14:  }

  15:  public ViewResult Create()

  16:  {

  17:      var viewModel = new CustomerFormModel();

  18:      return View(viewModel);

  19:  }

  20:  [HttpPost]

  21:  public ActionResult Create(CustomerFormModel form)

  22:  {

  23:  if (ModelState.IsValid)

  24:  {

  25:      //maps to domain object from view model

  26:      var command = Mapper.Map<CustomerFormModel,

  27:          NewCustomerCommand>(form);

  28:      var message = new BrokeredMessage(command);

  29:      // Send customer message to Service Bus Queue

  30:      ServiceBusQueueHelper.CustomersQueueClient.Send(message);

  31:      return RedirectToAction("Index");

  32:  }

  33:  return View(form);

  34:  }

  35:  }

Source Code

The source code of the Windows Azure Cloud Service app available on GitHub at https://github.com/shijuvar/AzureCloudServices

Segregation of Command and Query Operations

We have segregated the Command and Read operations in this demo app. A Command operation from a Web Role application, sends messages to Service Bus Queue and the process of the command operations handles from a Worker Role app. The Worker Role application process the queue messages and finally persists on the Table storage for the Read operations. We use the Table storage for Read model of the app. We can use Table storage as the Read model for building CQRS applications on the Windows Azure.

Summary

In this blog post, we have discussed about how to build multi-tier Windows Azure Cloud Services application using Web Role, Worker Role, Service Bus Queue and Table storage. Windows Azure Cloud Services is the Windows Azure offerings for Platform as a Service (PaaS) which lets the Cloud developers to build multi-tier highly scalable, reliable cloud applications on the Windows Azure Cloud platform. We can use Windows Azure Service Bus Queue or Storage Queue for communicating between Web Roles and Worker Roles. In this demo app, we have used Service Bus Queue for communicating between Web Roles and Worker Roles.

Using async/await with Windows Azure Service Bus Client SDK

shiju — Sat, 13 Apr 2013 03:50:43 GMT

The Windows Azure team has recently released Windows Azure Service Bus 2.0.0-beta which lets the Windows Azure developers to use Task based asynchronous operations while working with Windows Azure Service Bus. Now the Windows Windows Azure Service Bus SDK provides Async version for the Service Bus methods. The SDK will be working with both Visual Studio 2010 and Visual Studio 2012 as the SDK compiled against .Net Framework 4.0.

Using async/await with Windows Azure Service Bus

You can add the beta version of Azure Service Bus SDK using NuGet. Since the updated Service Bus SDK is just reached Beta, you have to specify the “Include Prerelease” option in the Manage NuGet windows as shown in the following picture.

The following code block shows the usage of aync/await with Service Bus Queue operations.

   1:  public static async Task<QueueClient> GetQueueClientAsync ()

   2:  {

   3:      QueueClient client;

   4:      string connectionString =

   5:          CloudConfigurationManager.GetSetting(

   6:          "Microsoft.ServiceBus.ConnectionString");

   7:      NamespaceManager namespaceManager = CreateNamespaceManager();

   8:      //Create the queue if it does not exists

   9:      if (!(await namespaceManager.QueueExistsAsync(QueueName)))

  10:      {

  11:          await namespaceManager.CreateQueueAsync(QueueName);

  12:      }

  13:      // Initialize the connection to Service Bus Queue

  14:      client = QueueClient.CreateFromConnectionString

  15:          (connectionString, QueueName);

  16:      return client;

  17:  }

In above code block, we are using async operations of QueueExists method and CreateQueue methods along with the await keyword. In the below code block, we are calling the above GetQueueClientAsync method and asynchronously sending messages to Service Bus Queue.

   1:  public async Task<ActionResult> Submit(OnlineOrder order)

   2:  {

   3:  if (ModelState.IsValid)

   4:  {

   5:      // Create a message from the order

   6:      var message = new BrokeredMessage(order);

   7:      // Getting the Queue

   8:      QueueClient queueClient =

   9:          await QueueConnector.GetQueueClientAsync();

  10:      // Submit the order

  11:      await queueClient.SendAsync(message);

  12:      return RedirectToAction("Submit");

  13:  }

  14:  else

  15:  {

  16:      return View(order);

  17:  }

The messages retrieving from Service Bus Queue as shown in the code block provided below.

   1:  // Receive the message

   2:  BrokeredMessage receivedMessage = null;

   3:  receivedMessage =await Client.ReceiveAsync();

   4:  if (receivedMessage != null)

   5:  {

   6:      // Process the message

   7:      Trace.WriteLine("Processing",

   8:          receivedMessage.SequenceNumber.ToString());

   9:      // View the message as an OnlineOrder

  10:      OnlineOrder order = receivedMessage.GetBody<OnlineOrder>();

  11:      Trace.WriteLine(order.Customer + ": " +

  12:          order.Product, "ProcessingMessage");

  13:      await receivedMessage.CompleteAsync();

14:

  15:  }

Creating and Deploying Windows Azure Web Sites with Microsoft WebMatrix 3

shiju — Thu, 04 Apr 2013 04:08:12 GMT

Microsoft WebMatrix is a free, lightweight and cloud-connected web development tool which can be used for building and deploying Windows Azure Web Sites. Microsoft WebMatrix supports ASP.NET, Node.js and PHP. A while ago I have written a post Building and Deploying Windows Azure Web Site with Node.js and MongoDB by using Microsoft WebMatrix, where I have demonstrated how we can develop and deploy Web Sites to Windows Azure. The newly released WebMatrix 3 is an excellent IDE for building and deploying Web Sites to Windows Azure. The WebMatrix 3 lets the developers to create Windows Azure Web Sites from the IDE itself and can easily publish to Windows Azure, without using Windows Azure management portal. You can add Windows Azure accounts to WebMatrix 3 and can easily create and deploy Windows Azure Web Sites using WebMatrix 3. WebMatrix 3 provides better supports for working with Windows Azure and source control integration with Git and TFS. The source control integration is a new feature to WebMatrix.

Download Microsoft WebMatrix 3

The new version of Microsoft WebMatrix can download from http://www.microsoft.com/web/webmatrix/next/

Add Microsoft Account to WebMatrix 3

We can add an Account including a Microsoft Account to WebMatrix 3, which can be used for managing web sites with Windows Azure. To add an account to WebMatrix, click the Sign in button or Add Account from the top right corner of WebMatrix Quick Start window. This will prompt the following dialog where we can use either sign in using a Microsoft account for Windows Azure or we can import an account, we downloaded from a hosting provider. We can use Windows Azure Management credentials (.publishsettings file) to import an account.

I have chosen Sign in using Microsoft Account where we can use our Windows Azure account credentials. Sign in using Windows Azure account will import the Windows Azure account management credentials to your WebMatrix IDE so that you can easily create and publish web sites to Windows Azure.

Create a Windows Azure Web Site in WebMatrix 3

Let’s create a sample web site in WebMatrix from a Site template. For this sample, let’s create a site from Site template as shown in the following picture.

This will prompt you to create a Windows Azure Web Site where you can specify the web site name and the Windows Azure data center region as shown in the following picture. This wizard will create a web site in Windows Azure

Publish Web Sites to Windows Azure

We can easily publish the web site contents by just clicking the publish button of WebMatrix whenever we want publish our contents. The publish option will prompt the publish compatibility for the publishing of first time and finally preview the contents to be uploaded to Windows Azure. For the later uploads, it will just prompt the Publish Preview windows. The following screenshots shows Publish Compatibility and Publish Preview windows.

The following screenshot shows that the Windows Azure web site is running successfully after the publish web site to Windows Azure.

Generating Entity Data Model Diagram from EF Code First DbContext

shiju — Sun, 03 Mar 2013 07:58:17 GMT

The Entity Framework Code First approach lets the developers to build applications with Domain-Driven Design (DDD) by hand coding your Persistence Ignorance (PI) classes. At the same time, it would be great if we could see the entity model in a visual diagram, which can also ensure that our domain model is accurate and our relationships are designed properly. The Entity Framework Power Tools lets you to view a read-only view of the Code First model in the Entity Model Designer, from a Code First DbContext class.

You can add the Entity Framework Power Tools from Visual Studio 2012. To install Entity Framework Power Tools from Visual Studio 2012, select the Extensions and Updates from the Tools menu and search for Entity Framework Power Tools in the Visual Studio online gallery, and install the Power Tools.

One you have installed the Entity Framework Power Tools, you can see a context menu Entity Framework. To generate a read-only Entity Model in a designer, select the Code First DbConext class and right click, from the Entity Framework context menu, select view Entity Data Model (Read-only) as shown in the below picture:

The following screen shot shows the Entity Data Model generated from my Codeplex project EFMVC

Please note that this is a read-only model which won’t allow to edit the model in the designer. By looking on the Data Model in the designer, you can verify that the domain model is correct and relationships are configured properly.

Demo app and eBook for Windows Azure Mobile Services for iOS Clients

shiju — Fri, 22 Feb 2013 09:53:12 GMT

Mobile Cloud and Windows Azure Mobile Services

The key advantage of the Cloud computing is the salability power and the business agility where you don't have to worry about your infrastructure and you can focus on your apps which can easily scale up and scale down the number of compute resources based on your scalability needs. It would be great if we could use the power and agility of Cloud computing to Mobile apps which can also be a solution to the lack of local resources in Mobile devices. The Mobile Cloud Computing is emerging as one of the most important extension of cloud computing, where both the data storage and the data processing will be happen in Cloud infrastructure instead of the mobile devices and on-premises servers.

Microsoft Windows Azure extends their Cloud computing offerings to Mobile devices which let you to build powerful Mobile apps that can utilize the power and scalability of Cloud computing. Windows Azure Mobile Services provides structured storage, user authentication and push notifications to iOS, Android, Windows Phone and Windows Store apps. You can use Windows Azure Mobile Services as the backend infrastructure for your mobile apps where you can enjoy the all power of Cloud computing to your Mobile apps which can easily scale up when users of the apps are increasing.

Demo app and eBook for Windows Azure Mobile Services for iOS Clients

In my organization Marlabs, our Windows Azure team has been working on few sample apps for Windows Azure Mobile Services. You can download an initial drop of a sample Windows Azure Mobile Services app for iOS Clients, which including a eBook, which demonstrates how to leverage Windows Azure Mobile Services for the sample iOS app.

You can download the sample app and eBook from http://azuremobileios.codeplex.com/

Automating Windows Azure with Windows Azure CLI

shiju — Fri, 25 Jan 2013 06:17:42 GMT

Recently, Microsoft Windows Azure team has announced the release of azure-cli 0.6.10 which can be used for automating Windows Azure in an easy and elegant manner. The azure-cli is a Node.js based cross platform command line tool for Windows Azure, which can be used for managing and deploying Windows Azure Websites, Windows Azure Storage, Mobile Services, Virtual Machines, Service Bus from command prompt on Windows, Mac and Linux.

Installing Windows Azure CLI

You can install Windows Azure CLI by either using a MSI installer for Windows or using a Node.js NPM module azure-cli. The Windows installer can download from here

The Azure CLI is a Node.js based command line tool, so the Windows installer for Azure CLI will automatically install Node.js and other required components.

Azure CLI is delivering as a Node.js NPM module so that we can install the Azure CLI using Node.js. The following command will install Azure CLI by using Node.js Package Manager.

In the above command, we install NPM module azure-cli

Using Windows Azure CLI

After installing Azure CLI, just type azure and enter in the command prompt that will show the following output which including all available commands

The information provided below is a few sample commands for automating Windows Azure with Azure CLI

Managing Windows Azure Accounts

The Azure CLI command “azure account download” will download a publishsettings file from Windows Azure portal. You have to login to the Windows Azure portal in order to download the publishsettings file.

The Azure CLI command “azure account import [publishsettings file] imports Windows Azure credentials so that you can easily manage Windows Azure Websites, Mobile Services, Virtual Machines, Service Bus by using the CLI commands.

Managing Windows Azure Storage

The Azure CLI command “azure account storage list” list out the all storage account

The Azure CLI command “azure account storage create [name] --location ["location"]” creates a storage account in the specified location.

The Azure CLI command “azure account storage delete [name]” removes the specified storage account

Managing Windows Azure Websites

The Azure CLI command “azure site list” list out the websites created in the Windows Azure account.

The Azure CLI command “azure site create [name]” creates a Website in the specified data center region. The below command creates a Website in West US region.

The Azure CLI command “azure site show [name]” shows the all details about the specified Azure Website

The Azure CLI command “azure site delete [name]” removes the specified Windows Azure Website

More Information on Azure CLI

For more details on the commands and reference on Azure CLI, check out the following links:

Summary

The Azure CLI is a great command line tool which lets Windows Azure developers to automate Windows Azure by using your favorite command line tools regardless of operating systems. By using Windows Azure CLI, we can manage and deploy Windows Azure Websites, Windows Azure Storage, Mobile Services, Virtual Machines, Service Bus from command prompt on Windows, Mac and Linux.

Building and Deploying Windows Azure Web Site with Node.js and MongoDB by using Microsoft WebMatrix

shiju — Fri, 04 Jan 2013 06:34:37 GMT

In this blog post, I will demonstrate how to build a web app with Node.js and MongoDB, and will deploy it on Windows Azure as a Windows Azure Web Site. Firstly, I will create a web site with Node.js, Express.js, Mongoose and MongoDB. Then I will create a MongoDB database on MongoLab, which is a MongoDB as a service hosted on Cloud, and finally deploy the web app to Windows Azure Web Site. The source code for the demo app is available on Github at https://github.com/shijuvar/NodeExpressMongo

About the Demo Web App

This is a simple Task management application which provide the functionality for add, edit, delete and list out the Tasks. The home page will list out the uncompleted Tasks and List page will list out all tasks.

Node.js modules for the web app

The following NPM modules will be used for this demo web app.

Express.js – A light-weight web application framework for Node.js
Mongoose - MongoDB object modeling framework for node.js
Jade – A server-side view engine for Node.js web apps, which will be used with Express application

Creating the web app with Microsoft WebMatrix IDE

Let’s create a Node.js Express web app from the Microsoft WebMatrix IDE by using the Express site template

The express template will create a basic Express site with necessary configuration for IISNode and will add the NPM modules Express and Jade.

Adding NPM Modules using WebMatrix

WebMatrix is providing an extension “NPM Gallery” which can be used for installing NPM modules from the WebMatrix . You can install this extension from the extension gallery as shown in the below picture

After adding the NPM Gallery, We can see the NPM Gallery extension icon on the top of the WebMatrix IDE

We can easily find and install NPM modules by using the NPM Gallery.

The Express template provided by WebMatrix will automatically add the NPM modules Express and Jade. In our app, we will be use NPM module Mongoose so that we have to install Mongoose module from the NPM gallery.

Structure of the web app

The web app will be structured as the following project structure.

The details for the application folders and files are provided below:

server.js – Entry point of the web app
routes.js – Specified the routes for web app
controllers – Controller classes which handles user interactions. The logic for the CRUD operations also implemented in the controller classes
models – Model of the app. The model schema defined with Mongoose
public – Static contents of the web app
views – View templates built with Jade
config.js – Configuration file used for specifying the connection string for MongoDB
web.config - Configuration file for the IISNode

Model for the web app

Let’s create the model with Mongoose for the demo web app. Mongoose is a schema based MongoDB object modeling framework for node.js. The model for the web app is provided in the below function:

   1:  function models(params) {

   2:  var mongoose = params.mongoose;

3:

   4:  /* Schema Definition */

   5:      var Task = new Schema({

   6:      name        :  { type: String, required: true }

   7:    , description : String

   8:    , status      : String

   9:    , startDate   : { type: Date, default: Date.now }

  10:    , dueDate     : Date

  11:    , completion  : {type: Number, default: 0}

  12:  });

  13:  mongoose.model('Tasks', Task);

  14:  };

  15:  module.exports = models;

The application is a simple task management application and the above schema definition contains the information for the MongoDB collection Tasks. The Mongoose object will be passed from the main entry of the app.

Server.js – Entry point of the web app

The server.js is the entry point of the web app and the implementation is given below:

   1:  /**

   2:   * Module dependencies.

   3:   */

   4:  //MPM Modules

   5:  var express = require('express')

   6:    , mongoose = require('mongoose');

7:

   8:  var config = require('./config.js')

   9:     , routes = require('./routes.js');

10:

  11:  mongoose.connect(config.db.mongodb);

  12:  var models = require('./models')({ mongoose: mongoose });

  13:  var controllers = require('./controllers')(

  14:  {mongoose: mongoose});

  15:  var app =  express.createServer();

16:

  17:  // Configuration

18:

  19:  app.configure(function(){

  20:    app.set('views', __dirname + '/views');

  21:    app.set('view engine', 'jade');

  22:    app.use(express.bodyParser());

  23:    app.use(express.methodOverride());

  24:    app.use(app.router);

  25:    app.use(express.static(__dirname + '/public'));

  26:  });

27:

  28:  app.configure('development', function(){

  29:    app.use(express.errorHandler({ dumpExceptions: true,

  30:  showStack: true }));

  31:  });

32:

  33:  app.configure('production', function(){

  34:    app.use(express.errorHandler());

  35:  });

36:

  37:  // Routes

  38:  routes.setup({

  39:      controllers: controllers,

  40:      app: app

  41:  });

42:

  43:  app.listen(process.env.port || 3000);

Routes of the web app

The following function will specify the routes for the web app

   1:  exports.setup = function(params) {

   2:      var app = params.app;

   3:      var controllers = params.controllers;

4:

   5:      // Routes for Tasks

   6:      app.get('/', controllers.index);

   7:      app.get('/tasks/list', controllers.list);

   8:      app.get('/tasks/add', controllers.newTask);

   9:      app.post('/tasks/addTask', controllers.addTask);

  10:      app.get('/tasks/edit/:id', controllers.editTask);

  11:      app.post('/tasks/updateTask', controllers.updateTask);

  12:      app.get('/tasks/delete/:id', controllers.deleteTask);

  13:  };

For each routes, we have called corresponding function of the controller class.

Controller – Handles user interactions

The controller class handles the all user interactions and renders corresponding view templates for each user request. The logic for the CRUD operations are also specified in the controller class. The controller class for the Task management is provided below:

   1:  function controllers(params) {

   2:      var mongoose = params.mongoose;

   3:      var Tasks = mongoose.model('Tasks');

   4:      controllers.index = function (req, res) {

   5:         Tasks.find({}).nor([{ status: 'Completed' },

   6:                  { completion: 100 }])

   7:                  .sort('-startDate')

   8:                  .exec(function (err, tasks) {

   9:              res.render('index', {

  10:                  page: 'index',

  11:                  title: 'Task Manager - ToDo List',

  12:                  tasks: tasks

  13:              });

  14:          });

  15:      };

  16:       controllers.list = function (req, res) {

17:

  18:          Tasks.find({}, function (err, tasks) {

  19:              res.render('list', {

  20:                  page: 'list',

  21:                  title: 'Task Manager - Task List',

  22:                  tasks: tasks

  23:              });

  24:          });

  25:      };

  26:      controllers.newTask = function (req, res) {

  27:              res.render('add', {

  28:                  page: 'add',

  29:                  title: 'Task Manager - Add Task'

  30:              });

  31:      };

  32:      controllers.addTask = function (req, res) {

33:

  34:           var form=req.body;

  35:           var task=new Tasks({

  36:               name: form.name,

  37:               description: form.description,

  38:               status: form.status,

  39:               startDate: form.startdate,

  40:               dueDate: form.duedate,

  41:               completion: form.completion

  42:           });

43:

  44:            task.save(function(err) {

  45:              if(!err) {

  46:                   res.redirect("/");

  47:                }

  48:          });

  49:      };

  50:      controllers.editTask = function (req, res) {

51:

  52:          Tasks.findById(req.params.id, function (err, task) {

  53:               res.render('edit', {

  54:                  page: 'add',

  55:                  title: 'Task Manager - Edit Task',

  56:                  task: task

  57:              });

  58:         });

  59:      };

  60:      controllers.updateTask = function (req, res) {

  61:          var form = req.body;

  62:          Tasks.findById(form.id, function (err, task) {

  63:              task.name = form.name;

  64:              task.description = form.description;

  65:              task.status = form.status;

  66:              task.startDate = form.startdate;

  67:              task.dueDate = form.duedate;

  68:              task.completion = form.completion;

  69:              task.save(function (err) {

  70:              if (!err) {

  71:                   res.redirect("/");

  72:              }

  73:               });

  74:          });

  75:      };

  76:      controllers.deleteTask = function (req, res) {

  77:          Tasks.findById(req.params.id, function (err, task) {

  78:              if (!err) {

  79:                  if (task) {

  80:                      task.remove();

  81:                      res.redirect("/");

  82:                  }

  83:              }

  84:          });

  85:      };

  86:      return controllers;

  87:  };

88:

  89:  module.exports = controllers;

MongoDB Database in MongoLab

This web app is using MongoDB for persistence storage and the database will be deployed on MongoLab. MongoLab is a cloud based database service for MongoDB which provides the hosting options for multiple cloud vendors including Amazon, Joyent, Rackspace and Windows Azure. We will be using Windows Azure for our demo web app. MongoLab is providing a free sign-up option for 0.5 GB database.

The below screen shot shows the create database option, which has chosen Windows Azure as the Cloud vendor

We will get a connection string for the MongoDB database from the MongoLab. I have put the connection string in the config.js file.

Create Windows Azure Web Site and download Publish Profile

We can easily create a Windows Azure Web Site from the Windows Azure portal. For creating a new web site, choose New, WEB SITE, QUICK CREATE and give the URL and data center region as shown in the below picture.

Windows Azure Web Site provides a publish profile which lets the Azure developers to easily deploy Windows Azure apps from development IDEs such as Visual Studio, WebMatrix and Cloud9. To download the publish profile, go to the dashboard of the Web Site which we have created previously and click Download Publish Profile from the quick glance section. This will generate a publish profile file with extension PublishSettings.

Deploying the web app to Windows Azure

We can easily deploy web apps to Windows Azure from WebMatrix IDE by using the publish profile. Let’s import the publish profile to our web site created in WebMatrix. To import publish profile and deploy to Windows Azure, click Publish button of WebMatrix which will show a publish wizard:

Select the Import publish profile to import the publish profile, and choose the .publishsettings and save the profile.

After saving the profile settings, continue the publish wizard which will deploy the web app to Windows Azure Web Site. Please note that publish profile is just a one time activity and you can deploy the app to windows azure at any time by simply clicking the publish button.

The below screen shot shows that the web app is running at Windows Azure

Source Code

The source code for this demo app available at https://github.com/shijuvar/NodeExpressMongo

Summary

In this post, we have developed a simple web app with Node.js and MongoDB. We have used Express.js framework for building the web app, and used cloud hosted MongoDB as service MongoLab for deploying MongoDB database. The Windows Azure Web Site allows the web app developers to easily build and deploy web apps to Windows Azure. Microsoft WebMatrix is a great IDE that lets the developers to quickly deploy web apps to Windows Azure.