RDA Architectural Guidance Practice Group Blog

SQL Server Express: Failed to generate a user instance of SQL Server error

2010-11-12T20:08:00.007-05:00

I ran into a quirky issue while re-tooling from VS 2008 to VS 2010. In case anyone runs into it, I thought it might be good to have a heads up. Instead of running them side-by-side, I completely uninstalled VS 2008 and did a clean install of VS 2010. As it turns out, that caused a bit of a problem with SQL Server express. This one was a fun one to track down, so some background information is in order.

I was working on a proof-of-concept and needed a data import for some sample code into SQL Server express. Why not just use the regular edition of SQL Server? The folks who wrote the sample code probably didn't want to assume that everyone had a regular SQL Server instance running in their dev environment and didn't want to exclude anyone from using their code. It so happens that I am running a regular SQL Server instance on my machine, but I wanted to accurately repro the setup for for the sample code based the provided instructions, which called for SQL Server express. I probably could have just cheated and imported the database into my regular SQL Server instance, but that would have also introduced more variables into the equation to validate my POC than I was willing to deal with.

Every time I tried to access the imported SQL data, I kept getting this error:

Failed to generate a user instance of SQL Server due to a failure in starting the process for the user instance

I checked the network stack, security permissions, everything. As it turns out, the SQL Server express persists some files in your app data directory that don't get cleaned out when you uninstall and reinstall. It's a problem when you attempt to spin up a user instance because a file already exists in your app data directory that SQL Server express is attempting to re-create. It might have been a bit easier to troubleshoot if it told you about the file it failed on in the initial error message. Instead, it just reports on the failed instance.

Solution? Delete the SQLEXPRESS folder under C:\Documents and Settings\username\Local Settings\Application Data\Microsoft\Microsoft SQL Server Data\ so that SQL Server express can re-create the files. If you've got some things in there that you want keep using, you might have to do more precise surgery and find the offending files. In my case, I didn't.

Did I figure this one out all by my lonesome? Not entirely. I still had to dig through the error logs to find the problem, but I'll give credit where credit is due for the solution:

http://forums.asp.net/t/1377174.aspx

Windows Phone 7 Trial API Walkthrough

2010-10-28T14:44:00.001-04:00

The Windows Phone 7 Trial Mode functionality is a power and simple tool. For those unfamiliar, the Windows Phone Marketplace allows for developers to list their applications in three ways: Free, Buy, and Try-Before-Buy. In order to be more marketable, it is usually a better option to offer customers the ability to try out an application before they give you their hard earned money. Another difference between this approach and other phone marketplaces is the user experience for upgrading their app from trial to full version. It is a simple two-click process, one click to upgrade, the other to confirm the purchase.

Implementing the trial mode code is a very straight forward exercise. Here is an example:

Microsoft.Phone.Marketplace.LicenseInformation license = new Microsoft.Phone.Marketplace.LicenseInformation();

public string ApplicationTitle
        {
            get
            {
                if (license.IsTrial() == true)
                {
                    return "My App (Trial Version)";
                }
                else
                {
                    return "My App";
                }
            }
        }

The above example demonstrates how we can change the way the app behaves for a trial user versus a fully licensed user. In this case we are changing the Application Title of the app. A trial user will see “My App (Trial Version)” at the top of their screen and a fully licensed user will see “My App”. Not very limiting, I know, but it demonstrates how easy it is to implement this in your code.

The code implementation is simple because Microsoft is doing much of the heavy lifting here. The Microsoft.Phone.Marketplace.LicenseInformation class uses Microsoft’s Zune Marketplace to check the license currently installed on the phone. It returns true if the license is a trial version and false if it is the full version. This leaves the developer to spend writing code and polishing the user experience rather than writing their own licensing services or writing a completely separate trial version of their applications.

IE8 and ASP.NET Sessions

2010-08-05T14:57:00.001-04:00

One behavior that seems to have inexplicably changed between IE8 and IE7 is the handling of session cookies. In IE7 (and 6) each browser instance and tab had it’s own session cookie and, as a result, session on the server. Not so in IE8! Every tab and browser instance (with some minor exceptions) now shares the same session cookie. When designing ASP.NET applications, this is something you need to be aware of. If you, for example, store an item currently being edited in session state and a user opens two browsers to edit two different entities, expect all kinds of strange results. If you want to test the behavior of a specific browser to see for yourself, visit this page. In my quick test, the latest version of Chrome behaves just like IE8.

So how do you make sure an application can support multiple browser windows? Well, there are a couple options, none of which is completely satisfying:

Eliminate the use of Session State and switch to cookies, hidden form elements or some other client side mechanism.
Enable cookiesless sessions (URL rewriting). Beware that this approach has some security implications as well as some practical effects on things like bookmarking and URL sharing.
Train your users to select “New Session” from the File menu in IE8. Not exactly easy since the menus are hidden by default. If you enable them you’ll notice that you have both “New Window” and “New Session” as options. The latter will allow multiple browsers running different sessions.

The moral of the story is that if you decide to use session state, be sure to plan for users opening more than one browser window.

SQL Azure 50GB Databases Now Available

2010-06-25T23:11:00.001-04:00

Ahead of the promised June 28 target, the SQL Azure team updated SQL Azure with Service Update 3 (SU3), providing new database sizes up to 50GB.

Web Edition databases can now be scaled to either 1GB or 5GB, while Business Edition databases have increments of 10GB, 20GB, 30GB, 40GB, and 50GB.

The Web Edition tiers are $9.99 and $49.95 monthly, while the Business Edition tiers are increments of $99.99.

The new database tiers come with a new pricing model that evaluates your maximum daily usage, and each day’s cost accrues at the appropriate tier, based on the database edition chosen. For instance, if a 20GB Business Edition database never exceeds 10GB, its daily rate accrues at the 10GB tier. On days in which the database exceeds 10GB, it accrues at the 20GB tier.

For more details, see my post here.

Azure Guest OS 1.4

2010-06-23T10:50:00.001-04:00

A few days ago, the Windows Azure team released a new Guest OS, version 1.4. The Guest OS is what runs in Azure’s environment and hosts your running applications.

The latest update includes fixes for Azure Drives and WCF Data Services. It also includes several security patches. If your Azure deployment is configured to automatically use the latest OS, then you’re already running Guest OS 1.4. This might have breaking changes for your code if you are using WCF Data Services.

For more details, see my post here.

Silverlight Unit Testing

2010-06-13T16:06:00.003-04:00

I have just written a short series on doing Silverlight unit testing.

Silverlight Unit Test Project Templates Compile Error - Shows how to solve errors that you may run into when creating Silverlight Unit Test projects.
Silverlight Asynchronous Unit Test MVVM and RIA Services - Provides simple and straight forward examples to get you started. Will show you how to create unit test for your RIA Services and for your ViewModels when using MVVM.
Silverlight RIA Services Load and Performance Testing - Provides an approach for doing load and performance testing for RIA services.

Azure SDK+Tools v1.2 now available!

2010-06-07T16:45:00.001-04:00

Today, the Azure team launched the latest SDK and related Visual Studio tools, version 1.2. This release has several features:

Built-in support for .NET 4 roles in your Azure application
IntelliTrace for debugging deployed Azure applications
All-new publishing wizard, allowing apps to be deployed directly to Azure without having to visit the web portal or run an external build script
Built-in storage and service monitoring from Visual Studio

The SDK is available for download here.

I wrote two detailed posts about this release with more information and walkthroughs:

Microsoft’s Jim Nakashima provides further detail here.

Are we done testing yet?

2010-06-04T20:31:00.003-04:00

Usually its every test manager's questions. "Are we done testing?", "Do we have enough confidence in our release"?. But on the complex projects with constant change in requirements, even Program Managers & Business stakeholders are "Paranoid" about test coverage and sign off. Development team will call out code complete and we have met all requirements. Test team will confirm all test cases have passed and there are no more bugs to regress and can't find any more bugs. Does this mean we are done testing? Does this mean we can sign off?

I think there is lot more than just code complete, feature working as defined in functional spec or business requirement document, all test cases have passed, and we have zero bugs. Below are certain guidelines for test team and engineering team so that they are ready when higher management asks the inevitable question - "Are we done testing yet?".

Is everyone (including key stakeholders) on board with the test strategy and release criteria?
Is our test strategy and planning consistent with the business requirements and business understanding?
Are we measuring release criteria accurately and are key stakeholders in agreement with the success criteria of the test coverage and test effort?
Do we have standard processes and controls in place to help our engineering team understand the requirements and make changes to code base?
Do we have knowledge base in place to capture quality data and trends over a period of time? Can everyone on the team retrieve this information at any given time?
Do we have enough visibility within the organization to effectively manage the change-control process?
Do we do regular reviews of the product to key stakeholders? Are they committed to provide feedback during various stages of the project development?

I haven't come across teams that have spent enough time clearly defining success criteria for the software development life cycle. Most of the time test team believes they have good reasons to not sign off, while program managers and other key stakeholders think that the primary end users will not be affected.

If test team can answer all or are atleast prepared for all the above questions, we can sure say with confidence that "we are done testing".

This post is open to further discussion. Would love to hear comments...

Use the Microsoft Addin Framework, MAF to Create Highly Scalable Classes in Any .Net Application

2010-05-25T08:04:00.000-04:00

.NET framework 3.0, 3.5 and 4.0 includes the System.AddIn namespace. This namespace can be used to create highly durable and extendable applications. MAF is a framework that allows for add on based development that includes code isolation for system safety, runtime loading, and unloading of add ons as well as message-based processing (i.e. publish and subscribe). MAF is compatible with any .NET application (I even made a Visual Studio AddIn with it) and is useful wherever there is a need for a de-coupled extendable codebase.

PRISM 4.0 P&P Features Survery

2010-04-28T17:04:00.001-04:00

Patterns and Practices is soliciting feedback on the features that should make it into PRISM 4.0. If you have experience or knowledge of PRISM, please take few moments to fill out the online survey. It was 20+ questions and took about 5 minutes.

Features Survey

RockNUG: Silverlight 4 Code and Notes

2010-04-28T14:39:00.001-04:00

On April 14, I presented an introduction to Silverlight 4 at the Rockville .NET User Group. My sample project code, along with presentation notes, are available here.

Azure team blogs and voting sites

2010-04-26T09:53:00.001-04:00

The Azure team has several blogs announcing new features, Azure sites, integration tools, customer stories, and general platform updates:

Windows Azure blog – visit this blog to see the latest platform updates, as well as OS updates and tools for platform integration (such as Jetty).
SQL Azure blog – this blog is dedicated to the Azure-specific version of SQL Server. This blog will provide information around new and upcoming features such as MARS.
Azure AppFabric blog – this blog is specific to AppFabric features such as access control, service bus, and experimental features, called AppFabric LABS.
Azure Storage blog – this blog is dedicated to blob and table storage, including code samples and useful tools (such as the recent storage explorer tool compilation).
Codename Dallas blog – this blog covers the latest information about the new Azure data-provider service.

Aside from blogs, the Azure team is soliciting feedback for future features. You can cast your votes and be heard here:

May 12 – Launching and Monitoring your First Azure App

2010-04-26T09:27:00.002-04:00

Join me online May 12 at 4pm Eastern, when I present at the Azure User Group, hosted in LiveMeeting. During this talk, we’ll go over the basic building blocks of an Azure application. We’ll then create our first Azure app and see how to deploy it into the cloud. We’ll also see how to monitor an app once it’s deployed.
Please register here if you’d like to attend.
For more information about the Azure User Group, visit the LinkedIn group page or follow AzureUG on twitter.

Silverlight Ramp-up Resources

2010-04-25T13:38:00.003-04:00

I completed a several part series of 200 and 300 level blogs that can be used by any experienced developer to quickly spin up Silverlight 4, MVVM, Custom RIA Domain Services and Data Binding.

Silverlight 4 Hands On Lab - Free MS Hands on lab that you can use to get started.
Silverlight 4 using MVVM Pattern, RIA Services and Custom Domain Service - Jump right into learning MVVM pattern with Silverlight and RIA Services. In this scenario we could not use Entity so we had to understand how RIA Services work without them.
Silverlight Custom Authentication Domain Service with RIA Services - Shows a quick way to do custom authentication services and shows how to create a domain service factory.
Binding ComboBox and AutoComplete Controls in Silverlight DataGrid - Discuss advanced binding concepts and how to bind using column templates in a grid.
RIA Service Domain Service Method Life-Cycle - Discusses the life-cycle of RIA Service methods.
Silverlight Localization and Resource Files - Good references on how to utilize resources files in your Silverlight apps.
Deep Dive into Custom RIA Service and Transactions - A deep dive in building DTOs with RIA Services and how the ChangeSet works to manage transactions.

Windows Phone Developer Tools and Visual Studio 2010 RTM

2010-04-22T15:33:00.001-04:00

Just a warning that if you are developing applications using the CTP of Windows Phone Developer Tools, do not upgrade to the RTM of Visual Studio 2010. The two are not compatible. You need to stay on the Release Candidate of Visual Studio 2010 until the Phone Developer Tools are updated. If you want to be notified when that happens, you can sign up to receive an email here.

Silverlight 4 is available!

2010-04-15T14:20:00.001-04:00

Today, Microsoft officially released Silverlight 4. As a developer, you’ll want to head over to www.silverlight.net/getstarted – you’ll find links for all needed tools:

Visual Studio 2010
Silverlight SDK
Silverlight Toolkit
Expression Blend 4 RC

Using an ADO.NET Entity Model Against SQL Server and SqlCE

2010-04-14T06:21:00.007-04:00

I ran into a problem recently with Visual Studio generated entity models. We have a partially connected application that uses the same data model as the server, however the client uses Sql Compact and the server uses SQL enterprise. We generated a single EDM diagram in visual studio against the server database. When doing this the storage metadata schema (SSDL) gets generated based on the provider. In order to use your datamodel against a seperate compatible store your consumers need to keep the SSDL in sync for each provider. This proved easy to do wrong an difficult to keep in sync as we would have to keep making local copies after each build that get updated. In order to make life alittle easier I decide to use automation of course. The differences in the SSDL in this case are only the providername and providermanifest:

Server :

<schema namespace="Model.Store" alias="Self" provider="System.Data.SqlClient" providermanifesttoken="2008"></schema>

Client:

<schema namespace="Model.Store" alias="Self" provider="System.Data.SqlServerCe.3.5" providermanifesttoken="3.5"></schema>

Given the minute differences we looked at how to merge a different ssdl along with the same msl and csdl. The simplest solution was to modify the consumer application project file to include a custom MSBUILD task.

The default behavior of the EDMX designer is to embed all three meta data artifacts into the containing assembly. By leaving this as is on the assembly we can post build load the assembly and read the metadata to do translations.

Here is the completed class:

   1: public class RegenerateClientSsdlTask : Task

2: {
3: public RegenerateClientSsdlTask()
4: {
5: }
6:
7: public string AssemblyName { get; set; }
8: public string ProviderName { get; set; }
9: public string ProviderManifestToken { get; set; }
10: public string OutputPath { get; set; }
11: public string SsdlPath { get; set; }
12:
13: public RegenerateClientSsdlTask(ResourceManager taskResources) : base(taskResources)

  14:         {

  15:         }

16:

  17:         public RegenerateClientSsdlTask(ResourceManager taskResources, string helpKeywordPrefix) : base(taskResources, helpKeywordPrefix)

  18:         {

  19:         }

20:

  21:         public override bool Execute()

  22:         {

23:

  24:             var setup = new AppDomainSetup { ApplicationBase = Path.GetDirectoryName(GetType().Assembly.Location) };

25:

  26:             AppDomain load = AppDomain.CreateDomain("Analyze", AppDomain.CurrentDomain.Evidence, setup);

27:

  28:             try

  29:             {

  30:                 var instance = load.CreateInstance(GetType().Assembly.FullName, typeof (SSDLProcessor).FullName);

31:

  32:                 var processor = instance.Unwrap() as SSDLProcessor;

33:

  34:                 processor.AssemblyName = AssemblyName;

  35:                 processor.ProviderName = ProviderName;

  36:                 processor.ProviderManifestToken = ProviderManifestToken;

  37:                 processor.OutputPath = OutputPath;

  38:                 processor.SsdlPath = SsdlPath;

39:

  40:                 load.DoCallBack(processor.ProcessSSDL);

41:

  42:                 return true;

43:

  44:             }

  45:             catch (Exception)

  46:             {

  47:                 return false;

  48:             }

  49:             finally

  50:             {

  51:                 AppDomain.Unload(load);

  52:             }

53:

  54:         }

55:

  56:         private class SSDLProcessor : MarshalByRefObject

  57:         {

  58:             public string AssemblyName { get; set; }

  59:             public string ProviderName { get; set; }

  60:             public string ProviderManifestToken { get; set; }

  61:             public string OutputPath { get; set; }

  62:             public string SsdlPath { get; set; }

63:

  64:             public void ProcessSSDL()

  65:             {

  66:                 var assm = Assembly.ReflectionOnlyLoadFrom(AssemblyName);

67:

  68:                 var ssdl = assm.GetManifestResourceStream(SsdlPath);

69:

  70:                 var ssdlDoc = XDocument.Load(ssdl);

71:

  72:                 if (ssdlDoc.Root != null)

  73:                 {

  74:                     XAttribute providerAttribute = ssdlDoc.Root.Attribute("Provider");

75:

  76:                     if (providerAttribute != null)

  77:                     {

  78:                         providerAttribute.Value = ProviderName;

  79:                     }

80:

  81:                     XAttribute manifestAttribute = ssdlDoc.Root.Attribute("ProviderManifestToken");

82:

  83:                     if (manifestAttribute != null)

  84:                     {

  85:                         manifestAttribute.Value = ProviderManifestToken;

  86:                     }

  87:                 }

88:

  89:                 ssdlDoc.Save(OutputPath);

  90:             }

91:

  92:         }

93:

94:

  95:     }

Within the previous task several things occur. In the calling build script we configure the task to tell it where to locate the dll, what the path is to the ssdl and what to change the provider configuration to and then lastly where to write out the generated ssdl. You'll notice we load all this into a seperate app domain as well as late load the tasks assembly. If we directly retrieve the metadata into the task the dll will get loaded in the current AppDomain which in our case was part of the visual studio build process. Doing this well work the first time but lock the dll and not allow for subsequent builds to be successful because of file locking.

So now that you have the code how do you use it? The first requirement is to make the assembly located in your visual studio solution so that the project file can reference it. In our solution we have a third party solution folder that contains all these references called Lib. Being centrally located in the solution we can just add relative paths. Once you have a compiled version in your solution you will need to open the end consumers csproj file in notepad. Once you have the file open at the top you will need to add the following directly under the project node:

<usingtask taskname="BuildTasks.RegenerateClientSsdlTask" assemblyfile="..\Lib\BuildTasks.dll"/>

Once you have done that scroll to the bottom and locate the following text:

   1: <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

   2: <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

   3:       Other similar extension points exist, see Microsoft.Common.targets.

   4:      <Target Name="BeforeBuild">

5:

   6:      </Target>

   7:     <Target Name="AfterBuild">

   8:     </Target>

   9: -->

You will need to uncomment the "AfterBuild" Target and update it to the following:

   1: <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

   2:      <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

   3: Other similar extension points exist, see Microsoft.Common.targets.

   4:     <Target Name="BeforeBuild">

5:

   6:     </Target> -->

   7:     <Target Name="AfterBuild">

   8:     <Message Text="Running SSDL Gen..." />

   9:     <RegenerateClientSsdlTask AssemblyName="$(TargetDir)\EvapSpec.Data.dll" ProviderName="System.Data.SqlServerCe.3.5"

  10:      ProviderManifestToken="3.5" SsdlPath="ES.ssdl" OutputPath="$(TargetDir)\ES.ssdl" />

  11:     <Message Text="Finished SSDL Gen..." />

  12:    </Target>

Now lets look at the parameters we have configured and how get those.

AssemblyName="$(TargetDir)\Data.dll" This is the reference containing the EDMX model. Since our project references this dll it gets copied into the ouput directory. By using $(TargetDir) we always get the output directory no matter how the project or build configuration changes.

ProviderName="System.Data.SqlServerCe.3.5" This is the provider we use in our connection string on the client

ProviderManifestToken="3.5" This is identifier for the provider.

SsdlPath="Model.ssdl" This is the resource name in the containing dll. The easiest way to get this is to look at the EntityConnection string in your app config. ie: "res://./Model.SSDL" indicates that the resource is at the root of the assembly and called Model.SSDL. Alternatively you can open Reflector and look at the resource tables.

OutputPath="$(TargetDir)\Model.ssdl" This is where we want the generated ssdl file to live. In order to simplify we write the file to where the client assembly lives. This is important as we have to update the connection string on the client to match.

Now to update the consuming application. Once we have the task configured we run a build and should see the SSDL file in the output directory. Lets update the app.config file to utilize it. If you haven't already copy the existing entity connection from your data project. It should look like this:

<add name="ModelEntities" connectionstring="metadata=res://*/Model.csdl|res://*/Model.ssdl|res://*/Model.msl;provider=System.Data.SqlClient;provider connection string="Data Source=(local);Initial Catalog=Model;Integrated Security=True"" providername="System.Data.EntityClient"/>

We need to update the SSDL path, provider name and connection string:

<add name="ModelEntities" connectionstring="metadata=res://*/Model.csdl|Model.ssdl|res://*/Model.msl;provider=System.Data.SqlServerCe.3.5;provider connection string="Data Source=Model.sdf"" providername="System.Data.EntityClient"/>

Notice I removed res://*/ from in front of Model.ssdl, this tells the loader to use a relative path to the executable on the filesystem versus attempting to read it from the assembly. We still use the same csdl and msl so we can leave those untouched. I also changed the provider name and connection string to use our local database.

In doing all this we now have a common business layer that can leave on the client or the server that is capable of using the same entity model queries.

Azure: Staging and Compute-Hour Metering

2010-04-13T08:28:00.001-04:00

In this post, I talked about how web and worker roles are considered live the moment they are deployed, whether stopped or running. I received a few follow-up questions about billing when using the Staging area, as well as clarification on how compute-hours are measured.

Production and Staging

When deploying to Azure, you have a choice between Production and Staging:

This comes in handy when upgrading your application. Let’s say you have an application already in Production, and you now have a new version you’d like to upgrade to. You can deploy that new version to a separate Staging area, which provides you with a separate “test URL” as well as any worker and web roles your application needs. You can run this app just like you’d run your production app. When you’re done testing, swap staging and production. This is effectively a Virtual IP address swap, so your end-users simply see an upgraded application as soon as you choose to execute the swap.

This is a terrific feature, allowing you to test an application without service disruption. It also allows you to quickly swap back to the previously-deployed version if something go wrong after deploying your new version to production.

Once you’re sure your new version is working ok, consider deleting your service from Staging. Be aware that your staging area is also consuming virtual machine instances. Staging instances and Production instances are equivalent: Each instance is a Virtual machine; Staging instances are billed just like Production instances. If you leave your service deployed to both Production and Staging, you will be accruing Compute-Hour charges for both. Just keep this in mind when estimating your monthly Azure costs.

How the hour is metered

As each application is deployed, its virtual machines are created. The moment those virtual machines are in place, metering begins. This includes stopped services. For instance: assuming we clicked Deploy on the Production area of our service, and uploaded an application comprising one worker role and one web role, we’d then see our deployment in a stopped state:

At this moment, the billing clock begins for each of the instances, and billing is based on a 60-minute window: If you deploy at 4:16pm, your 60-minute window is from 4:16pm to 5:16pm (it’s not 4pm-5pm). In this example, I have two roles, with a combined consumption of 2 compute-hours per clock-hour.
If I decide to stop either of these roles before the entire hour is consumed, it’s still metered for the full hour.

Multiple Deployments in a Clock-Hour

Let’s say I delete my deployment after only 5 minutes. And then I decide to deploy again to Production. At this moment, the clock starts again for my new deployment. Using our sample app above, with one worker role and one web role:

Deploy to Production at 4:16pm, delete deployment at 4:21pm. Compute-hours billed: 2
Deploy again to Production at 4:25pm, delete deployment at 4:30pm. Compute-hours billed: 2
Total clock time: 14 minutes. Total compute-hours: 4

I realize this is a contrived example, but I want to emphasize the fine details of compute-hours:

Each instance is metered from the moment it comes to life in a Virtual Machine.
Compute-hours are rounded up to the nearest hour. So a service is metered at 1 compute-hour, whether it runs for only 5 minutes or 59 minutes.
Services deployed within the same clock-hour are completely unrelated, billing-wise. If you stop and delete your application and then deploy it again, all within the same clock-hour, you will still be billed separately for each deployment.

Azure: New Guest OS 1.2

2010-04-07T08:03:00.001-04:00

On April 5, Azure Guest OS 1.2 became available. If you’ve published any new Azure services in the past day or two, your new deployments are probably using v1.2. In the Azure Portal, take a peek at the service configuration:

So: what does v1.2 have?

HTTP dynamic compression for webroles
Updates to the IIS URL Rewrite module
.NET 4 RC
Security patches

Ooh - .NET 4 RC??? Does that mean we can now deploy .NET 4 RC builds to Azure??? Well… Not yet. The Azure 1.1 SDK only supports .NET 3.5 build output. If you try changing your role’s target framework to .NET 4, you’ll get an error:

The .NET 4 RC framework is installed for compatibility testing. According to this MSDN article about Guest OS 1.2, there’s a known issue with unversioned performance counters.

This is a good sign though! April 12 is the Release-to-manufacturing (RTM) date for .NET 4. At MIX earlier this year, the Azure team announced that we’d see .NET 4 support within 90 days of RTM. Hopefully, having this new guest OS will help accelerate testing and bring that date closer to April 12. That also means you should send the Azure team any feedback you have regarding issues with the new Guest OS.

Azure: How to activate the MSDN Premium Special Account

2010-03-26T13:45:00.001-04:00

When setting up your Azure account, one thing you’ll need to do is select an Azure product to add to your shopping cart. Currently there’s only one product type available to the general public: Azure Platform Introductory Special. This is essentially a pay-per-use account, with a 25 free monthly compute-hours, one SQL Azure database for 3 months, and 500MB in/500MB out per month. Beyond that, you’re paying standard Azure rates. You can see the rate breakdowns here.

If you’re an MSDN Premium subscriber, you have a significantly-better offer available: Windows Azure Platform MSDN Premium. This plan offers 750 monthly compute-hours, 3 SQL Azure databases, and 7GB in/14GB out per month, for 8 months (see all details here). However, it’s not exactly easy to get this offer activated. Here’s how:

MSDN Subscription Portal

First, navigate to your MSDN subscription at http://msdn.microsoft.com. Sign in and click My Account:

Now you should see your full account details, along with all available services. Select the Azure service option:

Microsoft Online Services Customer Portal

This will take you to the Microsoft Online Services Customer Portal. Login with the same Live ID as your MSDN subscription. If this is your first time here, you’ll need to fill out some profile information:

. Once that’s done, you’ll see the MSDN Premium subscription offer in your cart:

Now all that’s left is to agree to the terms and checkout. You’ll have to provide your credit card information, but this is only used for covering charges beyond those provided for free.

Once you complete this step, you should now have the MSDN Premium Azure product. Select the Subscription tab to confirm:

Note: It’s possible that the status is pending, which simply means the account is still being provisioned. Chances are, if you refresh this page in a few minutes, it should be active.

If you made it this far, congratulations! You should now have Azure activated with your MSDN Premium benefits.

Azure Developer Portal

Now it’s time to visit the Azure portal, at www.azure.com:

Click Account (in the top-right corner). This will show you the various portal links:

Click Go to the Windows Azure Developer Portal.

At this point, simply login with your Live ID. Since its your first time, you’ll be asked to create an Azure project. Once you do, you’ll see it listed in My Projects:

Finish Line

And… you should now be all ready to add an Azure application service to your account! Now go run to Visual Studio, build your Hello Azure World! (a rite of passage), deploy it to your new Azure service, and go brag to all your friends!

Don’t Delete That Azure Service!

2010-03-23T17:08:00.001-04:00

I’m having some serious fun with Azure these days. I have my own pet project, but I also have several small “demo” projects where I’m demonstrating something for various clients. Each of these demos has its own Azure service.

An Azure Service is the place where you upload an application to: your web roles, your worker roles, storage. It has all your regional settings (such as geographic affinity), and manages how many instances you want to run for each web role and worker role. And, of course, the Azure service gets its own name within the cloudapp.net domain (e.g. http://YourServiceName.cloudapp.net).

Once you upload code to an instance, you start incurring usage metering. However, you may create an Azure services without deploying any code, which means no cost incurred. This lets you get things all set up, and eventually upload something for testing. Then, when you’re moving back to the development fabric to continue development, you can simply delete the deployment (but leave the Azure service definition intact). This lets you save those precious monthly compute-hours for when you really need ‘em (see my post here for more details about monthly hours).

Up until today, you were able to create up to 20 hosted services within your account. Maybe that seems like a lot, but imagine you’re a consultant working on several Azure projects, maybe some for clients, some for yourself. And maybe you’re trying out a few demos based on some training material. Or you’re testing out a demo for a user group talk. Suddenly, that 20-service limit seems pretty reasonable. It’s nice to get things all set up for each project, and not have to worry about configuring them again. It’s also nice to not worry about setting up cloudapp.net names (or losing the one you found, because someone else snagged it after you deleted it).

Well… as of today, each account is now capped at six Azure services. Don’t panic! If you currently have more than six configured services, they will not be deleted by Azure; you’re grandfathered. But… if you delete them, you won’t be able to re-add them until you’re below the six-service limit.

For more details about today’s Azure service changes, see this blog post by the Azure team.

So my words of wisdom today are, simply: Don’t delete that Azure service!

Azure Migration Strategies and Architecture Video

2010-03-22T10:39:00.006-04:00

Dr Z. and I sat down to have a discussion around migrating existing enterprise applications into the Azure AppFabric, it's now been posted over at Channel 9 so take a look here.

Here's the synopsis:

"In this episode, Damon Squires, principal architect at RDA, discusses with Zhiming Xue where in a typical enterprise solution Microsoft Azure AppFabric -- consisting of the Service Bus and the Access Control Service -- may be used, how on-premise data are communicated with these services running in the cloud and what benefits such a hybrid solution may bring to enterprise customers."

RIA Services RC, Deployment Guide, and Azure

2010-03-17T14:16:00.001-04:00

At the MIX conference this week, Scott Guthrie announced a Release Candidate of WCF RIA Services, along with a new RIA Services Toolkit, both available here.

Saurabh Pant has a great blog post about deploying RIA Services to your server. This post specifically targets .NET 4, Silverlight 4, and Visual Studio 2010, and even announces some hosting companies that now provide RIA Services RC support.

While I won't rehash all of the deployment details, I wanted to draw attention to Azure deployments. Saurabh points out that RIA Services RC only supports .NET 4. Currently, Azure only supports .NET 3.5. This means the “server” side of your RIA Services app cannot yet be used in Azure (although you can develop it locally and run with the Development Fabric).

I haven’t heard or seen any official statement about .NET 4 support on Azure, but my gut feeling (read: educated guess) is that we’ll see an Azure Virtual Machine upgrade at the same time .NET 4 is RTM, currently slated for April 12. Hopefully this will all be cleared up in the next month.

If you need to deploy a RIA Services application to Azure today, continue working with the RIA Services Beta which was announced at PDC in November. The Beta works with both .NET 3.5 and .NET 4.

Silverlight 4 RC Announced, Plays Nice with Visual Studio Again

2010-03-15T15:10:00.001-04:00

At PDC In November, we were treated to the announcement of Silverlight 4 and its sheer number of enhancements over version 3 (you can look at Tim Heuer’s blog post to see all the new features explained). Silverlight 4 Beta worked great with Visual Studio 2010 Beta 2.

Then we were treated to yet another announcement in February: Visual Studio 2010 RC, with many bug fixes and serious performance speed-up. Of course, I immediately uninstalled VS2010 Beta 2 and installed the RC before reading all the twitter traffic about Silverlight 4 being incompatible with Visual Studio 2010 RC!

Since then, we’ve heard nothing about the re-integration of SL4 with VS2010 except that it would “eventually happen.” Ever since, I’ve been working with two VM’s: One with VS2010 Beta 2 for SL4 development, and one with VS2010 RC for Azure development (the new Azure SDK requires VS2010 RC).

Well… as of this morning’s MIX keynote, the two are reunited again! The new Silverlight 4 Release Candidate is now available for download at www.silverlight.net, and is fully compatible with VS2010 RC. This release also includes an update to RIA Services RC as well.

While I haven’t had time to convert any projects, I did have time to install Silverlight 4 RC, out of curiosity. Sure enough, SL4 is now an option when creating a new Silverlight project:

Before installing, I did need to uninstall the SL4 Beta tools. After that, the installation went very smoothly.

Time to delete my VS2010 Beta 2 VM…

Azure: The true cost of web and worker roles

2010-03-12T14:48:00.001-05:00

Since February 1, Azure customers are now being billed for their consumption of Azure resources. If you were an early adopter, you might have been spoiled by the free usage during CTP over the past year, or even during January of this year, when “mock bills” were generated but no actual costs accrued.

Recently I’ve been fielding questions about the true expense of running Azure web roles and worker roles, including questions about Microsoft’s “free” account for MSDN Premium developers. Let me share a few tidbits here that will, hopefully, help you manage your Azure costs.

Roles and Virtual Machines

First things first: web and worker roles are hosted in virtual machines (VMs). Each role deploys to its own VM. So, if you have a web role for your Silverlight application, and a worker role for some background tasks (like periodically fetching data from an external source and storing it in SQL Azure), you will actually consume two VMs, one for each role.

Virtual Machines and Instances

Ok, next up: instances. At the most basic level, you could view a VM as synonymous with an instance, and in the example above, you’d have two instances. Things take a twist, though, when you consider that Azure offers multiple VM sizes. The smallest size sets the baseline, and is equivalent to 1 instance:

Type	Instance count	Cost per hour
Small	1	0.12
Medium	2	0.24
Large	4	0.48
Extra Large	8	0.96

Each of the VMs vary by number of CPU cores, RAM and disk space. The price scales along with the instance count, so an Extra Large VM costs 8x what a Small VM costs.

Instances running ‘round-the-clock effectively cost 24 hours x 0.12 x 30 days = $86 monthly for a Small VM, up to about $690 monthly for an Extra large VM.

Microsoft bills in instance-hours. So you might be billed 48 instance-hours on a given 24-hour period, which either means you had two Small VM running for 24 hours or one Medium VM running for 24 hours.

Instances and Lifetimes

Now we’re getting to the fun part. Let’s say you just created a brand new Azure service, setting up a new name (like MyCoolApp.cloudapp.net). You just finished your first code iteration, and you publish your code to that new service of yours. Just two roles, both set up with one Small VM each.

You might notice that it takes a few minutes to deploy your code to that new service. Why? Because Azure is spinning up new VMs for you. Why is that important? Hold that thought a moment…

Ok, you’re done uploading and deploying, and finally, the Azure dashboard tells you your app is running. You are officially on the clock. You are now being billed for your two instances.

Now let’s get back to the point about your two new VMs. You might decide that, after your first set of tests, you’re going to suspend your new service. That is, leave everything uploaded (so you can show off your new app to the Boss later today). Guess what: You are still officially on the clock. The simple truth is, Azure is still hosting two VMs for you, each taking up a “slot” in the cloud fabric. So you’re still being billed for it, whether the web and worker roles are running or suspended.

Lifetimes and Clock time

Alright – if you’ve gotten this far, you’ve realized that your newly-deployed app, even in a suspended state, is going to burn through hours pretty quickly. And if you’re an MSDN Premium subscriber, with 750 free compute-hours monthly, you might have just done some quick math:

2 instances x 24 hours x 30 days = 1,440 hours !!!

Essentially, your MSDN account is good for one Small VM (equal to 1 instance) running ‘round the clock, as that 1 instance burns just under 750 compute-hours.

So you quickly scramble to delete your deployment from your service (don’t worry, your service definition, and fancy URL, stay in place; just your code and VMs get deleted). Lucky for you, your app was only live for about 10 minutes before you discovered this. So You can afford to deploy several times daily with little-to-no risk, as long as you delete the deployment after each test / demo cycle. Right?

Well, not quite right. When you deploy a VM, you are billed hourly. So even if the VM is up for 10 minutes, you are billed for a compute-hour. Since our example is using two instances, we’ve consumed 2 compute-hours in a very short time.

Clock time vs CPU time

This final per-instance tidbit might be obvious by now, but I’ll call it out anyway, just for good measure. Each VM, whether suspended or active, is costing you in compute-hours. And to take that one step further: Even VMs sitting around mostly idle still consume compute-hours at the same rate. Let’s go back and think about that worker role we have. Maybe it wakes up every 24 hours and fetches temperature data, and stores it in your local database. Maybe that service call takes, oh, 10 seconds to retrieve all needed data, and another few seconds to store it. Then it goes to sleep for 23.99 hours. You are still running at 0.12 cents per instance-hour.

Cost-based architecture

What to do today

So here we are, fully armed with the true cost of these web and worker roles. And here we are, with our elegant Azure application architecture, with a web role for our Silverlight app, a WCF web role for our service tier, and one worker role for each 3rd-party service we want to interact with (that way, we have a very modular system, with each role doing only what it needs to). You probably see where I’m going with this: While our web role is going to be super-busy (and we might need to scale it up to handle our web traffic), and our WCF web role might have to be scaled up as well, our worker roles will likely remain at 1 instance per 3rd-party service.

From a cost perspective, each of those worker roles, sitting almost-completely idle, is burning $86 monthly. Just three external services and you’re up to $250 per month.

Going back to the MSDN Premium accounts, you would require 5 instances running, in order to test your application. That means you’d burn through your 750 hours in about 6 days.

You will want to consider Azure’s pricing model when developing your architecture. The cost structure associated with instances and their lifetimes may mean making compromises such as rolling all of your 3rd-party integration code into a single worker role, and managing your polling intervals accordingly.

Future-thinking

The Azure team is reaching out to the community, asking for input about future ideas, where you can suggest a new idea or vote on someone else’s idea (check out the voting site here). I want to draw your attention to a few ideas that could really help reduce cost:

Provide multiple roles per instance. The idea would be to host, say, all of your worker roles in a single instance. Maybe this wouldn’t help with your web roles, since they’ll likely be much busier, but for lower-usage worker roles, this could work out nicely.
Provide a way to schedule worker roles so they only run when needed.
Make it less expensive to run my very small service on Windows Azure. While this topic is a bit heated, it’s gotten the attention of Mike Wickstrand, Senior Director of Azure Product Planning.

What other great ideas would you add, to help create a more cost-effective model for your Azure rollout?