Friday, June 17, 2011

Windows Azure and Cloud Computing Posts for 6/17/2011+

image222 A compendium of Windows Azure, Windows Azure Platform Appliance, SQL Azure Database, AppFabric and other cloud-computing articles.


Note: This post is updated daily or more frequently, depending on the availability of new articles in the following sections:

To use the above links, first click the post’s title to display the single article you want to navigate.

Azure Blob, Drive, Table and Queue Services

imageNo significant articles today.

<Return to section navigation list> 

SQL Azure Database and Reporting

Benjamin Pollack (@bitquabit) posted Cache me if you can about caching SQL Server on 6/10/2011:

image I remember, when we first launched Kiln, that I was desperately hopeful that it’d actually make a dent. I was honestly quite scared that we might end up in a situation where, after we’d put in all of this effort, spent all of this time designing and coding and testing and writing really arcane and annoying crap like billing code, that no one would want Kiln, and we’d be forced to close shop.

image Good news! That’s no longer the problem.

The problem now is that we’re too successful.

What?! I hear some of you ask. Don’t you want to be too successful?!

I think I speak for my entire team when I say: hell yes! We want to keep on being too successful. If anything, we want to be even more too successful than we currently are.

But success does present problems. It’s awesome to have thousands of customers and terabytes of data, but then you start dealing with the boring details of questions like where do you put those terabytes of data, and how do you get that data to the customers in a timely manner. And that can be a really tough cookie to crack.

I’m going to be talking about several different aspects of how we’re handling scaling Kiln over the next few weeks, but today, I want to focus on one single narrow thing: caching.

The WISC Stack

imageThe main part of Kiln that you all know and love—the website—is a fairly typical WISC application. We have a couple of web servers running IIS and the Kiln website, which talk to several SQL Server boxes. The nice thing about well-engineered WISC stacks is that, like LAMP, you can scale the databases and the web servers independently. This is the bread-and-butter of designing a scalable application. So far, so good.

The thing is, just adding more SQL boxes isn’t always the answer. If you have complex queries that take a long time to run, then adding another box won’t help anything. It just gives you another box to run your complex query on at the same slow speed. Even if you’re only doing simple queries, adding more database boxes isn’t necessarily the answer. Good SQL boxes are expensive—doubly so if you’re using a big commercial DB package such as SQL Server or Oracle. While you might be able to afford buy more, you don’t want to if you can avoid it.

Instead, you should focus on just not hitting the database in the first place.

The S in WISC

It turns out that there are already some mechanisms we had in place to help with this. We prefetched certain data that we knew we needed nearly every request (like the full list of repositories), and then used that cache for any other lookups during the request. And LINQ to SQL does a bit of its own per-request object caching in certain situations (such as querying an entity by primary key), so we already had some actual data caching going on.

While that kind of stuff can help, what we really wanted to do was to try to avoid talking to SQL at all for common operations. Those complex queries that Kiln does—things like showing the amalgamated DAG for all related repositories—take a long time to run, but the resulting data doesn’t actually change that often. This is a clear and wonderful win, if we can pull it off.

Making it Happen

There were two problems we had to solve: where do you cache the data? and how do you get it there?


The first one was pretty easy: use Memcache. Memcache is used everywhere, is extremely well-understood, and has great implementations for both Windows and Linux. We ended up settling on Membase as the particular server implementation we liked, due to its easy-to-use administration console and trivial clustering support. For the client, we ended up going with the BeIT Memcached library, due to its easy customizability and simple design.

The second part was much more difficult. Kiln uses LINQ to SQL for its database access layer. That meant we had a problem: LINQ to SQL is a very complex beast, where objects have a database context that in turn is aware of all the objects that it’s managing. If you just grab a random LINQ object and throw it into Memcache, then it is not going to deserialize cleanly. Throw in that we have piles of custom logic in our LINQ-to-SQL-backed models, and you’ve got a recipe for pain.

We ended up solving this in two different ways:

  1. We modified our models to allow for detaching and reattaching to the database context. Before serialization, the object is detached, so it has no controlling database context. On deserialization, we attach it to the current context. This isn’t as fast as grabbing an attached object out of a cache (such as the old per-request prefetch cache mentioned earlier), but ends up incurring minimal overhead for the common case.
  2. We also had to modify our models to know that they might not have come from the DB. We rely heavily on signal handlers to make changes in a given model class propagate to all the parts of Kiln that need to be notified. These were firing erroneously as the deserialization code set piles of properties. The fix we came up with was to suppress signals for deserializing objects—which, since most of our model modifications are done by T4 templates anyway, was very easy to do in a DRY manner.

With these two changes, we were able to reliably store LINQ database entities in Memcache, get them back out, and work with them.

It was easy enough to verify that the number of queries was down, but would the caching code make a real difference?

The Result

I think this graph of what load looks like on one of our DB boxes, before and after the caching deployment, says more than I could in several paragraphs of text:

SQL Server load dramatically decreasing

We’ve cut the amount of data we’re getting from SQL by 75%.

The benefits we’re seeing are already impressive. We have faster load times and less DB traffic. But we can still do a lot more: now that we have the outlines of a caching framework, we can continue to profile and to move more of our expensive queries into the cache. Based on what we’ve seen so far, this should yield immediate and real benefits to our Kiln On Demand customers.

<Return to section navigation list> 

MarketPlace DataMarket and OData

Wes Yanaga posted a Windows Azure DataMarket June Update to the US ISV Evangelism blog on 6/17/2011:

image DataMarket Goes International!

We are super excited to announce the availability of DataMarket Service Update 2. Service Update 2 introduces a number of exciting new features, including:

  • imageInternationalization: SU2 is the first wave of our international rollout. With this release, we are enabling the purchase of datasets from Australia, Austria, Canada, France, Germany, Italy, Spain, and the United Kingdom in local currencies. It will be our endeavor to continue to expand this list.
  • Rich Visualization: Customers don't just want raw data; they want visualizations. This release includes a new service explorer that enables customers to create visualizations and export them in various formats for offline use. This is in addition to exporting data to PowerPivot and partner tools like Tableau to provide a rich, comprehensive platform.
  • Free trials on selected premium datasets for 30 days. If you are a Content Publisher, you can still choose to opt in! To begin, MetricMash, Dun & Bradstreet, Boundary Solutions, and StrikeIron all have free offerings available today.
  • OAuth 2.0 support: Developers want an integrated and embeddable DataMarket experience. DataMarket OAuth support enables you to seamlessly integrate your application to use DataMarket data and to allow your users to purchase required data subscriptions without leaving your application.
  • Facebook Integration: Customers can now share their favorite data offers on Facebook. Check out and Like your favorite data offer.
  • New Content Providers: DataMarket continues to add new data offers from numerous publishers, including MetricMash (unemployment data), Digital Trowel (U.S. business database), and Infochimps (social ranking). Additional details can be found below in the content update section.
  • DataMarket Excel Add-in CTP 2: Excel has been one of the key ways our customers interact with the DataMarket. CTP 2 of the Excel add-in leverages OAuth2.0, allowing you to sign in with your Windows Live ID and creating an easy and intuitive experience.
  • DataMarket MapApp for Bing Maps now Available! We are very excited to announce the launch of the new DataMarket Map App in the Bing Map App Gallery ! Using the Map App customers will be able to visualize layers of geocoded datasets directly in Bing Maps like Demographics data from ESRI & Alteryx, US Crime data, Historical Weather data from Weather Bug etc.
  • Click here to try the MappApp!
Content Update

Digital Trowel

  • PowerLinx Database of U.S.-Based Companies and Professionals: PowerLinx contains contact information of more than 10 million U.S. companies with website addresses, 25 million detailed company profiles, 25 million executives, including 5 million in-depth profiles with email addresses, and phone numbers.


  • U.S. Unemployment Data—1948 to Current: This dataset is based on the Current Population Survey (CPS) published by the U.S. Bureau of Labor Statistics and is updated monthly. The data is broken down into these unemployment categories: rate, length, population, and labor force participation.


  • Trstrank: The Infochimps Trstrank measures how important a Twitter user is. It's a sophisticated network measure of centrality, not just a count of the number of followers a user has.

Environmental Data Resources, Inc.

  • Environmental Hazard Rank: The EDR Environmental Hazard Ranking System depicts the relative environmental health of any U.S. Zip code based on an advanced analysis of its environmental issues.

Eastbanc Technologies

  • Voting Information Project: The Voting Information Project (VIP) offers cutting edge technology tools to provide voters with access to customized election information to help them navigate the voting process and cast an informed vote.
ISV Applications

Does your application leverage DataMarket data feeds? We are very interested in helping promote the many applications that use data from the DataMarket. If you have built an application using one or more DataMarket feeds, please send an email detailing the application and the feeds used to Your application could be featured on our blog, in this newsletter, and on our website.

About Windows Azure

The Windows Azure platform is commercially available in 41 countries and enables developers to build, host and scale applications in Microsoft datacenters located around the world. It includes Windows Azure, which offers developers an Internet-scale hosting environment with a runtime execution environment for managed code, and SQL Azure, which is a highly available and scalable cloud database service built on SQL Server technologies. Developers can use existing skills with Visual Studio, .NET, Java, PHP and Ruby to quickly build solutions, with no need to buy servers or set up a dedicated infrastructure, and with automated service management to help protect against hardware failure and downtime associated with platform maintenance.

Getting Started with Windows Azure
Learn What Other ISVs Are Doing on Windows Azure

For other videos about independent software vendors (ISVs) on Windows Azure, see:

Shish Shridhar described Experiments with OData from the BI perspective in a 6/7/2011 post to his MSDN blog (missed when posted):

 What’s OData

imageThe Open Data Protocol (OData) is a Web protocol for querying and updating data that provides a way to unlock your data and free it from silos that exist in applications today. OData does this by applying and building upon Web technologies such as HTTP, Atom Publishing Protocol (AtomPub) and JSON to provide access to information from a variety of applications, services, and stores. OData is being used to expose and access information from a variety of sources including, but not limited to, relational databases, file systems, content management systems and traditional Web sites. The protocol allows for a consumer to query a datasource over the HTTP protocol and get the result back in formats like Atom, JSON or plain XML, including pagination, ordering or filtering of the data. OData is released under the Open Specification Promise to allow anyone to freely interoperate with OData implementations.

OData Producers & Services

imageOData producers are services that expose their data using the OData protocol. You can find some of the odata producers listed at Some of the interesting Live OData Services listed are:

  • Facebook: An OData Service for consuming Facebook Insights data - LINK
  • Netflix: The complete netflix catalog title via OData. See the Netflix developer OData documentation for more information - LINK
  • Northwind: The famous Northwind Database exposed as an OData Service - LINK
  • PowerPivot: PowerPivot for Excel is a data analysis tool that delivers unmatched computational power directly within the application users already know and love—Microsoft Excel. It’s the user-friendly way to perform data analysis using familiar Excel features you already know, such as the Office Fluent user interface, PivotTable and, PivotChart views, and slicers. It’s the fast way to generate rich and interactive analysis tools, easily mistaken for IT solutions after weeks of effort. It’s the right way to achieve deeper business insight and shorter decision cycles. More about PowerPivot (and download it)

Connecting to Netflix Data using Excel and PowerPivot

As an experiment, I decided to connect to the Netflix OData source to analyze the Netflix catalog in Excel. The PowerPivot Addin for Excel has OData support built in. I used the From Data Feeds Option in PowerPivot to Import data from Netflix. The data feed Url I used was


It imported over 155K titles, over 190K people information into the PowerPivot tables. And there it is. I can now work with Pivottables and analyze the data. I can potentially import other data and do some correlation.


Shish is Director of BI Solutions for Microsoft’s Worldwide Industry Group.

<Return to section navigation list> 

Windows Azure AppFabric: Access Control, WIF and Service Bus

Scott Densmore (@scottdensmore) posted Windows Azure AppFabric Caching Tip - Use the applicationName attribute on 6/17/2011:

image We are working on updates to our Developing Applications for the Cloud content. In the first version we used a feature from MVC Futures to simulate View State in our code so we didn't have to deal with Session in the application. Now with the release of AppFabric Caching as a Session provider, we are switching our code to use this. At first we found the following:

"The Session State providers use the IIS Site Name to identify individual web applications to avoid sharing session state between different apps. And this is where you have a distinct difference between your local compute emulator and a live deployment.

image72232222222In the production environment, all of your web roles will host your application under the same Site Name on the different instances. In your emulator, on the other hand, all needs to be handled by one IIS Server, so you end up with different Site Names for each instance.

So, in essence, you won’t be able to test session state management with multiple web role instances on your compute emulator."

This wasn't a very good answer.

What we found is that adding in the optional applicationName element overrides the use of the IIS Site Name, so it works correctly both in the Compute Emulator and in the cloud.

<sessionState mode="Custom" customProvider="AppFabricCacheSessionStoreProvider">
<add name="AppFabricCacheSessionStoreProvider"
type="Microsoft.Web.DistributedCache.DistributedCacheSessionStateStoreProvider, Microsoft.Web.DistributedCache"
dataCacheClientName="default" />

The Windows Azure AppFabric Team reported Updates to Windows Azure AppFabric SDK available for download in a 6/17/2011 post:

image72232222222An update to the Windows Azure AppFabric SDK is available for download. The updated SDK introduces fixes to a few bugs related to the Caching service. You can find more details on the bugs it addresses here.

If you are not experiencing any of the issues the updated SDK solves there is no need to install the updated SDK. You can download the updated SDK here.

Note: This is the production environment SDK, not the SDK used to develop for the LABS/Previews environment.

As always, feel free to ask questions and provide us with feedback on the Windows Azure Platform Forums.

<Return to section navigation list> 

Windows Azure VM Role, Virtual Network, Connect, RDP and CDN

imageNo significant articles today.

<Return to section navigation list> 

Live Windows Azure Apps, APIs, Tools and Test Harnesses

The Windows Azure Team posted a Real World Windows Azure: Interview with Dario Solera, Cofounder of Threeplicate case study on 6/17/2011:

As part of the Real World Windows Azure series, we talked to Dario Solera, Cofounder of Threeplicate, about using the Windows Azure platform to deliver two applications. Here’s what he had to say:

MSDN: Tell us about Threeplicate and the applications you offer.

Solera: We started Threeplicate in January 2010. We’re a team of three based in Milan, Italy, and we set out to deliver two products. The first, Amanuens, is a software-as-a-service offering built on the Windows Azure platform that helps software companies localize products into multiple languages. The second product, ScrewTurn Wiki, is an open-source application that helps users create, manage, and share wikis. At the end of 2010, we were registering an average of 10,000 downloads of ScrewTurn Wiki per month. In the past year, Microsoft has helped us by making the application available through the Windows Web Application Gallery and, more recently, through Microsoft WebMatrix. These sites are the source of more than 25 percent of downloads.

MSDN: Tell us about Amanuens.

Amanuens makes localization easier and cheaper. Localization has traditionally consumed a lot of time and manpower. With Amanuens, software developers get the benefits of localization without having to take on the burdens and potential for error that usually come with it. Our solution connects directly to a source code repository to retrieve resource files. Once those files are identified, software developers can assign the localization duties to a translator or use our professional translation services. Once translation is completed, Amanuens pushes the confirmed material back into the source code repository without any manual intervention. The system is designed to make localization management as unobtrusive as possible.

MSDN: Who are the customers for Amanuens?

Amanuens is targeted at small and midsize independent software vendors who want to globalize their products (or are already doing it). But even individual mobile application developers and large enterprise developers can make use of the solution because it makes software localization a breeze.

MSDN: Why did you deploy Amanuens in the cloud?

We needed to achieve scalability right from the start. The solution has a web-based interface but it frequently runs background tasks that may take many minutes—or even hours—to complete. In designing and developing Amanuens, it was essential that we be able to get flexible computing power.

MSDN: How does Amanuens work with the Windows Azure platform?

imageAmanuens has a web-based interface that runs within a web role. Plus, it executes asynchronous tasks in the background. All data is stored in Windows Azure Table Storage and Windows Azure Blob Storage. We use the queue to schedule time-consuming tasks. We rely on the platform’s ability to run ASP.NET applications seamlessly and launch custom-built and third-party command-line tools.

Amanuens web-based interface that runs within a web role and frequently runs background tasks makes the localization process as unobtrusive as possible.

MSDN: Is ScrewTurn Wiki available in the cloud?

Solera: We have been working with Lokad—a company that provides forecasting software for sales, demand, and call volumes—to migrate its instance of ScrewTurn Wiki to the Windows Azure platform. They build impressive cloud-based forecasting tools and are big fans of both Windows Azure and our product. For now, this migration is a pilot program, but we are working to make ScrewTurn Wiki fully compatible with Windows Azure.

MSDN: What challenges did you face that made you decide to use cloud computing and the Windows Azure platform?

Solera: For the time being, users have to install ScrewTurn Wiki on their own servers. That’s the first problem. We have an extremely simple setup procedure, but there are many things that can go wrong because of the variety of systems and configurations on different companies’ servers. By deploying the product on the Windows Azure platform, we would make setup easy because the environment is totally controlled and defined.

MSDN: How does ScrewTurn Wiki work with the Windows Azure platform?

Solera: It’s very simple. ScrewTurn Wiki supports storing data in plain text files. We decided to create a Windows Azure drive and use it for storage; all storage requests are directed to the drive rather than to the local file system. By this means, the application requires very limited customization. We plan to have ScrewTurn Wiki fully compatible, and redesigned for scalability, with the Windows Azure platform by June 2011.

MSDN: What tools did you use to port ScrewTurn Wiki to Windows Azure?

Solera: We wanted a solution that would allow us to update the application as soon as new releases are available. We created a build script that downloads from our website, adds the required data files, and configures the Windows Azure deployment package. This porting happens with a single step and with zero changes to ScrewTurn Wiki.

MSDN: Did you look at any competitors in the cloud computing space?

Solera: Of course. However, we develop our products using the Microsoft .NET Framework, a software framework that supports several programming languages and is compatible with Windows Azure, so using Microsoft cloud computing is a natural choice for us.

MSDN: What are the benefits of using Windows Azure?

Solera: Besides the obvious benefit of dynamic scalability, Windows Azure abstracts all the problems that would normally arise from managing multiple dedicated servers. You don’t have to worry about keeping operating systems updated or propagating configuration changes across multiple machines. You can focus on the business logic rather than the boilerplate code.

ScrewTurn Wiki allows users to create, manage, and share wikis. It’s based on Microsoft ASP.NET 3.5.

To read more Windows Azure customer success stories, visit:

Joel Foreman posted Windows Azure Fundamentals: Where To Begin to the Slalom Consulting blog on 6/17/2011:

A self guided half-day introduction

image There is a ton of information available today about Windows Azure.  The sources are endless: MSDN, TechNet, Channel9, CodePlex, Blogs, Tweets, WhitePapers, Labs, Kits, SDKs, etc.  The question of where to start gets more and more relevant with the amount of information out there.  Therefore, I have provided some of the materials I think are worthy of the first look.

imageThese recommendations are based upon one goal: learn as much about Windows Azure as possible in a half day’s time across articles, whitepapers, videos, and labs.  There are extensive learning opportunities beyond these, but hopefully this provides a good place to start.


image The Windows Azure Platform Training Kit has some nice material for learning Windows Azure. We will be leveraging pieces of it. Before you begin your exploration of Windows Azure, download and install the kit. Make sure to have the pre-requisites installed. You can use the dependency checker that comes with the kit to help with this.

Section 1: Articles

This section should take about 30 minutes.

Section 2: White Papers

This section should take about an hour, and will go into the topics of the articles above in more detail.

Section 3: Videos

This section should take between 1 and 2 hours.

- AND/OR -

Check out these short videos in the Windows Azure Platform Training Kit

  • What is Windows Azure (6 min)
  • Windows Azure Storage Overview (7 min)
  • Deploying Applications on Windows Azure (13 min)
  • Windows Azure Compute (9 min)

Section 4: Hands-On Labs

This section should take about 2 hours.

The following labs can be found in the Labs portion of the training kit and are recommended as a starting point:

  • Building ASP.NET Applications with Windows Azure: Exercise 1: Moving a Web Application to the Cloud
  • Exploring Windows Azure Storage: Exercise 2: Working with BLOBs
  • Exploring Windows Azure Storage: Exercise 3: Working with Queues

I hope you find these materials helpful.  In a future post I will provide some recommendations for Windows Azure AppFabric and SQL Azure.

Nuno Filipe Godinho recommended Things to take into account when you deliver applications for Connected Devices – Windows Azure to the rescue on 6/16/2011:

image Currently one very important space is the development of Applications for Connected Devices like Windows Phones, Windows Slates and so on.

One important elements is that we are currently going more and more to Wireless, and so it’s important to understand the current state of the art on Wireless.

imageAccording to AT&T “We will deliver as much data over our network in the first 5 weeks of 2015 as we did all year in 2010”.

Also currently there are several identified congestion factors that are affecting Wireless, like:

  • More subscribers with smartphones consuming data, uploading and downloading photos and videos
  • Spectrum + cell towers + antennas + home users
  • Mobile Operator bandwidth caps
  • Latency of all communications between the server and the destination device, passing by the Cell Towers, Backhaul network, internet, firewalls and so on

And so having this is mint, it’s really important to understand that we as developers cannot continue thinking that we’re going to continue developing our apps and services the same way, without thinking about these network related topics, because this will affect greatly the User Experience of our Solutions. And one important note is that UX is not only related to the User Interface (UI), like some developers try to think, it’s more then that. It’s really about having a great experience while using our applications.

So in order to do great applications for connected devices, and support millions of those devices, we need to think about scale.

Some examples of how we can scale our applications are:

  • Making Database that almost nobody touches, since we really shouldn’t let every single device connect and work on our databases, instead we should really be doing multi-tier application to abstract those devices from the Database, and by doing that we are reducing the stress of our databases and at the same time enabling the possibility of scaling the services that really give us access to our data
  • Place thousands of Web Servers on commodity hardware, by scaling out their app
  • Replicate Data
  • Scale horizontally
  • Use NoSQL databases at the edge
  • Shard our data using small tables for fast access
  • Place Load-Balancing at every tier
  • Use Hundreds of terabytes of data in an in-RAM distributed cache (For example Facebook uses MemCache and has something like 300 TB of data in memcache)
  • Use pre-compile elements, since compiling slow (For example Facebook uses PHP because they think that is very productive for them, but it didn’t work very well in terms of compiling, so they made a team to create a PHP to C++ compiler in order to get more performance)
  • use MapReduce pattern for parallel analysis of “Big Data”

Some of the apps that are doing this are, Bing, Facebook, Twitter, Google, Zynga, and so on.

So how in order to achieve that kind of scale we have Windows Azure. But what should we do to take the best out of Windows Azure for Connected Devices?

  • Scale-out. This is easy in Windows Azure, because we can define the number of instance we want of a particular role
  • SQL Azure should be never touched by the Devices. Instead we should use:
    • In terms of Outbound Data - Worker roles that replicate outbound data from SQL Azure to NoSQL Azure Table Storage
    • In terms of inbound Data - Worker Role move inbound data from Azure queues to SQL Azure
  • Use Distributed caching, that in Windows Azure is handled by AppFabric Caching
  • Do wireless efficient Services. For example using Web Roles that expose REST + JSON WCF Services is very interesting, because it saves message size, and by doing so saves time and money
  • Also important is making our devices cache data and work on it offline. Not every thing should be made “live” and on top of “live” data. Don’t stress the wireless connection

I hope this helps you think better about your Connected Device Apps.

David Riddell McGhee reported Windows #Azure HPC Burst training course now online on 6/15/2011 to his Team Individualism blog:

If you are familiar with Windows HPC Server 2008 R2, and wish to learn how to use the Azure burst scenario, the training kit for you is now online. Details covered in this course are described in the article Windows HPC with Burst to Windows Azure: Application Models and Data Considerations.

imageThere are three primary burst models that are in the current training:

Parametric Sweep


Parametric sweep provides a straightforward development path for solving delightfully parallel problems on a cluster (sometimes referred to as "embarrassingly parallel" problems, which have no data interdependencies or shared state precluding linear scaling through parallelization). For example, prime numbers calculation for a large range of numbers. Parametric sweep applications run multiple instances of the same program on different sets of input data, stored in a series of indexed storage items, such as files on disk or rows in a database table. Each instance of a parametric sweep application runs as a separate task, and many such tasks can execute concurrently, depending on the amount of available cluster resources.



Service-oriented architecture (SOA) is an architectural style designed for building distributed systems. The SOA actors are services: independent software packages that expose their functionality by receiving data (requests) and returning data (responses). SOA is designed to support the distribution of an application across computers and networks, which makes it a natural candidate for scaling on a cluster. The SOA support provided by Windows HPC Server 2008 R2 is based on Windows Communication Foundation (WCF), a .NET framework for building distributed applications. Windows HPC Server 2008 R2 SP1 improves SOA support by hosting WCF services inside Windows Azure nodes, in addition to on-premises nodes.

Excel Offloading


The execution of compute intensive Microsoft Excel workbooks with independent calculations can be sometimes scaled using a cluster. The Windows HPC Server 2008 R2 SP1 integration with Windows Azure supports User Defined Functions (UDFs) offloading. Excel workbook calculations that are based on UDFs defined in an XLL file can be installed on the cluster’s nodes (on-premises and/or Windows Azure nodes). With the XLL installed on the cluster, the user can perform the UDF calls remotely on the cluster instead of locally on the machine where the Excel workbook is open.

Other links:

Excel specific:

Ben Lobaugh (@benlobaugh) described Scaling PHP Applications on Windows Azure Part III: Performance Monitor in a 6/14/2011 post to the Interoperability Bridges blog:

imageRecommended pre-read


imageThis is part III in a series of articles on scaling PHP applications on Windows Azure. I will be picking up from where I left off at the end of part II of this series. If you have not read parts I and II already I highly encourage you to do so as the referenced code has been built through each article in the series.

In this article I will show you how to build the performance monitor portion of this project. The performance monitor will be a PHP script that monitors the resource usage of a Windows Azure deployment and scales in or out according to need.

New values for setup.php

There is a new value we need to place in our setup.php file for this portion of the tutorial to work properly.

Open your setup.php and add the following:

define('AZURE_WEBROLE_END', '<YOUR WEB ROLE ENDPOINT>'); // Web Endpoint

This defines the endpoint for your web role. It is the name you chose when you created your hosting account. Save that file and let's get cracking on the monitor code.

Initial monitor setup

Before we dig in too deep lets create a new file that will run our performance monitor. Create a new file named monitor.php with the following content:



That is all for now. As you follow along this tutorial place all the new code we create in this file. Later we will look at rolling the performance monitoring code into a separate worker role that will continually monitor our performance metrics and automatically scale accordingly.

Retrieving Performance Metrics over time

We want to retrieve our performance metrics over a period of time so we can create charts, calculate averages, and make predictions. In part I of this series you learned how to subscribe to various performance metrics. These metrics are stored in the "WADPerformanceCountersTable". Windows Azure makes it very easy to retrieve performance metrics starting from a specific time with the table's partition key.

Handling C# DateTime.Ticks in PHP

The partition key is stored as a C# DateTime.Ticks timestamp based on when the metric was entered into the table. C# DateTime.Ticks have a resolution of nano seconds, however PHP's datetime functionality only handles down to microsecond. The conversion is not difficult; however we are going to use a pre-built library that already contains the functions we need.

Download C# DateTime.Ticks to Unix timestamp convertor from github

This library provides us with the following functions

  • ticks_to_time()
  • time_to_ticks()
  • str_to_ticks()

For an in-depth explanation of this issue see the article Converting DateTime.Ticks to a Unix timestamp and back in PHP

A note on Performance Metrics gathering

When we setup our performance metrics subscription in part I of this series we specified an interval of one minute between times when Windows Azure transfers our performance metrics to table storage. There are a couple of items to take note of here:

  • Performance metrics may be gathered more often than one minute and queued to be inserted into the WADPerformanceCountersTable
  • Performance metrics are scheduled to be written each minute but may not be in the table every minute, on the minute.

The first point is important to know, however the second point is critical. When your metrics are scheduled to be inserted into the table Windows Azure will queue a write operation. This write operation gathers the metrics you are subscribed to and that are not yet in the table and inserts them into the table. This insertion operation may actually cause the metrics to be written after the minute has passed. It is therefore not always safe to check back only to a range of one minute. The performance monitor may encounter errors or behave in an unexpected manner if the metrics are not available when requested. During my testing I found that three minutes will usually give back decent results, however an interval of five minutes has never failed to give back results. The interval used by your application will vary based on known and anticipated loads, and how your application responds to increased load.

Get the metrics

Now let's finally get some of the metrics from storage so we can finish building our performance monitor! The following function will retrieve the metrics for us over a given period of time.

function get_metrics($deployment_id, $ago = "-15 minutes") {

global $table;

// get DateTime.Ticks in past

$ago = str_to_ticks($ago);

// build query

$filter = "DeploymentId eq '$deployment_id' and Role eq 'WebRole' and PartitionKey gt '0$ago'";


// run query

$metrics = $table->retrieveEntities('WADPerformanceCountersTable', $filter);

$arr = array();

foreach ($metrics AS $m) {

// Global totals

$arr['totals'][$m->countername]['count'] = (!isset($arr['totals'][$m->countername]['count'])) ? 1 : $arr['totals'][$m->countername]['count'] + 1;

$arr['totals'][$m->countername]['total'] = (!isset($arr['totals'][$m->countername]['total'])) ? $m->countervalue : $arr['totals'][$m->countername]['total'] + $m->countervalue;

$arr['totals'][$m->countername]['average'] = (!isset($arr['totals'][$m->countername]['average'])) ? $m->countervalue : $arr['totals'][$m->countername]['total'] / $arr['totals'][$m->countername]['count'];

// Totals by instance

$arr[$m->roleinstance][$m->countername]['count'] = (!isset($arr[$m->roleinstance][$m->countername]['count'])) ? 1 : $arr[$m->roleinstance][$m->countername]['count'] + 1;

$arr[$m->roleinstance][$m->countername]['total'] = (!isset($arr[$m->roleinstance][$m->countername]['total'])) ? $m->countervalue : $arr[$m->roleinstance][$m->countername]['total'] + $m->countervalue;

$arr[$m->roleinstance][$m->countername]['average'] = (!isset($arr[$m->roleinstance][$m->countername]['average'])) ? $m->countervalue : ($arr[$m->roleinstance][$m->countername]['total'] / $arr[$m->roleinstance][$m->countername]['count']);


return $arr;


The array returned by this function contains an array of totals for all instances as well as totals for each individual instance. For now we are going to only look at the total average number of TCPv4 connections, which can be accessed via:

$metrics['totals']['\TCPv4\Connections Established']['average']

Scale Check

Please take note that in this article I will be showing you how to scale based on performance metrics from the number of TCPv4 connections established. This is a very simplistic way of determining when to scale and probably only one facet of what you will want to implement in your production applications.

For more in-depth information on the additional scaling features in Windows Azure see the additional reading links near the end of this article.

To make the code a little cleaner let's create a scale_check function. This function will return

  • 0 if no scaling is needed
  • 1 if more instances are needed
  • -1 if less instances are needed

When we call this function we will do it from the context of a switch statement that will handle the return values for us.

function scale_check($metrics) {

$ret = 0;

if(120 > $metrics['totals']['\TCPv4\Connections Established']['average']) {

$ret = 1;

} else if(20 > $metrics['totals']['\TCPv4\Connections Established']['average']) {

$ret = -1;


return $ret;


Note: The numbers (120 and 20) here are representative only. You will need to test your application to determine how many connections it can handle before needing to scale.

The switch statement is going to do the actual work of scaling for us. It will utilize the values passed back from scale_check() to determine our scaling needs.

switch (scale_check($metrics)) {

case 1:

// Add an instance

echo "Scaling Out";

$client->setInstanceCountBySlot(AZURE_WEBROLE_END, 'production', 'WebRole', get_num_roles('WebRole') + 1);


case 0:

// Do no add/remove an instances

echo "Perfomance within acceptable range";


case -1:

// Remove an instance

echo "Scaling in";

$client->setInstanceCountBySlot(AZURE_WEBROLE_END, 'production', 'WebRole', get_num_roles('WebRole') - 1);



Additional Code

Here are two additional functions that I like to use because it allows my application to be a bit more dynamic, instead of hard coding in values or hoping that a process does not die and cause a loss of information. Please be aware that the functions make calls to you Windows Azure account and therefore will increase the response time accordingly. In general speed should not be an issue.

The first function will pull the currently running deployment information and return the deployment id for you.

function get_deployment_id() {

global $client;

$s = $client->getDeploymentBySlot(AZURE_WEBROLE_END, 'production');

return $s->PrivateId;


When adding or removing instances you must specify the total number of instances that you want running. Instead of keeping a variable in memory that could easily loose it's value, it is possible to determine the number of currently running roles via the deployment information that can be retrieved. The following function does just that based on the name of the role you wish to calculate.

function get_num_roles($roleName) {

global $client;

$ret = 0;

$is_role = false;

$s = $client->getDeploymentBySlot(AZURE_WEBROLE_END, 'production');

$xml = new SimpleXMLElement(mb_convert_encoding($s->configuration, "UTF-16"));

foreach($xml->Role as $r) {

foreach($r->attributes() as $a=>$b) {

if($a == 'name' && $b == $roleName) $is_role = true;


foreach($r->Instances->attributes() as $a=>$b) {

if($is_role) return $b;




Add both of those functions to your monitor.php file and your performance monitor for this article should be complete. After you have all the new code in monitor.php, rebuild your app and navigate to the monitor.php page in your browser and you should see the result of your scaling operations.

Wrap Up

In part IV of this series I will show you how to wrap everything you have learned in the first 3 parts of this series into a Windows Azure Worker Role that will sit in the background monitoring your performance and automatically scaling your web role according to the scaling triggers that you use for your application.

Additional Reading

Designing scalable applications

What's Next?

 Ben Lobaugh (@benlobaugh) explained Scaling PHP applications on Windows Azure Part IV: Using worker roles for automated scaling in a 6/14/2011 post to the Interoperability Bridges blog:

imageRecommended pre-read


imageThis is part IV in a series of articles on scaling PHP application on Windows Azure. I will be picking up where I left off at the end of part II of this series. If you have not read parts I, II, and III I highly encourages you to do so as the referenced code has been built through each article in the series.

In this article I will show you how to roll all the code we previously created to monitor and scale our Windows Azure deployment into a worker role. This worker role will sit behind our web role constantly monitoring the performance metrics of the application running in or web role. When scaling thresholds are met the worker role will handle automatically adding and removing instances.

A Word of Caution!

Windows Azure charges you according to the number of instances and hours running. Whenever you are using any tool to automatically scale your instances up you should always set an upper limit to the number of instances that you are willing to pay for. If a malicious user triggers your scaling out code without an upper limit on the number of instances it could wind up costing many more dollars than you intended.

Some Reorganization

You have probably noticed that up until now we have been working out of the Web folder only. In this article we will begin using the Worker folder, but that requires some reorganization of our files. Moving these files also has the added benefit of added security as the certificate will now be hidden inside the Worker with no access from the outside world.

After your reorganization the file structure should look like the following:

  • Web
    • index.php
    • metrics.php
    • setup.php
    • view_all_metrics.php
  • Worker
    • monitor.php - Moved
    • setup.php - Copied
    • ticks_to_time.php - Moved
    • your_certificate.pem - Moved
    • worker.php

From this point forward we will be working inside the Worker folder and it should be assumed that all files referenced or created will be there unless noted otherwise.

Additions to setup.php

Open your setup.php file. The file should be a duplicate of what you have in the setup.php in the Web directory. At first it is tempting to assume there is a redundancy that can be easily eliminated by simply moving the setup.php up one directory and referencing it there in both the Web and Worker roles, however both roles are entirely separate and when your project is running they will not have access to the resources inside each other or in the main project folder.

As mentioned previously, we want to setup the maximum number of instances we are willing to have running. Also we are going to set the minimum number of instances. If we do not have a minimum number of instances it is possible that when the lower threshold is triggered the performance monitor could scale so low as to remove all running web roles. Not a good thing! The minimum number of instances you need to keep running at all times will be dependent upon your specific application, however it should be noted that 2 instances is the minimum to ensure SLA coverage. We will use 2 in this article.

define('MIN_WEBROLES', 2); 

define('MAX_WEBROLES', 20);

Let's also add a setting for how long the worker loop should pause between scaling checks in seconds. Set this at a reasonable. Windows Azure charges for the number of connections and also has a limit on how many connections can be handled per second.

define('LOOP_PAUSE', 10); // in seconds

The Worker

Because a worker does not provide public access to its files we will need to tell Windows Azure to run a file for us when the worker is initialized. This file is worker.php and we will be putting the logic for our worker in it.


As with every other file we have created we first must include the setup.php file. Your new file should currently look like the following:




The Loop

The Loop is the most important aspect of our worker. After deployment Windows Azure will only call our worker.php file once so in order to ensure that we are able to continuously run the performance monitoring code we must create an infinite loop. This loop needs to pause so we do not overwhelm our application and also because the performance counters are not continuous it does not make much sense to constantly poll the counters.

The loop itself is quite simple, what is put into it may be quite complex:

while(1) {

// performance monitoring code goes here

sleep(LOOP_PAUSE); // this should be the last line in the loop


The functions

The functions we created in monitor.php in part III of this series I am going to copy into the worker.php file. The following function should be copied:

  • get_deployment_id
  • get_metrics
  • get_num_roles
  • scale_check
The Logic

The logic we created in the monitor.php file can be copied and used without change. Copy the code into The Loop and you should wind up with the following.

while(1) {

$metrics = (get_metrics(get_deployment_id()));

$num_roles = get_num_roles('WebRole');

// check to see if we need to scale and scale accordingly

switch (scale_check($metrics)) {

case 1:

// Add an instance

if($num_roles < MAX_WEBROLES)

$client->setInstanceCountBySlot(AZURE_WEBROLE_END, 'production', 'WebRole', $num_roles + 1);


case 0:

// Do no add/remove an instances


case -1:

// Remove an instance

if($num_roles > MIN_WEBROLES)

$client->setInstanceCountBySlot(AZURE_WEBROLE_END, 'production', 'WebRole', $num_roles - 1);



sleep(LOOP_PAUSE); // This should be the last line in the loop


It should be noted here that I have removed all the echo statements. You will be unable to view the output of any echo calls since the worker role does not have any sort of interface with which you can view your application.

Creating the package

Note: As of the writing of this tutorial I am using the May 23 2011 release of the Windows Azure Command Line Tools for PHP. A significantly revised version of the tools is set to be released in the near future. This article will be updated to reflect those changes when the new tool is available.

Because we are not creating a package for just a web role the build process is a little more complex. There are two more parameters you must provide package.php with during the build process:

  • --worker-role-startup-script - This is the file Windows Azure will call when the worker role has deployed
  • --worker-role - This is the folder containing the files to be packaged for the worker role.

During the development of this article I used the following command which you can adapt to your specific scenario:

php.exe package.php --source="C:\Projects\scaling_demo\Web" --project="Scaling Demo" --runDevFabric -f --target="C:\Projects\scaling_demo\deploy" --worker-role-startup-script="worker.php" --worker-role="C:\Projects\scaling_demo\Worker"

After you run this command and upload the package files to your Windows Azure account you should see two roles running, WebRole and WorkerRole. With the Portal open to your deployment for reference, generate many connections to your web role. When the connection threshold is reached you should see your deployment going into "Updating" status in the Portal and in a few minutes a new instance of your web role will be running and helping to process the increased load. Continue to place a load of connections on your web role and you should see as many instances spin up as needed until the upper limit of running instances is reached.

Because I always use the same structure for my Windows Azure PHP projects I have developed a nice build script that takes care of a lot of the overhead for me. If you build packages often it might be worth taking the time to create a build script instead of remembering and typing all the package parameters. My build script is available for reference in a blog post here.

Wrap Up

Now that you successfully made it through this series you should be equipped with the tools you need to begin writing PHP application that scale on Windows Azure! As you are building your next million dollar application be sure to browse through the Windows Azure PHP website and consult with the many great articles on scalable architecture available on MSDN.

Additional Reading

Designing scalable applications
Useful Blogs

The Microsoft Case Study team posted Software Vendor [Synscape] Expands Computational Fluid Dynamics Reach by Adding Cloud on 6/7/2011 (missed when posted):

image Symscape, a developer of computational fluid dynamics (CFD) software, wanted to expand its customer base by making its CFD system even more affordable. The company used “burst to Windows Azure” functionality as part of the Windows HPC Server 2008 R2 SP1 operating system to offer nearly instantaneous scalability without significant up-front costs, making it possible for smaller manufacturing organizations to take advantage of CFD capabilities.

Business Needs
The Symscape tagline says it all: “Computational fluid dynamics for all.” The company makes computational fluid dynamics (CFD) software solutions available to businesses that were previously excluded from using CFD capabilities, due to the complexity and expense of the software necessary for most CFD computations.

Symscape built its flagship product, Caedium Professional, using OpenFOAM®, a set of open source tools for customizing and extending numerical solvers for continuum mechanics problems such as CFD. Caedium is a graphical user interface–driven integrated simulation environment that helps engineers test their designs by creating geometry, simulating fluid flow and heat transfer, and visualizing results.

The company wanted a way to further reduce the up-front hardware costs associated with Caedium adoption because the costs presented barriers for many small to medium-sized manufacturing organizations. To conduct timely CFD simulations that involve large data sets, companies had to invest in powerful individual computers or a high-performance computing (HPC) cluster. “Smaller firms may not have the best equipment to run CFD simulations and often cannot afford hardware upgrades,” says Dr. Richard Smith, Principal of Symscape. “We wanted to help small, innovative firms use Caedium and CFD without those capital expenses.”

Symscape also wanted to make it faster and easier for customers to scale up compute resources. “In the past, engineers had to either wait for adequate cluster resources to become available or procure additional computers,” says Smith. “That took valuable time or money—or, in some cases, both.”

Symscape had a version of Caedium that ran on the Windows HPC Server 2008 R2 operating system, and it also had produced a prototype solution that used the Windows Azure platform to connect cloud computing to Caedium. When the opportunity arose to develop a solution that combined the power of the two platforms, Symscape jumped at the chance. The company took part in a pilot project to test a “burst to Windows Azure” scenario, in which an on-premises Windows HPC Server 2008 R2 SP1 cluster quickly adds Windows Azure worker roles to its compute resources.

image“It’s natural for Windows HPC Server 2008 R2 and Windows Azure to go together,” says Smith. “From a business perspective, we see the burst scenario as a straightforward way to offer Windows Azure as an extension of Windows HPC Server 2008, without having to manage complicated customer billings.” Symscape has set up a model in which customers subscribe to Windows Azure and pay only for the hardware resources they use, with no additional software charges.

When engineers want to take advantage of Windows Azure worker roles, they can build a computational fluid dynamics model in Caedium, which will automatically prepare a file in a temporary directory that is referenced in a command to run a job on Windows HPC Server 2008 R2 SP1. The case directory is compressed into a .zip archive and uploaded with encryption to Windows Azure Blob Storage. The amount of data that will be uploaded to Windows Azure depends on each engineer’s specific simulation requirements and will likely range from four megabytes (100,000 cells) to four gigabytes (100,000,000 cells), although Symscape has tested up to 25 megabytes (600,000 cells). After the CFD processing takes place, the job status information and results are compressed into another .zip archive for automated on-premises retrieval.

Symscape plans to release the next version of Caedium, with Windows Azure capabilities, by July 2011. This version will give customers a choice between two processing scenarios. Customers with a Windows HPC Server 2008 R2 SP1 on-premises cluster can use burst functionality to scale compute capacity up and down as needed. Those without an on-premises cluster infrastructure can install Windows HPC Server 2008 R2 SP1 on a head node only and conduct all processing on Windows Azure worker roles.

image Symscape believes that enabling Caedium to burst to Windows Azure will help support the company’s mission of extending computational fluid dynamics availability to all. The company expects that the solution enhancement will increase profitability and raise its profile in the industry. “By taking advantage of Windows Azure integration and offering an HPC/cloud hybrid solution, we are putting ourselves at the forefront of cloud-based CFD,” says Smith. Benefits include:

  • Immediate scalability. By bursting to Windows Azure, Symscape customers will be able to immediately conduct their simulation work, without waiting for others’ jobs to finish or for additional hardware to be procured. “It will be a major boost for our customers to be able to access the compute resources that they need, when they need them,” says Smith.
  • Expanded CFD use. For Symscape, offering the new functionality makes CFD accessible to engineers who previously had limited means of using it to improve their designs. “Customers will be able to burst to Windows Azure to make the most of HPC and CFD without all the constraints of the past,” says Smith. “This new Caedium release is far more flexible and gives more engineers the opportunity to perform higher-fidelity CFD simulations to improve their products and processes.”
  • Increased profitability. Symscape anticipates a significant uptick in the size of its customer base because the affordable, pay-as-you-go approach of Windows Azure presents a cost-effective way for new companies to enter the market for CFD solutions. “We feel ‘bursting’ to Windows Azure is a strategic move that opens up doors for us to put our tools into the hands of businesses that can benefit from CFD capabilities but have struggled to get them,” says Smith. “As our number of customers grows, we become a healthier, more profitable company.”

For more information about other Microsoft customer successes, please visit:

For additional background on computational fluid dynamics (CFD), see Pointwise’s Another Fine Mesh blog and its This Week in CFD column.

<Return to section navigation list> 

Visual Studio LightSwitch

image222422222222No significant articles today.


Return to section navigation list> 

Windows Azure Infrastructure and DevOps

Byung Chul Tak, Bhuvan Urgaonkar and Anand Sivasubramaniam published their To Move or Not To Move: The Economics of Cloud Computing technical report in March 2011 (missed when published). From the Abstract and Introduction:

Cloud-based hosting promises cost advantages over conventional in-house (on-premise) application deployment. One important question when considering a move to the cloud is whether it makes sense for ‘my’ application to migrate to the cloud. This question is challenging to answer due to following reasons. Although many potential benefits of migrating to the cloud can be enumerated, some benefits may not apply to my application. Also, there can be multiple ways in which an application might make use of the facilities offered by cloud providers. Answering these questions requires an in-depth understanding of the cost
implications of all the possible choices specific to ‘my’ circumstances.

In this study, we identify an initial set of key factors affecting the costs of a deployment choice. Using benchmarks representing two different applications (TPC-W and TPC-E) we investigate the evolution of costs for different deployment choices. We show that application characteristics such as workload intensity, growth rate, storage capacity and software licensing costs produce complex combined effect on overall costs. We also discuss issues regarding workload variance and horizontal partitioning.

1 Introduction
Cloud-based hosting promises several advantages over conventional in-house (on-premise) application deployment.

  1. First, it claims to offer ease-of-management (although arguments against this have also been made [7]): since the cloud provider assumes management-related responsibilities involving procurement, upgrades, maintenance of hardware/software and supporting infrastructure, the customer is relieved of this burden and can focus on its core expertise.
  2. Second, it offers Cap-ex savings: cloud-based hosting eliminates the need for commitment in the purchase of IT equipment and other infrastructure; this may translate into a lowering the business entry barrier for some organizations.
  3. Third, it offers Op-ex reduction: this occurs due to the elimination of the need to pay for administrator salaries, utility electricity bills, real-estate rents/mortgages, etc. One aspect of Op-ex savings that is highly touted is that this model can allow a customer’s Op-ex to closely match its evolving resource needs (via usage-based charging) as opposed to being dictated by its worst-case needs (for which an in-house solution must provision).

The quintessential question when considering a move to the cloud is: should I migrate my application to the cloud? Whereas there have been several studies into this question, there is no consensus yet on whether the cost of cloud-based hosting is attractive enough compared to in-house hosting [19]. There are several aspects to this basic question that must be considered.

  1. First, although many potential benefits of migrating to the cloud can be enumerated for the general case, some benefits may not apply to my application. For example, benefits related to lowered entry barrier may not apply as much to an organization with a pre-existing infrastructural and administrative base. As another example, the benefits of pay-per-use are less attractive for a well-provisioned application whose workload does not vary much.
  2. Second, there can be multiple ways in which an application might make use of the facilities offered by a cloud provider. For example, using the cloud need not preclude a continued use of the in-house infrastructure. The most cost-effective approach for an organization might, in fact, involve a combination of cloud and in-house resources rather than choosing one over the other.
  3. Third, not all elements of the overall cost consideration may be equally easy to quantify. For example, the hardware resource needs and associated costs may be reasonably straightforward to estimate and compare across different hosting options. On the other hand, labor costs may be  significantly more complicated: e.g., how should the overall administrators’ salaries in an organization be apportioned among various applications that they manage? As another example, in a cloud-based hosting, how much effort and cost is involved in migrating an application to the cloud?

Answering these questions requires an in-depth understanding of the cost implications of all the possible choices specific to my circumstances. Given that these answers can vary widely across applications, organizations, and cloud providers, we believe the best way is to explore various applications case-by-case in an attempt to draw generalities or useful rules-of-thumb.

Research Contributions. We make the following contributions towards answering the questions posed above:

  • Identification and Classification of Cost Contributors: We identify a comprehensive set of factors affecting the costs of a deployement choice (in-house, cloud, and combinations). We classify these as “quantifiable” and “less quantifiable” based on how amenable they are to precise quantification. We
    also classify these into the “direct” and “indirect” categories: the former contributes solely towards the costs of my application (e.g., server costs) while the latter contributes to a group and requires that its contribution to my application be teased out (e.g., cooling costs).
  • Identification of Deployment Choices: Besides the two extreme deployment choices of pure in-house and pure cloud-based hosting available to an application, we identify a spectrum of hybrid choices that can offer the best of both worlds. Our hybrid choices capture both “vertial” and “horizontal” ways of partitioning an application, each with its own pros and cons.
  • Case Studies using NPV-based Cost Analysis: Using a diverse set of applications (open-source vs. licensed software, interactive vs. throughput-intensive, commercial versus scientific), cloud offerings (IaaS vs. SaaS), and workload characteristics (stagnant vs. growing, relatively constant vs. spikey) we study the evolution of costs for different deployment choices. We express these evolving costs using the well-regarded Net Present Value (NPV) concept. We conduct two such case-studies (an ecommerce benchmark that uses open-source software and a commercial application that uses Oracle database) for which our analysis offers a number of interesting insights and future directions.

The rest of this paper is organized as follows. Section 2 informs readers with various concepts related to cost analysis and migration, and assumptions we employed in the analysis. We also describe the method we used to determine the required number of hardware units for both in-house and cloud-based options.
Section 3 presents the cost analysis using the quantifiable and direct costs. Then, in Section 3.3, we look at how the workload variance affects the result of previous cost analysis. present concluding remarks in Section 4.

The authors analyze Windows Azure (see Figure 5, reproduced below) in addition to Amazon EC2.


Figure 5: Closer look at cost components for four cloud-based application deployment options at 5th year. Initial workload is 100 tps and the annual growth rate is 20%.

The Computer Systems Laboratory, Department of Computer Science and Engineering,
The Pennsylvania State University, University Park, PA 16802 published the technical report.

I question the authors’ assumption that “CPU speed doubles every year.” In recent years, CPU speed increases have been reduced or eliminated by tradeoffs of decreasing power consumption and increasing the number of CPU cores.

Lori MacVittie (@lmacvittie) asserted Mobile users feel the need …. the need for spe-  please wait. Loading… as an introduction to her F5 Friday: The Mobile Road is Uphill. Both Ways post of 6/17/2011 to F5’s DevCentral blog:

image We spent the week, like many other folks, at O’Reilly’s Velocity Conference 2011 – a conference dedicated to speed, of web sites, that is. This year the conference organizers added a new track called Mobile Performance.

image With the consumerization of IT ongoing and the explosion of managed and unmanaged devices allowing ever-increasing amounts of time “connected” to enterprise applications and services, mobile performance – if it isn’t already – will surely become an issue in the next few years. The adoption of HTML5, as a standard platform across mobile and traditional devices is a boon – optimizing the performance of HTML-based application is something F5 knows a thing or two about. After all, there are more than 50 ways to use your BIG-IP system, and many of them are ways to improve performance – often in ways you may not have before considered.


The number of people who are “always on” today is astounding, and most of them are always on thanks to rapid technological improvements in mobile devices. Phones and tablets are now commonplace just about anywhere you look, and “that guy” is ready to whip out his device and verify (or debunk) whatever debate may be ongoing in the vicinity.

Unfortunately the increase in use has also coincided with an increase in the amount of data being transferred without a similar increase in the available bandwidth in which to do it.

imageThe attention on video these past few years – which is increasing, certainly, in both size and length – has overshadowed similar astounding bloat in the size and complexity of web page composition. It is this combination – size and complexity – that is likely to cause even more performance woes for mobile users than video.

“A Google engineer used the Google bot to crawl and analyze the Web, and found that the average web page is 320K with 43.9 resources per page (Ramachandran 2010). The average web page used 7.01 hosts per page, and 6.26 resources per host. “  (Average Web Page Size Septuples Since 2003)

Certainly the increase in broadband usage – which has “more than kept pace with the increase in the size and complexity of the average web page” (Average Web Page Size Septuples Since 2003) – has mitigated most of the performance issues that might have arisen had we remained stuck in the modem-age.  But the fact is that mobile users are not so fortunate, and it is their last mile that we must now focus on lest we lose their attention due to slow, unresponsive sites and applications.  The consumerization of IT, too, means that enterprise applications are more and more being accessed via mobile devices – tablets, phones, etc… The result is the possibility not just of losing attention and a potential customer, but of losing productivity, a much more easily defined value that can be used to impart the potential severity of performance issues to those ultimately responsible for it.


imageIf you thought the need for application and network acceleration solutions was long over due to the rise of broadband, you thought too quickly. Narrowband, i.e. mobile connectivity, is still in the early stages of growth and as such still exhibits the same restricted bandwidth characteristics as pre-broadband solutions such as ISDN and A/DSL. The users, however, are far beyond broadband and expect instantaneous responses regardless of access medium.

Thus there is a need to return to (if you left it) the use of web application acceleration techniques to redress performance issues as soon as possible. Caching and compression are but two of the most common acceleration techniques available, and F5 is no stranger to such solutions. BIG-IP WebAccelerator implements both along with other performance-enhancing features such as Intelligent Browser Referencing pdf-icon (IBR) and OneConnect pdf-icon can dramatically improve performance of web applications by leveraging the browser to load more quickly those 6.26 resources per host and simultaneously eliminating most if not all of the overhead associated with TCP session management on the servers (TCP Multiplexing).

WebAccelerator – combined with some of the innate network protocol optimizations available in all F5 BIG-IP solutions due to its shared internal platform, TMOS – can do a lot to mitigate performance issues associated with narrowband mobile connections. The mobile performance problem isn’t new, after all, and thus these proven solutions should provide relief to end-users of both the customer and employee communities who weary of waiting for the web.

imageHTML5 – the darling of the mobile world - will also have an impact on the usage patterns of web applications regardless of client device and network type. HTML5 inherently results in more request and objects, and the adoption rate is fairly significant from the developer community. A recent Evans Data survey indicates increasing adoption rates; in 2010 28% of developers were using HTML5 markup, with 48.9% planning on using it in the future.

More traffic. More users. More devices. More networks. More data. More connections. It’s time to start considering how to address mobile performance before it becomes an even steeper hill to climb.

<Return to section navigation list> 

Windows Azure Platform Appliance (WAPA), Hyper-V and Private/Hybrid Clouds

Alan Le Marquand posted Announcing the Release of the ‘Enhancing Your Business and Career with the Private Cloud” course to the Microsoft Virtual Academy to the Microsoft Virtual Academy blog on 6/17/2011:

image The Microsoft Virtual Academy team would like to announce the release of the Enhancing Your Business and Career with the Private Cloud course.

This course contains 3 modules which focuses on how the private cloud can help your business and your IT Pro career.


The first module starts by covering the cloud business drivers and business processes. The subsequent modules will be discuss cloud computing at the business level and then show you how to extend that knowledge to the technical level.

The final module will cover how to extend your private cloud to the outside world and how the resulting hybrid cloud will benefit both your organization and you as an IT Pro.

Sign in and take this course today!

Carl Brooks (@eekygeeky) reported Microsoft sets Azure free; Appliance flutters to Fujitsu in a 6/16/2011 post to

image Almost a full year after a giddy, typically early Microsoft announcement, Redmond's Platform as a Service technology has left Microsoft's data centers and is running at giant IT supplier Fujitsu.

Microsoft Azure is available on Fujitsu hardware in the company's Tokyo data center, and customers can interact with it just like Microsoft's U.S.-based Azure services. The Fujitsu Global Cloud Platform/A5 (FGCP/A5 or Fujitsu Azure) will be live in August; users will have to sign up with Fujitsu to access the service, and pricing is expected to be the same as current Microsoft Azure pricing.


Users are by and large enthused, since this announcement cuts the Gordian Knot of enterprise IT security and public cloud services. Fujitsu says that, as a longstanding colocation and hosting provider, users can be assured their data is somewhere familiar, although it does not address concerns about multi-tenancy. Fujitsu Azure users will share data space on the platform within Fujitsu's environment, just like Microsoft Azure users do in Microsoft's data centers.

image"This latest development is a significant milestone in making Windows Azure a ubiquitous enterprise solution," said Brian Fino, an IT consultant specializing in Microsoft development.

He said there was an intense dichotomy in the enterprise at the moment, between the almost-absurd ease with which Azure could be used and the need for IT shops to maintain control over infrastructure and data, still by far the biggest roadblock to cloud.

Fino said he spends the majority of his time developing demonstration apps and mobile apps on Azure, but he believes that Microsoft enterprise users will come over to Azure in bigger ways as they get the security guarantees they need. He added that the consumption model and programming model were also quite novel to most IT shops, in part because it is so streamlined and standardized on Microsoft's best practices ideas.

"When I look at that commonality and the standardization, it's relatively antithetical to the way most enterprise organizations work," he said.

Fujitsu's Azure to start cloud trend?
Some think cloud services like Azure are actually reshaping the way IT shops are going to work. Azure MVP and consultant Brent Stineman says he's watched firsthand as exposure to Azure and other public cloud services have made the earth move in an IT department. Stineman works for Minnesota based IT consulting firm Sogeti.

"Eventually the programming models we're pioneering in the cloud will come back on premises," he said, like readily consuming bits and pieces of an app from wherever it is most efficiently run; a little bit of SQL from here, storage from there, a runtime from somewhere else, and so on.

He said the Fujitsu announcement is a part of that trend, since it's going to give users more flexibility in consuming Azure. But the real movement for Microsoft shops will come later, as their private cloud products mature.

Stineman feels Azure is at its best when somebody else runs it for simple economies of scale. He added that it's still early days for the service.

"The key points that people running into are they can't quite understand the pricing model and they jump in assuming they're doing things the way they're used to," he said.

There's still confusion at Microsoft and with partners and customers, Stineman said, over exactly where Azure fits and how it's going to get integrated with other enterprise IT. That may be because it is such a novelty for Microsoft; Azure was developed as an almost-independent, skunkworks project that suddenly got a lot of exposure and users when it launched last year.

That is certainly reflected in the arduous tale of getting Azure out of Microsoft's environment and into Fujitsu's. Dell hardware ran the original Azure environment, although Microsoft takes pains to say that it is hardware-agnostic, software-only technology. Jeff Stucker, director of the Azure program for Fujitsu America, said that software was not the problem. Instead, it was sorting out exactly how data center operations were going to run. An x86 CPU is a CPU and Windows is Windows (Azure is, in part, a customized Windows Server 2008), but the monitoring, management and administration tools Fujitsu uses all had to be integrated and tuned, a non-trivial undertaking.

"What we've done is basically replicate the architecture that Microsoft used…the other piece was the management; the cloud stuff, monitoring, patches, upgrades," Stucker said. He wouldn't say exactly which parts of Azure Microsoft is still responsible for, but Fujitsu does operate all the hardware and data storage. …

More on Azure from TechTarget:

Carl continued with a “Fujitsu's infrastructure provides cloud confidence” topic but didn’t discuss the missing WAPA offerings from purported partners HP and Dell Computer, which I’ve been grousing about since posting my Windows Azure Platform Appliance (WAPA) Finally Emerges from the Skunk Works article on 6/7/2011. See HP and Microsoft to Partner on Windows Azure Built on HP Converged Infrastructure and Dell Expands Cloud Strategy and Services With Microsoft Windows Azure Platform Appliance, both of 7/12/2010.

Full disclosure: I’m a paid contributor to TechTarget’s

Adam Hall posted Announcing the System Center Orchestrator Beta! to the System Center Team Blog on 6/15/2011:

image Hi everyone

Get a virtual machine ready and crank up your Hypervisor because you are going to want to kick the tires on the System Center Orchestrator Beta!

image We have built upon the best features of Opalis and made some significant improvements to release Orchestrator as part of the System Center family. If you have a Windows Server 2008 R2 virtual machine with SQL Server 2008 R2 installed, it will literally only take you minutes to start playing with the product!

Microsoft acquired Opalis in December 2009, with a vision to embed Runbook Automation into the System Center management capabilities.  Since then we have released 2 point releases to bring support for the latest Server platforms and provide integration into the existing System Center products … and now, we enter into the new generation with Orchestrator!

As we look ahead to the launch of System Center 2012, the now rebranded System Center Orchestrator will provide the critical Process Automation capabilities that will simplify Datacenter Management and allow our customers to build and manage their Private Clouds.

So, lets get Automated!

The Orchestrator Beta is now available for download and testing, you can either fly solo and take it for a spin yourself by simply downloading the Beta Bits, or you can get with the program … the Evaluation Program that is!

Still not sure? Lets take a look at what Orchestrator is all about

System Center Orchestrator 2012 delivers 3 core benefits to our customers:

  • Integration – Optimize and Extend your existing Investments
  • Orchestration – Deliver Flexible and Reliable Services
  • Automation – Lower Costs and Improve Predictability

With the implementation of Orchestrator, our customers and partners will be able to:

  • Connect heterogeneous environments through integration
  • Create custom integrations to any system using the Quick Integration Kit
  • Realize benefits and value faster through flexible process workflows
  • Improve service reliability across multiple tools, systems and departmental silos
  • Free up scarce IT resources for work that adds real value to your business
  • Reduce the number of manual and error-prone tasks and activities performed

We are very excited with this release, and we look forward to your feedback!

And if you’ve joined the Evaluation Program, we look forward to talking to you soon.

<Return to section navigation list> 

Cloud Security and Governance

Harry Hy posted End To End Service Level Management – A Key to Your Cloud Success to the BMC blog on 6/16/2011:

image Recently, I visited several large service providers who are rolling out their cloud offerings. One common question from them how they can measure the service level agreement in a way that not only they know its financial impact but also  its operations impact. The operations impact they meant is how they can operationally measure, maintain, and report the operational service level to their customers.

In many people’s eyes, the SLA is a number. But the real question is what that number means and how that number matters. In the cloud, when the cloud customer’s business relies on the service that the cloud can deliver, the answers become even more important. The SLA in the cloud should reflect perspective from all constituencies. Cloud users care about the real experience they will get from the cloud. The availability may be good (it is calculated over a period of time, monthly or annually). But what about the service response time? On the other hand, service providers worry about their commitment to the customer. How to proactively minimize any downtime and identify any potential problems become important.

As the diagram shows here, these two perspectives have to be reflected in your service level management. One is related to the other. You’ve got to have an end to end view and in the same time understand the perspectives from both customers and providers. You’ve got to proactively measure, manage, and maintain the service levels. And you can’t do that manually in the cloud where dynamics is the norm. You will need to find a solution to tie all these different perspectives together and proactively maintain them. For service providers, this will be the key to keep your cost down and customers happy.

Nubifer described Intelligent Cloud Chargeback Strategies in a 6/15/2011 post:

image The cloud isn’t the first attempt by IT departments to utilize cheap commodity computing power quickly, but the uncertainty fueled by the economy’s slow recovery has caused cloud computing to attract more hype. Cloud computing promises to reduce capital expenditure and management burden while at the same time increasing speed of response and ability for IT to flex and scale with business demands—and also stirs up the issues of IT chargebacks. A complex approach to IT funding, IT chargebacks used to be a recurring nightmare for CFOs and CIOs.

Responsibility Shifts
Traditionally, IT budgets are assigned by business unit, project or overall annual requirements. As a centralized IT resource charged on a usage-based billing model, cloud computing alters traditional budgetary lines and brings back the concept of the IT function charging its costs back to individual departments. IT chargeback methods remain as important as architecture, support or lifecycle considerations when building a cloud, despite the challenge of developing a costing model and socializing the new financial agreement throughout an organization.

Chargebacks have been hard to implement in the past, because calculating the full cost of service delivery is a very complex process with a range of associated variables. Organizations can build flexible IT resourcing into their operational expenditure with cloud computing, in order to manage cheaper, sustainable and predictable business workloads. They can simultaneously access extra resources when a business unit needs it, to get a new project up and running in no time at all, for example, without having to factor in the extra hardware, power, maintenance and labor costs commonly associated with new UT capital expenditure.

Placing IT in Control
The fact that cloud computing is fundamentally based on a chargeback model would seem to put the CIO in control of IT as a central business resource, enabling him to alleviate some of the pressure placed on the CFO—at least on the surface level. It is almost always a good thing to reduce capital expenditure, but decentralized, tangible resources allow for more traditional, consistent and obvious budget and resource division. When a department queries their share of the cloud services budget in comparison to other departments, or as a proportion of the IT bill to the business overall, problems can arise. The benefit of a flexible environment is to address highs and lows in usage, but these patterns can also engender concern about how costs are allocated between different groups.

For this reason, it is key than any CIO considering a move to cloud computing must work with the CFO to agree upon standard procedures upfront for purchasing, accessing and monitoring cloud resources and service levels to make sure that each business unit only pays for the IT they need and use. At first look, private clouds seem like they would be reasonably straightforward chargeback environments. Questions of ownership, however, still arise—mainly: what department should pay for the operating, support and maintenance expenses linked to the cloud? So what is the answer? All departments partaking should own a part of the operating expenses.

In a private cloud direct application usage expenses aren’t the only cost that needs to be issued as a chargeback to an IT department—unlike in a public cloud governed by a third party. It follows that the additional costs must be split based on fair usage statistics. When given the correct tracking information, this is a fairly simple proportion to determine—but the difficult part is to find the appropriate management systems to monitor and control usage of the private cloud.

The fundamental components of implementing a robust chargeback infrastructure are:

  • Reaching an agreement with the business around the appropriate pricing model for cloud resources
  • Collecting accurate usage information through a cloud lifecycle management solution
  • Ensuring this utilization information and the associated costs are visible by the user through the services portal from which they manage their cloud services and request new cloud services
  • Aggregating these costs according to relevant business entities—project-based or departmental—to roll up meaningful costs and enable future based decisions with solutions
  • Aligning this new pay-per-use model with the financial systems and decision process of the business

A head start into the cloud is given to IT departments with well-developed business service management (BSM) software deployments that allow them to align IT resources with business demand. BSM enables businesses to align IT service delivery with the business’ priorities—so that IT is supporting the business in the places it needs it the most. A key to managing this process, management software can be used to ensure that budgets can be set depending on the relevance each user group has to the business priorities at any given time in the case of pay-as-you-go computing.

If this is done correctly, IT funding can become an entirely simpler process that guarantees business departments pay only for the resources they consume and ensures that the post-recession CFO has one less challenge to contend with.

<Return to section navigation list> 

Cloud Computing Events

<Return to section navigation list> 

Other Cloud Computing Platforms and Services

Carl Brooks (@eekygeeky) posted New wave of private cloud players washes up onshore in a 6/16/2011 article for

imageAn interesting roundup of launches this week; apparently the vendor side has wised up to the pesky fact that building a private cloud infrastructure gets you…a bunch of virtual servers you can turn on and off. It doesn't actually help you do anything productive, it just offers a tidy automated platform and a way to tell your boss that "yes, we are 'doing cloud,' no, we are not using ACME Public Cloud, your vacation pictures are safe."

image It's a mildly incestuous bunch too: Opscode, run by former website honcho Jesse Robbins, has announced Private Chef, which will be delivered in a hardware appliance (yes, really). It's a clone of Opscode's infrastructure scripting automation software, Chef, that will handle your virtual infrastructure in house. Jesse, if you're reading, I hereby nominate "Cafeteria Chef" for a budget virtual version of Opscode I can run (get it myself) and "Gyro Cart Chef" for the mobile development version. The possibilities are endless.

RightScale, which makes heavy use of the open source Chef project, announced myCloud, a virtual machine (VM) you can run in your own infrastructure to link up your RightScale public account and your private cloud platform. It, promises CEO Michael Crandall, will bring you all the fun of RightScale and all the peace of mind of your own personal VMs.

Of course, you'll still use RightScale's portal, which is slightly weird but I can see the appeal. And there's a catch: You've got to be running Eucalyptus or as your platform. So for now, the 90% or so of you running VMware are still high and dry.

Why those two platforms? "Eucalyptus was really the first entrant and I think was the second," Crandall said. He added that those platforms are simply most ready for serious use; RightScale users looking at hybrid cloud, which Crandall feels is the definitive trend, are pretty much up to speed on those two. So far, this is all IT hippy stuff, although Crandall claims that VMware vCloud support is on the way.

More in-house cloud options arrive
Commercial open source data management vendor Talend also announced Talend Cloud, which will run across pretty much any of the public vendors and private virtualization platforms, hooks up with and NetSuite, and so on.

Non-IT hippy vendor Network Automation, Inc. announced it now supports Amazon Web Services for your point-and-click app building or infrastructure management needs. CEO Gary Bishop said Network Automation's usual demographic of small and medium businesses were already getting into Amazon by fits and starts, using SQS or S3 and the odd EC2 instance to get capacity they needed. He added that most of NAI's clients would rather cut off an ear than buy hardware or data center space when Amazon Web Services is out there, so the trend is undeniable.

And of course, there's HP, which launched (or re-launched, depending on how long you've known about it) CloudSystem, a massive bunch of technical partnerships, software automation and BladeSystem Matrix gear to get customers into the cloud, on a cloud or both. HP has basically said it doesn't give a plugged nickel for cloud idealism and has shoveled its entire automation portfolio on to users with a message of "You want cloud? You figure it out."

CloudSystem will now live on your racks, manage your VMs and -- when you want or need capacity -- burst out to a host of providers like Verizon or HP's own data centers. It is hypervisor agnostic and hardware agnostic; there is application automation (Moab from Adaptive), billing solutions, and on and on.

Will the kitchen sink approach work for HP? Maybe; we'll let you know when customers actually buy it. But the trend is clear; the market is moving on from the joys of Infrastructure as a Service and users are asking for the next level of utility computing; actual usefulness, inside their own data centers.

Full disclosure: I’m a paid contributor to TechTarget’s

<Return to section navigation list>