Role Deployment Location on Azure

It is important to know where exactly will your role be deployed on the production machine in Azure data center. It is also important to know where windows is installed so you can reference its tools when writing startup tasks.

Well on windows Azure windows is deployed on drive D: !!!

Your role will be deployed to drive E: (E:\sitesroot\  for web role and a mirror in e:\AppsRoot for all roles)

you can learn about the location of your web role by simply open IIS Manager and explore to the web site of your role.

Manu

Blob Parallel Upload and Download

To gain the best performance from azure blob storage it is required to upload and download data in parallel. For very small files it is OK to use the simple blob API (UploadFile, UploadFromStream etc.) but for large chucks of data parallel upload is required.

To do parallel upload we'll use a block blob when working with streaming data (such as images or movies) and use the producer consumer design pattern. One thread read the stream, create blocks and put them into a queue. A collection of other threads read blocks from the queue and upload them to the cloud. Once all the threads finished the whole blob is committed.

Lets see the code:

public class PrallelBlobTransfer
    {
        // Async events and properties
        public event EventHandler TransferCompleted;
        private bool TaskIsRunning = false;
        private readonly object _sync = new object();

        // Used to calculate download speeds
        Queue<long> timeQueue = new Queue<long>(100);
        Queue<long> bytesQueue = new Queue<long>(100);

        public CloudBlobContainer Container { get; set; }
       
        public PrallelBlobTransfer(CloudBlobContainer container)
        {
            Container = container;
        }

       
        public void UploadFileToBlobAsync(string fileToUpload, string blobName)
        {
            
            if (!File.Exists(fileToUpload))
                throw new FileNotFoundException(fileToUpload);
            
            var worker = new Action<Stream,string>(ParallelUploadStream);

            lock (_sync)
            {
                if (TaskIsRunning)
                    throw new InvalidOperationException("The control is currently busy.");

                AsyncOperation async = AsyncOperationManager.CreateOperation(null);
                var fs = File.OpenRead(fileToUpload);
                worker.BeginInvoke(fs,blobName, TaskCompletedCallback, async);

                TaskIsRunning = true;
            }
        }
        
        public void UploadDataToBlobAsync(byte[] dataToUpload, string blobName)
        {
            var worker = new Action<Stream, string>(ParallelUploadStream);

            lock (_sync)
            {
                if (TaskIsRunning)
                    throw new InvalidOperationException("The control is currently busy.");

                AsyncOperation async = AsyncOperationManager.CreateOperation(null);
                var ms = new MemoryStream(dataToUpload);
                worker.BeginInvoke(ms, blobName, TaskCompletedCallback, async);

                TaskIsRunning = true;
            }
        }

        public void DownloadBlobToFileAsync(string filePath, string blobToDownload)
        {
            var worker = new Action<Stream,string>(ParallelDownloadFile);

            lock (_sync)
            {
                if (TaskIsRunning)
                    throw new InvalidOperationException("The control is currently busy.");

                AsyncOperation async = AsyncOperationManager.CreateOperation(null);
                var fs = File.OpenWrite(filePath);
                worker.BeginInvoke(fs, blobToDownload, TaskCompletedCallback, async);

                TaskIsRunning = true;
            }
        }
        
        public void DownloadBlobToBufferAsync(byte[] buffer, string blobToDownload)
        {
            var worker = new Action<Stream, string>(ParallelDownloadFile);

            lock (_sync)
            {
                if (TaskIsRunning)
                    throw new InvalidOperationException("The control is currently busy.");

                AsyncOperation async = AsyncOperationManager.CreateOperation(null);
                var ms = new MemoryStream(buffer);
                worker.BeginInvoke(ms, blobToDownload, TaskCompletedCallback, async);

                TaskIsRunning = true;
            }
        }

        public bool IsBusy
        {
            get { return TaskIsRunning; }
        }
        
        // Blob Upload Code
        // 200 GB max blob size
        // 50,000 max blocks
        // 4 MB max block size
        // Try to get close to 100k block size in order to offer good progress update response.
        private int GetBlockSize(long fileSize)
        {
            const long KB = 1024;
            const long MB = 1024 * KB;
            const long GB = 1024 * MB;
            const long MAXBLOCKS = 50000;
            const long MAXBLOBSIZE = 200 * GB;
            const long MAXBLOCKSIZE = 4 * MB;

            long blocksize = 100 * KB;
            //long blocksize = 4 * MB;
            long blockCount;
            blockCount = ((int)Math.Floor((double)(fileSize / blocksize))) + 1;
            while (blockCount > MAXBLOCKS - 1)
            {
                blocksize += 100 * KB;
                blockCount = ((int)Math.Floor((double)(fileSize / blocksize))) + 1;
            }

            if (blocksize > MAXBLOCKSIZE)
            {
                throw new ArgumentException("Blob too big to upload.");
            }

            return (int)blocksize;
        }

        /// <summary>
        /// Uploads content to a blob using multiple threads.
        /// </summary>
        /// <param name="inputStream"></param>
        /// <param name="blobName"></param>
        private void ParallelUploadStream(Stream inputStream,string blobName)
        {
          // the optimal number of transfer threads
            int numThreads = 10;

            long fileSize = inputStream.Length;

            int maxBlockSize = GetBlockSize(fileSize);
            long bytesUploaded = 0;

            // Prepare a queue of blocks to be uploaded. Each queue item is a key-value pair where
            // the 'key' is block id and 'value' is the block length.
            var queue = new Queue<KeyValuePair<int, int>>();
            var blockList = new List<string>();
            int blockId = 0;
            while (fileSize > 0)
            {
                int blockLength = (int)Math.Min(maxBlockSize, fileSize);
                string blockIdString = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(
string.Format("BlockId{0}", blockId.ToString("0000000"))));
                KeyValuePair<int, int> kvp = new KeyValuePair<int, int>(blockId++, blockLength);
                queue.Enqueue(kvp);
                blockList.Add(blockIdString);
                fileSize -= blockLength;
            }

            var blob = Container.GetBlockBlobReference(blobName);
            blob.DeleteIfExists();

            BlobRequestOptions options = new BlobRequestOptions()
            {
                RetryPolicy = RetryPolicies.RetryExponential(
RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultMaxBackoff),
                Timeout = TimeSpan.FromSeconds(90)
            };

            // Launch threads to upload blocks.
            var tasks = new List<Task>();

            for (int idxThread = 0; idxThread < numThreads; idxThread++)
            {
                tasks.Add(Task.Factory.StartNew(() =>
                {
                    KeyValuePair<int, int> blockIdAndLength;

                    using (inputStream)
                    {
                        while (true)
                        {
                            // Dequeue block details.
                            lock (queue)
                            {
                                if (queue.Count == 0)
                                    break;

                                blockIdAndLength = queue.Dequeue();
                            }

                            byte[] buff = new byte[blockIdAndLength.Value];
                            BinaryReader br = new BinaryReader(inputStream);

                            // move the file system reader to the proper position
                            inputStream.Seek(blockIdAndLength.Key * (long)maxBlockSize, SeekOrigin.Begin);
                            br.Read(buff, 0, blockIdAndLength.Value);

                            // Upload block.
                            string blockName = Convert.ToBase64String(BitConverter.GetBytes(
                                blockIdAndLength.Key));
                            using (MemoryStream ms = new MemoryStream(buff, 0, blockIdAndLength.Value))
                            {
                                string blockIdString = Convert.ToBase64String(
ASCIIEncoding.ASCII.GetBytes(string.Format("BlockId{0}", blockIdAndLength.Key.ToString("0000000"))));
                                string blockHash = GetMD5HashFromStream(buff);
                                blob.PutBlock(blockIdString, ms, blockHash, options);
                            }
                            
                        }
                    }
                }));
                
            }

            // Wait for all threads to complete uploading data.
            Task.WaitAll(tasks.ToArray());
            
            // Commit the blocklist.
            blob.PutBlockList(blockList, options);
        }

        /// <summary>
        /// Downloads content from a blob using multiple threads.
        /// </summary>
        /// <param name="outputStream"></param>
        /// <param name="blobToDownload"></param>
        private void ParallelDownloadFile(Stream outputStream, string blobToDownload)
        {
            int numThreads = 10;
            var blob = Container.GetBlockBlobReference(blobToDownload);
            blob.FetchAttributes();
            long blobLength = blob.Properties.Length;

            int bufferLength = GetBlockSize(blobLength);  // 4 * 1024 * 1024;
            long bytesDownloaded = 0;

            // Prepare a queue of chunks to be downloaded. Each queue item is a key-value pair 
            // where the 'key' is start offset in the blob and 'value' is the chunk length.
            Queue<KeyValuePair<long, int>> queue = new Queue<KeyValuePair<long, int>>();
            long offset = 0;
            while (blobLength > 0)
            {
                int chunkLength = (int)Math.Min(bufferLength, blobLength);
                queue.Enqueue(new KeyValuePair<long, int>(offset, chunkLength));
                offset += chunkLength;
                blobLength -= chunkLength;
            }

            int exceptionCount = 0;

            using (outputStream)
            {
                // Launch threads to download chunks.
                var tasks = new List<Task>();
                for (int idxThread = 0; idxThread < numThreads; idxThread++)
                {
                    tasks.Add(Task.Factory.StartNew(() =>
                    {
                        KeyValuePair<long, int> blockIdAndLength;

                        // A buffer to fill per read request.
                        byte[] buffer = new byte[bufferLength];

                        while (true)
                        {
                            
                            // Dequeue block details.
                            lock (queue)
                            {
                                if (queue.Count == 0)
                                    break;

                                blockIdAndLength = queue.Dequeue();
                            }

                            try
                            {
                                // Prepare the HttpWebRequest to download data from the chunk.
                                HttpWebRequest blobGetRequest = BlobRequest.Get(blob.Uri, 60, null, null);

                                // Add header to specify the range
                                blobGetRequest.Headers.Add("x-ms-range", 
string.Format(System.Globalization.CultureInfo.InvariantCulture, "bytes={0}-{1}", 
blockIdAndLength.Key, blockIdAndLength.Key + blockIdAndLength.Value - 1));

                                // Sign request.
                                StorageCredentials credentials = blob.ServiceClient.Credentials;
                                credentials.SignRequest(blobGetRequest);

                                // Read chunk.
                                using (HttpWebResponse response = blobGetRequest.GetResponse() as
                                    HttpWebResponse)
                                {
                                    using (Stream stream = response.GetResponseStream())
                                    {
                                        int offsetInChunk = 0;
                                        int remaining = blockIdAndLength.Value;
                                        while (remaining > 0)
                                        {
                                            int read = stream.Read(buffer, offsetInChunk, remaining);
                                            lock (outputStream)
                                            {
                                                outputStream.Position = blockIdAndLength.Key + offsetInChunk;
                                                outputStream.Write(buffer, offsetInChunk, read);
                                            }
                                            offsetInChunk += read;
                                            remaining -= read;
                                            Interlocked.Add(ref bytesDownloaded, read);
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                // Add block back to queue
                                queue.Enqueue(blockIdAndLength);

                                exceptionCount++;
                                // If we have had more than 100 exceptions then break
                                if (exceptionCount == 100)
                                {
                                    throw new Exception("Received 100 exceptions while downloading." + ex.ToString());
                                }
                                if (exceptionCount >= 100)
                                {
                                    break;
                                }
                            }
                        }
                    }));
                }

                // Wait for all threads to complete downloading data.
                Task.WaitAll(tasks.ToArray());
            }
        }

        private void TaskCompletedCallback(IAsyncResult ar)
        {
            // get the original worker delegate and the AsyncOperation instance
            Action<Stream, string> worker = (Action<Stream, string>)((AsyncResult)ar).AsyncDelegate;
            AsyncOperation async = (AsyncOperation)ar.AsyncState;

            // finish the asynchronous operation
            worker.EndInvoke(ar);

            // clear the running task flag
            lock (_sync)
            {
                TaskIsRunning = false;
            }

            // raise the completed event
            async.PostOperationCompleted(state => OnTaskCompleted((EventArgs)state), new EventArgs());
        }

        protected virtual void OnTaskCompleted(EventArgs e)
        {
            if (TransferCompleted != null)
                TransferCompleted(this, e);
        }


        private string GetMD5HashFromStream(byte[] data)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] blockHash = md5.ComputeHash(data);
            return Convert.ToBase64String(blockHash, 0, 16);
        }
        
    }

Enjoy

Manu

Hosting Classic ASP on Azure

Is it possible to run a classic Asp site on Windows Azure? Of Course it is, Anything that runs on IIs can be hosted in Azure.

So How do we do it?

1. Create a simple asp page in notepad (e.g. using http://support.microsoft.com/kb/301097)
2. Create startup.cmd to install ASP engine
   • start /w pkgmgr /iu:IIS-AS
3. Create a ASP .Net Web role and modify csdef to include a startup task:
   • <Startup>
   • <Task commandLine="startup.cmd" executionContext="elevated" taskType="simple" />
   • </Startup>
4. Add both files to web role - change properties to 'Content' and 'Copy if New'.
5. Build and Publish solution to Azure

More info:

 Windows Azure (How-to enable classic ASP support).

Manu

Moles Fails with InteliiTrace On

Moles is a great infrastructure for injecting mock functions into existing code. This is of course very useful when writing unit tests. Unfortunately from version 0.93 (now we are in 0.94) moles fails when IntelliTrace is on.

When running tests that uses moles and IntelliTrace is on the test will abort with the exception: [agent] host process exited with unmanaged profiler failed (-667 - 0xfffffd65)

To fix this simply disable IntelliTrace (Tools|Options|IntelliTrace|Enable IntelliTrace)
and run your tests.

Manu

Scale Data Applications with Sql Azure

When designing a data application, traditionally the bottleneck lies within the database. A traditional on-premises database does not scale very well. It is difficult to split a database between a cluster of machines so usually the database runs on the most powerful machine available which tend to be expensive.

To solve the problem some data processing is moved form its natural environment (i.e. DB) to the business tier which scale much better. The business tier is easy to replicate so it can help reduce the performance bottleneck of the database.

In Sql Azure things are different. Sql Azure is NOT running on simple Sql servers 2008 machines which happen to be on the cloud. Sql Azure has a different architecture. It runs on a grid of servers split into service and platform layers. The platform layer runs the sql engine and the service layer is responsible for the connection and provisioning.

"SQL Azure subscribers access the actual databases, which are stored on multiple machines in the data center, through the logical server. The SQL Azure Gateway service acts as a proxy, forwarding the Tabular Data Stream (TDS) requests to the logical server. It also acts as a security boundary providing login validation, enforcing your firewall and protecting the instances of SQL Server behind the gateway against denial-of-service attacks. The Gateway is composed of multiple computers, each of which accepts connections from clients, validates the connection information and then passes on the TDS to the appropriate physical server, based on the database name specified in the connection"

An important aspect about Sql Azure is the fact that this is a shared infrastructure. You do not own a specific server.  This is why Sql Azure billing is calculated according to the amount of storage you use only and does not take the cpu consumption of the database into consideration.

Another thing to know about Sql Azure is the fact that your databases are replicated across 3 different servers. Large databases can be split horizontally using Sql Azure Sharding.

"Sharding is an application pattern for improving the scalability and throughput of large-scale data solutions. To “shard” an application is the process of breaking an application’s logical database into smaller chunks of data, and distributing the chunks of data across multiple physical databases to achieve application scalability"

Sql Azure in contrast to on-premises databases scales very well.
SQL Azure combined with database sharding techniques provides for virtually unlimited scalability of data for an application.

And a final word about billing: The only compute power customers are charged for in windows azure is on the running roles. Sql Azure CPU is free !!!

So the conclusion is that in cloud applications you might want to consider to move data processing back to the database, use Sql Azure Sharding and save money.

Enjoy

Manu

Application security auditing and logging

Auditing is one of the main pillars of security policies. The question is how to do it wisely

The infrastructure can log almost everything. For example access to files, registry keys databases etc. The problem is that the infrastructure has no knowledge about the application use cases. It means that the context for these logs is missing.

Let us ask what is the purpose of auditing? The trivial reason is to collect information that will be useful in case of a problem, yet how do you know that there is a problem after all?

Auditing can help you identify that you are in an abnormal state and something is wrong.
To do that you have to be able to distinguish between normality and abnormality. The application knows its use cases. It knows their behavior patterns and so can identify that something is wrong. This is why only the application layer can perform smart security auditing.

Application logging and auditing is used to collect enough information to analyze the behavior of the application use cases and identify any abnormal situation, then the information collected with traditional logging is used to identify the problem and find the best action.

Enjoy

Manu

Http error 405 when calling STS

I wrote a simple example for demonstrating delegation with Windows Identity Framework (WIF).
I created a simple web site that used a simple custom STS for authentication. The web site called another web service to calculate a simple calculation (calculator).

The web site used passive federation using a simple asp.net STS. SOAP Web service in general can only use passive federation for authentication, so I created another WCF custom STS.

The idea was that the web application will obtain an act-as token from the active STS using the token it received from the client (using the passive STS) and then call the calculator web service.

When I run the code I got the "http error 405 method not allowed".

Http error 405 means that there is a mismatch between the http verb (e.g. Post, Get) between the call and the service. If the service waits for a http put and we send a http get request this is the error that will be triggered.

My problem was simple. I called the base address of the STS instead of the STS itself. I did that by specifying the base address of the STS in the issuer configuration. When I fixed the address to the real address of the STS the problem was solved.

 <customBinding>
   <binding name="CustomBinding_ICalc">
     <security authenticationMode="IssuedTokenForCertificate" 
           messageSecurityVersion="WSSecurity11WSTrust13WSSecureConversation13WSSecurityPolicy12BasicSecurityProfile10">
            <issuedTokenParameters keyType="SymmetricKey"
                                   tokenType="http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1">
              <issuer address="http://manu-newlap/WCFSTS/service.svc"
                      binding="ws2007HttpBinding"
                      bindingConfiguration="http://manu-newlap/WCFSTS">
              </issuer>
              <issuerMetadata address="http://manu-newlap/WCFSTS/mex" />
            </issuedTokenParameters>
          </security>
          <httpTransport/>
   </binding>
 </customBinding>

The call to the STS to obtain an Act-As token is implemented by sending a http post request that contains the bootstrap token received from the passive STS. The base address does not allow non Get requests so my Post request was rejected.

remember that STS is a simple WCF service. The same rules that applies in simple WCF applies here.

Hope this will help.

Manu

כלכלת ענן

Hi this post will be written in Hebrew (sorry for all English speakers)

כולנו שומעים על ענן מכל כיוון אפשרי. נשאלת השאלה למה?
מה עושה את הענן הזה לשם החם הבא? מה הסוד מאחורי המושג הזה?

הכול מתחיל ונגמר בכסף. הסיפור הוא כלכלי.

מחוק מור למדנו שכל שנתיים מערכות מכפילות את יכולתן הטכנולוגית השאלה שנשאלת מה קורה למחיר? בסביבה הטכנולוגית כיום הלקוח התרגל לא רק לקבל מערכות טובות יותר ככל שהזמן עובר, אלא גם לשלם פחות. זה מוזר מבחינה כלכלית – לקבל יותר אך לשלם פחות.

הכול טוב ויפה מצדו של הצרכן אבל נותן השירות או ספק התוכנה נמצא במצב מביך, הלקוח דורש דרישות הולכות וגדלות אך מצד שני הוא מוכן לשלם פחות. בימינו הצרכן דורש אמינות מושלמת זמינות מוחלטת, ביזור ועמידה בעומסים משתנים. ניתן כמובן לספק יכולות כאלו הבעיה רק שזה ממש יקר. והלקוח כאמור לא מוכן לשלם.

במצב כזה אין ברירה אלא לשנות משהו בסיסי כי במצב הנוכחי פשוט אי אפשר לספק את הדרישות במחירי השוק. פה מגיע הענן.

הענן הוא ההזדמנות של השוק לגדול מבחינה טכנולוגית ועדיין להישאר רלוונטי מבחינה כלכלית. זוהי הסיבה שכולם מדברים על הענן מפני שזו היא התשתית עליה תתבסס התעשייה בעתיד הקרוב.

הרעיון שעומד מאחורי הענן אינו חדש. תשתיות הן דבר יקר ובעל נצילות נמוכה. שיתוף תשתיות הוא פוטנציאל אדיר לחיסכון בכסף. המימוש המפורסם ביותר של הרעיון הזה מגיע מתשתיות החשמל. למי מאתנו יש תחנת כוח ביתית שמספקת את כל תצרוכת החשמל שלנו? לרובנו זו נראית שאלה מגוחכת. למה לי לבנות תשתית יקרה של גנרטורים שיספקו לי הרבה חשמל למזגנים בקיץ ולחימום בחורף ומעט חשמל באביב ובסתיו כשאני יכול בפשטות כה רבה לקנות חשמל בזול מחברת חשמל ולשלם בדיוק לפי הצריכה שלי?

האנלוגיה ברורה. למה לי להקים מרכז מחשוב יקר שיספק לי את הכוח הדרוש לשעות העומס ויעמוד בטל בשאר ימות השנה כשאני יכול בפשטות לקנות כוח מחשוב ואזורי אחסון בענן ולשלם בדיוק לפי צריכה?

כנראה עוד מספר שנים השאלה עם לעבוד בענן תראה טריוויאלית בדיוק כמו השאלה אם לרכוש חשמל מספק מרכזי. כיום אנו בתחילתו של עידן אבל הכיוון ברור והתעשייה כולה מתנהגת בהתאם. ספקי התקשורת (Telecoms) בונים לנו ערוצים ייעודיים לענן כדי להבטיח ביצועים בסביבה מבוזרת. ספקי הענן בונים מרכזי מחשוב (Data Centers) ענקיים ומשקיעים מיליארדים בפיתוח הטכנולוגיה אשר תאפשר לנו בקלות להשתמש בשירותי הענן שלהם. יצרני מערכות ההפעלה וה – Hypervisors בונים תשתיות תוכנה ייעודיות לבניית מרכזי מחשוב ענן (ראה Windows Server 8 כדוגמא). יצרני החומרה בונים רכיבים מיוחדים עבור שרתים בענן וספקי התוכנה מספקים את מרכולתם כ – Software as a Service.

בקיצור הענן הוא הדבר הבא כי הוא מספק את ההזדמנות הכלכלית שכל כך דרושה לתעשיית המידע.

Azure ServiceBus Topic using REST API – Part 4

In the three last post's we learned how to use Azure ServiceBus REST API to send and receive messages using Topics.

The difference between Queues and Topics is the fact that with topics different customers can receive different messages according message filtering which is deployed as filtering rules on the subscription. MSDN describe the following about topics and rules:

Topics extend the messaging features provided by Queues with the addition of Publish-Subscribe capabilities.
Each Subscription can define one or multiple Rule entities. Each Rule specifies a filter expression that is used to filter messages that pass through the subscription and a filter action that can modify message properties. In particular, the SqlFilterExpression class allows you to define a SQL92-like condition on message properties:

• OrderTotal > 5000 OR ClientPriority > 2
• ShipDestinationCountry = ‘USA’ AND ShipDestinationState = ‘WA’

Conversely, the SqlFilterAction class can be used to modify, add or remove properties, as the filter expression is true and the message selected, using a syntax similar to that used by the SET clause of an UPDATE SQL-command.

• SET AuditRequired = 1
• SET Priority = 'High', Severity = 1

Each matching rule generates a separate copy of the published message, so any subscription can potentially generate more copies of the same message, one for each matching rule.

Let us learn how to Add a rule and action using the REST API.

To add a rule to a subscription we need to provide a rule description. To do that I created a rule, action and filter description classes.

The rule description contains rule actions.

The rule description contains rule filters

Now we are ready to add a new rule using REST API

As you can see the first thing we do is delete the default rule that accepts all messages. Then we attach the serialization of our rule description to a PUT Http request we send to the URI of the new rule at:
https://{serviceNamespace}.servicebus.windows.net/{topicName}/subscriptions/{subscriptionName}/rules/{ruleName}

That is it. We have a new rule on our subscription.

With that I end the Series of post about using REST API of AppFabric Topics.

Enjoy

Manu

Azure ServiceBus Topic using REST API – Part 3

In the last two posts we showed how to use the Azure ServiceBus service bus REST API to send a message to a topic.
In this post we will see how to listen on a topic and receive a message.

There are two options:

1. Receive a message and delete it from the topic.

2. Receive the message but keep it locked on the queue until we decide to delete it (for example after message processing succeeded).

The following table describe the information that will be placed in the brokerProperties object 

To delete a lock or delete message (after the lock is deleted) I will use a general method for deleting service bus resources

That's all we received a message. On the next post we will learn how to create a rule for a subscription.

Enjoy

manu

Azure ServiceBus Topic using REST API – Part 2

In the last post I described why to use REST API when working with Azure service bus and demonstrated how to create a topic and subscription.

In this post we will actually send a message to the topic.

When sending a http request with a message to a topic we have to provide two special headers
1. Authorization header with the token we received from ACS
2.  BrokerProperties with Json serialization of metadata of metadata about our message.

To do that let us create a special class that will help us represent and serialize the metadata.

Now we know how to create a token (previous post) and represent metadata. so let us send a message

As you can see I put the receiver name in the "To" properties of the BrokerProperties object. This will allow us later to create a rule that filter the messages accordingly (e.g. To=receiver)

Also you can see that I propagated all of the message's properties. A propagated property is placed as a Http header and provide the ability to later filter messages according to its value by creating a relevant rule.
In production I assume that you will propagate only the properties you need !!!

The body message contains the DataContract Serialization of our data.
All we need to do is send the Http Request (using POST verb) to our topic at:
https://{namespace}.{appfabric.windows.net}/{topicname}//messages?timeout=60

Enjoy

Manu

My Application Security Talk on Canada's TechDays

Starting the end of February, Canada's TechDays TV will air brand new TechDays sessions (exclusive to TechDays Online). The experts will be LIVE and INTERACTIVE which means that throughout the session, as well as after the session, you’ll be able to post your questions via chat or Twitter and have them answered in real-time.

To launch this new TV channel, MS Canada chose me to talk about "Securing.NET Applications", In this session I discuss a range of security topics including: what is application security, security design and the SDL, identity Management, role-based security and claim based identity, cryptography, secure communication, and input validation. By the end of this session, I emphasized that .NET provides the tools and technologies to implement mitigations for threats identified during the security design.

If you want to watch the recording here

Enjoy

Manu

Azure ServiceBus Topic using REST API – Part 1

To use Service Bus, we must ensure that our firewall allows outgoing TCP communication on TCP ports 9350 to 9354. This is not a very strong request yet some customers cannot touch their firewall policy and so their firewall blocks all interaction with the service bus. In such scenarios (any many others) AppFabric REST API is the only alternative to work with the service bus.

When working with the REST API we have to construct Http request to the service bus resource we want to work with. Unfortunately the REST API documentation is not accurate. In this post I will describe how to execute basic operation against service bus topics using REST API.

All operations against the service bus requires authentication. To do that we have to call Access Control Service (ACS), prove our identity and receive a token which will be presented to Service bus. In a previous post ("Securing AppFabric Service Bus with ACS") I described in details how to configure ACS.

Let us call ACS and receive a token:

Now Let us create a topic

Before sending a message to the topic let us create a subscription

Now we are ready to send a message. This will be described in the next post.

Enjoy

Manu

Windows Azure Benchmarks - Part 17: Compare Storage types performance

One of the most common questions customers ask is how does windows azure perform.
Well Microsoft published a series of benchmarks in an excellent web site called azurescope.
The thing is azurescope is going down on January 15th 2012 so I decided to publish these benchmarks here and make sure they will be available to the public.

Let us discuss storage types and compare their performance.

Charts on this page compare the maximum throughput achieved for the various storage types irrespective of the VM Size or values of other parameters on which the test was run. Please refer individual test cases for detailed information.

Key Analysis

• Page Blobs provide better throughput than Block Blobs.
• In best cases, Windows Azure Drives can deliver similar performance as that of a local disk.
• The observed write performance of Sql Azure is better than Windows Azure Tables while the read performance of Windows Azure Tables is better than Sql Azure.

Enjoy

Manu

Windows Azure Benchmarks - Part 16: Sql Azure write latency

One of the most common questions customers ask is how does windows azure perform.
Well Microsoft published a series of benchmarks in an excellent web site called azurescope.
The thing is azurescope is going down on January 15th 2012 so I decided to publish these benchmarks here and make sure they will be available to the public.

Let us discuss Sql Azure write latency.

This test measures the write latency observed from a Windows Azure worker role instance while accessing SQL Azure.

Key Analysis

• The number of pre-populated items have almost no affect on the observed latencies

Enjoy

Manu