Wednesday, June 01, 2011

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

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


• Updated 6/1/2011 12:00 Noon and later with articles marked by Bill Wilder, Giga Om Events, Alex Handy, Arriet Business Solutions, Skip Brown, James Staten, Jo Maitland, Windows Azure Team, Jeff Wettlaufer, Microsoft System Center Team, and Me.

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

Steve Yi posted Video How-To: Extending SQL Azure Data to Android and Other Platforms to the SQL Azure Team blog on 6/1/2011:

image This video demonstrates how easy it is to extend, share, and integrate SQL Azure data with mobile and heterogeneous applications using other programming platforms via an OData service. 

imageThe video shows how easy it is to expose data by creating an OData service and how a variety of different client applications, including an Android phone, can easily and efficiently interact with a SQL Azure database.  The video concludes by referring users to additional resources that offer further support.

Take a look at the source code on Codeplex.

Check it out, and if you have any questions, please leave a comment.  Thanks!

James Podgorski posted Entity Framework with SQL Azure in Write Scenarios on 5/31/2011:


image This blog posting is an addendum to a previous posting in which various transient fault detection principles were applied with Entity Framework LINQ queries performing read operations against a SQL Azure backend database. A number of customers have been clamoring for a supplement that includes write scenarios and thus the first motivation for expanding upon this topic. A second reason is to pass along additional information learned from our experience working with SQL Azure.


imageA number of Entity Framework and SQL Azure experiences need to be articulated before sample code can be presented:

First of all, retrying a sequence of operations on a DbContext or ObjectContext instance is not guaranteed to lead to the same outcome as performing the same sequence successfully in the first attempt. This is because not all of the methods on the context and not all the changes that you can perform on an object graph are idempotent.

Besides, when any connection failure occurs during the execution of a query or SaveChanges, it cannot be safely assumed that the context will land in a consistent state. This is because the internal state of the context and in the objects it tracks are not transactional in nature. Unlike how a failure would cause a database transaction to rollback, a failure that occurs while Entity Framework is interacting with a database will leave the objects in memory in whatever state they were in when the failure occurred. There is no guarantee that this state is going to be valid, and simply retrying the operations may not lead to consistent results.

Note that with the queries included in our previous post things are relatively safe, because (a) in general when you retry the query that previously failed, the objects that were already hydrated in the previous attempt will return and those that didn’t come in the first attempt will be added to the results, and (b) even if the in-memory state get corrupted, we are not making writes to the database and thus there is no possibility of permanent data corruption.

There are other situations in which retrying with the same context instance might be relatively safe, but given there are so many variables that can have an influence on that (e.g. the APIs used, the changes performed to the object graph, whether your entities have store computed values and whether you are using stored procedures or dynamic SQL for updates) the simplest possible recommendation is to not reuse a context instance after a failure happened during the execution of a query or during SaveChanges.

Sample – Scoped Retry Over Connection

The first sample applies retry policies to the opening of the EntityConnection for the given context. The reasoning for this is that experience has told us that a large number of transient faults will occur as we obtain a working connection to SQL Azure, and in this way we can cover a broad case with retry logic and fallback to those traditional fault handling techniques for those lesser occurring events. Below is a sample of wrapping the connection with retry policies. The aim of executing ‘declare @i int’ on the connection is to verify that the connection is not stale and if so can be close and subsequently removed from the connection pool by the Close operation. You can review the previous blog in which we applied this very same retry policy in the partial method OnContextCreated, which simplifies the code isolating the retry logic to one place.

using (EntityConnection conn = new EntityConnection("name=AdventureWorksEntities"))
    RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));
    policy.ExecuteAction(() =>
            string ss = conn.ConnectionString;
            var storeConnection = (SqlConnection)((EntityConnection)conn).StoreConnection;
            new SqlCommand("declare @i int", storeConnection).ExecuteNonQuery();
        catch (Exception e)
            throw e;

    using (AdventureWorksEntities dc = new AdventureWorksEntities(conn))
        var salesHeader = (from x in dc.SalesOrderHeaders
                                        where x.PurchaseOrderNumber == "PO348186287"
                                        select x).First();

        var product = (from x in dc.Products
                       where x.ProductNumber == "FR-R92B-58"
                       select x).First();

        short quantity = 1;
        SalesOrderDetail salesDetail = new SalesOrderDetail
            LineTotal = product.ListPrice * quantity,
            OrderQty = quantity,
            Product = product,
            SalesOrderHeader = salesHeader,
            UnitPrice = product.ListPrice,
            UnitPriceDiscount = 0,
            ModifiedDate = DateTime.Now,
            rowguid = Guid.NewGuid(),

        salesHeader.TotalDue = salesHeader.TotalDue + salesDetail.LineTotal;
        salesHeader.ModifiedDate = salesDetail.ModifiedDate;


Sample – Scoped Retry Over ObjectContext

The second sample applies general guidance for scoping retry logic over the entirety of the ObjectContext queries. In this example, we consider the non-idempotent nature of the ObjectContext by scoping the retry policies outside of the creation of the context and thus insuring the consistency of state manager. In general, this technique is similar to what we come to expect with any application. The exceptions are handled and appropriate course of action is implemented, in this case a re-execution of the queries using a distinct ObjectContext.

RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));
policy.ExecuteAction(() =>
    using (AdventureWorksEntities dc = new AdventureWorksEntities())
        var salesHeader = (from x in dc.SalesOrderHeaders
                                        where x.PurchaseOrderNumber == "PO348186287"
                                        select x).First();

        var product = (from x in dc.Products
                       where x.ProductNumber == "FR-R92B-58"
                       select x).First();

        short quantity = 1;
        SalesOrderDetail salesDetail = new SalesOrderDetail
            LineTotal = product.ListPrice * quantity,
            OrderQty = quantity,
            Product = product,
            SalesOrderHeader = salesHeader,
            UnitPrice = product.ListPrice,
            UnitPriceDiscount = 0,
            ModifiedDate = DateTime.Now,
            rowguid = Guid.NewGuid(),

        salesHeader.TotalDue = salesHeader.TotalDue + salesDetail.LineTotal;
        salesHeader.ModifiedDate = salesDetail.ModifiedDate;



In this blog we learned that it is not safe to reuse a DbContext or ObjectContext when a transient connection failure occurs during the execution of a query or in SaveChanges, and we demonstrated two samples that show how you can execute write commands to SQL Azure and properly handle transient fault conditions.

No significant articles today.

James Podgorski posted SQL Azure and Entity Framework Connection Fault Handling to the AppFabricCAT team blog on 12/10/2010 (missed when posted):

image A number of customers are choosing to use Entity Framework with Microsoft SQL Azure, and rightfully so.  Entity Framework provides an abstraction above the database so that queries are developed using the business model or conceptual model and queries are executed using the richness of LINQ to Entities.  SQL Azure is a cloud-based database based upon SQL Server which provides reliability and elasticity for database applications.  And, the Entity Framework supports SQL Azure, both the designer and the provider runtime can be used against either a SQL Server database on premise or in the cloud.

imageBut these same customers are describing connectivity drops, classified as general network issues, and are asking for the best practice to handle such network issues between SQL Azure instances and clients utilizing Entity Framework.  In fact, SQL Azure has a whole host of reasons to terminate a connection including but not exclusive to resource shortages and other transient conditions.  Similar issues apply when using ADO.NET; networks can be unreliable and are often suspect to sporadic fits resulting in dropped TCP connections.  There are a number of blog posts, such as 'SQL Azure: Connection Management in SQL Azure' and 'Best Practices for Handling Transient Conditions in SQL Azure Client Applications', which provide connection fault handling guidance and even a framework for creating retry policies with SQL Azure client. Neither article is fully comprehensive regarding the Entity Framework aspects.  The purpose of this blog posting is to fill in the details and discussion points for the many developer options to handle and recover from intermittent connectivity drops when using Entity Framework.

Background Information – Connection Pooling

It is well known that the creation and teardown of database connections to SQL Server is expensive, thus ADO.NET uses connection pools as an optimization strategy to limit the cost of the database connection creation and teardown operations.  The connection pool maintains a group of all physical connections to the database and when clients such as Entity Framework request a connection, ADO.NET provides the next available connection from the pool.  The opposite occurs when clients close a connection – the connection is put back into the pool.  What is less understood is that the connection pooler will remove connections from the pool only after an idle period OR after the pooler detects that the connection with the server has been severed.  But the pooler can only detect severed connections after an attempt has been made to issue a command against the server.  This means that clients such as Entity Framework could potentially draw a severed or invalid connection from the pool.  With high latency and volatile networks, this happens on a more frequent basis.  The invalid connections are removed from the pool only after the connection is closed.  Alternatively the client can flush all of the connections using ClearAllPools or ClearPool methods.  See MSDN article ‘SQL Server Connection Pooling' for a more verbose description of the concepts.

Background Information - Entity Framework Database Connection

The Entity Framework provider abstracts most if not all of the facets from executing a query against the backend store, from establishment of the connection, to the retrieval of the data and materialization of the POCO or EntityObjects.  Nevertheless it does provide access to the underlying store connection through the Connection property of the System.Data.Objects.ObjectContext.

The ObjectContext wraps the underlying System.Data.SqlClient.SqlConnection to the SQL Server database by using an instance of the System.Data.EntityClient.EntityConnection class.  The EntityConnection class exposes a read/write StoreConnection property which is essentially the underlying SqlConnection to the SQL Azure instance.  That mouthful simply says that we have a mechanism upon which to read the current state of a connection and assign the store connection if so desired.  Since we have access to the database connection, we can most certainly catch exceptions thrown when the network transport has failed and retry our operations per a given retry policy.

One subtlety which requires a touch of clarification, take the code snippet below. In this example the connection was explicitly opened on the context. The explicit opening of the connection is a way of informing EF not to open and reopen the connection on each command. Had I not opened the connection in this way, EF would implicitly open and close a database connection for each query within the scope of the context. We will leverage this knowledge in the connection retry scenarios that follow.

using (AdventureWorksLTAZ2008R2Entities dc = new AdventureWorksLTAZ2008R2Entities())
// ...
Case #1 – Retry Policies

Let’s take the following code as an example. How many connections are drawn from the pool? The answer is two, one for the retrieval of the customer and another for the retrieval of the address. This means that if implemented in this general way, Entity Framework will use a new connection for every query it executes against the backend data store given the scope of the current ObjectContext. It pulls a connection for the pool, submits the query against the database and closes the connection for each LINQ query. You can see this by running SQL Profiler on an instance of SQL Server as shown in the table below the query.

using (AdventureWorksLTAZ2008R2Entities dc = new AdventureWorksLTAZ2008R2Entities())
int cId = 29485;
Customer c1 = (from x in dc.Customers
where x.CustomerID == cId
select x).First();

Address ad1 = (from x in dc.Addresses
from y in dc.CustomerAddresses
where y.CustomerID == cId && x.AddressID == y.AddressID
select x).FirstOrDefault();
Audit Login  
RPC:Completed exec sp_executesql N'SELECT TOP (1)
[Extent1].[CustomerID] AS [CustomerID] …
Audit Logout  
RPC:Completed exec sp_reset_connection
Audit Login  
RPC:Completed exec sp_executesql N'SELECT
[Limit1].[AddressID] AS [AddressID], …
Audit Logout  

[Above table reconstructed from incorrect structure in original]

But there is an interesting facet to the code above, the connection to the database was not explicitly created.  The EntityConnection was transparently created by the Entity Framework when the AdventureWorksLTAZ2008R2Entities ObjectContext was instantiated and the StoreConnection property or actual SqlConnection state is set to closed. Only after the LINQ query is executed by the EF provider is the connection opened and the query submitted to SQL Server.  The state of the inner connection changes to closed and the connection placed back into the pool once the results have been successfully retrieved.

In this example, we have two places in which a transient network error or invalid connection in the pool could affect the query and cause a System.Data.EntityException, for the retrieval of the customer and for the retrieval of the address.  The inner exception of the EntityException is of type System.Data.SqlClient.SqlException and it contains the actual SQL Server error code for the exception.

A policy can be applied to wrap the LINQ queries to catch the EntityException and retry the query given the particular metrics of the policy.  The retry policy in the code below utilizes the Transient Conditions Handling Framework described in the blog written by my teammate Valery. This blog provides a very comprehensive selection of retry policies which will properly handle the thrown exceptions. The basic principle is to support a number of retries with increasing periods of wait between each subsequent retry (i.e. a backoff algorithm).  In this case we abort the operation after 10 attempts with a wait periods of 100ms, 200ms… up to 1 second.

using Microsoft.AppFabricCAT.Samples.Azure.TransientFaultHandling;
using Microsoft.AppFabricCAT.Samples.Azure.TransientFaultHandling.SqlAzure;
using (AdventureWorksLTAZ2008R2Entities dc = new AdventureWorksLTAZ2008R2Entities())
int cId = 29485;
int MaxRetries = 10;
int DelayMS = 100;

RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));

Customer c1 = policy.ExecuteAction<Customer>(() =>
(from x in dc.Customers
where x.CustomerID == cId
select x).First());

Address ad1 = policy.ExecuteAction<Address>(() =>
(from x in dc.Addresses
from y in dc.CustomerAddresses
where y.CustomerID == cId && x.AddressID == y.AddressID
select x).FirstOrDefault());

This retry policy approach is not without its challenges, particularly in regards to the developer experience.  The Func delegates require that a type be passed in, something that is somewhat cumbersome when using anonymous types because the return type must be set to an object type.  This means that the developer must cast the object to the anonymous type to make use of it, a sample of which is shown below.  I created a CastHelper class for that purpose.

public static class CastHelper
public static T Cast<T>(object obj, T type)
return (T)obj;
var c1 = policy.ExecuteAction<object>(() =>
(from x in dc.Customers
where x.CustomerID == cId
select new { x.CustomerID, x.FirstName, x.LastName }).First());

var anon = CastHelper.Cast(c1, new { CustomerID = -1, FirstName = "", LastName = "" });
Case #2 – Retry Policy With Transaction Scope

Case #2 expands the previous case to include a transaction scope.  The dynamics of the sample changes because a System.Transactions.TransactionScope object is used to ensure data consistency of all scoped queries using an ambient transaction context which is automatically managed for the developer. But from the trace shown below we still observe the typical pattern of Audit Logout events with the SQL Transaction Begin and End events.  This begs the question:  How can we have a local transaction (non-distributed) if our data access code spans multiple connections?   Well, in this case we are not truly spanning multiple physical connections because every connection drawn from pool is based upon the proper connection string and, for those enlisted in a transaction, the thread context.  We can imagine the connection pool subdivided into subdivisions based upon individual transaction contexts and the connection string.  In this way, pulling a connection from the pool guarantees that we are not attempting to enlist in a distributed transaction.

The net result:  We cannot implement our retry policies at the query or SaveChanges level and still maintain the ACID properties of the transaction.  The retry policies must be implemented against the entire transactional scope as shown below.  Note that if you do attempt to place retry logic against the individual queries and a network glitch occurs, be assured than an EntityException will be thrown having an inner SqlException with a message of “MSDTC on Server “xxx” is unavailable”, SQL Azure does not support distributed transactions.  Nevertheless, this is not SQL Azure specific problem. The error is non-recoverable at the query statement level; it is all or nothing with transactions.

using (AdventureWorksLTAZ2008R2Entities dc = new AdventureWorksLTAZ2008R2Entities())
int MaxRetries = 10;
int DelayMS = 100;

RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));
TransactionOptions tso = new TransactionOptions();
tso.IsolationLevel = IsolationLevel.ReadCommitted;
policy.ExecuteAction(() =>
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, tso))
int cId = 29485;

Customer c1 = (from x in dc.Customers
where x.CustomerID == cId
select x).First();

Address ad1 = (from x in dc.Addresses
from y in dc.CustomerAddresses
where y.CustomerID == cId && x.AddressID == y.AddressID
select x).FirstOrDefault();

string firstName = c1.FirstName;
c1.FirstName = c1.LastName;
c1.LastName = firstName;


string addressLine1 = ad1.AddressLine1;
ad1.AddressLine1 = ad1.AddressLine2 == null ? "dummy data" : ad1.AddressLine2;
ad1.AddressLine2 = addressLine1;

Case #3 – Implement Retry Policy in OnContextCreated

If your scenario is such that the EF queries return very quickly, which is the most typical pattern, then it probably suffices to employ a retry policy solely at the connection level. If other words, only retry when a connection fails to open. The premise is that if the client application acquires a valid connection, no other network related errors will occur while during the execution of my queries. If an error does occur, the application can catch the exception and resubmit as it would in a traditional non-cloud based implementation. Besides, this tactic offers the least invasive solution because as you will from the code sample below, we only have to implement the retry policy in one spot. The remainder of the EF code works the same as if it was executing against an on premise SQL Server.

Remember earlier we stated that the ‘validity’ of a connection is only determined after a command is issued against the server. So conceivably to ensure a valid connection, one must attempt to open a connection and submit a command to the database. If an exception is thrown, the connection is close and thus removed from the pool. There is an associated overhead to opening and submitting a command just to check the validity of a connection and for this reason the ADO.NET connection pool elects not to perform this on behalf of the client application.

The tactic is to implement the OnContextCreated partial method of the models context which is called each time a new context is instantiated. In this partial method, employ a retry policy which opens a connection, submits a dummy query and handles exceptions with proper closure of invalid connections. In this way, the pool is ‘cleansed’ of all connections that have disconnected due to network glitches or idle expirations. The tradeoffs are obvious, the additional round trip to the SQL Azure database and the possible delay while the OnContextCreated method closes invalid connections.

partial void OnContextCreated()
int MaxRetries = 10;
int DelayMS = 100;

RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));
policy.ExecuteAction(() =>
string ss = Connection.ConnectionString;
var storeConnection = (SqlConnection)((EntityConnection)Connection).StoreConnection;
new SqlCommand("declare @i int", storeConnection).ExecuteNonQuery();
// throw new ApplicationException("Test only");
catch (Exception e)
throw e;


The sample above submits a lightweight batch to the database, the only overhead to the database is the time to execution of the RPC statement.  All looks good, but there is one important fact that may catch you.  From the profiler trace we observe that the same connection is used for each query database query. This is by design and as discussed early, i.e. when a connection is explicitly opened by the developer it tells EF not to open/reopen a connection for each command. The series of Audit Login/Logout events to retrieve the customer entity or address entity are not submitted as we saw in Case #1 and #2. This means we cannot implement a retry policy for each individual query like I showed earlier. Since the EntityConnection has been assigned to the ObjectContext, EF takes the position that you really truly want to use one connection for all of your queries within the scope of that context. Retrying a query on an invalid or closed connection can never work, a System.Data.EntityCommandExecutionException will be thrown with an inner SqlException contains the message for the error.


Three cases were examined. Retry policies with/without a transaction scope and an implementation of OnContextCreated. The first two cases apply if you wish to introduce retry policies on all of your queries, in or out of a TransactionScope. You may find justification in this approach if your EF queries are apt to become throttled by SQL Azure which manifests itself during execution. The programming paradigms while not overly complex do require more work on the part of the developer. Applying a retry policy in the OnContextCreated method provides slimmer coverage but offers the best bang for the effort. In the majority of cases, network related exceptions tend to reveal themselves just after the connection is retrieved from the pool, thus a policy implemented right after the connection is opened should prove sufficient for those cases where database queries are expected to return quickly.

<Return to section navigation list> 

MarketPlace DataMarket and OData

Sudhir Hasbe announced DataMarket Map App for Bing Maps Now Available!!! in a 5/31/2011 post:

image Starting today you can view many geocoded datasets from DataMarket directly on Bing Maps using our new Map App. Following are steps that show you how to use the new Map App. 

Step 1:


Step 2: Select DataMarket Mapper from Map Apps.


Step 3: Enter your account key for DataMarket. You can get your account key from the account information page on DataMarket( You can use demo key(mqpmTgC2iwTcG2HvHS5HTZymNHAQEzl0eC3JPqpWgHA=) with some free dataset subscriptions.


Step 4: Select datasets you are interested in viewing. You will only be able to view datasets with Geocoding and few datasets that we geocode.


Step 5: Select data set to view on Map


Hugo reported to a Google Groups OpenTSDB and OData thread on 5/19/2011 (missed when posted):

imageI just pushed the code to my fork of the resposity. Can you have look at it and tell me what you think about the stuff so far?

OpenTSDB is a new distributed, scalable time-series database that’s described here.

<Return to section navigation list> 

Windows Azure AppFabric: Access Control, WIF and Service Bus

• Skip Brown posted a 00:03:21 Windows Azure AppFabric: An Introduction to Service Bus Topics video segment to YouTube on 5/19/2011 (missed when posted):

image722322222This short video introduces the Windows Azure AppFabric Topic capability. It runs through the key features and benefits (such as high scalability, low latency and high throughput). Additionally, it runs though some typical Cloud based scenarios which help the performance and scalability of your applications.

Skip is a senior product manager at Microsoft.

Rich Garibay (@rickggaribay) posted Exploring Azure AppFabric Service Bus V2 May CTP: Topics on 5/30/2011:

imageIn my previous post [see article below], I discussed Azure AppFabric Service Bus Queues, a key new capability in the first CTP of the Azure AppFabric Service Bus V2 release that was announced on May 17th.

Queues are an important addition to Azure AppFabric Service Bus capabilities because they provide a solid foundation on which to build loosely coupled distributed messaging solutions. The natural decoupling of queues introduces a number of natural side effects that can further benefit non-functional quality attributes of your solution such as performance, scalability and availability.

image722322222The graphic on the right is taken from my recent whitepaper “Developing and Extending Apps for Windows Azure with Visual Studio”image and shows the perpetual mismatch of supply and demand of IT capacities. If we think of this mismatch as load on the Y axis being introduced over time, the result is either failure to deliver a service or spending too much on hardware. The goal, then is to align the demand with capacity.

imageQueues allow us to get closer to the drawing on the left because capacity can be tuned to scale as needed and at its own pace. This is effective because with queues, a consumer/worker can be throttled to only consume what it can handle. If the consumer/worker is offline, items in the queue will queue up, providing classic “store and forward” capabilities. If the consumer/worker is very busy, it will only consume the messages it is able to reliably pull from the queue. If we add more consumers/workers, each consumer/worker will consume messages at its optimal rate (determined by processing capacity, tuning, etc.), resulting in a natural distribution of work. Of course, stronger, more capable consumers/workers may consume more messages, but as long as there are messages in the queue, there is work to be done and the capacity can be allocated accordingly.

As you can see, queues are a great pattern for building loosely coupled distributed solutions, and the ability to add consumers/workers to a process or message exchange in a manner that is transparent from the client/producer perspective makes queues even more useful.

This is the idea behind topics. Before I dive into topics though, let’s talk about the problem that topics are trying to solve.image

imageIn distributed systems, it is useful to design message exchanges in terms of publishers and subscribers. Publishers are clients that are either sending a request-response message and will wait for a response; or are sending a single, one way message and expect no response. Subscribers care about these messages for one reason or another and thus subscribe to these messages. This is the essence of the Publish-Subscribe, or more succinct “Pub-Sub” messaging pattern. A one-way pub-sub  message exchange pattern is modeled to my left, and again to my right to build on a concrete example. Purchases, be they on-line or at brick-and-mortar retail outlets typically involve a point-of-sale (POS) system.

One of the first things a smart, modern POS software does when a unit is sold is to update inventory on that product so that the company can make proactive, intelligent decisions about managing inventory levels. In most cases, this is an administrative function, that is (or should be) transparent to the customer. When an order/sale is placed, an event occurs which is of interest to an Inventory Service that is responsible for decrementing the inventory count on a shared store. Of course, this is just one of several things that likely need to happen when an order is placed. Credit card authorization as well as fulfillment (whatever that means in the context of the purchase) needs to take place as shown below on your left.

All of a sudden things are more complex than they were before. I want to decouple the POS Client from the downstream business of authorizing a credit card and shipping the product to the customer’s doorstep. Depending on the context, the credit authorization process may be request-response or one-way. For most high-volume online retailers, the financial outcome of imagethe transaction is transparent to the purchasing experience. Ever gotten an email from after you made your purchase letting you know that your order is in a pending state because you need to update your expiration date on file so it can authorize your credit card? This asynchronous approach is common to facilitate scale and performance, and it is also good business.

It is very important to note that when the credit card authorization is designed as one-way, there are a number of guarantees that must be made. First, the Credit Service must receive the message, no matter how busy the front-end or back-end services are. Second, but of equal importance, is that the Credit Service must receive the message once and only once. Failure to deliver on the first or second guarantee will lead to lost revenue, either due to lost transactions or very disgruntled customers.

Using queues is a first step towards achieving these desired outcomes. However, now we need to reason about who should have the responsibility of sending the message to each subscriber? It can’t be the POS Client, because we want to decouple it from this kind of intimate knowledge. Adding this responsibility to each subscriber is also just as bad, or arguably worse. image

What we need is an intermediary that forms both a logical and physical relationship between publishers and subscribers such that the minimum degree of coupling is accomplished between the two and no more. This is exactly what a topic provides.

Topics are nothing new. They have been the mainstay of JMS-based systems for years, and thus have proven their usefulness in the field of distributed computing as a great way to logically associate actions to events, thus achieving pub-sub in a minimally coupled manner.

In our scenario, when a sale occurs, the POS Client publishes a message to the “Orders” topic to signal a new order event. At this point, corresponding subscribers are notified by the topic. This logical relationship is modeled to your right. Each one of the subscribers might receive a copy of the same message, in which case we would define the message exchange pattern as multi-cast. It is also possible-and likely- that each service exposes a different contract and thus, transformation between a canonical message and the expected message must take place, but this is a subject for a later post.

How the subscribers receive the message, be it one-way or request-response, is a physical implementation decision. In the classic sense, the logical abstraction of a topic affords us some latitude in choosing a physical transport that will fuse the publisher and subscriber(s) together. 

Note: Theory aside, everything I am sharing here is based on my experience over the last few days jumping into these early bits. I am not an expert on the implementation of these capabilities or the features of the CTP and am merely sharing my learnings and thoughts as I explore these exciting new features. If you have questions, know of a different or better way to do something as it applies to the CTP, or have any any corrections, please use the comments below and I’ll gladly consider them and/or share them with the product team and post updates back here.

Exploring Azure AppFabric Service Bus V2 Topics

In Azure AppFabric Service Bus V2, the physical transport used in Topics is Azure AppFabric Service Bus Queues, which allows us to harness the physical advantages of queues and the logical abstraction that topics provide to design our distributed solutions at internet scale.

If you’ve played with the Azure AppFabric Service Bus Queues, or read my introduction to this series you might be wondering what makes Azure AppFabric Service Bus Topic so special. So far, you might be thinking that we could accomplish much of what I’ve discussed with Queues and you wouldn’t be alone. I struggled with this initially as well.

The way that Queues and Topics are implemented in the current technology preview, Topics don’t really seem all that useful until you want to refine when or under what conditions a Subscriber should receive a message beyond simply being subscribed to a Topic, and this can be pretty powerful.

In fact, we can code the scenario shown in the article on Queues to be functionally equivalent with Topics without immediately gaining much.

Creating Topics and Subscriptions

Start by creating a ServiceBusNamespaceClient and MessagingFactory just as before:

  1: ServiceBusNamespaceClient namespaceClient = new ServiceBusNamespaceClient( 
  2:         ServiceBusEnvironment.CreateServiceUri( 
  3:         "sb", serviceNamespace,  
  4:         string.Empty),  
  5:         sharedSecretCreds); 
  7: MessagingFactory messagingFactory = MessagingFactory.Create( 
  8:     ServiceBusEnvironment.CreateServiceUri( 
  9:     "sb",  
 10:     serviceNamespace,  
 11:     string.Empty), 

Next, create a Topic called “Orders”:

  1: Topic ordersTopic = namespaceClient.CreateTopic("Orders");

The underlying queue infrastructure is created for you.

Now, create a subscription for the Inventory Service on the “Orders” topic:

  1: Subscription inventoryServiceSubscription = ordersTopic.AddSubscription("InventoryServiceSubscription");

At this point, the creation of the Topic and Subscription above would take place in a management context without regard to, or any knowledge of the actual publisher or subscriber(s).

I would expect tooling either from Microsoft or the community or both to start to crop up soon to provide a user experience for these types of management chores, including the ability to enumerate Queues, Topics, etc. For example, before I create a Topic, I need to ensure that the Topic doesn’t already exist or I will get an MessagingEntityAlreadyExistsException. I used the GetQueues method on the namespace client, and if the Topic or Queue entity exists, use the DeleteQueue or DeleteTopic method.

Publishing on a Topic

Now, the client/publisher creates a TopicClient and MessageSender and sends the message on the Orders Topic:

  1: TopicClient pOSClientPublisher = messagingFactory.CreateTopicClient("Orders"); 
  3: MessageSender msgSender = pOSClientPublisher.CreateSender(); 
  5: Order order = new Order(); 
  6: order.OrderId = 42; 
  7: order.Products.Add("Kinect", 70.50M); 
  8: order.Products.Add("SamsungFocus", 199.99M); 
  9: order.Total = order.Products["Kinect"] + order.Products["SamsungFocus"]; 
 11: var msg = BrokeredMessage.CreateMessage(order); 
 13: msgSender.Send(msg); 
 14: msgSender.Close();

Note that the client/publisher knows nothing about the subscriber. It is only bound to a logical Topic called “Orders” on line 1 above. It is running in some other process somewhere in the world (literally) that has an internet connection and can make an outbound connection on TCP port 9354***.

Subscribing to a Topic

On the receiving end, a SubscriptionClient is created along with a MessageReciever. The SubscriptionClient instance is created from the MessagingFactory instance which accepts the name of the topic and the subscription itself.

Note the RecieveMode is the same as before which will have the effect of ensuring that the Inventory Service Subscriber receives the message at most once (FWIW, I think PublisherClient and SubscriberClient make more sense that SubscriptionClient and TopicClient respectively, but the intent of the classes is pretty clear and again, these are early bits so expect changes as the team gets feedback and continues to bake the API):

  1: SubscriptionClient inventoryServiceSubscriber = messagingFactory.CreateSubscriptionClient("Orders", "InventoryServiceSubscription"); 
  3: MessageReceiver msgReceiver = inventoryServiceSubscriber.CreateReceiver(ReceiveMode.PeekLock); 
  5: var recdMsg = msgReceiver.Receive(); 
  6: msgReceiver.Close(); 
  8: var recdOrder = recdMsg.GetBody<Order>(); 
 10: Console.WriteLine("Received Order {0} on {1}.", recdOrder.OrderId, "Inventory Service Subscriber");

The code above would be wrapped into a polling algorithm that allows you to have fine control over the polling interval, which as Clemens Vasters pointed out in a side conversation recently is a key capability that allows you to throttle your subscribers. The samples in the SDK show a polling technique which works, but it would be nice to see an option for setting some config and letting the API do this for you.

Regardless of the approach you take to checking for messages, the only thing the subscriber knows about is the Topic name and the name of the subscription on line 1 above (having to provide the subscription name in addition to the topic name, seems a bit redundant to me and more coupling than is needed).

Multiple Subscribers

At this point, we’ve emulated the functionality of the Queuing example shown in my first post in the series.

While we’ve increased our level of abstraction, and are no longer thinking about (or care) about the fact that there’s a queue in between the publisher and subscriber, so far, topics haven’t bought us much just yet…

Think back to the scenario above. There are two other services that care about orders. We can create subscriptions for them just as we did for the Inventory Service at management/configuration time:

  1: Subscription fulfillmentServiceSubscription = ordersTopic.AddSubscription("FulfillmentServiceSubscription"); 
  2: Subscription creditServiceSubscription = ordersTopic.AddSubscription("CreditServiceSubscription");

Of course, new subscriptions can be added long after the Topic has been created, and this is one of the many powerful aspects of this logical abstraction from publishers and subscribers. This approach introduces agility into your solutions because you can add subscribers with minimal friction, and in a fully location transparent manner.

As with the publisher (TopicClient), subscribers (SubscriberClients) live in their own process anywhere in the world with an internet connection and can be fired up at will. If one is offline, or unavailable, the message will be queued (provided that previous subscribers have peeked the message (ReceiveMode.PeekLock) as opposed to popping it off the queue (ReceiveMode.ReceiveAndDelete). Below is the simple code for adding listeners/Subscribers for the Credit Service and Fulfillment Service:

  1: // Credit Service Subscriber 
  2: SubscriptionClient creditServiceSubscriber = messagingFactory.CreateSubscriptionClient("Orders", "CreditServiceSubscription"); 
  4: msgReceiver = creditServiceSubscriber.CreateReceiver(ReceiveMode.PeekLock); 
  5: recdMsg = msgReceiver.Receive(); 
  6: msgReceiver.Close(); 
  8: recdOrder = recdMsg.GetBody<Order>(); 
 10: Console.WriteLine("Received Order {0} on {1}.", recdOrder.OrderId, "Credit Service Subscriber"); 
 12: // Fulfillment Service Subscriber 
 13: SubscriptionClient fulfillmentServiceSubscriber = messagingFactory.CreateSubscriptionClient("Orders", "FulfillmentServiceSubscription"); 
 15: msgReceiver = fulfillmentServiceSubscriber.CreateReceiver(ReceiveMode.PeekLock); 
 16: recdMsg = msgReceiver.Receive(); 
 17: msgReceiver.Close(); 
 19: recdOrder = recdMsg.GetBody<Order>(); 
 21: Console.WriteLine("Received Order {0} on {1}.", recdOrder.OrderId, “Fulfillment Service Subscriber");

Creatiimageng two additional SubscriptionClients for the Credit Service and Fulfillment Service results in all three subscribers getting the message as shown on the right. Again, in my examples, I am running each subscriber in the same process, but in the real world, these subscribers could be deployed anywhere in the world provided they can establish a connection to TCP 9354.

Rules/Actions, Sessions/Groups

Now, what if we wanted to partition the subscribers such that in addition to subscribing to a Topic, additional logic could be evaluated to determine if the subscribers are really interested in the message? Our online retailer probably (err, hopefully) has a centralized inventory management system and credit card processor, but may have different fulfillment centers across the world.

Based on the customer’s origin, the order should go to the closest fulfillment center to minimize cost and ship times (i.e. North America, South America, Africa, East, Europe, Asia, Australia).

Azure AppFabric Service Bus V2 supports this approach with Sessions, Rules and Actions. I group these into the idea of a message pipeline. In addition to the subscriptions, the Topic evaluates additional context or content of the published message configured at management time to introduce some additional filtering and very lightweight orchestration. The topic subscription is the right place for this to happen because again, it is a management-time task. Publishers and subscribers merely send/receive messages. It is the benefit of a logically centralized, yet physically distributed messaging model that affords us the ability to manage these details in a centralized way.

You can create a RuleDescription to evaluate some property or field in the message that indicates country of origin, and as an action, set a property on the message to identify the fulfillment center.

To illustrate this, first, I’ve added two properties to the BrokerMessage that I am publishing on the “Orders” Topic. I’ll use these properties when I configure my rule and action next:

  1: msg.Properties.Add("CountryOfOrigin", "USA"); 
  2: msg.Properties.Add("FulfillmentRegion", "");

Notice that in line 2 above, I’ve intentionally created the “FulfillmentRegion” property with an empty string, since we are going to apply some logic to determine the fulfillment region.

Now, I use a RuleDescription and SqlFilterExpression to determine if the CountryOfOrigin is the United States. If the SqlFilterExpression evaluates to true, then the SqlFilterAction fires and sets the FulfillmentRegion  to “North America”:

  1: RuleDescription fulfillmentRuleDescription = new RuleDescription(); 
  2: fulfillmentRuleDescription.FilterExpression = new SqlFilterExpression("CountryOfOrigin = 'USA'"); 
  3: fulfillmentRuleDescription.FilterAction = new SqlFilterAction("set fulfillmentRegion='North America'");

Of course, in the real world, there would be a more sophisticated process for identifying the country of origin, but simple, contrived examples make it so that articles get published.

The evaluation and any corresponding actions must fire when the message is in-flight as any actions taken could influence the routing of the message, as with the example above which will meet a subscription rule we’ll configure on the Fulfillment Service Description next.

OK, so now we have some properties we can play with and we’ve defined a RuleDescription. The last thing we need to do is modify the FulfillmentServiceSubscription to include the RuleDescription I just created. This makes the FulfillmentSubscription conditional, based on the conditions we've defined in the instance of the RuleDescription called fulfillmentRuleDescription:

  1: Subscription fulfillmentServiceSubscription = ordersTopic.AddSubscription("FulfillmentServiceSubscription", fulfillmentRuleDescription);

Now, when I run my code, all three subscribers receive the order message just as before, however this time, we know that the only reason that the Fulfillment Service is getting the message is because it is acting as the North America fulfillment center. If I modify the CountryOfOrigin property in line 1 in the 3rd code sample up from here to anything but “North America” the Fulfillment Service will not receive the message at all.

As I continue to model out my subscribers, I could create a subscription for each fulfillment center that is capable of receiving real-time orders and then create RuleDescriptions accordingly. This would allow me to distribute fulfillment geographically (good for scale, reliability and happy customers) as well as ensuring that I am always only pulling back messages that I need. If, during peak times around holidays, the volume of orders increases, I can simply add additional fulfillment subscribers for that region to ensure that packages ship as quickly as possible and that no orders are lost.

Closing Thoughts

So far, I’m pretty impressed with the powerful messaging capabilities that Azure AppFabric Service Bus V2 Topics introduced in the May CTP, and I’m excited to see where things are going.

As Azure AppFabric Service Bus matures further, I would love to see additional transport channels supported by Azure AppFabric Service Bus Topics. Just as with the creation of the Topic and Subscriptions as a management function, the transport would also be defined and created/configured at management time. This is really where the power and elegance of Topics shines through in my opinion because the publisher and subscriber don’t know or care about the transport- they’re just connecting to a topic and sending and/or receiving messages.

By way of some nit picks, I think that PublisherClient makes more sense than TopicClient, and along with considering a modification to SubscriptionClient, having a PublisherClient and SubscriberClient that publish and subscribe to a Topic seems a lot cleaner and more intuitive to me.

I’m also trying to get used the fact that we need Clients and Senders/Receivers. Again, to me it would seem more intuitive to simply have a PublisherClient and SubscriberClient that own the sending and receiving. Perhaps we’re jus seeing visible seams in the API due to the early nature, or there’s a good reason for this that I haven’t thought of yet.

At PDC 10, the AppFabric team announced that they are investing in an “Integration Service” that will provide additional messaging capabilities by way of transformation and advanced mapping similar to how we leverage these capabilities in BizTalk today. I can see Topics getting much more robust when, in addition to modifying properties on the BrokerMessage, we can mediate and transform a message in-flight just before reaching a subscriber, and I can also think of some nice message enrichment patterns that would be very nice.

*** One important thing to note is that in the current May CTP, Queues and Topics do not provide the same NAT/Firewall traversal capabilities of their relay siblings. For the .NET Messaging API (which I’ve been using to share my learnings thus far) as well as the WCF ServiceBusMessagingBinding, outbound TCP 9354 is required. Also note that the channel type is Net.Tcp (think WCF). This means that in the current CTP, the only way to ensure full interoperability across publishers/subscribers and guarantee an outbound connection (assuming HTTP ports aren’t locked down) is to use the REST API, but I suspect we’ll see more parity of this important feature across client types for Queues and Topics.

What’s Next?

There’s still much to explore around sessions, filtering, the WCF ServiceBusMessagingBinding, the REST API and how we might bridge Azure AppFabric Service Bus with on-premise messaging capabilities. Exciting stuff- stay tuned!

The PowerScritpting blog announced Up Next: Vittorio Bertocci will be with us to discuss AppFabric cmdlets on 6/2/2011 at 6:30 PM PDT:

image On this week’s show (6/2/11 @ 9:30pm EST right here on Ustream!), we’ll be talking to Vittorio Bertocci about AppFabric cmdlets. Be sure to drop by the Ustream channel Thursday so that you can post questions to Vittorio and interact with your fellow PowerShellers!

Rich Garibay (@rickggaribay) described Exploring Azure AppFabric Service Bus V2 May CTP: Queues on 5/17/2011 (missed when posted):

Today, the AppFabric team announced the first Community Technology Preview of the Azure AppFabric Service Bus V2.

image The second release of Azure AppFabric Service bus is a significant milestone that the team has been hard at work on for several months. While I’ve had the privilege of attending a number of SDRs and watching this release move from ideation to actual bits, this is the first time I’ve been able to actually get my hands on the code, so I’ve spent the better part of this evening diving in.

image722322222First, if you are new to the Azure AppFabric Service Bus, there are many resources available to get you up to speed. I highly recommend this whitepaper by Aaron Skonnard: A Developer’s Guide to the Service Bus. If you are a visual learner, please consider checking out my webcast on AppFabric Service Bus here:

In a nutshell, like most ESBs, Azure AppFabric Service Bus is the manifestation of a number of core messaging patterns that provide the ability to design messaging solutions that are loosely coupled. What makes the Azure AppFabric Service Bus unique is that it provides these capabilities at “internet scale”, meaning that it is designed to decouple clients and services regardless of whether they are running on premise or in the cloud. As a result, the AppFabric Service Bus is a key technology for enabling hybrid scenarios at the platform level (i.e. PaaS) and serves as a key differentiator in the market today for enabling organizations to adopt cloud computing in a pragmatic way.

Messaging patterns in general provide a common frame on which to think about and build composite applications. Cloud and hybrid computing necessitate many of the same messaging patterns found within the on-premise enterprise and introduce new complexities that are somewhat unique.  imageAzure AppFabric Service Bus V2 introduces tried and true messaging capabilities such as Queues, Topics, Pipes and Filters (Rules/Actions) as well as sequencing semantics and of course durability.

It is important to note that the Azure AppFabric Service Bus is not a replacement for on-premise publish-subscribe messaging. It enables new scenarios that allow you to integrate your current on-premise messaging and provide the ability to compose clouds, be they your own, your partners or those of private cloud providers such as Microsoft. The drawing on the right is from the Microsoft whitepaper I mentioned in the introduction. Notice that the Azure AppFabric Service Bus is providing the ability to integrate clients and services regardless of where they reside, and for non-trivial SOA, on-premise pub-sub for decoupling composed services and clients is essential.


Queues are typically used to provide temporal decoupling, which provides support for occasionally connected clients and/or services. With a queue, a client writes to a known endpoint (private/local or public/somewhere on the network) without regard to the state of the downstream service. If the service/consumer is running, it will read work items or messages from the queue. Otherwise, the queue will retain the message(s) until the service is available to retrieve the message or the message expires.

As promised, Azure AppFabric Service Bus V2 delivers on durable messaging capabilities beyond the current Message Buffer feature with the introduction of Queues.

Queues are supported in the .NET API (shown below), REST API and with a new WCF Binding called “ServiceBusMessagingBinding”. While my preferred approach will certainly be WCF, the .NET API helps to understand the new API. In addition, the process of creating a queue is required even with WCF since queue creation is outside of WCF’s immediate area of concern.

The first thing you need to do when working with Queues, Topics and Subscribers is create a Service Bus Namespace Client which is an anchor class for managing Service Bus entities:

ServiceBusNamespaceClient namespaceClient = new 
serviceNamespace, string.Empty), 

Once you have an instance of the ServiceBusNamespaceClient, you can create a queue by simply instantiating the Microsoft.ServiceBus.Messaging.Queue class (I’ve set the queueName field to “Orders”):

  Queue queue = namespaceClient.CreateQueue(queueName);
Next, create a Queue client. The Queue Client manages both send and receive operations:

1: MessagingFactory messagingFactory =

MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty), sharedSecretCreds);

   2:  var queueClient = messagingFactory.CreateQueueClient(queue); 

The code above uses the Microsoft.ServiceBus.Messaging.MessagingFactory which accepts your namespace and security credentials and returns an instance of the MessagingFactory.

Next, you create an instance of Microsoft.ServiceBus.Messaging.MessageSender using the CreateSender method:

   1:  var messageSender = queueClient.CreateSender();
   2:  messageSender.Send(msg);
   3:  messageSender.Close();

Line 7 below creates a BrokeredMessage, which is a new message class which represents a unit of communication between Service Bus clients. Note that this class has nothing to do with the System.ServiceModel.Channels Message class, however when using the ServiceBusMessagingBinding the classic WCF Message class is used. The BrokeredMessage class consists of a number of methods and some interesting properties including ContentType, CorrelationId, MessageId, Label and a property bag called Properties which we’ll explore as we progress through the new features.

In this example, I’m using an overload of CreateMessage that accepts a serializable object. The method uses the DataContractSerializer with a a binary XmlDictionaryWriter to create a BrokeredMessage.

   1:  Order order = new Order();
   2:  order.OrderId = 42;
   3:  order.Products.Add("Kinect",70.50M);
   4:  order.Products.Add("SamsungFocus", 199.99M);
   5:  order.Total = order.Products["Kinect"] + order.Products["SamsungFocus"];
   7:  var msg = BrokeredMessage.CreateMessage(order); 

Finally, we can send the message:

   1:  var messageSender = queueClient.CreateSender();
   2:  messageSender.Send(msg);
   3:  messageSender.Close();

With much of the infrastructure code out of the way, we can use the same queueClient instance to create a MessageReciever and request the BrokeredMessage message from the Orders queue:

   1:  var messageReceiver = queueClient.CreateReceiver(ReceiveMode.ReceiveAndDelete);
   2:  var recdMsg = messageReceiver.Receive();
   3:  messageReceiver.Close();

Note the ReceiveMode in line 1 above. This has the effect of enforcing an “Exactly-Once” “At Most Once” (thanks David Ingham) receive semantic since the first consumer to read the message will pop it off the queue. The opposite option is RecieveMode.PeekLock which provides “At Least Once” delivery semantics. As David Ingham, Program Manager on the AppFabric team kindly adds in his comments below: “If the consumer is able to record the MessageIds of messages that it has processed then you can achieve “ExactlyOnce” processing semantics with PeekLock mode too.” –Thanks David!

Once we have the BrokeredMessage, we can retrieve the body:

   1:  var recdOrder = recdMsg.GetBody<Order>();
   2:  Console.WriteLine("Received Order {0} with total of ${1}",recdOrder.OrderId,recdOrder.Total); 

The cool thing about the CTP is that Microsoft is offering you a free labs environment in which to explore and play. In the CTP, you can create a maximum of 100 queues, with a maximum size of 100MB each and messages can not exceed a payload size of 256KB- pretty workable constraints for a first CTP.

To get started, and dive in for yourself, be sure to download the Azure AppFabric V2 SDK at:

In my next post, we’ll explore Topics and Subscriptions which allow for rich pub-sub including the ability to multicast to thousands of potential subscribers.

Hats off to the AppFabric Messaging team for all of their hard work with this release!

<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

• Arriet Business Solutions, Inc. announced Ariett Solutions on Microsoft Windows Azure on 6/1/2011:

image Ariett’s MyTripNet and Xpense – leading travel and expense management solutions - are offered as a Software as a Service (SaaS) on the Microsoft Windows Azure platform.

Why Microsoft Windows Azure?

imageMicrosoft Windows Azure is the cloud platform that empowers Ariett to develop and run its applications with unbounded scalability and ease-of-use. With this flexible platform, Ariett customers can easily access our solutions anywhere in the world, to any scale, to meet the demands of their business.

Ariett cloud-based solution on the Windows Azure platform excels at meeting customers demand for privacy, security and reliable accessibility. By using Windows Azure, Ariett offers our customers critical levels of scalability and a security-enhanced infrastructure, with low capital expenditures and operational costs.

Subsequently, our solutions do not require the client’s IT resources to maintain, or support over time – thus lowering costs. With zero-footprint, you can start immediately, regardless of your organizational size. Microsoft manages the system software itself, including applying updates, and Ariett manages the application software including updates.

And Microsoft data centers meet compliance standards and other key accreditations for information security, such as the International Organization for Standardization (ISO) 27001:2005, the Sarbanes-Oxley Act, and the Statement on Auditing Standards (SAS) 70 Type II.

For more information on solutions currently available in the cloud, as well as a roadmap for future cloud product releases, please contact us, send us an email at, or call 781-826-1120. 

Ariett SaaS Resources

To review a copy of our Ariett Service Level Agreement (SLA) or Terms of Service, please visit out Resources page (requires registration).

• Bill Wilder posted Azure FAQ: How do I run MapReduce on Windows Azure? on 6/1/2011:

Q. Some cloud environments support running MapReduce. Can I do this in Windows Azure?

A. The answer is yes. One way is through the open source Apache Hadoop project which implements MapReduce. Details on how to run Hadoop on Azure are available on the Distributed Development Blog.

imageThere is also a MapReduce tutorial on the Apache Hadoop project site which explains the goal of the project, as followed by detailed steps on how to use the software.

“Hadoop MapReduce is a software framework for easily writing applications which process vast amounts of data (multi-terabyte data-sets) in-parallel on large clusters (thousands of nodes) of commodity hardware in a reliable, fault-tolerant manner.” – from Overview section of Hadoop MapReduce tutorial

You may also be interested in checking out DryadLINQ from Microsoft Research. Though not identical to MapReduce, they describe it as “a simple, powerful, and elegant programming environment for writing large-scale data parallel applications running on large PC clusters.” As of this writing it was not licensed for commercial use, but was available under an academic use license.

Is this useful? Did I leave out something interesting or get something wrong? Please let me know in the comments! Think other people might be interested? Spread the word!

See also the Alex Handy described The top five most powerful Hadoop projects in a 6/1/2011 post to SD Times on the Web article in the Other Cloud Computing Platforms and Services section near the end of this post.

Eric Nelson (@ericnel, pictured below) listed Windows Azure MSDN How To tips in one place … in a 6/1/2011 post:

image With thanks to Wriju for doing the work to pull these together.

How to: Build a Windows Azure Application
How to Configure Virtual Machine Sizes
How to Configure Connection Strings
How to Configure Operating System Versions
How to Configure Local Storage Resources
How to Create a Certificate for a Role
How to Create a Remote Desktop Protocol File
How to Define Environment Variables Before a Role Starts
How to Define Input Endpoints for a Role
How to Define Internal Endpoints for a Role
How to Define Startup Tasks for a Role
How to Encrypt a Password
How to Restrict Communication Between Roles
How to Retrieve Role Instance Data
How to Use the RoleEnvironment.Changing Event
How to Use the RoleEnvironment.Changed Event

imageHow to: Use the Windows Azure SDK Tools to Package and Deploy an Application
How to Prepare the Windows Azure Compute Emulator
How to Configure the Compute Emulator to Emulate Windows Azure
How to Package an Application by Using the CSPack Command-Line Tool
How to Run an Application in the Compute Emulator by Using the CSRun Command-Line Tool
How to Initialize the Storage Emulator by Using the DSInit Command-Line Tool
How to Change the Configuration of a Running Service
How to Attach a Debugger to New Role Instances
How to View Trace Information in the Compute Emulator
How to Configure SQL Server for the Storage Emulator

How to: Configure a Web Application
How to Configure a Web Role for Multiple Web Sites
How to Configure the Virtual Directory Location
How to Configure a Windows Azure Port
How to Configure the Site Entry in the Service Definition File
How to Configure IIS Components in Windows Azure
How to Configure a Service to Use a Legacy Web Role

How to: Manage Windows Azure VM Roles
How to Create the Base VHD for a VM Role in Windows Azure
How to Install the Windows Azure Integration Components
How to Enable Windows Azure Connect for a VM Role
How to Develop an Adapter for a VM Role in Windows Azure
How to Prepare the Server Image for Uploading to Windows Azure
How to Upload a VHD to Windows Azure
How to Create and Deploy the VM Role Service Model
How to Use Certificates With a VM Role in Windows Azure
How to Change a Server Image for a VM Role by Using a Differencing VHD
How to Change the Configuration of a VM role
How to Manage the Lifecycle of VM Role Instances in Windows Azure

How to: Administering Windows Azure Hosted Services
How to Setup a Windows Azure Subscription
How to Setup Multiple Administrator Accounts

How to: Deploy a Windows Azure Application
How to Package your Service
How to Deploy a Service
How to Create a Hosted Service
How to Create a Storage Account
How to Configure the Service Topology

How to: Upgrade a Service
How to Perform In-Place Upgrades
How to Swap a Service's VIPs

How to: Manage Upgrades to the Windows Azure Guest OS
How to Determine the Current Guest OS of your Service
How to Upgrade the Guest OS in the Management Portal
How to Upgrade the Guest OS in the Service Configuration File

How to: Manage Management Certificates
How to Create a Management Certificate
How to Add a Management Certificate to a Windows Azure Subscription

How to: Manage Service Certificates
How to Add a New Certificate to the Certificate Store
How to Associate a Certificate with a Service
How to Update a Certificate in the Certificate Store
How to Configure an HTTPS Endpoint in Windows Azure
How to Control Access to Certificates on a Virtual Machine

How to: Use Storage Services
How to Create a Storage Account
How to Read Configuration Settings for the Storage Client Library and Handle Changed Settings

How to: Configure Windows Azure Connect
How to Activate Windows Azure Roles for Windows Azure Connect
How to Install Local Endpoints with Windows Azure Connect
How to Create and Configure a Group of Endpoints in Windows Azure Connect

How to: Manage CDN on Windows Azure
How to Enable CDN for Windows Azure
How to Map CDN Content to a Custom Domain
How to Remove Content from the CDN
How to Manage Expiration of Blob Content
How to Manage Expiration of Hosted Service Content

Related Links

Maarten Balliauw (@maartenballiauw) reported MyGet now supports pushing from the command line in a 6/1/2011 post:

image One of the work items we had opened for MyGet was the ability to push packages to a private feed from the command line. Only a few hours after our initial launch, David Fowler provided us with example code on how to implement NuGet command line pushes on the server side. An evening of coding later, I quickly hacked this into MyGet, which means that we now support pushing packages from the command line!

For those that did not catch up with my blog post overload of the past week: MyGet offers you the possibility to create your own, private, filtered NuGet feed for use in the Visual Studio Package Manager.  It can contain packages from the official NuGet feed as well as your private packages, hosted on MyGet. Want a sample? Add this feed to your Visual Studio package manager:

Pushing a package from the command line to MyGet

The first thing you’ll be needing is an API key for your private feed. This can be obtained through the “Edit Feed” link, where you’ll see an API key listed as well as a button to regenerate the API key, just in case someone steals it from you while giving a demo of MyGet :-)


Once you have the API key, it can be stored into the NuGet executable’s settings by running the following command, including your private API key and your private feed URL:

1 NuGet setApiKey c18673a2-7b57-4207-8b29-7bb57c04f070 -Source

After that, you can easily push a package to your private feed. The package will automatically show up on the website and your private feed. Do note that this can take a few minutes to propagate.

1 NuGet push RouteMagic. -Source

More on the command line can be found on the NuGet documentation wiki.

Other change: Authentication to the website

Someone on Twitter (@corydeppen) complained he had to login using Windows Live ID. Because we’re using the Windows Azure AppFabric Access Control Service (which I’ll abbreviate to ACS next time), this was in fact a no-brainer. We now support Windows Live ID, Google, Yahoo! and Facebook as authentication mechanisms for MyGet. Enjoy!

<Return to section navigation list> 

Visual Studio LightSwitch

image2224222222No significant articles today.


Return to section navigation list> 

Windows Azure Infrastructure and DevOps

VSM1106Cover90px My New Migration Paths to the Microsoft Cloud cover article for the June 2011 issue of Visual Studio Magazine, which went live on 6/1/2011, answers “Will emerging developer tools and hybrid Platform as a Service features ramp up project and data deployments to Windows Azure?” From the introductory paragraphs:

Scott Guthrie, the former corporate vice president of the .NET imageDeveloper Platform, who's worked on ASP.NET since it was alpha code, will begin the toughest challenge of his career when he assumes control of the Azure Application Platform team, starting this month. The Windows Azure platform will face heightened scrutiny from Microsoft top management after a major reorganization of the company's Server and Tools Business (STB) group and the Developer Division, which is part of the STB. The re-org was announced internally in May [2011].

image Microsoft CEO Steve Ballmer -- along with some others on his leadership team -- appears to be disappointed in Windows Azure uptake by .NET developers during its first year of commercial availability. Gaining developer mindshare requires leveraging their current investment in .NET programming skills by minimizing application architecture and coding differences between traditional ASP.NET projects and Windows Azure Web Roles. Convincing developers and their IT managers to sign up for pay-per-use Windows Azure subscriptions necessitates proof of quick and easy migration of existing ASP.NET Web apps from on-premises or traditionally hosted servers to Microsoft datacenters.

imageI'll describe the progress the Windows Azure team has made since Bob Muglia, the former head of the STB group, and Scott Guthrie announced a range of new tooling and services at the Microsoft Professional Developers Conference (PDC) in November [2010]. …

image The magazine’s art department wasn’t able to render Figure 3 (Concero) with print quality and it missed the online edition’s “Deploy Private and Hybrid Clouds” section. Here’s my original version of Figure 3 and its caption:


Figure 3. Manage Windows Azure Subscriptions and Private Windows Server 2008 R2 Clouds with “Project Concero”

image “Project Concero” is the codename for a new Microsoft Systems Center feature for managing virtualized Windows Server 2008 R2 server instances on premises and in the Azure cloud. A limited-feature release is expected in the second half of 2011. (Screen capture courtesy of the Microsoft System Center Team.)

There wasn’t enough room in the magazine for the references in Table 1: Timeline of Advances in Migrating .NET Projects and SQL Server Databases to Windows Azure and SQL Azure, so it’s reproduced below (without the Short URL column):

Major updates to the Windows Azure Software Development Kit (SDK) and Visual Studio Tools for Azure have a tendency to occur in “waves,” which are often associated with a Microsoft event, such as Professional Developer Conferences, World Wide Partner Conferences, MIX and the like. All major Azure SDK updates include usability and application migration enhancements, as well as updates to libraries and Visual Studio templates.



Description or Event



World Wide Partner Conference 2010


Jeffrey Schwartz

Microsoft's Cloud in a Box


Systems Center vNext Team

Windows Azure Monitoring Management Pack Release Candidate (RC) Now Available for System Center Operations Manager 2007


MSDN Library

Collecting Logging Data by Using Windows Azure Diagnostics



Professional Developer Conference 2010


Windows Azure Team

Just Released: Windows Azure SDK 1.3 and the new Windows Azure Management Portal


Neil MacKenzie

Configuration Changes to Windows Azure Diagnostics in Azure SDK v1.3


Windows Azure Team

New Full IIS Capabilities: Differences from Hosted Web Core


Roger Jennings

Adding Trace, Event, Counter and Error Logging to the OakLeaf Systems Azure Table Services Sample Project


Windows Azure Team

Windows Azure Software Development Kit (SDK) Refresh Released (v1.3.1)


Andy Cross

File Based Diagnostics Config with IntelliSense in Azure SDK


Steven S. Warren

What Server App-V means for applications in the cloud


MSDN Library

Overview of the Windows Azure VM Role


Andy Cross

Windows Azure SDK V1.4 Released


Andy Cross

Implementing Azure Diagnostics with SDK V1.4



Microsoft Management Summit 2011



System Center Virtual Machine Manager (VMM) 2012 Beta Resource Page



Download Microsoft System Center Virtual Machine Manager (VMM) 2012 Beta


Kenon Owens

90 seconds to the cloud: Virtual Machine Manager 2012 Beta (video)


Jeffrey Schwarz

Server App-V Beta Added to SCVMM 2012


System Center Team

Announcing System Center Project Codename “Concero”


Kristian Nese

The cloud is moving closer to the IT pro (Project Concero)


George Huey

SQL Azure Migration Wizard v3.6.1


Windows Azure Team

Windows Azure SDK and Windows Azure Tools Refresh for Microsoft Visual Studio (March 2011) v1.4.1


Azure AppFabric Team

Windows Azure AppFabric Access Control April release available now! (v2.0.1)


Shashank Pawar

SQL Server as a Service/ SQL Server Private Cloud Offering



MIX 2011


James Conard

What’s New in the Windows Azure Platform (MIX 11 session video)


Neil MacKenzie

Windows Azure Traffic Manager


Windows Azure Team

Now Available: Windows Azure SDK 1.4 Refresh with Web Deploy Integration


Windows Azure Team

Windows Azure Platform Training Kit - April Update


Nuno Filipe Godinho

MIX11 - Session Review - What’s New in the Windows Azure Platform


Robin Shahan

How to Migrate a Web Application to Windows Azure and SQL Azure


John R. Rymer

How Cloud Computing Will Change Application Platforms


Jonathan Hassell

Project Concero and its role in Microsoft's cloud strategy


SQL Server Team

SQL Server Migration Assistant v5.0 is now available


AppFabric CAT Team

Windows Azure AppFabric Caching Service Released and notes on quotas


Mary Jo Foley

Microsoft's plan to increase its focus on developers: The full internal memo


Mary Jo Foley

Microsoft reorg: Scott Guthrie to head new Azure Application Platform team


Kurt Mackie

System Center 2012 Preview: What to Expect


Jeffrey Schwartz

HP Exec Leaks Cloud Plans


Windows Azure Team

New Windows Azure Connect Features Add New Locations, Enhance Interface

You also can download the table along with the code from the button on the article’s first page.

Full disclosure: I’m a contributing editor for 1105 Media’s Visual Studio Magazine.

On topic similar to my article, Michael Desmond (@MichaelDesmond) posted The Sinofsky Shuffle to his Visual Studio Magazine Frameworks column on 6/1/2011:

image When Scott Guthrie, former corporate vice president of the .NET Platform at Microsoft, left the Developer Division to head up a new Windows Azure business unit, I was more than concerned. Guthrie, after all, is widely credited with energizing the Microsoft development portfolio and helping spearhead the company's commitment to openness and interoperability. His ability to connect with rank-and-file developers has been a huge asset for Microsoft.

image But Redmond has been down this road before. Steven Sinofsky built a well-earned reputation as a disciplined manager leading the Office group, producing stable, on-time releases of the massive Microsoft productivity suite. So when Windows Vista went off the rails, Microsoft tapped the low-key Sinofsky to take control. The result, Windows 7, has (nearly) made us forget all about Windows Vista. Call it the Sinofsky Shuffle.

imageGuthrie is another case of a man whose talents fit the challenge. Where Sinofsky brought discipline, Guthrie brings creative energy to a Windows Azure platform that's yet to generate real excitement. As head of the Azure Application Platform group, Guthrie can do what he does best -- connect with developers and create a development ecosystem.

And it turns out that .NET developers -- particularly Web developers -- will still have Guthrie to kick around. Guthrie wrote on his blog that he'll "continue to run a lot of the core .NET teams," listing ASP.NET, Windows Communication Foundation, Windows Workflow Foundation, AppFabric, IIS, Visual Studio Web Tools and WebMatrix.

Guthrie is no longer in the Developer Division, but his leadership should continue to shape key areas of the development stack.

Michael is editor in chief of Visual Studio Magazine.

Full disclosure: I’m a contributing editor for Visual Studio Magazine.

The Windows Azure Team recommended that you Analyze Your Move to the Cloud and Windows Azure With MAP 6.0 Beta in a 6/1/2011 post:

If you’re considering a move to the cloud for your portfolio of applications, planning your journey just got a bit easier.  The next version of the Microsoft Assessment and Planning (MAP) Toolkit—version 6.0— is now available for free download as part of the MAP 6.0 Beta Program. This new release includes the Windows Azure Migration Portfolio Analysis, which offers the ability to quantify and label applications and services in your organization’s IT environment to consider migrating to the Windows Azure platform.

imageThe Windows Azure Migration Portfolio Analysis will enable you to:

  • Catalog all of the applications in your environment
  • Estimate the needed capacity to run your applications on the Windows Azure platform
  • Evaluate applications based on migration difficulty
  • Stack rank applications in terms of migration suitability
  • Obtain a TCO-ROI analysis for the application

The MAP 6.0 Beta will also help you:

  • Accelerate planning to private cloud with Hyper-V Cloud Fast Track Onboarding
  • Identify migration opportunities with enhanced heterogeneous server environment inventory
  • Assess your client environment for Office 365 readiness
  • Determine readiness for migration to Windows Internet Explorer 9
  • Discover Oracle database schemas for migration to SQL Server

MAP works with the Microsoft Deployment Toolkit [see article below] and Security Compliance Manager to help you plan, securely deploy, and manage new Microsoft technologies—easier, faster, and at less cost. Learn more.

Click here to register for the MAP 6.0 Beta Review program.

• Jeff Wettlauger of the System Center Team announced availability of the Microsoft Deployment Toolkit 2012 Beta 1 in a 6/1/2011 post":

image The next version of the Microsoft Deployment Toolkit—version 2012— is now available for beta download. To participate, register for MDT 2012 Beta 1 at Microsoft Connect.

image Microsoft Deployment Toolkit (MDT) 2012 Beta 1 rides the next wave of System Center releases with support for System Center Configuration Manager 2012. For Lite Touch installations, MDT 2012 improves the overall client-side user experience, while also providing behind-the-scenes enhancements for partitioning, UEFI, and user state migration. These features, combined with many small enhancements, bug fixes, and a smooth and simple upgrade process, make MDT 2012 Beta 1 more reliable and flexible than ever.

Key Benefits:

  • Fully leverages the capabilities provided by System Center Configuration Manager 2012 for OS deployment.
  • Improved Lite Touch user experience and functionality.
  • A smooth and simple upgrade process for all existing MDT users.

Tell the MDT team what you think! To participate in the MDT 2012 Beta 1 program, download and test the tool in your environment and then provide timely feedback and suggestions to our development team. MDT 2012 Beta 1 runs through August 2011. Please submit your feedback through Connect and direct any support questions you may have to Thank you for taking the time to help us improve the MDT product feature and functions. Your time and assistance are much appreciated.

Next steps:

Get the latest tips from Microsoft Solution Accelerators—in 140 characters or less! Follow us on Twitter: @MSSolutionAccel.

• Jo Maitland (@JoMaitlandTT) asked Can cloud performance tests determine real-world results? in a 6/1/2011 article for

image IT shops interested in moving workloads to the cloud should check out the performance rankings of cloud providers by CloudSleuth, a cloud monitoring service owned by Compuware Inc. But experts say to take the results with a hefty grain of salt.

imageGoogle App Engine came in first, followed by Microsoft Azure, then GoGrid. The rankings measures the response time to a test application that all providers in the study agreed to run in their cloud. The tests are run from 125 end-user U.S. locations in all 50 states and from 75 international locations in 30 countries and are conducted every 15 minutes. For more details on the methodology and results, check out CloudSleuth's application Global Provider View.

image "A few seconds matter a great deal -- to some applications more than others, but at a certain scale it matters to almost everybody," said Geva Perry, cloud computing analyst and consultant. "If users have to wait for an application to load, you have a user experience problem right there."

At scale, Perry said this also becomes a cost problem. In a 10-second period, for example, how many calls and responses can you get from your application? With hundreds or potentially thousands of users, that operation can be parallelized which has a direct bearing on the cost savings.

Real-world implications of cloud performance tests
CloudSleuth's test application is a simple, simulated retail shopping site, but user experience is important for any application, not just for online bookstores.'s business depends on it. CloudSleuth's data is helpful, but there are some gaps.

"It is useful, assuming your app is anything like the application they use," said James Staten, VP and principal analyst at Forrester Research.

Architectures and workloads are different. They can be compute intensive versus data intensive, or throughput sensitive versus latency sensitive, and each provider might rank differently based on the different kinds of applications its cloud service targets. Their architectures might use more memory or disk storage or use the network differently, and so the results would not be the same for every application.

Staten advised enterprises to perform a test of their own application on different providers' clouds to get a real indicator of performance. He added that there's some "gaming of the system" going on too, where service providers will tweak and tune their service to run the CloudSleuth app really well.

"[CloudSleuth] is really a sales tool for Compuware to go to service providers and say, 'here's how you improve performance' … but still, putting the data out there is a way to keep everyone honest," Staten said.

Ideally, users would like to be able to see how much it costs for different kinds of performance and workloads. If the best performance costs twice as much and you only have one small app and a few users, it's not worth the price. But if you have to run 10,000 instances of your application and you can't tolerate even a microsecond's delay, it's a big deal.

The Wall Street banks are a good example of the latter, as they are typically price insensitive. Their trading applications are worth millions of dollars to the bank, so a microsecond matters, and they will spend any amount of money to get the best performance. But for most companies, cost matters significantly.

CloudSleuth is planning to offer users the ability to benchmark and test their own applications. Competitors to CloudSleuth include Keynote and Cedexis. The cloud providers mentioned in this story were contacted for comment but did not get back to us by press time.

Jo Maitland is the Senior Executive Editor of

Lori MacVittie (@lmacvittie) asserted If Amazon’s Availability Zone strategy had worked as advertised its outage would have been non-news. But then again, no one really knows what was advertised… as an introduction to her When Black Boxes Fail: Amazon, Cloud and the Need to Know post of 6/1/2011 to F5’s DevCentral blog:

image There’s been a lot said about the Amazon outage and most of it had to do with cloud and, as details came to light, about EBS (Elastic Block Storage). But very little mention was made of what should be obvious: most customers didn’t – and still don’t - know how Availability Zones really work and, more importantly, what triggers a fail over. What’s worse, what triggers a fail back?  Amazon’s documentation is light. Very light. Like cloud light.

quote-badge Availability Zones are distinct locations that are designed to be insulated from failures in other zones. This allows you to protect your applications from possible failures in a single location. Availability Zones also provide inexpensive, low latency network connectivity to other Availability Zones in the same Region.

-- Announcement: New Amazon EC2 Availability Zone in US East

imageNow, it’s been argued that part of the reason Amazon’s outage was so impactful was a lack of meaningful communication on the part of Amazon regarding the outage. And Amazon has admitted to failing in that regard and has promised to do better in the future. But just as impactful is likely the lack of communication before the outage; before deployment.  After all, the aforementioned description of Availability Zones, upon which many of the impacted customers were relying to maintain availability, does not provide enough information to understand how Availability Zones work, nor how they are architected.

Scrounging around the Internet turns up very little on how Availability Zones work, other than isolating instances from one another and being physically independent for power. In the end, what was promised was a level of isolation that would mitigate the impact of an outage in one zone.

Turns out that didn’t work out so well but more disconcerting is that there is still no explanation regarding what kind of failure – or conditions – result in a fail over from one Availability Zone to another. Global Application Delivery Services (the technology formerly known as Global Server load balancing) is a similar implementation generally found in largish organizations. Global application delivery can be configured to “fail over” in a variety of ways, based on operational or business requirements, with the definition of “failure” being anything from “OMG the data center roof fell in and crushed the whole rack!” to “Hey, this application is running a bit slower than it should, can you redirect folks on the east coast to another location? Kthanxbai.” It allows failover in the event of failure and redirection based on failure to meet operational and business goals. It’s flexible and allows the organization to define “failure” based on its needs and on its terms. But no such information appears to exist for Amazon’s Availability Zones and we are left to surmise that it’s like based on something more akin to the former rather than the latter given their rudimentary ELB (Elastic Load Balancing) capabilities.

When organizations architect and subsequently implement disaster recovery or high-availability initiatives – and make no mistake, that’s what using multiple Availability Zones on Amazon is really about – they understand the underlying mechanism and triggers that cause a “failover” from one location to another. This is the critical piece of information, of knowledge, that’s missing.  In an enterprise-grade high-availability architecture it is often the case that such triggers are specified by both business and operational requirements and may include performance degradation as well as complete failure. Such triggers may be based on a percentage of available resources, or other similar resource capacity constraints. Within an Amazon Availability Zone apparently the trigger is a “failure”, but a failure of what is left to our imagination.

But also apparently missing was a critical step in any disaster recovery/high availability plan: testing. Enterprise IT not only designs and implements architectures based on reacting to a failure, but actually tests that plan. It’s often the case that such plans are tested on a yearly basis, just to ensure all the moving parts still work as expected. Relying on Amazon – or any cloud computing environment in which resources are shared – makes it very difficult to test such a plan. After all, in order to test failover from one Availability Zone to another Amazon would have to forcibly bring down an Availability Zone – and every application deployed within it. Consider how disruptive that process might be if customers started demanding such tests on their schedule. Obviously this is not conducive to Amazon maintaining its end of the uptime bargain for those customers not deployed in multiple Availability Zones. 

image Without the ability to test such plans, we return to the core issue – trust. Organizations relying wholly on cloud computing providers must trust the provider explicitly. And that generally means someone in the organization must understand how things work. Black boxes should not be invisible boxes, and the innate lack of visibility into the processes and architecture of cloud computing providers will eventually become as big a negative as security was once perceived to be.

Interestingly enough, a 2011 IDG report on global cloud computing adoption shows that high performance (availability and reliability) are the most important – 5% higher than security. Amazon’s epic failure will certainly do little to alleviate concerns that public cloud computing is not ready for mission critical applications.

Now, it’s been posited that customers were at fault for trusting Amazon in the first place. Others laid the blame solely on the shoulders of Amazon. Both are to blame, but Amazon gets to shoulder a higher share of that blame if for no other reason than it failed to provide the information necessary for customers to make an informed choice regarding whether or not to trust their implementation. This has been a failing of Amazon’s since it first began offering cloud computing services – it has consistently failed to offer the details necessary for customers to understand how basic processes are implemented within its environment. And with no ability to test failover across Availability Zones, organizations are at fault for trusting a technology without understanding how it works. What’s worse, many simply didn’t even care – until last week.

explanation-i-demand-oneNow it may be the case that Amazon is more than willing to detail such information to customers; that it has adopted a “need to know” policy regarding its architecture and implementation and its definition of “failure.”  If that is the case, then it behooves customers to ask before signing on the dotted line. Because customers do need to know the details to ensure they are comfortable with the level of reliability and high-availability  being offered. If that’s not the case or customers are not satisfied with the answers, then it behooves them to – as has been suggested quite harshly by many cloud pundits – implement alternative plans that involve more than one provider.

A massive failure on the part of a public cloud computing provider was bound to happen eventually. If not Amazon than Azure, if not Azure then it would have been someone else. What’s important now is take stock and learn from the experience – both providers and customers – such that a similar event does not result in the same epic failure again. Two key points stand out: 

  1. The need to understand how services work when they are provided by a cloud computing provider. Black box mentality is great marketing (hey, no worries!) but in reality it’s dangerous to the health and well-being of applications deployed in such environments because you have very little visibility into what’s really going on. The failure to understand how Amazon’s Availability Zones actually worked – and exactly what constituted “isolation” aside from separate power sources as well as what constitutes a “failure” – lies strictly on the customer.  Someone within the organization needs to understand how such systems work from the bottom to the top to ensure that such measures meet requirements. 
  2. The need to implement a proper disaster recovery / high availability architecture and test it. Proper disaster recovery / high availability architectures are driven by operational goals which are driven by business requirements. A requirement for 100% uptime will likely never be satisfied by a single site, regardless of provider claims.

And if you can’t test it but need to guarantee high uptime and can’t get the details necessary to understand – and trust – the implementation to provide that uptime,  perhaps it’s not the right choice in the first place.

Or perhaps you just need to demand an explanation.  

Frank Artale posted Cloud’s rise as a pervasive platform on 5/31/2011 to his Platforms in the Cloud blog for Computerworld:

image Buzz Lightyear might disagree, but cloud is a platform, not a destination.

Notice that I did not say "the cloud" but rather "cloud." That differentiation is important because I'm talking about a thing -- not a place.

image New and widespread computing platforms appear only every so often, and a set of cloud technologies in aggregate represents the next pervasive platform. "The cloud," on the other hand, is clearly a place that is an implementation of a cloud platform, plus a whole lot of process and procedure to make it run.

While the place is certainly interesting and yields some great marketing, it's the platform (i.e., the thing) that makes it all happen. Without a true platform that enables it, "the cloud" is really just an outsourced data center. Need more convincing? For perspective, let's take a quick look back at some previous platform shifts, such as the dark days when we had to tweak our NOSes to create a (somewhat) usable PC server platform.

Tweaking our NOSes

In the late 1980s, the first network operating systems (NOS) started to appear. Their primary use case was file- and print-serving. The way you deployed one of these was to contact a network reseller and pay a ridiculous amount of money for someone to come install network adapters and device drivers in desktop PCs and to also install the NOS on one larger desktop PC. For the server and a few desktops, software alone might have run into the $7000 range, and then the cost of labor was more. Hardware was very specific to the NOS and the desktop PC drivers. To create a file server, what the NOS vendors and their high-margin resellers did was bend the desktop PC platform (something built to run character-mode word processors and spreadsheets and do dialup communications). As a result, performance and reliability were hard to characterize, because the platform was not built for the use case.

Birth of the PC server platform

In the early 1990s, the hardware guys decided to create an adaptation of the deskside PCs that was properly configured to suit the server use case "out of the box." That is, networking was standard on the machines, as were properly sized and performing memory, cache and disk subsystems. The new platform was tested with new NOSes (like Netware, OS/2, Windows NT, and a bit later Linux and ESX) that were designed with the target platform in mind, as opposed to being retrofitted. Total cost of ownership came down dramatically, and the NOS became commodity-priced. The PC server platform was born and was defined by both hardware and software functions.

Of course, I'm oversimplifying all of this, but I recall history in order to set context for where we are today.

Cloud formation

The venerable operating systems of the 1990s are at the core of what runs applications in the cloud today. So EC2, Rackspace, Joyent, and the various VMware and Windows Server hosters use those operating systems -- coupled with hypervisors, modern chipsets and the server design work that was done -- to create very stable and scalable server nodes. On top of and underneath those systems are management layers that have been put together to express the server utilities we recognize as familiar infrastructure as a service (IaaS) today.

While important and necessary, the natural evolution of those operating systems is not "cloud, the software platform." When you take one of the server OSes from the 1990s and the 2000s, along with its captive set of server applications and tools, and try to say it is a cloud platform, you are tweaking it in the same way the early NOS guys bent the PC platform to make it act like a server. There are new systems like Windows Azure, which has taken a fresh approach while starting from a known core.

What now?

I'm not saying we should throw away the OSes and hypervisors that have taken us this far. Those structures do an amazing and all too easily forgotten job of making the server nodes reliable, scalable and secure. What I am saying is that the cloud platform is something much more. This is something designed for a different kind of scalability, management (or lack thereof), application enablement and security that can be layered onto the core that works so well today.

imageIn this inflection point, we can think about products and services that were not possible before. Recently much of that action is in the layers above the OS and hypervisor (an example is VMware's recent Cloud Foundry announcement). The folks at Amazon (AWS) and Microsoft (Azure Services) are working at it too, in addition to a bevy of startups pushing the envelope and challenging traditional thinking. Red Hat recently entered the space to add more to the mix with its OpenShift Platform as a Service. [Emphasis added.]

This blog will be about the platform and the requirements it aims to satisfy, with news and opinions and stuff in between, and I'll draw heavily from patterns that I have observed over the past 26 years. Stay tuned!

Frank Artale is a partner at Ignition Partners, a venture capital firm, where he specializes in cloud, core infrastructure, networking, and security investments

Roberto Brunetti’s new Windows Azure™ Step by Step book from Microsoft Press went live on Safari Online on 5/31/2011:

image Teach yourself how to build and host scalable applications in the cloud using the services and features of Windows® Azure™ -- one step at a time. Ideal for those with fundamental programming skills, this tutorial provides practical, learn-by-doing exercises for mastering the entire Azure platform.

From the Introduction:

Who Should Read This Book
imageThis book’s goal is to aid .NET developers who want to start working with the components of the Windows Azure platform—from the operating system to SQL Azure and Windows Azure AppFabric. A solid knowledge of the .NET Framework is helpful in fully understanding the code examples and following the exercises using Visual Studio. The content of this book should also prove useful to software architects who need an overview of the components they plan to include in the overall architecture of a cloud-based solution.

Who Should Not Read This Book
If you have already been working with the Windows Azure platform, this book is probably not for you. This book is an introductory guide to developing applications that leverage the platform.

<Return to section navigation list> 

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


No significant articles today.

<Return to section navigation list> 

Cloud Security and Governance

Chris Hoff (@Beaker) posted an Incomplete Thought: The Curious Case Of the Carnival Cloud to his Rational Survivability blog on 6/1/2011:

The former Thunderbolt roller coaster, Coney I...

As a follow-on example to my blog titled The Curious Case of the MBO Cloud, in which I detailed the mad rush of companies to deploy something — anything — that looks like a “cloud” to achieve an artificial benchmark of cloudiness, I present you the oft-experienced “Carnival Cloud.”

What’s a Carnival Cloud?

Have you been to Disneyland?  Perhaps a Six Flags theme park?  Perhaps even Coney Island?  If so,  you’ve likely marveled at the engineering and physics associated with some of the rides.  Seeing a train of interconnected people haulers hurtling around a steel (or wooden) substructure of vomit-inducing gravity abuse is a marvelous thing.

I saw a documentary on the construction of some of these modern wonders.  Amazing.  Well modeled, precision engineered, expertly designed and a remarkably good track record of safety.  Yes, sometimes bad things happen, but rarely do you see a rollercoaster at a theme park decommissioned due to inherent design flaws.

I do however sometimes reflect on these rides and the notion that one willingly slaps down some money, straps in, gets rocketed around at 60+ mph pulling G’s rivaling that of some fighter aircraft and realize there’s really no Plan B should something go ass over tea kettles.

One simply has to trust in the quality of design, the skills of the engineering, the on-going maintenance efforts and the 16 year old who pushes the go-button after your crotch-squashing safety bar is slammed into one’s lap and morphs your unmentionables.

…keep your hands inside the ride at all times…

We trust that we’ll come out the other side and give no pause to the fact that the hopes for such are granted by the fact that these rides are often heavily automated, computer controlled and are instrumented to detect failure or flaw.

Now, have you been to a local fair or carnival?

Contrast your experience at Six Flags — often with the same level of risk — with a local carnival ride that’s unloaded from the back of a 1972 Chevy Stepsider, bolted together (and repeatedly unbolted) with some handtools and the sticky residue of lubricating oil and cotton candy.

I don’t know about you, but putting my life in the hands of carnie who does double duty as the bearded lady doesn’t inspire confidence, especially when the Tilt-o-whirl has the potential to demonstrate the unfortunate ramifications of cascading failure domains in physics that run well beyond the fact the some of these operators can’t count past the 4 missing fingers they have on their right hand.

This isn’t saying that carnivals aren’t fun.  This isn’t implying that toothliness ain’t close to Godliness (especially when the afterlife is one missing bolt away.) This isn’t saying you shouldn’t go, thereby missing the nacho cheese-dipped pretzel logs and colon-clogging funnel cakes.

Nay, the point is to simply suggest that there’s a lot to be said for solid infrastructure — regardless of where it’s sourced — that’s performant, safe, operated and maintained in a ruthlessly diligent manner, instrumented well and is subject to constant rigor and inspection.

Relating that to cloud, your experience — depending upon your appetite for risk (and nacho cheese) — will dictate whether your E-ticket ride ends well or as a footnote on MSNBC.

Mmmm. Ableskivers and giant stuffed armadillos.  Anyone got change for a $20?


Related articles

Todd Hoff asserted Why is your network so slow? Your switch should tell you in a 6/1/2011 post to the High Scalability blog:

Who hasn't cursed their network for being slow while waiting for that annoying little hour glass of pain to release all its grains of sand? But what's really going on? Is your network really slow? PacketPushers Show 45 – Arista – EOS Network Software Architecture has a good explanation of what may be really at fault (paraphrased):

Network operators get calls from application guys saying the network is slow, but the problem is usually dropped packets due to congestion. It's not usually latency, it's usually packet loss. Packet loss causes TCP to back off and retransmit, which causes applications to appear slow.

Packet loss can be caused by a flakey transceiver, but the problem is usually network congestion. Somewhere on the network there's fan-in, a bottleneck develops, queues build up to a certain point, and when a queue overflows it drops packets. Often the first sign of this happening is application slowness.

Queues get deeper and deeper because the network is getting more and more use over time. Traffic is continually being added.

Get your switch to tell you about your queue stats so you can take proactive action. Find out if your network is going to drop packets before it happens. Polling doesn't work. Polling for stats will miss problems because you can miss queue threshold crossings. You need alerts to be correct. Polling can't see the microbursts which cause loss. It doesn't take a lot of loss to cause problems. 

An obvious fix is to reduce the traffic on your network. Perhaps applications are in tight loops and are flooding the network. Maybe your network needs upgrading.  In some cases a WAN accelerator might help.

But the idea that your network infrastructure shouldn't be hiding problems, but should be telling you when you are having problems, is an overlooked one. From a code perspective it's just impossible to tell what's really happening on the underlying layers without help from the network.

The podcast also has a good discussion of modern embedded architecture practices, but I thought this take on network issues, and how your network infrastructure should be helping you debug root causes, was helpful and worth pulling out.

Related Articles

Nicole Freiss posted Changes to HIPAA Privacy Rule Proposed by HHS - Find Out Who Has Accessed Your Health Records on 6/1/2011 to the Information Law Group blog:

image On May 31, 2011 the Department of Health and Human Services Office for Civil Rights issued a notice of proposed rulemaking that would add substantial data privacy requirements to the HIPAA Privacy Rule. One of the requirements the HHS proposed pursuant to both the HITECH Act and its more general authority under HIPAA is for individuals to have the right to request from a covered entity (such as a health care provider or a health plan) a list of any individuals or entities that have accessed the individuals’ electronic health records. Currently, HIPAA and HHS regulations require covered entities to track access to health records, but they covered entities are not required to provide that information to patients.

The proposed rule would give patients the right to request an “access report” which would document the identities of those who electronically viewed their protected health information. “This proposed rule represents an important step in our continued efforts to promote accountability across the health care system, ensuring that providers properly safeguard private health information,” said Georgina Verdugo, Director of the Office for Civil Rights. “We need to protect peoples’ rights so that they know how their health information has been used or disclosed.”

image The right to an access report would apply only to health information that is maintained using an electronic system, as tracking access to paper records is not automated and would be unduly burdensome according to HHS. The proposed regulations would require covered entities to generate, upon request, an access report from access log data, which is collected by electronic record systems each time a user accesses protected health information.

Access reports would detail the access by covered entities as well as business associates –entities that create, receive, maintain, or transmit certain health-related information on behalf of covered entities. The proposed rule requires covered entities and business to retain access logs for no less than three years so that an access reports can document access to the individual’s health information for the three years prior to the individual’s request for the report.

Covered entities and business associates are already required to comply with the HIPAA Security Rule, which obligates them to track access to protected health information. As such, HHS believes that the proposed rule will not be unduly burdensome. According to HHS, many electronic systems are already configured to log the activities that the proposed access reports would reference.

Under the proposed rule, access reports would include the date and time of access, and the name of the individual or entity accessing an individual’s health information. Additionally, if available, an access report would include a description of the information that was accessed and of the action taken by the user (e.g., whether they created, modified or deleted the information). Access reports also must include a statement informing individuals of their right to request access reports in their notices of privacy practices. Additionally, while individuals would be entitled to receive their first access report free of charge, the proposed rule would allow covered entities to charge reasonable, cost-based amounts for any subsequent reports requested within a 12-month period.

To minimize the volume of data in an access report, covered entities could give individuals the option to limit the coverage of the report by a specific date, time period, or person. For example, the individual requesting a report could elect to limit an access report to disclose only whether a particular family member accessed the individual’s health records within the last six months. Additionally, HHS is recommending – although not requiring in the proposed rule – that covered entities offer individuals the option to limit access reports to specific organizations. For example, if an individual does not wish to learn whether his or her health records were accessed by business associates, the covered entity would not need to obtain access logs from the relevant business associate to include in the access report the covered entity provides to the individual.

The proposed rule would require covered entities and business associates that implemented electronic record systems after January 1, 2009 to produce access reports beginning January 1, 2013. Entities that have implemented electronic record systems acquired on or before January 1, 2009 would be required to comply with the proposed rule beginning January 1, 2014. HHS has requested comments regarding a variety of issues the proposed rule has raised, and will receive comment submissions until August 1, 2011 (to submit a comment, click HERE ).

InfoLawGroup’s Nicole Friess and Boris Segalis collaborated on this blog post.

Michael Crandall described How to Ensure Business Continuity in the Cloud in a 5/31/2011 post to Giga Om’s Structure blog:

image After years of hype, the IT industry finally had a rude awakening this spring, reminding us that cloud computing infrastructures are vulnerable to the same genetic IT flaw that plagues traditional data center operations: Everything fails sooner or later.

image In March, an 8.9 earthquake and subsequent tsunami caused widespread disruptions to power supplies and network connectivity to data centers across Japan, causing Japanese companies to rethink their traditional disaster recovery strategies. Several weeks later, the EBS system in one of Amazon’s EC2 data centers in the Eastern U.S. failed due to a faulty router upgrade and a cascade of resulting events, sent hundreds of customers—including many Web 2.0 companies such as Foursquare and Reddit—scrambling in an effort to resume services.

image Ironically, these events also highlight how cloud infrastructures, when managed correctly, actually provide unprecedented capabilities to deliver high availability, resiliency and business continuity in IT operations.

Planning for Failure in the Cloud

Protecting your organization from unplanned downtime is widely dependent on building redundancy and diversity directly into your disaster recovery and business continuity systems. Business systems need to be able to run on a number of different infrastructures — whether they be public clouds such as Amazon or Rackspace, or private clouds using traditional on-premise hardware — and be able to fail over between them quickly and efficiently as necessary.

Despite the Amazon outage, public clouds now provide organizations with an impressively wide array of options to implement business continuity at a level of affordability that simply did not exist a few years ago. Consider this: Right now, from my laptop, I can launch servers in a dozen disparate locations worldwide – including the U.S., Europe, and Asia – for pennies per hour. As a result, I can design a system for my business that can reasonably withstand localized outages at a lower cost than previously possible.

The key is to design your infrastructures for the possibility of failure. Amazon’s CTO Werner Vogels has been preaching this religion for many years, suggesting the only way to test the true robustness of a system is to ‘pull the plug.’ Netflix — itself a major cloud infrastructure user — has created a process it calls “the Chaos Monkey” that randomly kills running server instances and services just to make sure the overall system continues to operate well without them. Not surprisingly, Netflix’s overall operation saw little impact from the AWS U.S. East outage when it occurred.

Implementing failure-resilient systems isn’t easy. How can you quickly move your operations from one infrastructure to the next when the pressure is on and the alarm bells are ringing? How do you design a system that not only allows new compute resources to begin to operate as part of your service, but also folds in an up-to-date copy of the data your users and customers depend on?

Redundancy and Automation in the Cloud

There is, of course, no magic bullet. But there is a general approach that does work: combining redundancy in design with automation in the cloud management layer. The first step requires architecting a solution that uses components that can withstand failures of individual nodes, whether those are servers, storage volumes, or entire data centers. Each component (e.g. at the web layer, application layer, data layer) needs to be considered independently, and designed with the realities of data center infrastructure and Internet bandwidth, cost and performance in mind. Solutions for resilient design are almost as many and varied as are the software components they utilize. For example, databases alone comprise a wide range of approaches and resiliency characteristics, including SQL, NoSQL, replication, caching technologies, etc.

But the secret sauce really comes in how your architecture is operated. What parts of the system can respond automatically to failure, what parts can respond nearly automatically, and which not at all? To be more specific, if a given cloud resource goes down — be it a disk drive, a server, a network switch, a SAN, or an entire geographical region — how seamlessly can you launch or fail over to another and keep operations running? Ideally, of course, the more that;s automated (or nearly so), the better your operational excellence.

Achieving that level of automation requires your system design and configuration be easily replicable. Servers, for example, need to be quickly re-deployable in a predictable fashion across different cloud infrastructures. It’s this automation that gives organizations the life-saving flexibility they need when crisis strikes. Our own RightScale ServerTemplate methodology, as an example, provides this re-deployment capability that allows a server, if brought down from an outage, to be launched in another cloud in a matter of minutes.

Customizable Best Practices in the Cloud

The right cloud management solution should simplify the process of launching entire deployments through customizable best practices. It should also provide complete visibility into all infrastructures through a central management dashboard – a ‘single pane of glass’ – through which administrators can monitor performance and make capacity changes based on real-time needs. The same automation and control that gives organizations the ability to scale up or down using multiple servers when demand increases also allows them to migrate entire server deployments to a new infrastructure when disaster strikes.

The fallout from the Japanese earthquake and Amazon outage is being felt throughout the business community and is causing organizations to rethink how they ensure business continuity. Cloud architecture provides the distributed structures necessary to counteract regional disasters, but companies also need the cloud management capabilities necessary to fail over their operations to multiple infrastructures in a way that keeps things up and running.

Some may have thought the cloud was a magic bullet. It’s not, and that’s actually good news. By recognizing one of the original founding principles of cloud architectures — that everything fails at some point — businesses are now in a position to design and build services that are more resilient than in the past, at a fraction of the cost. With the right architecture and management layer, cloud-based services can provide unparalleled disaster protection and business continuity.

Michael Crandell is CEO of RightScale … .

<Return to section navigation list> 

Cloud Computing Events

Giga Om Events reported Structure 2011 Is in Just Three Weeks. Only 100 Tickets Left. in a 6/1/2011 post:

image Structure 2011 is just around the corner. Last year, we sold out, and currently we have just over 100 tickets left for sale. Have you purchased yours?

With over 32 sessions and 24 in-depth workshops, Structure 2011 will help you make sense of where cloud services are headed and how they’ll affect everything from application development to data center design.

As you hear about the next wave of cloud technology and services, you might wonder: How in the world am I going to implement all this?
Attend the Structure 2011 workshops, and find out how. From new revenue opportunities leveraging the cloud to best practices, you’ll get a deeper understanding of cloud services and where to go next.

Workshop topics include:

  • Making Cloud Real in Healthcare
  • Public Cloud: Delivering on the Promised Benefits
  • Cloud Computing: The Future is Hybrid
  • Addressing the Challenges of Enterprise Clouds
  • Ethernet Fabrics: Foundation for the Cloud
  • Reducing Server Power Consumption by 75%: An Overview and Customer Case Studies
  • Solid State Flash Memory and a New Dawn for Scalable Datacenter Storage
  • Best Practices for Enterprise Cloud Efficiencies
  • Lessons Learned Aggregating Data in the Cloud
  • The What, How and Why of Secure SaaS Delivery Evaluating Enterprise Clouds
  • The Promise of the Cloud: Getting Down to Dollars and (Common) Sense
  • Cloud Mavericks: Going Out on a Limb, Without Falling Out of the Tree
  • Clouds on a Horizon: Disruptions Ahead  

Workshops will be lead by notable cloud practioners including IBM, NetApp, Microsoft, Rackspace, Cisco, CA Technologies, Deloitte and more. See the full list here.

Anyone with a vested interest in cloud computing won’t want to miss the most powerful cloud computing conference in the industry.
We have less than 100 tickets still available for Structure 2011, so be sure to get yours now.

Full disclosure: Giga Om provided me a free press pass to Structure 2011.

Joe Panettieri reported on 6/1/2011 from the Ingram Micro Cloud Summit Gartner VP Tiffani Bova: Cloud Sea Change Is Real for VARs, MSPs:

image During Ingram Micro Cloud Summit, Gartner VP Tiffani Bova [pictured at right] told VARs and MSPs that we’re reached the cloud computing inflection point. The world isn’t ending. The sky isn’t falling. But the hype around cloud obscures the very real sea-change occurring for VARs and MSPs, according to Bova.

“The transition between eras is never smooth but cloud is your future,” Bova told roughly 275 VARs and MSPs attending the Ingram summit today in Phoenix, Ariz.

During her keynote Bova mentioned:

  • image Vertically focused service providers — especially those in micro verticals — will thrive.
  • MSPs and VARs should partner up with small ISVs in vertical markets to succeed in the cloud.
  • Channel partners should select vendors that demonstrate a grasp of the new reality. Those vendors should understand how to manage the shift from product to service; new pricing models; and what may or may not cannibalize on-premises products.
  • The top CIO priority for this year is all about growth, attracting new customers and business agility. In many cases, cloud solutions can deliver on those goals.
  • Not all outsourcing providers will morph and adapt. “Outsourcing does not equal cloud; outsourcing does not equal managed services,” said Bova.
  • On the SMB front, “they’re looking to spend on cloud,” said Bova. “If you don’t sell the license or don’t sell the server it doesn’t mean there isn’t something for you to do.”
  • Bova said MSPs will move to cloud broker and cloud aggregator models.
  • By 2015, Gartner thinks cloud services brokerages will be the single largest revenue growth opportunity in cloud computing. Virtualization would not have happened without the channel.

imageBova didn’t raise any fear, uncertainty or doubt (FUD) about the cloud. She also didn’t paint it as an easy opportunity for VARs and MSPs. Instead, she delivered a balanced approach. Bova is right: We’ve reached a market inflection point. The cloud noise is too loud. But if you tune out the hype and really focus on the cloud opportunities you’ll find them. The opportunities are real.

David Pallman reported on 6/1/2011 that he’ll participate in three SoCal Azure Bootcamps scheduled for early June:

image 3 Microsoft-sponsored Windows Azure Bootcamps are about to kick off in Southern California. Each of these is a full-day event and an excellent way to get started with Microsoft cloud computing.

Los Angeles Windows Azure Bootcamp
Timagehursday June 2, 2011
Microsoft LA Office
333 S Grand Ave, Suite 3300
Los Angeles, CA 90071
Instructor: David Pallmann, Neudesic - Windows Azure MVP and author
Alice Pang, Microsoft

Orange County Windows Azure Bootcamp
Monday June 6, 2011
Microsoft Irvine Office
3 Park Plaza, Suite 1600
Irvine, CA 92614
David Pallmann and Michael Collier, Neudesic - Windows Azure MVPs
Alice Pang, Microsoft

San Diego Windows Azure Bootcamp
Tuesday June 7, 2011
Microsoft San Diego Office
9255 Towne Centre Dr, Suite 400
San Diego, CA 92121
Instructors: David Pallmann and Michael Collier, Neudesic - Windows Azure MVPs
Alice Pang, Microsoft

<Return to section navigation list> 

Other Cloud Computing Platforms and Services

• James Staten asserted Are banks using cloud computing? A definitive yes in a 6/1/2011 post to his Forrester blog:

image Ever since 2009 when NIST published its first definition of cloud computing there has been a promise of community clouds and now we finally have a second one in the financial services market, thanks to NYSE Technologies. The IT arm of NYSE Euronext announced beta of Capital Markets Community Platform, its cloud computing offering this week and the effort, on the surface, is a good example for other vertical markets to follow.

image For years, financial services firms such as investment banks and hedge funds have been competing on trade execution speed and volume - where milliseconds per trade can translate into billions of dollars in competitive advantage. And in doing so, they have found that you can't beat the speed of light. Thus if you want very, very fast connections to the stock market you need to be as close to the servers used by the market as possible. The way to do this prior was to find out where the data center for an exchange was located and put your servers as close as possible and hopefully on the same network backbone. If the exchange was in a colocation facility then you wanted the cage right next door. This method gave larger investment banks a distinct advantage as you had to be able to afford a full cage and have priority access.

image To help level the playing field a bit more, NYSE Technologies new IaaS offering lets financial firms of any size place VMs directly on the same infrastructure as the exchange. Using VMware vCloud Director for secure tenancy, NYSE is able to separate financial firms from each other as well as from the exchange itself. It also lets NYSE control access which presumably promotes fairness in the market. Now financial firms can compete on their trading algorithms, market insights and knowledge without geolocation, colo relationships and big money prioritization creating an uneven playing field. This doesn't mean that a large financial institution can't still colocate a massive server farm, just that winning isn't defined by your ability to do so.

This effort by NYSE is a classic example of a community cloud in that it is a private IaaS solution (yes, there is dedicated hosting too) designed specifically to meet the needs of a particular market and open to all members of that community. It is similar to an effort created several years ago by NASDAQ called Market Replay that let's financial institutions exercise their algorithms against yesterday's market. That cloud solution leverages Amazon Web Services' Simple Storage Service (S3) public cloud infrastructure. But NYSE Capital Markets Community Platform is for access to the live market. This service, when it goes live (expected July 1) will affect actual trades.

Community clouds exist in higher education, pharmaceuticals and other markets so this isn't brand new but is another testament to how real the cloud computing market is and shows a best practice for how to set up a solution that serves the unique needs of a particular market. Well done, NYSE.

Alex Handy described The top five most powerful Hadoop projects in a 6/1/2011 post to SD Times on the Web:


Running Hadoop jobs and keeping a cluster up is a full time administrator job. Setting up jobs and parceling them out to the cluster can be difficult, especially if you're building multiple applications that rely on Hadoop inputs and outputs. Stitching these external applications together can be a pain, and bringing their needs together inside of map/reduce jobs can make things even more complicated.
We'll let the Cascading project describe itself here:

As a library and API that can be driven from any JVM-based language (Jython, JRuby, Groovy, Clojure, etc.), developers can create applications and frameworks that are "operationalized". That is, a single deployable JAR can be used to encapsulate a series of complex and dynamic processes all driven from the command line or a shell, instead of using external schedulers to glue many individual applications together with XML against each individual command line interface.

Not only does Cascading abstract away from map/reduce, it also allows developers to deploy their jobs in a much simpler way. That being done, cascading allows developers to build applications on top of Hadoop with a much simpler design model.

The cascading tree also includes a number of tools based on the system. One of those tools, dubbed the “Multitool,” even allows developers to run grep and sed jobs right against the cluster's data set.

Read more: Next Page

Alex continues with a page each for Mahout, Hive, Avro and Storm

SD Times on the Web posted Heroku Announces Major New Version, "Celadon Cedar"; Includes New Process Model, Full Node.js Support on 6/1/2011:

Heroku, the leading open Platform-as-a-Service (PaaS), has unveiled a major new release, "Celadon Cedar." The new version of Heroku has been used by hundreds of developers and customers in alpha and private beta and is now in public beta for the first time.

Celadon Cedar enables more powerful and complex apps with the following capabilities:

• New process model, including support for heterogeneous workers (background processes)

• Procfile for managing and defining process types, giving fine-grained control over processes

• Procfiles can be used outside of Heroku with the new open source Foreman project

• All processes running on Heroku are now called dynos, which are fully managed and run by the Heroku platform

• Updated HTTP stack including full HTTP 1.1 support with key features including long polling and chunked response

Unprecedented app visibility is provided by:

• Logplex: complete, consolidated logs for your apps as well as the infrastructure running your apps

• Command-line access to real-time, filterable application logs

• Heroku ps: visibility into real-time state of all dynotypes in your app

• Heroku Releases: a feature for instant roll-back and full audit trail of app versions

Multi-Language features are:

• Automatic language detection upon deploy

• Full Node.js support

• Ruby 1.9.2 support

• Ability to configure language support via Procfile

Erosion-resistant features for reliability, security, and durability include:

• Dyno manifold for scaling and distributing processes

• Full isolation of processes for security and performance

• Unlimited scaling of apps to N dynos

• LXC used as a container for all dynos running on Celadon Cedar

"Over the past three years, we've worked with tens of thousands of developers who are building for the cloud.  This new version of the Heroku platform is the culmination of what we've learned, and is a major step forward in realizing our vision to serve the millions more developers who will soon be moving to cloud app platforms," said Adam Wiggins, co-founder, Heroku. "The response from the hundreds of developers who have been using Cedar during our private beta has been incredible, and we couldn't be more excited to put it into the hands of developers worldwide."

Read more: Next Page

SYS-CON Media and Events reported Cloud Expo 2011 New York will have a A Rock Star Faculty, Top Keynotes, Sessions, and Top Delegates!:

Cloud Expo 2011 New York, June 6-9, 2011, at the Javits Center, New York City, New York, will feature technical sessions from a rock star conference faculty and the leading Cloud industry players in the world.

The growth and success of Cloud Computing will be on display at the upcoming Cloud Expo conferences and exhibitions in New York, June 6-9, and in Santa Clara, November 7-10, 2011.

The recent Cloud Expo at the Santa Clara Convention Center in Santa Clara, CA, was the largest Cloud Computing conference ever produced, more sponsors, exhibitors and delegates than all other Cloud events of the year combined!

The four-day New York event will attract more than 10,000 delegates from 48 countries and over 600 sponsors and exhibitors on a 120,000 sq ft show floor!

All main layers of the Cloud ecosystem will be represented in the 7th and 8th International Cloud Expo - the infrastructure players, the platform providers, and those offering applications, and they'll all be here to speak, sponsor, exhibit and network.

"Cloud Expo was announced on February 24, 2007, the day the term ‘cloud computing' was coined," said Fuat Kircaali, founder and chairman of SYS-CON Events, Inc. "Cloud has become synonymous with ‘computing' and ‘software' in two short years, and this event has become the new PC Expo, Comdex, and InternetWorld of our decade. By 2012, more than 50,000 delegates per year will be attending Cloud Expo."

Sponsorship Opportunities
for Cloud Expo 2011 New York
Cloud Expo 2011 New York "show prospectus" has shipped. Sponsorship, exhibit, and keynote opportunities can be obtained from Carmen Gonzalez by email at events (at), or by phone 201 802 3021.

Early Bird Registration Options
for Cloud Expo 2011 New York
Cloud Expo delegates can pre-register for Cloud Expo 2011 New York with $800+ savings here.

<Return to section navigation list>