Shiju Varghese's Blog

Social meet up on Twitter for MEET Windows Azure on June the 7th

shiju — Mon, 28 May 2012 05:16:12 GMT

Get ready to MEET Windows Azure live on June the 7th. The Microsoft Windows Azure team is conducting an online event “Meet Windows Azure” on June 7th 2012 starting at 1 PM PDT. The event will be presented by Scott Guthrie. If you want to watch event live, you can register here: http://register.meetwindowsazure.com/.

If you are planning to attend the event and want to be social, there is a Social meet up on Twitter event organized by Windows Azure MVP Magnus Martensson

MEET Windows Azure Blog Relay:

Roger Jennings (@rogerjenn): Social meet up on Twitter for Meet Windows Azure on June 7th
Anton Staykov (@astaykov): MEET Windows Azure on June the 7th
Patriek van Dorp (@pvandorp): Social Meet Up for ‘MEET Windows Azure’ on June 7th
Marcel Meijer (@MarcelMeijer): MEET Windows Azure on June the 7th
Nuno Godinho (@NunoGodinho): Social Meet Up for ‘MEET Windows Azure’ on June 7th
Shaun Xu (@shaunxu) Let's MEET Windows Azure
Maarten Balliauw (@maartenballiauw): Social meet up on Twitter for MEET Windows Azure on June 7th
Brent Stineman (@brentcodemonkey): Meet Windows Azure (aka Learn Windows Azure v2)
Herve Roggero (@hroggero): Social Meet up on Twitter for Meet Windows Azure on June 7th
Paras Doshi (@paras_doshi): Get started on Windows Azure: Attend “Meet Windows Azure” event Online
Simran Jindal (@SimranJindal): Meet Windows Azure – an online and in person event, social meetup #MeetAzure (+ Beer for Beer lovers) on June 7th 2012
Magnus Mårtensson (@noopman): Social meet up on Twitter for MEET Windows Azure on June 7th
Kris van der Mast (@KvdM):
Shiju Varghese (@shijucv) Social meet up on Twitter for MEET Windows Azure on June the 7th

I hope to see you online for the social meet event on the 7th. My Twitter user name is @shijucv

Call to action: Link to this blog post on your blog and I will update this post to link to you.

Developing and Deploying Node.js Express Web App on Windows Azure

shiju — Sat, 26 May 2012 17:54:47 GMT

In my last post Beginner’s Guide to Node.js on Windows Azure, I have introduced Node.js and Windows Azure Tools for Node.js. In this post, I will demonstrate how to develop and deploy a Node.js web app using Windows Azure PowerShell for Node.js. In this demo web app, I will be using Node module Express as the web app framework and Jade as the view engine for the HTML view templates. We are using Windows Azure PowerShell for Node.js for developing and deploying the app on Windows Azure. If you want to deploy Node.js apps on Windows Azure using Cloud9 IDE, check out my blog post from here.

This blog post and demo app will demonstrate the following:

How to develop and test Node.js apps on Windows Azure using Windows Azure PowerShell for Node.js
How to install Node modules using npm with Windows PowerShell cmdlets
How to use Express module for developing web apps
How to use Jade view engine with Express web app
How to deploy Node.js web app on Windows Azure

The Windows Azure PowerShell for Node.js is a command-line tool that allows the Node developers to build and deploy Node.js apps in Windows Azure using Windows PowerShell cmdlets. Using Windows Azure PowerShell for Node.js, you can develop, test, deploy and manage Node based hosted service in Windows Azure. For more reference on Windows Azure PowerShell for Node.js, check out my blog post Windows Azure PowerShell for Node.js.

Create Hosted Service and Web Role using PowerShell for Node.js,

For getting the Windows Azure PowerShell for Node.js, click All Programs, Windows Azure SDK for Node.js and run Windows Azure PowerShell for Node.js, as Administrator.

The Windows PowerShell cmdlet will create a hosted service named ExpressNode

The above new Azure service will create the files ServiceConfiguration.Cloud.cscfg, ServiceConfiguration.Local.cscfg ServiceDefinition.csdef and deploymentSettings.json in the ExpressNode folder

The following command will add a new Web Role with name ExpressWebApp

This will create the following files in the web role ExpressWebApp as shown in the below picture

Install Express and Jade Modules

The demo Node web app will be developed by using the Express framework. Express is an MVC framework for Node, which can be use for developing web apps and REST based web services. Let’s install express module onto the web role project. We can install the Express module using the node package manager npm which will be working with Windows Azure PowerShell for Node.js. To install the Express, navigate to the web role project folder and execute the command npm install express as shown in the below picture:

The express framework provides a scaffolding tool which can use for generating the basic MVC app with default structure. Let’s execute the Express scaffolding tool to generate the app

The scaffolding tool generate the files as shown in the above picture. By default, Express is using Jade view engine and will create few Jade files with extension .jade. We need to install the node modules having dependency with application generated by Express scaffolding tool. To install the all dependent node packages, just execute the command npm install.This command will install the all dependent node modules. In our web app, it will install the dependent module Jade. All dependencies will be identified from the file package.json.

Let’s modify the generated application by Express scaffolding tool. I have just renamed the generated app.js with server.js and added few code for our demo purpose. This below picture shown the folder structure of the modified app.

Node.js Web App with Express and Jade

The demo web app is a very simple app in which the home page will show the few blog list in a html table and the uri ‘/api’ expose a API method which returns all blog data as JSON format. The screen shots of the completed application is shown below

Let’s create the HTTP server with Express and configure the basic configurations for the Express web app

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

   2:  var app = module.exports = express.createServer();

   3:  var port = process.env.port || 1337;

4:

   5:  // Configuration

   6:  app.configure(function(){

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

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

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

  10:  })

We can import the Node modules using require(‘module_name’). Here we have imported the Express module and created an HTTP server using its createServer() method. In the configurations we have specified the folder name of the View files and set Jade as the View Engine.

View Model Data for the Web App

Let’s create some dummy data for passing to our view model object from the Express routes methods.

   1:  function Blog(author,url,technology) {

   2:    this.author = author;

   3:    this.url=url;

   4:    this.technology=technology;

   5:  }

6:

   7:  // Blogs

   8:  var blogs = [

   9:      new Blog('Shiju Varghese',

  10:        'http://weblogs.asp.net/shijuvarghese/',

  11:        'Windows Azure')

  12:    , new Blog('Glenn Block',

  13:      'http://codebetter.com/glennblock/',

  14:      'Node on Azure')

  15:    , new Blog('Steve Marx',

  16:      'http://blog.smarx.com/',

  17:      'Windows Azure')

  18:    , new Blog('Scott Guthrie',

  19:      'http://weblogs.asp.net/scottgu/',

  20:      'ASP.NET & Azure')

  21:    , new Blog('Rinat Abdullin',

  22:      'http://abdullin.com/',

  23:      'CQRS')

  24:  ];

Web App Routes

Our web app has two routes. The request for ‘/’ will pass the blog data to view template which will render the blog data in html table. The request ‘/api’ is exposing as API method and will return the blog data as JSON string.

   1:  app.get('/', function(req, res){

   2:  res.render('index', {title:'home',blogs: blogs });

   3:  });

   4:  app.get('/api', function(req, res){

   5:    res.json(blogs);

   6:  });

The HTTP Get request for ‘/’ will render the view file index.jade where we are passing view model data for title and blogs. Since we have specified the view engine as Jade, we don’t have to specify the .jade extension when specifying the view name. The application will look the view index.jade on the Views folder and will take layout.jade as the layout page if that jade files is exists.

Let’s add the Jade template syntax for the index.jade for displaying the blogs data in html table

   1:  html

   2:  head

   3:      title Index

   4:  body

   5:      h1 Favourite Blogs

   6:      form

   7:          table(border="1")

   8:              tr

   9:                  th Author

  10:                  th Url

  11:                  th Technology

12:

  13:                  each item in blogs

  14:                      tr

  15:                          td #{item.author}

  16:                          td

  17:                              a(href ='#{item.url}') #{item.url}

  18:                          td #{item.technology}

19:

Let’s add a layout.jade which can use as layout page for the our web app

   1:  html

   2:    head

   3:      title= title

   4:      link(rel='stylesheet',

   5:       href='/stylesheets/style.css')

   6:    body!= body

Running the Web App in Windows Azure Emulator

The Windows PowerShell cmdlet Start-AzureEmulator –lauch will create the local package and you can run the app from the Windows Azure development emulator

Download and Import Windows Azure

We need to import the publish settings files in order to upload publish our apps on Windows Azure. Let’s download the Windows Azure publish settings file from Windows Azure Management portal. The PowerShell cmdlet Get-AzurePublishSettings will redirect to publish settings download page in the Windows Azure Management portal. Let’s download the publish settings file.

To import the publish settings file to our web role app, execute the PowerShell cmdlet Import-AzurePublishSettings with the location of the publish settings file we have downloaded in previous step. Please note that this is one time activity for your web role app. In later deployments, you can directory publish the app without import the publish settings file.

Publishing Node Web App on Windows Azure

Let’s publish our Node web app on Windows Azure by using Windows PowerShell cmdlet Publish-AzureService with name as ExpressNodeOnAzure and location as East Asia.

The following screen shot shows the Node web app running from the Windows Azure.

Source Code

The source code of the Node.js app can download from GitHub at https://github.com/shijuvar/NodeOnAzure. I have been using this source code repository for putting Node.js samples for Windows Azure and will add more samples on later time.

Summary

Windows Azure is great and easy platform for building Node.js apps. Windows Azure is providing very rich support for building and deploying Node.js web apps on Windows Azure.The Windows Azure PowerShell for Node.js allows the Node developers to build, test and deploy Node.js apps on Windows Azure using Windows PowerShell cmdlets. Using Windows Azure PowerShell for Node.js, you can develop, test, deploy and manage Node based hosted service in Windows Azure

Beginner’s Guide to Node.js on Windows Azure

shiju — Wed, 23 May 2012 17:56:32 GMT

In this post, I will provide an introduction to Node.js and Windows Azure tools for Node.js and will also provide few resources to start and develop Node.js apps on Windows Azure.

Introduction to Node.js

The Node.js website is given the following introduction on Node.js

“Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.”

Node.js is created by Ryan Dahl in 2009 and supported by his employer Joyent. Node.js is an open-source server-side JavaScript platform for building high performance scalable network programs. Node.js is built on the top of Google's V8 JavaScript engine and the framework is also using other two open source projects libev and libeio. Node.js uses a non blocking and event-driven I/O model which provides the ability to handle thousands of parallel operations with greater performance. Node.js is popular for its performance and the Node.js apps are executed on the V8 runtime engine. Node.js lets the developers to write JavaScript programs on the server-side and its provides a JavaScript API to access the network and file systems. Node.js is providing the highly efficient TCP/IP networking features with the support of powerful asynchronous programming model which lets the developers to build highly scalable real-time apps. Ryan Dahl is mainly created the Node.js framework for building highly scalable real-time apps that communicating with larger audience in the web.

Node is not a solution for every problems, but it is a great platform for some specific problems. Since Node is capable for handling thousands concurrent requests, it is a great platform for building highly scalable systems. Node is good platform form building JSON based HTTP APIs, next generation real-time and collaborative web apps, Single page apps, Streaming data and many type of network programs. Today many organizations are adopting Node.js for their server-side stack for the Mobile apps. Big companies such as Linkedin, Walmart, Yahoo, Google and Mozilla are using Node.js for their apps.

Installing Node.Js on Windows

You can download the Node.js installer for Windows from here. After installing the Node.js, you can run Node programs from the Windows command-line. The iisnode project which allows to hosting node.js apps on IIS web server. The documentation of iisnode page is available from here.

NPM

npm is a package manager for node.js programs.You can use npm to install node modules created by community. npm manages dependencies of node modules. npm is very similar to NuGet in the .Net. To install a Node module, run the npm command as shown in the below

npm install <module name>

The following command will install a node module express

npm install express

Creating a HTTP Server using Node.js

Let’s create a simple HTTP server using Node.js.

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

   2:  http.createServer(function (req, res) {

   3:  res.writeHead(200, {'Content-Type': 'text/plain'});

   4:  res.end('hello world\n');

   5:  }).listen(8000, "127.0.0.1");

The above program will create a HTTP server which will listen for an event in port 8000 at http://127.0.0.1. Let me save this file as server.js. To execute this program, open up Windows command-line and enter the following command:

node server.js

Let's navigate to http://127.0.0.1:8000/ in a web browser that show a web page which shows the text "hello world".

Node.js on Windows Azure

Windows Azure is a powerful cloud platform which provides the first class support for Node.js which lets the Node developers to build and deploy Node.js apps onto Windows Azure. IISNode is the enable component of Windows Azure for Node.js apps.The blog post Top Benefits of Running Node.js on Windows Azure provides the major benefits for deploying Node.js apps in Windows Azure. For more details on Windows Azure support for Node.js, check out the Windows Azure Node.js Developer Center.

Windows Azure SDK for Node.js

The Windows Azure SDK for Node.js provides the full fledged support to develop and deploy lopeNode.js apps onto Windows Azure. With Windows Azure SDK for Node.js, you can deploy Node.js apps onto Windows Azure as a Web Role which will be available for scalability provided by Windows Azure. You can download the Windows Azure SDK for Node.js from here. The current version of the SDK is 0.5.4.

Windows Azure PowerShell for Node.js

The Windows Azure PowerShell for Node.js is a command-line tool that allows the Node developers to build and deploy Node.js apps in Windows Azure using Windows PowerShell cmdlets. Using Windows Azure PowerShell for Node.js, you can develop, test, deploy and manage Node based hosted service in Windows Azure. For more details on Windows Azure PowerShell for Node.js, check out my blog post Windows Azure PowerShell for Node.js. The following resource will provide all details about the Windows Azure PowerShell for Node.js

Using Cloud9 IDE for Building and Deploying apps in Windows Azure

Cloud9 IDE is a cross-platform, browser-based development environment for JavaScript and Node.js apps which can be used for developing and deploying Node.js apps in Windows Azure. My blog post Building and Deploying Node.js Apps to Windows Azure using Cloud9 IDE

Here’s a few more links for Node.js and Windows Azure

Windows Azure Node.js Developer Center
Glen Block’s (Senior Program Manager - Windows Azure SDK for Node.js) Blog
Anode => Windows Azure + Node.js
Interview with Glenn Block Talking About Node.js on Windows Azure
Node.js–How to use Node Package Manager (npm) and Underscore
My GitHub repository on Node.js on Windows Azure
Developing and Deploying Node.js Express Web App on Windows Azure
The Node Beginner Book
Useful Node.js Tools, Tutorials And Resources

Building a Simple HTTP API using Node.js with MongoDB and Mongoose

shiju — Sat, 19 May 2012 12:27:00 GMT

In this post, I will demonstrate how to build a simple HTTP API using Node.js with NoSQL database MongoDB. This demo app will be using MongoDB object modeling tool Mongoose to connecting with MongoDB from the Node app. This demo app is a very basic level JSON based HTTP API which is not following any better practices and mainly created this sample demo for demonstrating Node.js and MongoDB using with Mongoose Node package.

Node.js and MongoDB for building REST JSON API

Node.js is a very powerful platform for building highly scalable REST based JSON APIs. A Node.js app with a NoSQL database MongoDB can provide great performance and better scalability. The latest speed up results for the MongoDB Native Driver for Node.js available from here. I am in the process of building highly scalable REST API on the Windows Azure platform using Node.js and MongoDB and will be put the samples on my Github repositories in future.

Node packages

The following Node packages to be installed in the app in order to working the demo app.

Express is a web development module for Node.js. Mongoose is a Node.js ORM module for working with MongoDB database.

Creating Server and Connecting to MongoDB

The following code block will create the server using express module and connecting to the MongoDB database using the Mongoose.

   1:   //Creating server

   2:  var express = require('express')

   3:        , app = express.createServer()

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

5:

   6:  //Connecting to MongoDB

   7:   mongoose.connect('mongodb://localhost/ProductDB');

Creating the Model using Mongoose

Let’s define the Model objects using the Mongoose

   1:  //Models using Mongoose

   2:   var Schema = mongoose.Schema

   3:   , ObjectId = Schema.ObjectID;

4:

   5:   var Product = new Schema({

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

   7:    ,unitPrice  : { type: Number, required: true }

   8:    ,itemsInStock  : { type: Number, required: true }

   9:    });

10:

  11:  var Category = new Schema({

  12:   name   : { type: String, required: true, trim: true }

  13:   ,description    :  { type: String, required: true, trim: true }

  14:   ,products         : [Product]

  15:   });

16:

  17:  var ProductCatalog = mongoose.model('Category', Category);

In the above code block, we have created the schema for Product and Category and Prodcut schema used as embedded document in the Category schema. We can define the Model using the mongoose.Model.

var ProductCatalog = mongoose.model('Category', Category);

Exposing the API methods

The following function returns the all product catalog information as a JSON string. The request for ‘/’ will return the all product catalog data.

   1:   //Get all product catalog

   2:    app.get('/', function(req,res){

   3:   ProductCatalog.find({}, function(error, data){

   4:              if(error){

   5:               res.json(error);

   6:              }

   7:              else if(data == null){

   8:               res.json('Empty data')

   9:              }

  10:              else{

  11:                res.json(data);

  12:              }

13:

  14:          });

  15:      });

The following function returns the category information for a given category name. The request ‘/name’ will be executed the following API method.

   1:  //Get a specified category

   2:  app.get('/:name', function(req,res){

   3:   ProductCatalog.findOne({ name: req.params.name },

   4:      function(error, category){

   5:   if(error){

   6:        res.json(error);

   7:       }

   8:       else if(category == null){

   9:             res.json('Category not found!')

  10:       }

  11:    else{

  12:       res.json(category);

  13:        }

  14:     });

  15:    });

16:

The request for '/addcategory/name/description' will be executed the following method and will add a new category to the MongoDB database.The method will return the added data as JSON.

   1:  app.get('/addcategory/:name/:description',

   2:   function(req, res){

   3:   var categoryData = {

   4:   name: req.params.name

   5:    , description: req.params.description

   6:  };

7:

   8:  var category = new ProductCatalog(categoryData);

   9:   //Save data

  10:   category.save( function(error, data){

  11:  if(error){

  12:   res.json(error);

  13:  }

  14:  else{

  15:  res.json(data);

  16:     }

  17:   });

  18:  });

Source Code

I have created a repository in Github for putting REST API samples. This is the first and basic level sample which can be download from here. This is a very introductory level post mainly used for demonstrating Node.js and MongoDB with Mongoose. I will update the source code repository with more samples.

Windows Azure SDK for Node.js 0.5.4 Released

shiju — Mon, 14 May 2012 06:14:58 GMT

The Microsoft Windows Azure team has released the Windows Azure SDK for Node.js 0.5.4 which will be using the Node.js 0.6.17 and iisnode 0.1.19. The Node.js 0.6.17 contains a security fix against the HTTP Server Security Vulnerability detected by recently. It would be recommended to upgrade to the new version of Azure SDK for Node.js if you have already deployed any Node.js app to Windows Azure which will provide better security. The iisnode 0.1.19 provides iisnode.yml file instead of XML based configurations which can be use for setting up all iisnode settings. You can download the Windows Azure SDK for Node.js 0.5.4 from here.

Windows Azure Supports Voice and SMS Capabilities

shiju — Fri, 04 May 2012 07:06:18 GMT

Windows Azure is now supports Telephony and SMS capabilities to the apps hosted in Windows Azure by using the Twilio API. Twilio is a third-party service that provides a cloud-based telephony service which allows to add scalable, reliable voice and text messaging capabilities into you apps. Using Twilio's native libraries for Java, PHP and .NET, developers can build telephony enabled web apps hosted on Windows Azure in which we can make and receive phone calls and SMS messages from phones and web apps. Twillio is providing 1,000 free text messages or 1,000 voice minutes for Windows Azure developers and you can get the free offerings for Windows Azure from here .

Check out the following links for getting more details on Twillio API and working it with Windows Azure

Dependency Injection in ASP.NET Web API using Autofac

shiju — Sun, 01 Apr 2012 09:29:11 GMT

In this post, I will demonstrate how to use Dependency Injection in ASP.NET Web API using Autofac in an ASP.NET MVC 4 app. The new ASP.NET Web API is a great framework for building HTTP services. The Autofac IoC container provides the better integration with ASP.NET Web API for applying dependency injection. The NuGet package Autofac.WebApi provides the Dependency Injection support for ASP.NET Web API services.

Using Autofac in ASP.NET Web API

The following command in the Package Manager console will install Autofac.WebApi package into your ASP.NET Web API application.

PM > Install-Package Autofac.WebApi

The following code block imports the necessary namespaces for using Autofact.WebApi

using Autofac;

using Autofac.Integration.WebApi;

The following code in the Bootstrapper class configures the Autofac.

   1:  public static class Bootstrapper

   2:  {

   3:   public static void Run()

   4:   {

   5:       SetAutofacWebAPI();

   6:   }

   7:   private static void SetAutofacWebAPI()

   8:   {

   9:      var configuration = GlobalConfiguration.Configuration;

  10:      var builder = new ContainerBuilder();

  11:      // Configure the container

  12:      builder.ConfigureWebApi(configuration);

  13:      // Register API controllers using assembly scanning.

  14:      builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

  15:      builder.RegisterType<DefaultCommandBus>().As<ICommandBus>()

  16:          .InstancePerApiRequest();

  17:      builder.RegisterType<UnitOfWork>().As<IUnitOfWork>()

  18:          .InstancePerApiRequest();

  19:      builder.RegisterType<DatabaseFactory>().As<IDatabaseFactory>()

  20:          .InstancePerApiRequest();

  21:      builder.RegisterAssemblyTypes(typeof(CategoryRepository)

  22:     .Assembly).Where(t => t.Name.EndsWith("Repository"))

  23:      .AsImplementedInterfaces().InstancePerApiRequest();

  24:      var services = Assembly.Load("EFMVC.Domain");

  25:      builder.RegisterAssemblyTypes(services)

  26:      .AsClosedTypesOf(typeof(ICommandHandler<>))

  27:          .InstancePerApiRequest();

  28:      builder.RegisterAssemblyTypes(services)

  29:      .AsClosedTypesOf(typeof(IValidationHandler<>))

  30:          .InstancePerApiRequest();

  31:      var container = builder.Build();

  32:      // Set the WebApi dependency resolver.

  33:      var resolver = new AutofacWebApiDependencyResolver(container);

  34:      configuration.ServiceResolver.SetResolver(resolver);

  35:   }

  36:  }

The RegisterApiControllers method will scan the given assembly and register the all ApiController classes. This method will look for types that derive from IHttpController with name convention end with “Controller”. The InstancePerApiRequest method specifies the life time of the component for once per API controller invocation. The GlobalConfiguration.Configuration provides a ServiceResolver class which can be use set dependency resolver for ASP.NET Web API. In our example, we are using AutofacWebApiDependencyResolver class provided by Autofac.WebApi to set the dependency resolver.

The Run method of Bootstrapper class is calling from Application_Start method of Global.asax.cs.

   1:  protected void Application_Start()

   2:  {

   3:      AreaRegistration.RegisterAllAreas();

   4:      RegisterGlobalFilters(GlobalFilters.Filters);

   5:      RegisterRoutes(RouteTable.Routes);

   6:      BundleTable.Bundles.RegisterTemplateBundles();

   7:      //Call Autofac DI configurations

   8:      Bootstrapper.Run();

   9:  }

Autofac.Mvc4

The Autofac framework’s integration with ASP.NET MVC has updated for ASP.NET MVC 4. The NuGet package Autofac.Mvc4 provides the dependency injection support for ASP.NET MVC 4. There is not any syntax change between Autofac.Mvc3 and Autofac.Mvc4

Source Code

I have updated my EFMVC app with Autofac.WebApi for applying dependency injection for it’s ASP.NET Web API services. EFMVC app also updated to Autofac.Mvc4 for it’s ASP.NET MVC 4 web app. The above code sample is taken from the EFMVC app. You can download the source code of EFMVC app from http://efmvc.codeplex.com/

Windows Azure PowerShell for Node.js

shiju — Tue, 20 Mar 2012 07:59:28 GMT

For getting the PowerShell for Node.js, click All Programs, Windows Azure SDK Node.js and run Windows Azure PowerShell for Node.js, as Administrator.

The followings are the few PowerShell cmdlets that lets you to work with Node.js apps in Windows Azure

Create New Hosted Service

New-AzureService <HostedServiceName>

The below cmdlet will created a Windows Aazure hosted service named NodeOnAzure in the folder C:\nodejs and this will also create ServiceConfiguration.Cloud.cscfg, ServiceConfiguration.Local.cscfg and ServiceDefinition.csdef and deploymentSettings.json files for the hosted service.

PS C:\nodejs> New-AzureService NodeOnAzure

The below picture shows the files after creating the hosted service

Create Web Role

Add-AzureNodeWebRole <RoleName>

The following cmdlet will create a hosted service named MyNodeApp along with web.config file.

PS C:\nodejs\NodeOnAzure> Add-AzureNodeWebRole MyNodeApp

The below picture shows the files after creating the web role app.

Install Node Module

npm install <NodeModule>

The following command will install Node Module Express onto your web role app.

PS C:\nodejs\NodeOnAzure\MyNodeApp> npm install Express

Run Windows Azure Apps Locally in the Emulator

 Start-AzureEmulator -launch

The following cmdlet will create a local package and run Windows Azure app locally in the emulator

PS C:\nodejs\NodeOnAzure\MyNodeApp> Start-AzureEmulator -launch

Stop Windows Azure Emulator

Stop-AzureEmulator

The following cmdlet will stop your Windows Azure in the emulator.

PS C:\nodejs\NodeOnAzure\MyNodeApp> Stop-AzureEmulator

Download Windows Azure Publishing Settings

Get-AzurePublishSettings

The following cmdlet will redirect to Windows Azure portal where we can download Windows Azure publish settings

PS C:\nodejs\NodeOnAzure\MyNodeApp> Get-AzurePublishSettings

Import Windows Azure Publishing Settings

Import-AzurePublishSettings <Location of .publishSettings file>

The following cmdlet will import the publish settings file from the location c:\nodejs

PS C:\nodejs\NodeOnAzure\MyNodeApp> Import-AzurePublishSettings c:\nodejs\shijuvar.publishSettings

Publish Apps to Windows Azure

Publish-AzureService –name <Name> –location <Location of Data centre>

The following cmdlet will publish the app to Windows Azure with name “NodeOnAzure” in the location Southeast Asia. Please keep in mind that the service name should be unique.

PS C:\nodejs\NodeOnAzure\MyNodeApp> Publish-AzureService –name NodeonAzure –location "Southeast Asia” –launch

Stop Windows Azure Service

Stop-AzureService

The following cmdlet will stop your service which you have deployed previously.

PS C:\nodejs\NodeOnAzure\MyNodeApp> Stop-AzureService

Remove Windows Azure Service

Remove-AzureService

The following cmdlet will remove your service from Windows Azure.

PS C:\nodejs\NodeOnAzure\MyNodeApp> Remove-AzureService

Quick Summary for PowerShell cmdlets

Create a new Hosted Service	New-AzureService <HostedServiceName>
Create a Web Role	Add-AzureNodeWebRole <RoleName>
Install Node Module	npm install <NodeModule>
Running Windows Azure Apps Locally in Emulator	Start-AzureEmulator -launch
Stop Windows Azure Emulator	Stop-AzureEmulator
Download Windows Azure Publishing Settings	Get-AzurePublishSettings
Import Windows Azure Publishing Settings	Import-AzurePublishSettings <Location of .publishSettings file>
Publish Apps to Windows Azure	Publish-AzureService –name <Name> –location <Location of Data centre>
Stop Windows Azure Service	Stop-AzureService
Remove Windows Azure Service	Remove-AzureService

Using Node Package Manager in Cloud9 IDE

shiju — Wed, 14 Mar 2012 09:26:11 GMT

NPM - Package Manager for Node.js

npm is a package manager for node that is run through command-line interface. It can use it to install and publish your node programs. npm manages dependencies for an application.Node packages are represented as package.json files. The npm is a very similar like NuGet package manager for .NET.
Using npm, you can quickly find node packages, download them, install them, and manage packages you have already installed.

Cloud9 IDE supports Node Package Manager

With Cloud9 IDE, you can install node modules to your Node.js apps using npm. You can use the link http://search.npmjs.org/ to find out Node packages. To using npm from Cloud9 IDE, go to the text box at the end of the IDE and type the following command, and enter.

npm install <packagename>

In the above picture, we are installing node module express. This will shows the following in the console

The below picture shows node modules installed into our Node.js project.

Building and Deploying Node.js Apps to Windows Azure using Cloud9 IDE

shiju — Thu, 08 Mar 2012 10:20:46 GMT

In this post, I will demonstrate how to building Node.js apps using Cloud9 IDE ad deploying Node.js apps to Windows Azure from the Cloud9 IDE. Cloud9 IDE is a cross-platform, browser-based development environment for JavaScript and Node.js apps which is integrates with GitHub and BitBucket repository services. Cloud9 IDE is the most popular developer tool among the Node developers. Since Cloud9 IDE is working and running on the browser, developers can work from any OS platform. Using with Cloud IDE, you can build and deploy Node.js apps to Windows Azure. The Cloud9 IDE can access from http://c9.io/. Cloud9 IDE provides a free subscription as well as a paid subscription with more features.

Node.js

Node.js is a server-side JavaScript platform for building high performance scalable network programs. Node.js is built on the top of Google's JavaScript runtime engine V8 which is used in Google Chrome. Node.js uses an event-driven I/O model which provides the ability to handle thousands of parallel operations with greater performance. Node.js is popular for its performance and the Node.js apps are executed on the V8 runtime engine. Node.js lets the developers to write JavaScript programs on the server-side and its provides a JavaScript API to access the network and file systems.

Node.js for Windows Azure

Windows Azure is a powerful cloud platform which provides the first class support for Node.js apps. The Windows Azure SDK for Node.js provides the all support to develop and deploy Node.js apps to Windows Azure. With Windows Azure SDK for Node.js, you can deploy Node.js apps to Windows Azure as a Web Role.

Working with Cloud9 IDE

The Cloud9 IDE allows the developers to build and run Node.js apps. Let me explain how to develop Node apps from the Cloud9 IDE in the following steps.

Creating a New Project

In the Cloud9 IDE, select the Create New Project from My Projects tab. In the Create a new project dialog, enter a project name and click the Create button to create a new project as shown in the below pictures.

The Cloud9 IDE

Create a New Project Dialog

Creating and Editing files in Cloud9 IDE

After creating a project in Cloud9, click Start Editing as shown in the below picture. This will enable you create and edit files in the Cloud9 IDE.

You can add a new file by select New File from File menu. This will add a new tab titled *Untitled1.

To save your file, select Save As option from the File menu. This will show the below dialog box, where you can enter the file name and save it to the project created in Cloud9.

Creating a Node.js App in Cloud9 IDE

Our sample Node.js application is a simple app which provides request handlers for the following three types of HTTP requests.

Request handler for Home page which will provide a HTML form with two form fields.
Request handler for handling and processing posted data submitted from the HTML form.
Request handler for Http 404 No Found requests.

In this app, we will be creating a HTTP server which will be listen for HTTP requests.

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

   2:  var querystring = require('querystring');

   3:  var utils = require('util');

   4:  var url = require("url");

5:

   6:  var port=process.env.PORT;

7:

   8:   var server = http.createServer(function(req, res) {

   9:    switch (req.url) { //checking the request url

  10:      case '/':

  11:        homePageHandler (req, res); //handler for home page

  12:        break;

  13:      case '/register':

  14:        registerFormHandler (req, res);//hamdler for register

  15:        break;

  16:      default:

  17:        nofoundHandler (req, res);// handler for 404 not found

  18:        break;

  19:    }

  20:  });

  21:  server.listen(port);

  22:  //function to display the html form

  23:  function homePageHandler (req, res) {

  24:    res.writeHead(200, {'Content-Type': 'text/html'});

  25:     var body = '<html>'+

  26:      '<head>'+

  27:      '<meta http-equiv="Content-Type" content="text/html; '+

  28:      'charset=UTF-8" />'+

  29:      '</head>'+

  30:      '<body>'+

  31:      '<form action="/register" method="post">'+

  32:      'Name:<input type=text value="" name="name" size=15></br>'+

  33:      'Email:<input type=text value="" name="email" size=15></br>'+

  34:      '<input type="submit" value="Submit" />'+

  35:      '</form>'+

  36:      '</body>'+

  37:      '</html>';

  38:  //response content

  39:  res.end(body);

  40:  }

  41:  //handler for Post request

  42:  function registerFormHandler (req, res) {

  43:  //var pathname = url.parse(req.url).pathname;

  44:  //console.log("Request for " + pathname + " received.");

  45:   var postData = "";

  46:    req.on('data', function(chunk) {

  47:        // append the current chunk of data to the postData variable

  48:        postData += chunk.toString();

  49:      });

  50:      req.on('end', function() {

51:

  52:     // doing something with the posted data

  53:        res.writeHead(200, "OK", {'Content-Type': 'text/html'});

  54:        // parse the posted data

  55:        var decodedBody = querystring.parse(postData);

  56:        // output the decoded data to the HTTP response

  57:        res.write('<html><head><title>Post data</title></head><body><pre>');

  58:        res.write(utils.inspect(decodedBody));

  59:        res.write('</pre></body></html>');

  60:        res.end();

  61:      });

  62:  }

  63:  //==========Error handler==========

  64:  function nofoundHandler(req, res) {

  65:    res.writeHead(404, {'Content-Type': 'text/plain'});

  66:    res.end('404 Error - Request handler not found');

  67:  }

In the above section of the program, we are importing different Node modules to our program.

var http = require('http');

var querystring = require('querystring');

var utils = require('util');

var url = require("url");

In the Node.js sample app, we are creating a HTTP server which will be listening for HTTP requests. Based on the request url, the server will call the corresponding request handlers.

var server = http.createServer(function(req, res) {

  switch (req.url) { //checking the request url

    case '/':

      homePageHandler (req, res); //handler for home page

      break;

    case '/register':

      registerFormHandler (req, res);//hamdler for register

      break;

    default:

      nofoundHandler (req, res);// handler for 404 not found

      break;

});

server.listen(port);

Running the App from Cloud9 IDE

You can run the apps from Cloud9 IDE by click Debug button from the toolbar

The debugger will show an output window where you can get a URL generated by the Cloud9 IDE to access your application.

Running App in Browser

The below picture shows the output of the request for home page

The below picture shows the output of the request for the form action register. This will show the posted data submitted from a HTML form.

Deploying Node.js App to Windows Azure using Cloud9 IDE

You can easily create a Deployment for Windows Azure from Cloud9 IDE itself. To create a deployment for Windows Azure, Select Deploy and click Create a Deploy Server

The option for Create a Deploy Server will show the below dialog box where you can choose the deployment type as Windows Azure for deploying apps to Windows Azure. This will show the below window for download and upload the Windows Azure publish settings.

After uploading the Windows Azure publish settings, click Create new option to create a new hosted service in Windows Azure. You can also able to choose an existing hosted service deployed in Windows Azure. The below window for new hosted service allows you put configurations for your Windows Azure hosted service. After putting the configurations for Windows Azure, click the Create button for creating a new deployment for Windows Azure. This will create a new deployment and this will show a deployment under the Deploy tab.

Deploying the App to Windows Azure

Under the Deploy tab of Cloud9 IDE, you can see all the deployments you have created earlier. For deploying our Node.js app to Windows Azure, click the deployment we have created previously.This will show the below dialog.

For the first time deployment for a new hosted service, it will ask for creating a new web.config and .csdef file as shown in the below pictures. Select Yes for crating a new web.config and .csdef file.

After creating the web.config and .csdef file, click the Deploy button for deploy our Node.js app to Windows Azure. This will successfully deploy our Node.js app to Windows Azure.

Summary

In this post, we have created a simple Node.js app with request handlers within the Cloud9 IDE and later deployed it to Windows Azure using Cloud9 IDE. The Windows Azure SDK for Node.js provides the all support to develop and deploy Node.js apps to Windows Azure. The Cloud9 IDE provides the greater support to build and deploy apps to Windows Azure.

EFMVC App Migrated to ASP.NET MVC 4

shiju — Thu, 01 Mar 2012 07:04:52 GMT

I have upgraded my EFMVC app from ASP.NET MVC 3 to ASP.NET MVC 4 Beta. EFMVC is a demo web app initially built for demonstrating ASP.NET MVC and EF Code First. Now I am planning to add more features onto EFMVC and want to add cloud specific features with Windows Azure. You can expect more implementations in future releases.

The current migration does not contains any major code changes. I have added a Windows Azure web role and will add some cloud specific features on later. The migration process was very smooth and the Autofac.MVC3 has been working with ASP.NET MVC 4 app without any issue. But I am having some issues with Autofac.MVC3 package while integrating with ASP.NET Web API services. I have used the current AutofacDependencyResolver class to integrating with DependencyResolver. The ASP.NET Web API expects a System.Web.Http.Services.IDependencyResolver implementation instead of System.Web.Mvc.IDependencyResolver which is used by ASP.NET MVC.

The below is the updated feature list of the EFMVC app

Windows Azure Web Role
CRUD demo in ASP.NET MVC 4 with Entity Framework 4.3 Code First
Generic repository for Entity Framework Code First
Repository Pattern and Unit of Work
Dependency Injection using Autofac
Razor View Engine
Solution Architectures using Commands(write operations), Command Handlers, Command Dispatcher
ASP.NET Web API

You can download the source from http://efmvc.codeplex.com/

ASP.NET MVC 4 Beta Released

shiju — Fri, 17 Feb 2012 14:44:00 GMT

Microsoft has announced the availability of ASP.NET MVC 4 Beta. You can get the all details on ASP.NET MVC 4 Beta at http://www.asp.net/mvc/mvc4. The greatest new feature of ASP.NET MVC 4 Beta is the addition of ASP.NET Web API which lets the developers to build REST based services which can be easily consume from variety of clients including browsers and mobile devices. These HTTP services are ideal for clients which are building by using Ajax and following a highly responsive UI.

For more details on ASP.NET Web API, you can watch the presentation taken by Daniel Roth, a Senior Program Manager at Microsoft, from here.

The following are the other new features included in the ASP.NET MVC 4

Refreshed and modernized default project templates
New mobile project template
Many new features to support mobile apps
Recipes to customize code generation
Enhanced support for asynchronous methods

The new ASP.NET MVC 4 project dialog is shown below

Microsoft Reduces Prices on SQL Azure Cloud Storage

shiju — Thu, 16 Feb 2012 14:20:00 GMT

Microsoft has reduced the price of SQL Azure storage which will greatly attract customers to migrating their apps to Windows Azure. The newly announced price of SQL Azure decreases 48 percentages to 75 percentages of cost from the previous cost.

The new price details are given below

GB	Previous Pricing	New Pricing	New Price/GB	Total % Decrease
5	$49.95	$25.99	$5.20	48%
10	$99.99	$45.99	$4.60	54%
25	$299.97	$75.99	$3.04	75%
50	$499.95*	$125.99	$2.52	75%
100	$499.95 *	$175.99	$1.76	65%
150	$499.95*	$225.99	$1.51	55%

Tips and Important Steps for Migrating Apps to Windows Azure

shiju — Sun, 29 Jan 2012 11:45:00 GMT

The following are the few important steps and tips for migrating ASP.NET apps to Windows Azure.

Convert the ASP.NET application into a Web Role project.
Verify that the application is running correctly in the development environment.
Make sure that your application is 64-bit compatible since Window azure is a 64-bit environment.
Since Window Azure Web Roles runs on IIS7 Integrated mode, make sure that your web application does not have any issues with running on IIS 7 Integrated mode.
If your web app is using Session, Membership, Roles and Profile data, you have to find a way to make the state information is working with Windows Azure environment. You can use ASP.NET Universal Providers for handling Session, Membership, Roles and Profile which will be working with Sql Azure. The Windows Azure Caching Service is also providing a provider for ASP.NET Session state which will be faster than working with Sql Azure, but will be bit expensive than using Sql Azure.
If you are using ASP.NET caching, it would be recommended to use The Windows Azure Caching Service. The Windows Azure Caching Service is the better way to use Caching in Windows Azure.
Upload and save files to BLOB storage, if your web application is dealing with documents, media files, etc.
If your application is using any Windows services or using any background processing, migrate these services to Worker Roles.
Put messages to Windows Azure storage Queue or Service Bus Queue if you want to communicate between Web Role and Worker Role.
If you want to make federated claims-based authentication and single sign-on, you can use Windows Azure Access Control Service (ACS) that enables federated authentication. It will work with external identity providers such as Windows Live, Google, Facebook, and Open ID and you can also able to define service identities in ACS that lets you to authenticate without using an external identity provider.
Use startup tasks if you want to perform operations and install components before your Azure Role starts on Virtual Server. You can add startup tasks by editing the ServiceDefinition.csdef file.
Consider moving out some configuration settings in web.config files to ServiceConfiguration.cscfg so that you do not require redeployment after every change in configuration. Data in the ServiceConfiguration.cscfg file can be edited at runtime.
The Windows Azure environment does not provide a SMTP relay or mail relay service. So if your application is using e-mail services, it would be recommended to use a third party service (like SendGrid or AuthSMTP) to send email from inside Windows Azure.
If you are using Sql Azure, use a SQL Server 2008 R2 client so that you can easily migrate database schema and data into Sql Azure. And you can connect the Sql Azure from the SQL Server 2008 R2 client.

Building a Windows Azure App using Azure Queue, Azure Table and ASP.NET MVC Web Role

shiju — Thu, 01 Dec 2011 18:20:00 GMT

In this post, I will demonstrate a Windows Azure app using Azure Queue, Azure Table and a ASP.NET MVC 4 Web Role application. This post is explaining few initial steps for building a demo Azure app where asynchronous commands (write operations that changes the data) put into Azure Queue and an Azure Work Role will persist the data into Azure Table from Queue messages for the read operations. The source code is available from http://azurehack.codeplex.com/ .The demo application will modify and add more functionality on later.

Windows Azure Storage Services

The Windows Azure storage services provide the following services that are secure, scalable and easy to access that remain persistent and durable storage in the cloud.

Binary Large Object (BLOB) – BLOB service is the file system in the cloud which provide storage for large pieces of data, such as images, video, documents etc. BLOB is the simplest way to store text or binary data on Windows Azure.

Tables – Windows Azure Table Storage Service provides queryable structured storage.Table Storage service is very similar to NoSQL databases that lets you to massively scalable your apps.

Queues – Queue service provides reliable storage and delivery of messages and can be use for messaging between Web and Worker role instances.

Drives – Windows Azure Drive provides durable NTFS volumes for Windows Azure applications.

Demo Windows Azure App

In our demo app, all database write commands will be perform in an asynchronous way and these command messages will send to Azure Queue. A worker role will retrieve the Queue messages and will persist the data into Azure Table. The web role app is built with ASP.NET MVC 4. In this simple demo app, we are creating Customer entity data and these data will list in a AS.NET MVC view page from a Azure Table. The request for creating a new Customer data will write a message to Azure Queue. The below class is representing the write command for creating new Customer

public class NewCustomerCommand : AzureQueueMessage

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string Address { get; set; }

        public string Phone { get; set; }

        public string Email { get; set; }

The new NewCustomerCommand is inherited from a class AzureQueueMessage. The AzureQueueMessage class is the base class for the Azure Queue messages.The AzureQueueMessage class is shown below

public abstract class AzureQueueMessage

    public string Id { get; set; }

    public string PopReceipt { get; set; }

    public int DequeueCount { get; set; }

    public DateTime? InsertionTime { get;  set; }

    public DateTime? ExpirationTime { get; set; }

We are using strongly typed Azure Queue message. The below code block shows the contract type for our strongly type Azure Queue

public interface IAzureQueue<T> where T : AzureQueueMessage

    void EnsureExist();

    void Clear();

    void AddMessage(T message);

    T GetMessage();

    T GetMessage(TimeSpan timeout);

    IEnumerable<T> GetMessages(int maxMessagesToReturn);

    void DeleteMessage(T message);

    void DeleteMessage(CloudQueueMessage message);

    void DeleteQueue();

    int ApproximateMessageCount { get; }

Creating Queue messages from ASP.NET MVC Controller

The below code block in the ASP.NET MVC action method will create the strongly typed queue message with type NewCustomerCommand. The write command NewCustomerCommand is representing the operation for creating a new Customer entity.

CloudStorageAccount account;

public CustomerController()

    account = CloudStorageAccount.

         FromConfigurationSetting("DataConnectionString");

[HttpPost]

public ActionResult Create(CustomerFormModel formModel)

if (ModelState.IsValid)

    AzureQueue<NewCustomerCommand> queue = new

                        AzureQueue<NewCustomerCommand>(account);

    queue.AddMessage(new NewCustomerCommand

        FirstName = formModel.FirstName,

        LastName = formModel.LastName,

        Address = formModel.Address,

        Phone = formModel.Phone,

        Email = formModel.Email

});

return RedirectToAction("Index");

 return View(formModel);

The class AzureQueue is a strongly typed Azure Queue. We are adding a message to the Queue with the information of NewCustomerCommand. A worker role will look on the Queue message and will perform the operations for our command.

Processing Queue messages in Worker Role

The Worker Role is similar to a windows service and mainly using for background processing. In our application, we are using the Worker Role for processing the Queue message send from Web Role application. The Azure Queue is a great way to communicate between Web Role and Worker Role.

In the following code block in Worker Role, we are creating a strongly typed Queue with NewCustomerCommand and getting the unprocessed Queue messages from the Queue. After that, the data of the each Queue message is using for creating a Customer entity and will persist this data into Azure Table. The Table storage can be use for read operations of our application. We are deleting the Queue message after persisting the Customer entity into Azure Table.

var account = CloudStorageAccount.

FromConfigurationSetting("DataConnectionString");

AzureQueue<NewCustomerCommand> queue = new

   AzureQueue<NewCustomerCommand>(account);

queue.EnsureExist();

while (true)

try

 var message = queue.GetMessage();

 if (message != null)

AzureTable<Customer> table = new AzureTable<Customer>(account);

    var guiid= Guid.NewGuid().ToString();

    table.AddEntity( new Customer

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

        PartitionKey = guiid,

        RowKey = message.FirstName,

        FirstName = message.FirstName,

        LastName=message.LastName,

        Address=message.Address,

        Phone=message.Phone,

        Email=message.Email

});

    queue.DeleteMessage(message);

    catch { }

    Thread.Sleep(5000);

We are using a Azure Table entity Customer for persisting the Customer data. The Customer Table entity is shown below

public class Customer : TableServiceEntity

    public string Id { get; set; }

    public string FirstName { get; set; }

    public string LastName { get; set; }

    public string Address { get; set; }

    public string Phone { get; set; }

    public string Email { get; set; }

The Customer entity is inherited from TableServiceEntity for making the Customer entity as a Azure Table. The TableServiceEntity provides properties PartionKey, RowKey and Timestamp. The server manages the value of Timestamp, which cannot be modified. We need to update the values of PartitionKey and RowKey.The partition key is a unique identifier for the partition within a given table, specified by the PartitionKey property. The partition key forms the first part of an entity's primary key. The second part of the primary key is the row key, specified by the RowKey property. The row key is a unique identifier for an entity within a given partition. Together the PartitionKey and RowKey uniquely identify every entity within a table.

The AzureTable class is using for the all CRUD operations for Azure Table. The below code block shown the contract type of AzureTable class.

public interface IAzureTable<TEntity> where TEntity : TableServiceEntity

    IQueryable<TEntity> Query { get; }

    bool CreateIfNotExist();

    bool DeleteIfExist();

    void AddEntity(TEntity obj);

    void AddEntity(IEnumerable<TEntity> objs);

    void AddOrUpdateEntity(TEntity obj);

    void AddOrUpdateEntity(IEnumerable<TEntity> objs);

    void DeleteEntity(TEntity obj);

    void DeleteEntity(IEnumerable<TEntity> objs);

Reading the data in ASP.NET MVC App

We are showing the Customer data from Azure table and periodically refresh the data using Ajax. The following code in the ASP.NET MVC action method querying the data from Azure Table Customer.

public ActionResult Index()

  AzureTable<Customer> table = new AzureTable<Customer>(account);

  var customers = table.Query;

  if (Request.IsAjaxRequest())

     return PartialView("_List", customers);

 return View(customers);

Since our write command is working in an asynchronous way, we are refreshing the view page periodically using Ajax for latest data

@model IEnumerable<AzureHacks.Domain.Models.Customer>

@{

    ViewBag.Title = "Index";

<h2>Index</h2>

<p>

    @Html.ActionLink("Create New", "Create")

</p>

<div id="CustomerList">

@Html.Partial("_List", Model)

</div>

 <script type="text/javascript">

$(function () {

setInterval(function () {

 $.get('@Url.Action("Index")', {}, function (view) {

    $("#CustomerList").html(view);

})

 },5000);

});

</script>

Source Code

The source code can be download from http://azurehack.codeplex.com/

Summary

This post is an initial step for building a demo app on the Windows Azure. We have discussed Azure storage services Queue and Table and explored the Worker Role for processing Queue messages. Azure Queue is a great way to communicate between Web Role and Worker Role. And the Azure Table is providing a great way to store massively scalable structured data that is available for querying the data. We are are performing our commands in an asynchronous way and Azure Table is using for our read operations.