When looking at how people like to deploy their applications to a cloud environment, a large faction seems to prefer being able to use their source control system as a source for their production deployment. While interesting, I see a lot of problems there: your source code may not run immediately and probably has to be compiled. You don’t want to maintain compiled assemblies in source control, right? Also, maybe some QA process is in place where a deployment can only occur after approval. Why not use source control for what it’s there for: source control? And how about using a NuGet repository as the source for our deployment? Meet the Windows Azure NuGetRole.

Disclaimer/Warning: this is demo material and should probably not be used for real-life deployments without making it bullet proof!

Download the sample code: NuGetRole.zip (262.22 kb)

How to use it

If you compile the source code (download), you have X steps left in getting your NuGetRole running on Windows Azure:

  • Specifying the package source to use
  • Add some packages to the package source feed (which you can easily host on MyGet)
  • Deploy to Windows Azure

When all these steps have been taken care of, the NuGetRole will download all latest package versions from the package source specified in ServiceConfiguration.cscfg:

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <ServiceConfiguration serviceName="NuGetRole.Azure" 
 3                       xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceConfiguration" 
 4                       osFamily="1" 
 5                       osVersion="*">
 6   <Role name="NuGetRole.Web">
 7     <Instances count="1" />
 8     <ConfigurationSettings>
 9       <Setting name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" value="UseDevelopmentStorage=true" />
10       <Setting name="PackageSource" value="http://www.myget.org/F/nugetrole/" />
11     </ConfigurationSettings>
12   </Role>
13 </ServiceConfiguration>

Packages you publish should only contain a content and/or lib folder. Other package contents will currently be ignored by the NuGetRole. If you want to add some web content like a default page to your role, simply publish the following package:

NuGet Package Explorer MyGet NuGet NuGetRole Azure

Just push, and watch your Windows Azure web role farm update their contents. Or have your build server push a NuGet package containing your application and have your server farm update itself. Whatever pleases you.

How it works

What I did was create a fairly empty Windows Azure project (download).  In this project, one Web role exists. This web role consists of nothing but a Web.config file and a WebRole.cs class which looks like the following:

 1 public class WebRole : RoleEntryPoint
 2 {
 3     private bool _isSynchronizing;
 4     private PackageSynchronizer _packageSynchronizer = null;
 5 
 6     public override bool OnStart()
 7     {
 8         var localPath = Path.Combine(Environment.GetEnvironmentVariable("RdRoleRoot") + "\\approot");
 9 
10         _packageSynchronizer = new PackageSynchronizer(
11             new Uri(RoleEnvironment.GetConfigurationSettingValue("PackageSource")), localPath);
12 
13         _packageSynchronizer.SynchronizationStarted += sender => _isSynchronizing = true;
14         _packageSynchronizer.SynchronizationCompleted += sender => _isSynchronizing = false;
15 
16         RoleEnvironment.StatusCheck += (sender, args) =>
17                                         {
18                                             if (_isSynchronizing)
19                                             {
20                                                 args.SetBusy();
21                                             }
22                                         };
23 
24         return base.OnStart();
25     }
26 
27     public override void Run()
28     {
29         _packageSynchronizer.SynchronizeForever(TimeSpan.FromSeconds(30));
30 
31         base.Run();
32     }
33 }

The above code is essentially wiring some configuration values like the local web root and the NuGet package source to use to a second class in this project: the PackageSynchronizer. This class simply checks the specified NuGet package source every few minutes, checks for the latest package versions and if required, updates content and bin files.  Each synchronization run does the following:

 1 public void SynchronizeOnce()
 2 {
 3     var packages = _packageRepository.GetPackages()
 4         .Where(p => p.IsLatestVersion == true).ToList();
 5 
 6     var touchedFiles = new List<string>();
 7 
 8     // Deploy new content
 9     foreach (var package in packages)
10     {
11         var packageHash = package.GetHash();
12         var packageFiles = package.GetFiles();
13         foreach (var packageFile in packageFiles)
14         {
15             // Keep filename
16             var packageFileName = packageFile.Path.Replace("content\\", "").Replace("lib\\", "bin\\");
17        
18             // Mark file as touched
19             touchedFiles.Add(packageFileName);
20 
21             // Do not overwrite content that has not been updated
22             if (!_packageFileHash.ContainsKey(packageFileName) || _packageFileHash[packageFileName] != packageHash)
23             {
24                 _packageFileHash[packageFileName] = packageHash;
25 
26                 Deploy(packageFile.GetStream(), packageFileName);
27             }
28         }
29 
30         // Remove obsolete content
31         var obsoleteFiles = _packageFileHash.Keys.Except(touchedFiles).ToList();
32         foreach (var obsoletePath in obsoleteFiles)
33         {
34             _packageFileHash.Remove(obsoletePath);
35             Undeploy(obsoletePath);
36         }
37     }
38 }

Or in human language:

  • The specified NuGet package source is checked for packages
  • Every package marked “IsLatest” is being downloaded and deployed onto the machine
  • Files that have not been used in the current synchronization step are deleted

This is probably not a bullet-proof solution, but I wanted to show you how easy it is to use NuGet not only as a package manager inside Visual Studio, but also from your code: NuGet is not just a package manager but in essence a package management protocol. Which you can easily extend.

One thing to note: I also made the Windows Azure load balancer ignore the role that’s updating itself. This means a roie instance that is synchronizing its contents will never be available in the load balancing pool so no traffic is sent to the role instance during an update.