Short version – I’m leaving Microsoft and will miss working with you, long version keep reading   Working at Microsoft was the most fun I’ve had till date at any company and I have to say that each day here has brought interesting challenges and learnings of all sorts. I count myself lucky and privileged to have worked and contributed to the Windows Azure team which without a doubt is the shining north star of the company. There is a lot that we have accomplished and a lot that I’m super excited looking into the future of Windows Azure –  You can bet that I will be cheering for all the accomplishments of the team from the sidelines.   The best part of it all has been getting to know and work with a lot of amazingly smart people. But it is time for me to step out and try something new that scares the day lights of me   Few interesting things I learned at Microsoft – ·         Never ask anyone how long they have worked for Microsoft unless you want to face plant – (especially if you haven’t crossed 10 years of service) ·         If you don’t have a Windows Phone, prepare yourself for a pep talk every elevator ride. ·         Never underestimate the influencing power you get from 1:1 lunch meetings. ·         You can learn a lot about a person by quickly scanning their Office space. ·         Before you get a patent, you will invent dozens of acronyms. ·         You can quickly tell the difference between a dev. and a PM by looking at their calendar, unless the ninja PowerPoint skills don’t give it away first. ·         Admin’s are your best friend. (Hi Robyn J)   Thanks for giving me the privilege of working with you and being part of this amazing company. Tomorrow is my last day, but you can connect with me on LinkedIn, Twitter or my personal email   Jacob

A Primer on Windows Azure Roles

Windows Azure supports three types of roles:

1. Web role: used for web applications and is supported by IIS 7.
2. Worker role: used for general development and/or to perform any background processing work for a web role.
3. VM role: used to run an image of Windows Server 2008 R2 created on-premise with any required customizations.

In addition to these with 1.3 SDK, you now have to ability to launch your Web/Worker role with elevated privileges and/or use startup tasks to run scripts/exe’s/msi etc. with elevated privileges. So think of it as Web/Worker role with Jet packs.

With great power comes greater responsibility

The diagram above is not meant to say one is better or the other is bad, it is meant to give you an understanding of the differences with respect to the abstraction and control that varies with each of them. As you start changing the environment going upwards, manageability of the application environment becomes more of your responsibility rather than the Fabric’s.

Startup Tasks

To demonstrate a scenario where you need to prep your application environment with a dependency, let’s attempt to install Internet Explorer 9 beta on a Cloud VM which is running on Windows Server 2008 R2.

Please note that to try this on Windows Server 2008 (non R2) you might have to additionally install Platform update for Windows Server 2008 for DirectX  (which is a dependency for IE9).

Here is the screenshot of my solution explorer for visual clarity.

I have a tiny little REST service “DistributeRain” which simply returns the installed browser information

public class DistributeRain {
    Version ver = null;

    //REST Service to return browser information [WebInvoke(UriTemplate = "/GetBrowserVersion", Method = "GET")]
    public string GetBrowserVersion()
    {
        Thread t = new Thread(new ThreadStart(GetBrowserInfo));
        t.SetApartmentState(ApartmentState.STA);
        t.Start();
        t.Join();
        return ver.ToString();
    }

    //Grab the version public void GetBrowserInfo ()
    {
        WebBrowser browser = new WebBrowser();
        ver = browser.Version;
    }
}

First let’s try an out-of-box install of our service with some of the default configuration settings in the ServiceConfiguration file that is generated with the 1.3 SDK. We still haven’t done anything to install IE9 beta.

Here is how my service configuration looks, notice the highlighted line

<?xml version="1.0" encoding="utf-8"?> <

ServiceConfiguration serviceName=“RainCloud” xmlns=“http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceConfiguration” osFamily=“1” osVersion=“*“

> <Role name="RainService"> <Instances count="1" /> <ConfigurationSettings> <Setting name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" value="UseDevelopmentStorage=true" /> <Setting name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" value="true" /> <Setting name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountUsername" value="username" /> <Setting name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountEncryptedPassword" value="password" /> <Setting name="Microsoft.WindowsAzure.Plugins.RemoteAccess.AccountExpiration" value="2999-03-23T23:59:59.0000000-07:00" /> <Setting name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" value="true" /> </ConfigurationSettings> <Certificates> <Certificate name="Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" thumbprint="thumbprint" thumbprintAlgorithm="sha1" /> </Certificates> </Role> </ServiceConfiguration> 

So the following attributes determines the Operating System on which your role will be deployed

osFamily="1" osVersion="*"

1.X versions of the OS are compatible with Windows Server 2008 SP2 and 2.X is compatible with Windows Server 2008 R2.

Let’s deploy the above solution as is and check the results.

So we got back Internet Explorer 7, which comes installed out-of-box with a Windows Server 2008 SP2 compatible OS.

Take a look at the OS matrix for the OS flavors available on Azure.

Now lets flip the osFamily switch and redeploy with the following change.

osFamily="

2

" osVersion="*"

Like expected you get back a version corresponding to Internet Explorer 8 which is running on a Windows Server 2008 R2 compatible OS.

You can change the version of the Operating System from theportal

 

Now that we know the lay of the land, let’s attempt to install Internet Explorer 9 beta on a Windows Server 2008 R2 instance.

Install IE9 beta

So the magic piece of code is highlighted below in the ServiceDefinition file.

<?xml version="1.0" encoding="utf-8"?> <ServiceDefinition name="RainCloud" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition"> <WebRole name="RainService"> <Sites> <Site name="Web"> <Bindings> <Binding name="Endpoint1" endpointName="Endpoint1" /> </Bindings> </Site> </Sites> <Endpoints> <InputEndpoint name="Endpoint1" protocol="http" port="80" /> </Endpoints> <Imports> <Import moduleName="Diagnostics" /> <Import moduleName="RemoteAccess" /> <Import moduleName="RemoteForwarder" /> </Imports>  <Startup

> <Task commandLine=“IE9.cmd” executionContext=“elevated” taskType=“simple“> </Task> </Startup

> </WebRole> </ServiceDefinition> 

You need to simply set the commandLine to the name of the program/script that you want to run and executionContext to the permissions with which you want the commandLine arguments to run.

So what is in our IE9.cmd file?

IE9-Windows7-x64-enu.exe /quiet

Yes, that’s it!

Remember to use silent switches (non UI) while installing executables/MSI’s to avoid the need for user intervention.

Make sure to change the command file properties in Visual Studio to “Copy to the Output Directory”

Seems like we’re all set to have IE9 installed on Azure, let’s try another deploy and retest.

So seems like our IE9 install failed for some reason. Some debugging by remoting in revealed an error “Process exit code 0×00000070 (112) [There is not enough space on the disk. ]”

I did notice in the logs, that the IE9 install was attempting to install a .MSU file (which is a windows update), and anytime you think about Windows Update in Azure, know that Windows update is disabled since all OS updates are managed for you by the platform itself. So I went ahead and turned on Windows Update with a slight change to my startup task.

I added the following to my IE9.cmd batch file.

sc config wuauserv start= auto net start wuauserv

IE9-Windows7-x64-enu.exe /quiet

Ideally you should turn off Windows Update right after your installs are completed, and installing IE9 introduces reboot scenarios. I will not cover install + reboot scenarios in this blog post.

So I was feeling slightly more confident, but the next deploy with this change had the same issue.

Steve Marx suggested remoting into the Azure VM and running the Startup task as a “System” user which is a great way to simulate what the startup task was attempting to do. I saw the same error when running as System which validated that the issue had something to do with space where the install files were expanding.

%TEMP%

So there is a 100MB limit on the TEMP folder used by the startup tasks. So to extend the Quota and make sure that my process had access to the TEMP variable, I wrote a console app which spawned my IE9 install and prior to spawning the install, it did the following to set the TEMP variable. All you need to do after that is to call the console app from the startup task.

Directory.CreateDirectory(path);
Environment.SetEnvironmentVariable("TEMP", path);

Let’s see what our REST service returns back after this change.

Perfect, we now get back the version corresponding to IE9 beta. Hopefully this will get you started with thinking about the possibilities and applications for Startup tasks.

I will cover Elevated privileges and VM Roles in subsequent blog posts. Stay tuned!

So both my predictions came true There were a lot of announcements on the Azure platform and the developer toolset space, but I will highlight some of the main announcements in this post.

Cost

Like I mentioned in my previous post, cost has been a BIG pain point for developers wanting get their feet wet with Azure. Windows Azure will soon provide access to the new “Extra Small” Windows Azure instances as part of the “Cloud Essentials Pack” offer that will replace the existing partner offers.

This offer provides free access to the Windows Azure platform including 750 extra small instance hours and a SQL Azure database per month at no charge and will be available to Microsoft Partner Network members.

Availability: January 7th, 2011.

IaaS support

We knew this was coming. With the introduction of Virtual Machine Role, Windows Azure now supports the IaaS model. This should VERY effectively push all those IT decision makers who were on the fence over the cost involved with migration of existing Windows Server applications to Windows Azure and enable customers to quickly move their existing business apps and data over to the cloud.

Availability: End of 2010.

As an added bonus to this, Windows Azure will support constructing VM role images for the VM role in the cloud as well.

Availability: 2011.

Elevated Privileges and Full IIS

The new Elevated Privileges functionality for the Web and Worker role will provide developers the ability to run apps with Admin rights. Elevated mode should let you install dependencies which need admin mode while still running under the PaaS model.

Availability: End of 2010.

The Azure Web role will provide Full IIS functionality and the ability to install IIS modules.

Availability: End of 2010.

Server Application Virtualization

This is a BIG move; Microsoft is going to support deploying custom virtualized application images onto the Windows Azure worker role. Now customers can migrate their native applications to Windows Azure without the need to rewrite them. So customers can still benefit from the automated service and operation management capabilities of Windows Azure.

Availability:

CTP: End of 2010.

Release: Second half of 2011.

Remote Desktop functionality

Windows Azure will support an out-of-the-box ability to connect and remote into a running Azure instance, this should help facilitate better monitoring and troubleshooting from a development and support standpoint.

Availability: End of 2010.

Windows Azure Connect (Project Sydney)

Windows Azure Connect aka Project Sydney essentially enables a simple mechanism to setup an IP-based network connectivity between on-premises and Windows Azure resources. This scenario enables a Hybrid model which I will cover in subsequent posts.

Availability:

CTP: End of 2010.

There were a ton of other nice enhancements to the existing infrastructure and the developer experience, but I’ll cover them in a later post.

1) Pricing for developers

Last week Amazon announced that beginning November 1, new AWS customers will be able to run a free Amazon EC2 instance for a year. This is a huge incentive to make their service appealing and approachable to the developer community.

Here are the highlights taken from http://aws.amazon.com/free/

For a long time “Make it less expensive to run my very small service on Windows Azure.” has been the top request on MyGreatWindowsAzureIdea and Microsoft has heard it loud and clear.

And based on the following video interview with Doug Hauger, General Manager of WIndows Azure, it sounds like something along the lines of addressing this will be announced at the PDC this year. (at video time: 1:00)

http://www.youtube.com/watch?v=zdDMKeKs1as

The stars are aligning for the good.

Blogging is officially dead and I’m announcing that with this blog post.

And just like that I decided to revive my old blogger account and port it over to WordPress over the weekend. No idea why, but it seemed like a good idea at that time J. So here I am, saw-ing the tree branch I’m sitting on.

So let me rephrase the catchy blog title to “Traditional blogging is an endangered species”, well in some of its current forms. Twitter and other micro-blogging sites has been a great medium for voicing opinions, sharing content, breaking news, syndicating content and blah and blah.

Agreed these micro-blogging tools do little when it comes to producing content comparable to traditional blogs, it is the marketplace for content producers and a huge sinkhole for meta-data. Without links to high value content there is little value in twitter, sure you could still tweet something like this.

It is a mutually beneficial relationship between content producers and consumers, without which the value proposition for twitter drops.

Micro-blogging sites has produced a new breed of bloggers, well “micro-bloggers” whose 140 character updates/tweets have a bigger/different impact than traditional bloggers, in terms of engaging an audience in meaningful conversations on their platform and syndicated networks.

This will and has been taking away a huge slice of blog audience in terms of “conversation”, “search”, “relevance” and “real-time” requirements. Blogging was never really the right product for those things to begin with. Traditional blogging will survive, but just not in the same form and shape we know today.

Platform as a Service/PaaS

Windows Azure at the moment supports the PaaS model, so in other words consumers can build and deploy cloud applications created by using programming languages and tools supported by the provider. The consumers don’t have to manage or control the underlying cloud infrastructure i.e. network, servers, operating systems, or even local storage.

Infrastructure as a Service/IaaS

Windows Azure will support “VM role” sometime in the near future which should put Microsoft in the IaaS arena along with Amazon EC2.

With the IaaS model the consumer is provided the ability to provision compute, storage, networks and other fundamental computing resources. The consumer can choose to deploy and run arbitrary software without having to manage or control the underlying cloud infrastructure, while still maintaining control over the operating system, storage, deployed applications and certain networking components.

A picture is definitely worth a thousand words, here is a high-level overview I put together to help visualize the Cloud service models in terms of the scope of management

Software as a Service/SaaS

On-Premise model is by far the most used model among ISV’s to deliver applications to their clients. Each time a new client is brought on-board, the solution is deployed to the client’s on-premise location. From thereon, the client needs to manage and control the entire breadth of the infrastructure i.e. network, servers, operating systems, storage, individual application capabilities and even datacenter logistics.

So something like this:

SaaS is all about providing customers the ability to use the software vendor’s applications running on a cloud infrastructure which are accessible from variety of client devices. The customer doesn’t have to deal with the hassle of managing/controlling/securing the underlying cloud infrastructure except for application configuration settings/customization.

Using the SaaS model, the ISV can now provide the goodness of Cloud computing in addition to providing their clients with high scalability and reduce costs by resource pooling and taking advantage of a multi-tenant model. From an application developer perspective, you should be able to leverage and use SaaS as long as the cloud service provider supports IaaS/PaaS. So the answer with Windows Azure is yes again, you can use SaaS with Windows Azure.

If you need to see an example of this, Vittorio Bertocci just released a great sample of running using SaaS with Azure that you can look at.

Two of the new SharePoint 2010 features which caught my eye right away were:

1) Business Connectivity Services

This is Business Data Catalog the way it should have been with version 1. BCS now supports CRUD operations, yes, you heard it right. No more relying on 3^rd party tools and worry about scalability of business apps with newer versions of SharePoint (Ok, I made that sound too easy!)

So new BCS features as per this post seems like:

• Read and Write capability
• Integrated Editor Environment into SharePoint Designer 2010 and Visual Studio 2010
• Integrated into Office 2010 Suite

2) Client Object Model API

Just as it sounds, this is a client side API for interacting with data on the SharePoint server using JavaScript, .NET code, or Silverlight.

Still not excited? Then how about this one?

SharePoint Server 2010 won’t support Internet Explorer 6 J

I’ll post the conference updates/announcement via twitter . See you all at the SharePoint Conference 2009!

*  Disclosure: Details in this post aren’t from any of the NDA materials or the actual software. You can find this info in the SharePoint 2010 sneak peak  

One of my colleagues @gdurzi recently asked me this question. Sounds straightforward enough to be supported out of the box with TFS right? Too many quirks with this. And I recommended using the ever faithful MSBuild <Exec> task to make a call to TFSBuild.exe to queue a new build from the first TFSBuild.proj with something like this

TFSBuild.exe start /queue %TFSSVR% %TEAMPROJECT% %BUILDTYPE%

An issue with using TFSBuild.exe is that you cannot pass Build agents as a command line argument which was a deal breaker for us.

There are several approaches that you can take based on your particular scenario so let’s define the scenario here, you have a Main_Build TFS build definition that builds your core project and you want the ability to have multiple staging builds running the same Main_Build for compilation/building, but be custom staged for deployment based on who calls Main_Build. Very useful when you have a product which rolls out to multiple clients with a need for custom pre-build and post-build actions per client.  So here is one way to do Build Chaining with TFS 2008.

Step 1: Let’s create a custom MSBuild task using the Team Foundation object model which queues a build using the default build agent associated with the Build definition file.

Sample code for Queuing: QueueTFS.cs

using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Build.Client;

// Get the team foundation server. 
TeamFoundationServer _tfsServer = TeamFoundationServerFactory.GetServer(_tfs); 

// Get the IBuildServer 
IBuildServer buildServer = (IBuildServer)_tfsServer.GetService(typeof(IBuildServer)); 

// Get the build definition for which a build is to be queued. 
IBuildDefinition definition = buildServer.GetBuildDefinition(teamProject, buildDefinition); 

// Create a build request for the build definition. 
IBuildRequest request = definition.CreateBuildRequest(); 
request.CommandLineArguments = "Pass any custom command line args here"; // Ex: Custom Targets file

// Queue the build. 
buildServer.QueueBuild(request, QueueOptions.None);

Step 2: Now copy the QueueTFS.dll to a new folder in TFS where you want to create the staging Build definition file. Now let’s create a minimal TFSBuild.proj file which uses our new MSBuild task and overrides the EndToEndIteration target. This will be our Staging build definition which will trigger the Main_Build build. Note that you will have to create this TFSBuild.proj by hand and simply point the project file location from the Build definition UI to the new folder.

Sample code for a minimal TFSBuild.proj:

<?xml version="1.0" encoding="utf-8"?> 
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5"> 
<Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\TeamBuild\Microsoft.TeamFoundation.Build.targets" /> 
  <UsingTask TaskName="MyNewCustomTFSTask" AssemblyFile="QueueTFS.dll"/> 
  <Target Name="EndToEndIteration"> 
    <Message Text="About to trigger main build" Importance="high"/> 
    < MyNewCustomTFSTask TFS="http://TFSServer.com:8080/" TeamProject="TeamProject" BuildDefinition="Main_Build" TargetsFile="Custom.Target" XYZ="XYZ" /> 
    <!-- When everything is done, change the status of the task to "Succeeded" --> 
    <SetBuildProperties TeamFoundationServerUrl="$(TeamFoundationServerUrl)" BuildUri="$(BuildUri)" TestStatus="Succeeded" CompilationStatus="Succeeded"/> 
  </Target> 
</Project>

Step 3: Edit your Main_Build TFSBuild.proj file with the pre-build and post-build target calls. 

  <Target Name=“BeforeCompile“>

    <CallTarget Targets=“Custom_PreBuild“/>    

  </Target>

  <Target Name=“AfterDropBuild“ Condition=“‘$(BuildBreak)’!=’true’“>    

    <CallTarget Targets=“Custom_PostBuild“/>

  </Target>

We wanted the ability to run Main_Build by itself as well, to support this we add conditional imports in our Main_Build TFSBuild.proj to import a default targets file with empty Custom_PreBuild and Custom_PostBuild targets. $(CustomTarget) is what you would pass as a command line argument in Step 1 for request.CommandLineArguments

<Import Project="$(CustomTarget)" Condition="'$(CustomTarget)'!=''"/>
<!--Import CustomContoso.Target if no partner is passed in—>
<Import Project="EmptyCustom.Target" Condition="'$(CustomTarget)'==''"/> 
 

Step 4: Now create your targets file Custom.Target and EmptyCustom.Target with Custom_PreBuild and Custom_PostBuild targets and you are done.

I added support for updating build steps and a few other minor things which outside the scope of this blog post, but this should hopefully get you started.

Ran into this issue yesterday, thought I will post it out here for anyone who runs into the same issue, since this is a very common issue with open source projects.

After wiring up the bits from CruiseControl.Net 1.4.4 SP1 with TFS on a machine running 64 bit OS, I was getting strange exceptions like

“Could not load file or assembly ‘Microsoft.TeamFoundation.VersionControl.Client, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a’ or one of its dependencies…..”

The DLL in question seemed to be present in the GAC. So what really went wrong?

Windows Loader is responsible for deciding how to load and execute a program and the way it does that is by looking at the PE header on the app. This PE Header bit is set when the Platform Target in the build configuration of Visual Studio is set to one of the following:

• x64: 64-bit—denotes that the developer has built the assembly specifically targeting a 64-bit process.
• x86: 32-bit—denotes that the developer has built the assembly specifically targeting a 32-bit process.
• Any CPU: Agnostic—denotes that the developer built the assembly that can run in either 64-bit or 32-bit mode.

When .Net apps are compiled with the default “Any CPU” your program will run as a 32 bit process on a 32 bit machine or as a 64 bit process on a 64 bit machine. The Windows Loader sees such DLLs as Agnostic DLL’s.

Simply marking the Platform Target as “Any CPU” does not guarantee that it will run on both 32-bit and 64-bit Windows.

Reason:  It is not possible to inject a 32-bit DLL into a 64-bit process, so be careful if your program has dependencies on native 32 bit DLLs or is making native calls assuming 32-bit. Exactly what was happening in my case.

Now how can you troubleshoot this issue when you don’t have the source code for an assembly? I use Dumpbin to evaluate this, open up your VS2005/2008 command prompt and run the following command

dumpbin Program.exe /headers

How can you fix such apps to working correctly on a 64 bit machine? Applications and assemblies marked/compiled as a 32 bit can run on 64-bit Windows with WOW64 emulator, so the PE header can be modified to be run as 32 bit

Run the CoreFlags Conversion utility from the VS2005/2008 command prompt

CorFlags.exe Program.exe /32BIT+ 

This should flip the PE header bit to mark the app/assembly as a 32 bit,  this does not affect the build of the assembly in anyway since this just conveys how the JIT compiler should interpret the assembly.

You can turn the bit back on with a

CorFlags.exe Program.exe /32BIT-

So in my case to fix the CruiseControl issue, I just ran the following:

CorFlags.exe CCService.exe /32BIT+ 

CorFlags.exe CCNet.exe /32BIT+