Archive for August, 2013

I have blogged previously on the Brokered Messaging API but in this blog I will get more deeper, with some technical examples that maybe it will help clarify how to best use the services bus brokered Messaging classes. You can also find the best practices for using the Windows Azure Service Bus Brokered Messaging in a previous blog post.

The Windows Azure Service Bus
Brokered Messaging has several main classes that are mainly used to deliver basic development for your application. You will have to use these classes:

  • BrokeredMessage: is the type of the message that will be send from an application through the service bus
  • QueueClient: is the client that you have to create to handle all the instructions when using the Windows Azure Brokered Messaging Queue
  • QueueDescription: handle all the metadata of the queue.
  • TopicClient: is the client that you have to create to handle all the instructions when using the Windows Azure Brokered Messaging Topic/Subscription.
  • TopicDescription: handle all the metadata of the topic created.
  • SubscriptionClient: is the client that you have to create to handle all the instructions for the subscriptions when working with the Windows Azure Messaging Topic/Subscription
  • SubscriptionDescription: handle all the metadata for the subscription you create.
  • NamespaceManager: is responsible for runtime of the operations of the service bus messaging entities from inserting, creating, deleting and so on.
  • MessagingFactory: is responsible for tracking, monitoring and handling the lifecycle of the message
  • MessageReciver: this is the class responsible for receiving the Brokered Message from the sender application
  • MessageSender: this is the class responsible for sending the Brokered Message from an application to another
  • MessageSession:
  • Filter: helps you filter the messages according to topics so you can easily send the brokered message to its exact target application.
  • TokenProvider: is the security token that you will need to use for initiating a new instance of messaging factory and namespace manager.

You can have a look on the Service Bus namespaces from the following 2 documents, the first one is an overview on the Microsoft.ServiceBus Namespace and the second one is the Microsoft.ServiceBus.Messaging Namespace.

Here is a simple example for starting developidng Windows Azure Service Bus Brokered Messaging, the queue using the .NET.

The following code example is for those who are interested to start developing Windows Azure Service Bus using the Node JS for both the Windows Azure Service Bus Brokered Messaging whether using queue:

//creating Windows Azure Service bus Brokered Message using queue

 

//here is a brief explanation

//the initialization is very sample

// the main three functions are, creating the queue, sending the message and receiving the message

 

var azure = require(‘azure’);

var queuename = ‘queuename’;

var queuemsg = ‘the msg you want to send through the queue’;

 

var sbclient = azure.createServiceBusService();

 

//function to create the Windows Azure Service bus Queue

function createSBQueue(){

    sbclient.createQueue(queuename, function(error){

    if(!error){

        console.log(“Queue Created”);

    }});

}

 

//function to send through the Windows Azure Service Bus Queue created

function sendQueueMsg(){

    sbclient.sendQueueMessage(queuename, queuemsg, function(error){

    if(!error){

        console.log(“Queue Message delivered”);

    }});

}

 

//function to receive from the clients through the Windows Azure Service Bus Queue Created

function receiveQueueMsg(){

    sbclient.receiveQueueMessage(queuename, function(error, message){

    if(!error){

        console.log(message.body);

    }});

}

or Topic/Subscription:

//creating Windows Azure Service bus Brokered Message using queue

 

//here is a brief explanation

//the initialization is very sample

//four functions are needed, one to create the topic, the second to create the subscription

//the third for sending the message to a subscription and the fourth to receive the message

 

var azure = require(‘azure’);

 

var topic = ‘topicname’;

var subsc = ‘subscriptionname’;

 

var msg = ‘my msg’;

 

var sbclient = azure.createServiceBusClient();

 

//function to create the topic

function createTopic(){

    sbclient.createTopic(topic, function(error){

        if(!error){

            console.log(‘Topic Created’);

        }});

}

 

//function to create the subscription

function createSub(){

    sbclient.createSubscription(subsc, function(error){

        if(!error){

            console.log(‘Subscription Created’);

        }});

}

 

//function to send a message

function sendMsg(){

    sbclient.sendTopicMessage(topic, msg, function(error){

        if(!error){

            console.log(‘Message sent’);

        }});

}

 

//function to receive a message

function receiveMsg(){

    sbclient.receiveSubscriptionMessage(topic, subsc, function(error, message){

        if(!error){

            console.log(message.body);

        }});

}

Previously I have blogged about Windows Azure Blob Storage, getting here in more details about it. The Windows Azure Blob Storage is the unstructured data, where a lot of solutions and services is based on. The Windows Azure PageBlob is another type of the Blob Storage after introducing the Windows Azure BlockBlob.

The Windows Azure PageBlob is mainly used for the pages that requires a lot input and output. For example a static page that waits a lot of incoming users to complete the form. The PageBlob is mainly designed to meet all these requirements. The Maximum size of a PageBlob is 1 TB where each page blob is up to 4MB after the user finish the writing request in the page.

You can also find the following code example for building an application using .Net and C# to start working with the Windows Azure PageBlob.

static void WriteToPageBlob(Uri blobEndpoint, string accountName, string accountKey)

{

//Create service client for credentialed access to the Blob service.

CloudBlobClient blobClient =

new CloudBlobClient(blobEndpoint, new StorageCredentialsAccountAndKey(accountName, accountKey));

// create container if it does not exist

CloudBlobContainer cloudContainer = blobClient.GetContainerReference(“mypageblobs”);

cloudContainer.CreateIfNotExist();

//Get a reference to the page blob that will be created.

CloudPageBlob pageBlob = cloudContainer.GetPageBlobReference(“apageblob”);

//Generate some data to write.

byte[] data = new byte[1024];

Random rnd = new Random();

rnd.NextBytes(data);

//Create a 100 MB page blob.

pageBlob.Create(100 * 1024 * 1024);

//Write two sets of pages. Note that you can write 4 MB per call to WritePages().

pageBlob.WritePages(new MemoryStream(data), 0);

pageBlob.WritePages(new MemoryStream(data), 4096);

//Populate the page blob’s attributes.

pageBlob.FetchAttributes();

Console.WriteLine(“Blob length = {0}”, pageBlob.Properties.Length);

//Print out the current range of pages.

PrintPageRanges(“Before write to 10240:”, pageBlob);

//Write another page.

pageBlob.WritePages(new MemoryStream(data), 10240);

//Print out the new range of pages.

PrintPageRanges(“After write to 10240:”, pageBlob);

//Clear a page.

pageBlob.ClearPages(4096, 1024);

//Print out the new range of pages.

PrintPageRanges(“After clearing page at 4096:”, pageBlob);

//Delete the page blob.

pageBlob.Delete();

}

static void PrintPageRanges(string msg, CloudPageBlob cloudBlob)

{

//Write out the page ranges for the page blob.

IEnumerable<PageRange> ranges = cloudBlob.GetPageRanges();

Console.Write(“{0}:<“, msg);

foreach (PageRange range in ranges)

{

Console.Write(” [{0}-{1}] “, range.StartOffset, range.EndOffset);

}

Console.WriteLine(“>”);

}

You can find another details about the other type of Windows Azure BlockBlob in this post.

Previously I have blogged about Windows Azure Blob Storage, getting here in more details about it. The Windows Azure Blob Storage is the unstructured data, where a lot of solutions and services is based on. The BlockBlob is a solution based on the Blob Storage that mainly helps optimize the performance. The Blob storage is a perfect way to store data, from different kind, from PDFs, Docs, to PNG, JPEG or AVIs and others.

Now to optimize the transfer of the data Windows Azure Storage introduced the Windows Azure Block Blob that helps dividing the large blobs in smaller blocks to facilitate the transfer between the Windows Azure datacenter and the clients that are trying to access the data. One of the main problems that the BlockBlob helps avoid is that when sending a specified blob to the client, an error may occur when transferring these packets, one of these packets may face any kind of problem. Dropping any kind of these packets will require the transfer of the whole blob another time. However if you are using the Windows Azure BlockBlob, when sending a BlockBlob from the server to the Client, this blob is divided into small blocks if any of these faces any kind of problems the server will only transfer the block dropped.

BlockBlob let you upload a large block efficiently uploaded. The maximum size of a block is 4 MB maximum and the maximum size of the blob block is 200 GB. Each block has a block ID and the block is not committed until you give the all the blocks their IDs. With blob block you can upload multiple blocks parallel in the same time decreasing the time of uploading. You can upload the blocks in any order and define their sequence in the final block list.

You can also find an example for building an application using .Net and C# to start working with the Windows Azure BlockBlob. You can use something like the following code, where it represents another small brief introduction into the Windows Azure BlockBlob but using the Node JS.

var azure = require(‘azure’);

var blobservice= azure.createBlobService();

var options = {contentType: request.uploadedFile.Type };

blobservice.createContainerIfNotExists(request.containerName, function(error){

if(!error){

response.send(statusCodes.Ok, {message:’Container Created’});

}

});

blobservice.createBlockBlobFromFile(request.containerName,request.fileName, request.uploadedFile.path, options, function(error)

{if(!error){

response.send(statusCodes.OK, {message:’blockblob created’});

}

});

You can find another details about the other type of Windows Azure PageBlob in this post.

With the introduction of the Windows Azure Media Services, you might not need to use the Windows Azure BlockBlob especially that the Windows Azure Media Services mainly helps a lot in streaming the Media files. However if you are working with files with a large size of file, you will certainly have to think about using the Windows Azure BlockBlob.

The Windows Azure Media Services is a tool that helps the developers storing, transferring and streaming different types of media. It is basically based on the Windows Azure unstructured storage, Blob Storage. This service is mainly to help the developer with mainly three things: Upload Media, Encode Video and Deliver and Stream Video.

First of all you have to create a Media Service account on the Windows Azure, to do so go to your Windows Azure account and follow the steps.

Now Congratulations!! Let’s get in depth about the features that you can start using on the Windows Azure portal.

As you can see in the following, the home page of the media services created, normally in any home page whether in the Windows Azure Mobile Services or Windows Azure Media Services, this page helps you with the basics of the development that will help any developers. As you can see Windows Azure Media Services is only to be created using only 2 programing languages, C# and Java.

It also helps you with the development to achieve any of the previously mentioned issues the upload, the streaming or download and encode.

The last thing is you will find a sample project where you can download and go through the basic of the development whether using the C# and the Java development.

In the Dashboard, you will be able to monitor the performance and the tasks queued, delivered and failed of the Windows Azure Media Service Created. Also you can find a link where you can download the Windows Azure Media Service SDK. For your information, to start developing you will need the following 3 SDKs, the Windows Azure SDK, the Windows Azure Media Service SDK and the WCF Data Services 5.0 for OData V3 libraries.

The third tab is to help you scale your running Media Services whether for streaming or Encoding.

You can also upload some content directly to Windows Azure Media Services without the need to code or create any kind of application. You can do so not only from your local computer but from the Windows Azure Storage if previously uploaded to a Windows Azure Storage account.

The Windows Azure Service Bus Notification Hub is finally released and it is generally available to be used in the development. It supports multiple platform push notification like Google, Microsoft and apple push notification. The Notification Hub will easily help the application to reach millions of users through their mobile or windows application by simply sending them a Notification through the Service Bus.

Here are the differences between the Windows Azure Mobile Services and the Notification Hub push notification. This table is taken from Announcing General Availability of Windows Azure Notification Hubs & Support for SQL Server AlwaysOn Availability Group Listeners

Mobile Services

Notification Hubs

MPNS, WNS, APNS, and GCM support

Yes

Yes

Turnkey event-triggered push

Yes

No

Device registration management

No

Yes

Interest tags for routing messages to a subset of users

No

Yes

Templates for formatting messages to user preferences including language

No

Yes

Broadcast to >1 million devices at once within minutes

No

Yes 

With the release of Microsoft Visual Studio 2013 preview, it didn’t support the Windows Azure SDK 2.0. So the new SDK 2.1 is specially designed to extend the Visual Studio 2013 capabilities to support the Windows Azure development. Certainly the Windows Azure SDK 2.1 also is available for the older visual studio 2010 and 2012.

The first part is related to Windows Azure Virtual Machine, is to take the full control over the Windows Azure Virtual Machine over the Windows Azure. You can now start and stop the Virtual Machine created on the Windows Azure that will help you with more control on the Visual Studio. Now the Virtual Machine after the creation the Virtual Machine, the Virtual Machine start costing you money and every minutes it cost you more as long as the Virtual Machine is running. Now you can take control over the Virtual Machine created because when you stop it, it will stop costing you and will give you the chance to save money until you start it again. This feature is available now from Visual studio directly you can start and stop the Virtual Machines.

The second main feature is the introduction of the Windows Azure Express Emulator. Beside when developing a webrole or a workerrole using the Compute emulator (Cloud Services) you can use the express emulator to run it and test it as the express one doesn’t require you to run as administrator to test your project as it uses less resources.

Certainly there are some new updates in the server explorer that can helps you get more details about your cloud services and resources.

To download Windows Azure SDK 2.1:

For the Relay Messaging Service Bus, it goes with the same process like the Brokered Messaging but only in the configuration part.

Now Congratulation you have created your Windows Azure Service Bus Relay Service on the Windows Azure.

You can follow the following instruction to create a Relay Service, however it is a lot easier than the Brokered Messaging. Before starting working on the Relay Service, I recommend that you learn more about what is the Service Bus Relay Messaging, the Brokered Messaging and what are the difference between them.