Rather than present this session entirely on my own, I decided to invite some of my customers to come and talk about their own experiences.  I am extremely excited that the following three customers will join me at PDC:

CCH, a Wolters Kluwer Company – CCH is a Wolters Kluwer company, based in Riverwoods, Illinois, providing tax and business law information and software solutions. The company has approximately 700 products for the United States market.

Accenture – Launched originally as the business and technology consulting arm of Arthur Andersen, Accenture is now among the world’s largest consulting organizations. It employs more than 180,000 people in 52 countries.

Domino’s Pizza – See how Domino’s Pizza is running Java and Tomcat in Windows Azure to run their eCommerce application.  Windows Azure provides high scalability to handle Super Bowl load, interoperability with different platforms and technologies, and the ability to integrate to on-premises resources.

Our intent with this talk is to make it highly interactive – translation: ask us questions!  We have a lot of information to share with you, and while we like to present, we’d much rather engage in a meaningful conversation.  Thus, we plan to quickly provide the following information for each of the solutions migrated:

1. Background on the application (i.e. what does it do? who uses it? what technology stack?).
2. The previous architecture (before the migration to Windows Azure) and some of the challenges this architecture presented.
3. The new architecture leveraging the Windows Azure platform.
4. The migration process: what was easy, what was hard, what worked, and what didn’t.

After providing these details, we want to open the session up for Q&A.

We know that we won’t answer all of your questions in the time allotted to us, so we plan to stick around after the presentation so that we can talk to you 1-on-1 and answer your questions.

It’s going to be a great PDC – I hope you’re there!  If so, be sure and come to our presentation on Lessons Learned: Migrating Applications to the Windows Azure Platform.

This got the attention of a few folks, and I promised I’d follow-up on this with some details on how I got this to work.  Of course, I completely forgot to do so, and was only recently reminded (thanks, Roger Jennings).

You can still take a look at that application here (if nothing else, I find it interesting to look at the specifications of the CTP machines for Windows Azure): http://wmi.cloudapp.net/

In actuality, the solution is really quite straightforward – I used WMI.

What’s WMI?  Well, it stands for Windows Management Instrumentation.  Here’s quick blurb from MSDN:

Windows Management Instrumentation (WMI) is the infrastructure for management data and operations on Windows-based operating systems. You can write WMI scripts or applications to automate administrative tasks on remote computers but WMI also supplies management data to other parts of the operating system and products, for example System Center Operations Manager, formerly Microsoft Operations Manager (MOM), or Windows Remote Management.

For more information on how to use WMI in .NET, take a look at the WMI .NET Overview.  Lots of great information.

Assuming you’ve read the overview, it should be clear that this is really pretty easy.  At the heart of this are the following two lines of code …

ManagementClass mgmt = new ManagementClass(managementClass);

ManagementObjectCollection objCol = mgmt.GetInstances();

… where managementClass represent one of the Win32 classes (i.e. Win32_NTLogEventLog).

Now, to make this work, you need to iterate through the collection of management objects.  Something like the following works:

foreach (var obj in objCol)

{

    foreach (var prop in obj.Properties)

    {

        ...

    }

}

Now, I did two additional things to make this easy.

1. I created a dropdown list with all the Win32 classes so that you can easily choose which class to review.
2. I defined a querystring value that, if it exists, loads a specific Win32 class.

There are a lot of Win32 classes, so here’s the array I used – feel free to leverage it yourself:

public static string[] Win32Classes =

{

    "Win32_1394Controller",

    "Win32_1394ControllerDevice",

    "Win32_Account",

    "Win32_AccountSID",

    "Win32_ACE",

    "Win32_ActionCheck",

    "Win32_ActiveRoute",

    "Win32_AllocatedResource",

    "Win32_ApplicationCommandLine",

    "Win32_ApplicationService",

    "Win32_AssociatedBattery",

    "Win32_AssociatedProcessorMemory",

    "Win32_AutochkSetting",

    "Win32_BaseBoard",

    "Win32_BaseService",

    "Win32_Battery",

    "Win32_Binary",

    "Win32_BindImageAction",

    "Win32_BIOS",

    "Win32_BootConfiguration",

    "Win32_Bus",

    "Win32_CacheMemory",

    "Win32_CDROMDrive",

    "Win32_CheckCheck",

    "Win32_CIMLogicalDeviceCIMDataFile",

    "Win32_ClassicCOMApplicationClasses",

    "Win32_ClassicCOMClass",

    "Win32_ClassicCOMClassSetting",

    "Win32_ClassicCOMClassSettings",

    "Win32_ClassInfoAction",

    "Win32_ClientApplicationSetting",

    "Win32_CodecFile",

    "Win32_CollectionStatistics",

    "Win32_COMApplication",

    "Win32_COMApplicationClasses",

    "Win32_COMApplicationSettings",

    "Win32_COMClass",

    "Win32_ComClassAutoEmulator",

    "Win32_ComClassEmulator",

    "Win32_CommandLineAccess",

    "Win32_ComponentCategory",

    "Win32_ComputerShutdownEvent",

    "Win32_ComputerSystem",

    "Win32_ComputerSystemEvent",

    "Win32_ComputerSystemProcessor",

    "Win32_ComputerSystemProduct",

    "Win32_ComputerSystemWindowsProductActivationSetting",

    "Win32_COMSetting",

    "Win32_Condition",

    "Win32_ConnectionShare",

    "Win32_ControllerHasHub",

    "Win32_CreateFolderAction",

    "Win32_CurrentProbe",

    "Win32_CurrentTime",

    "Win32_DCOMApplication",

    "Win32_DCOMApplicationAccessAllowedSetting",

    "Win32_DCOMApplicationLaunchAllowedSetting",

    "Win32_DCOMApplicationSetting",

    "Win32_DefragAnalysis",

    "Win32_DependentService",

    "Win32_Desktop",

    "Win32_DesktopMonitor",

    "Win32_DeviceBus",

    "Win32_DeviceChangeEvent",

    "Win32_DeviceMemoryAddress",

    "Win32_DeviceSettings",

    "Win32_DFSNode",

    "Win32_DFSNodeTarget",

    "Win32_DFSTarget",

    "Win32_Directory",

    "Win32_DirectorySpecification",

    "Win32_DiskDrive",

    "Win32_DiskDrivePhysicalMedia",

    "Win32_DiskDriveToDiskPartition",

    "Win32_DiskPartition",

    "Win32_DiskQuota",

    "Win32_DisplayConfiguration",

    "Win32_DisplayControllerConfiguration",

    "Win32_DMAChannel",

    "Win32_DriverForDevice",

    "Win32_DriverVXD",

    "Win32_DuplicateFileAction",

    "Win32_Environment",

    "Win32_EnvironmentSpecification",

    "Win32_ExtensionInfoAction",

    "Win32_Fan",

    "Win32_FileSpecification",

    "Win32_FloppyController",

    "Win32_FloppyDrive",

    "Win32_FontInfoAction",

    "Win32_Group",

    "Win32_GroupInDomain",

    "Win32_GroupUser",

    "Win32_HeatPipe",

    "Win32_IDEController",

    "Win32_IDEControllerDevice",

    "Win32_ImplementedCategory",

    "Win32_InfraredDevice",

    "Win32_IniFileSpecification",

    "Win32_InstalledSoftwareElement",

    "Win32_IP4PersistedRouteTable",

    "Win32_IP4RouteTable",

    "Win32_IP4RouteTableEvent",

    "Win32_IRQResource",

    "Win32_JobObjectStatus",

    "Win32_Keyboard",

    "Win32_LaunchCondition",

    "Win32_LoadOrderGroup",

    "Win32_LoadOrderGroupServiceDependencies",

    "Win32_LoadOrderGroupServiceMembers",

    "Win32_LocalTime",

    "Win32_LoggedOnUser",

    "Win32_LogicalDisk",

    "Win32_LogicalDiskRootDirectory",

    "Win32_LogicalDiskToPartition",

    "Win32_LogicalFileAccess",

    "Win32_LogicalFileAuditing",

    "Win32_LogicalFileGroup",

    "Win32_LogicalFileOwner",

    "Win32_LogicalFileSecuritySetting",

    "Win32_LogicalMemoryConfiguration",

    "Win32_LogicalProgramGroup",

    "Win32_LogicalProgramGroupDirectory",

    "Win32_LogicalProgramGroupItem",

    "Win32_LogicalProgramGroupItemDataFile",

    "Win32_LogicalShareAccess",

    "Win32_LogicalShareAuditing",

    "Win32_LogicalShareSecuritySetting",

    "Win32_LogonSession",

    "Win32_LogonSessionMappedDisk",

    "Win32_LUID",

    "Win32_LUIDandAttributes",

    "Win32_ManagedSystemElementResource",

    "Win32_MappedLogicalDisk",

    "Win32_MemoryArray",

    "Win32_MemoryArrayLocation",

    "Win32_MemoryDevice",

    "Win32_MemoryDeviceArray",

    "Win32_MemoryDeviceLocation",

    "Win32_MethodParameterClass",

    "Win32_MIMEInfoAction",

    "Win32_ModuleLoadTrace",

    "Win32_ModuleTrace",

    "Win32_MotherboardDevice",

    "Win32_MountPoint",

    "Win32_MoveFileAction",

    "Win32_MSIResource",

    "Win32_NamedJobObject",

    "Win32_NamedJobObjectActgInfo",

    "Win32_NamedJobObjectLimit",

    "Win32_NamedJobObjectLimitSetting",

    "Win32_NamedJobObjectProcess",

    "Win32_NamedJobObjectSecLimit",

    "Win32_NamedJobObjectSecLimitSetting",

    "Win32_NamedJobObjectStatistics",

    "Win32_NetworkAdapter",

    "Win32_NetworkAdapterConfiguration",

    "Win32_NetworkAdapterSetting",

    "Win32_NetworkClient",

    "Win32_NetworkConnection",

    "Win32_NetworkLoginProfile",

    "Win32_NetworkProtocol",

    "Win32_NTDomain",

    "Win32_NTEventlogFile",

    "Win32_NTLogEvent",

    "Win32_NTLogEventComputer",

    "Win32_NTLogEventLog",

    "Win32_NTLogEventUser",

    "Win32_ODBCAttribute",

    "Win32_ODBCDataSourceAttribute",

    "Win32_ODBCDataSourceSpecification",

    "Win32_ODBCDriverAttribute",

    "Win32_ODBCDriverSoftwareElement",

    "Win32_ODBCDriverSpecification",

    "Win32_ODBCSourceAttribute",

    "Win32_ODBCTranslatorSpecification",

    "Win32_OnBoardDevice",

    "Win32_OperatingSystem",

    "Win32_OperatingSystemAutochkSetting",

    "Win32_OperatingSystemQFE",

    "Win32_OptionalFeature",

    "Win32_OSRecoveryConfiguration",

    "Win32_PageFile",

    "Win32_PageFileElementSetting",

    "Win32_PageFileSetting",

    "Win32_PageFileUsage",

    "Win32_ParallelPort",

    "Win32_Patch",

    "Win32_PatchFile",

    "Win32_PatchPackage",

    "Win32_PCMCIAController",

    "Win32_Perf",

    "Win32_PerfFormattedData",

    "Win32_PerfFormattedData_ASP_ActiveServerPages",

    "Win32_PerfFormattedData_ContentFilter_IndexingServiceFilter",

    "Win32_PerfFormattedData_ContentIndex_IndexingService",

    "Win32_PerfFormattedData_InetInfo_InternetInformationServicesGlobal",

    "Win32_PerfFormattedData_ISAPISearch_HttpIndexingService",

    "Win32_PerfFormattedData_MSDTC_DistributedTransactionCoordinator",

    "Win32_PerfFormattedData_NTFSDRV_SMTPNTFSStoreDriver",

    "Win32_PerfFormattedData_PerfDisk_LogicalDisk",

    "Win32_PerfFormattedData_PerfDisk_PhysicalDisk",

    "Win32_PerfFormattedData_PerfNet_Browser",

    "Win32_PerfFormattedData_PerfNet_Redirector",

    "Win32_PerfFormattedData_PerfNet_Server",

    "Win32_PerfFormattedData_PerfNet_ServerWorkQueues",

    "Win32_PerfFormattedData_PerfOS_Cache",

    "Win32_PerfFormattedData_PerfOS_Memory",

    "Win32_PerfFormattedData_PerfOS_Objects",

    "Win32_PerfFormattedData_PerfOS_PagingFile",

    "Win32_PerfFormattedData_PerfOS_Processor",

    "Win32_PerfFormattedData_PerfOS_System",

    "Win32_PerfFormattedData_PerfProc_FullImage_Costly",

    "Win32_PerfFormattedData_PerfProc_Image_Costly",

    "Win32_PerfFormattedData_PerfProc_JobObject",

    "Win32_PerfFormattedData_PerfProc_JobObjectDetails",

    "Win32_PerfFormattedData_PerfProc_Process",

    "Win32_PerfFormattedData_PerfProc_ProcessAddressSpace_Costly",

    "Win32_PerfFormattedData_PerfProc_Thread",

    "Win32_PerfFormattedData_PerfProc_ThreadDetails_Costly",

    "Win32_PerfFormattedData_PSched_PSchedFlow",

    "Win32_PerfFormattedData_PSched_PSchedPipe",

    "Win32_PerfFormattedData_RemoteAccess_RASPort",

    "Win32_PerfFormattedData_RemoteAccess_RASTotal",

    "Win32_PerfFormattedData_RSVP_ACSRSVPInterfaces",

    "Win32_PerfFormattedData_RSVP_ACSRSVPService",

    "Win32_PerfFormattedData_SMTPSVC_SMTPServer",

    "Win32_PerfFormattedData_Spooler_PrintQueue",

    "Win32_PerfFormattedData_TapiSrv_Telephony",

    "Win32_PerfFormattedData_Tcpip_ICMP",

    "Win32_PerfFormattedData_Tcpip_IP",

    "Win32_PerfFormattedData_Tcpip_NBTConnection",

    "Win32_PerfFormattedData_Tcpip_NetworkInterface",

    "Win32_PerfFormattedData_Tcpip_TCP",

    "Win32_PerfFormattedData_Tcpip_UDP",

    "Win32_PerfFormattedData_TermService_TerminalServices",

    "Win32_PerfFormattedData_TermService_TerminalServicesSession",

    "Win32_PerfFormattedData_W3SVC_WebService",

    "Win32_PerfRawData",

    "Win32_PerfRawData_ASP_ActiveServerPages",

    "Win32_PerfRawData_ContentFilter_IndexingServiceFilter",

    "Win32_PerfRawData_ContentIndex_IndexingService",

    "Win32_PerfRawData_InetInfo_InternetInformationServicesGlobal",

    "Win32_PerfRawData_ISAPISearch_HttpIndexingService",

    "Win32_PerfRawData_MSDTC_DistributedTransactionCoordinator",

    "Win32_PerfRawData_NTFSDRV_SMTPNTFSStoreDriver",

    "Win32_PerfRawData_PerfDisk_LogicalDisk",

    "Win32_PerfRawData_PerfDisk_PhysicalDisk",

    "Win32_PerfRawData_PerfNet_Browser",

    "Win32_PerfRawData_PerfNet_Redirector",

    "Win32_PerfRawData_PerfNet_Server",

    "Win32_PerfRawData_PerfNet_ServerWorkQueues",

    "Win32_PerfRawData_PerfOS_Cache",

    "Win32_PerfRawData_PerfOS_Memory",

    "Win32_PerfRawData_PerfOS_Objects",

    "Win32_PerfRawData_PerfOS_PagingFile",

    "Win32_PerfRawData_PerfOS_Processor",

    "Win32_PerfRawData_PerfOS_System",

    "Win32_PerfRawData_PerfProc_FullImage_Costly",

    "Win32_PerfRawData_PerfProc_Image_Costly",

    "Win32_PerfRawData_PerfProc_JobObject",

    "Win32_PerfRawData_PerfProc_JobObjectDetails",

    "Win32_PerfRawData_PerfProc_Process",

    "Win32_PerfRawData_PerfProc_ProcessAddressSpace_Costly",

    "Win32_PerfRawData_PerfProc_Thread",

    "Win32_PerfRawData_PerfProc_ThreadDetails_Costly",

    "Win32_PerfRawData_PSched_PSchedFlow",

    "Win32_PerfRawData_PSched_PSchedPipe",

    "Win32_PerfRawData_RemoteAccess_RASPort",

    "Win32_PerfRawData_RemoteAccess_RASTotal",

    "Win32_PerfRawData_RSVP_ACSRSVPInterfaces",

    "Win32_PerfRawData_RSVP_ACSRSVPService",

    "Win32_PerfRawData_SMTPSVC_SMTPServer",

    "Win32_PerfRawData_Spooler_PrintQueue",

    "Win32_PerfRawData_TapiSrv_Telephony",

    "Win32_PerfRawData_Tcpip_ICMP",

    "Win32_PerfRawData_Tcpip_IP",

    "Win32_PerfRawData_Tcpip_NBTConnection",

    "Win32_PerfRawData_Tcpip_NetworkInterface",

    "Win32_PerfRawData_Tcpip_TCP",

    "Win32_PerfRawData_Tcpip_UDP",

    "Win32_PerfRawData_TermService_TerminalServices",

    "Win32_PerfRawData_TermService_TerminalServicesSession",

    "Win32_PerfRawData_W3SVC_WebService",

    "Win32_PhysicalMedia",

    "Win32_PhysicalMemory",

    "Win32_PhysicalMemoryArray",

    "Win32_PhysicalMemoryLocation",

    "Win32_PingStatus",

    "Win32_PnPAllocatedResource",

    "Win32_PnPDevice",

    "Win32_PnPEntity",

    "Win32_PnPSignedDriver",

    "Win32_PnPSignedDriverCIMDataFile",

    "Win32_PointingDevice",

    "Win32_PortableBattery",

    "Win32_PortConnector",

    "Win32_PortResource",

    "Win32_POTSModem",

    "Win32_POTSModemToSerialPort",

    "Win32_PowerManagementEvent",

    "Win32_Printer",

    "Win32_PrinterConfiguration",

    "Win32_PrinterController",

    "Win32_PrinterDriver",

    "Win32_PrinterDriverDll",

    "Win32_PrinterSetting",

    "Win32_PrinterShare",

    "Win32_PrintJob",

    "Win32_PrivilegesStatus",

    "Win32_Process",

    "Win32_Processor",

    "Win32_ProcessStartTrace",

    "Win32_ProcessStartup",

    "Win32_ProcessStopTrace",

    "Win32_ProcessTrace",

    "Win32_Product",

    "Win32_ProductCheck",

    "Win32_ProductResource",

    "Win32_ProductSoftwareFeatures",

    "Win32_ProgIDSpecification",

    "Win32_ProgramGroup",

    "Win32_ProgramGroupContents",

    "Win32_ProgramGroupOrItem",

    "Win32_Property",

    "Win32_ProtocolBinding",

    "Win32_Proxy",

    "Win32_PublishComponentAction",

    "Win32_QuickFixEngineering",

    "Win32_QuotaSetting",

    "Win32_Refrigeration",

    "Win32_Registry",

    "Win32_RegistryAction",

    "Win32_RemoveFileAction",

    "Win32_RemoveIniAction",

    "Win32_ReserveCost",

    "Win32_ScheduledJob",

    "Win32_SCSIController",

    "Win32_SCSIControllerDevice",

    "Win32_SecurityDescriptor",

    "Win32_SecurityDescriptorHelper",

    "Win32_SecuritySetting",

    "Win32_SecuritySettingAccess",

    "Win32_SecuritySettingAuditing",

    "Win32_SecuritySettingGroup",

    "Win32_SecuritySettingOfLogicalFile",

    "Win32_SecuritySettingOfLogicalShare",

    "Win32_SecuritySettingOfObject",

    "Win32_SecuritySettingOwner",

    "Win32_SelfRegModuleAction",

    "Win32_SerialPort",

    "Win32_SerialPortConfiguration",

    "Win32_SerialPortSetting",

    "Win32_ServerConnection",

    "Win32_ServerFeature",

    "Win32_ServerSession",

    "Win32_Service",

    "Win32_ServiceControl",

    "Win32_ServiceSpecification",

    "Win32_ServiceSpecificationService",

    "Win32_Session",

    "Win32_SessionConnection",

    "Win32_SessionProcess",

    "Win32_SettingCheck",

    "Win32_ShadowBy",

    "Win32_ShadowContext",

    "Win32_ShadowCopy",

    "Win32_ShadowDiffVolumeSupport",

    "Win32_ShadowFor",

    "Win32_ShadowOn",

    "Win32_ShadowProvider",

    "Win32_ShadowStorage",

    "Win32_ShadowVolumeSupport",

    "Win32_Share",

    "Win32_ShareToDirectory",

    "Win32_ShortcutAction",

    "Win32_ShortcutFile",

    "Win32_ShortcutSAP",

    "Win32_SID",

    "Win32_SIDandAttributes",

    "Win32_SMBIOSMemory",

    "Win32_SoftwareElement",

    "Win32_SoftwareElementAction",

    "Win32_SoftwareElementCheck",

    "Win32_SoftwareElementCondition",

    "Win32_SoftwareElementResource",

    "Win32_SoftwareFeature",

    "Win32_SoftwareFeatureAction",

    "Win32_SoftwareFeatureCheck",

    "Win32_SoftwareFeatureParent",

    "Win32_SoftwareFeatureSoftwareElements",

    "Win32_SoundDevice",

    "Win32_StartupCommand",

    "Win32_SubDirectory",

    "Win32_SystemAccount",

    "Win32_SystemBIOS",

    "Win32_SystemBootConfiguration",

    "Win32_SystemConfigurationChangeEvent",

    "Win32_SystemDesktop",

    "Win32_SystemDevices",

    "Win32_SystemDriver",

    "Win32_SystemDriverPnPEntity",

    "Win32_SystemEnclosure",

    "Win32_SystemLoadOrderGroups",

    "Win32_SystemLogicalMemoryConfiguration",

    "Win32_SystemMemoryResource",

    "Win32_SystemNetworkConnections",

    "Win32_SystemOperatingSystem",

    "Win32_SystemPartitions",

    "Win32_SystemProcesses",

    "Win32_SystemProgramGroups",

    "Win32_SystemResources",

    "Win32_SystemServices",

    "Win32_SystemSetting",

    "Win32_SystemSlot",

    "Win32_SystemSystemDriver",

    "Win32_SystemTimeZone",

    "Win32_SystemTrace",

    "Win32_SystemUsers",

    "Win32_TapeDrive",

    "Win32_TCPIPPrinterPort",

    "Win32_TemperatureProbe",

    "Win32_Thread",

    "Win32_ThreadStartTrace",

    "Win32_ThreadStopTrace",

    "Win32_ThreadTrace",

    "Win32_TimeZone",

    "Win32_TokenGroups",

    "Win32_TokenPrivileges",

    "Win32_Trustee",

    "Win32_TypeLibraryAction",

    "Win32_UninterruptiblePowerSupply",

    "Win32_USBController",

    "Win32_USBControllerDevice",

    "Win32_USBHub",

    "Win32_UserAccount",

    "Win32_UserDesktop",

    "Win32_UserInDomain",

    "Win32_UTCTime",

    "Win32_VideoConfiguration",

    "Win32_VideoController",

    "Win32_VideoSettings",

    "Win32_VoltageProbe",

    "Win32_Volume",

    "Win32_VolumeChangeEvent",

    "Win32_VolumeQuota",

    "Win32_VolumeQuotaSetting",

    "Win32_VolumeUserQuota",

    "Win32_WindowsProductActivation",

    "Win32_WMIElementSetting",

    "Win32_WMISetting"

};

Other than attaching the results of the WMI query to a generic list and binding to a DataList, that’s pretty much it.  The end result is a web page that you can use to view system details via WMI:

As I’ve said, this is a very simple demonstration of WMI in Windows Azure.  What would be more interesting is to see how someone might combine the ability to spin up asynchronous processes in Windows Azure (as described in my post How to Leverage the RoleEntryPoint in an Azure Web Role) that query data via WMI and centralize it in Azure storage (i.e. combining and centralizing all event logs) – that would be very cool!

In case anyone wants to take a look, I’ve uploaded the code to SkyDrive.

Enjoy!

• You can’t spin up your own threads in Google App Engine.
• You build your applications according to how Google thinks your apps should be built (the argument being that Google knows how to run highly available services at scale, which I think is a fair statement).

Now to be fair, there are good reasons for this – the Google App Engine has a number of very good use cases (Don Schwarz demonstrated one of them when showing the audience a multiplayer game running on Google App Engine).

Note: I’d like state for the record that I mean no criticism of other cloud vendors (i.e. Amazon, Google, and SalesForce).  I think each of them have a place in the market, and exhibit various strengths.  That said, I do believe that the Windows Azure Platform stands out as the only real platform that can bridge the chasm between cloud services and on-premises software. (Note to self: back this statement up in a future blog post.)

I would argue, however, that most enterprise developers require a little more flexibility when building out enterprise class applications.  The Windows Azure Platform provides this flexibility (I mean, come on – sometimes you just want to execute some native code!).

I decided to test how far I could take this flexibility in Windows Azure.

I am a big fan of Worker Roles in Windows Azure.  I really like the idea of having an asynchronous, “headless” service that’s working for me in the background.  I wanted to see if I could spin up an equivalent to a Worker Role in a Web Role, so that in addition to having my Web application running in a Web Role I could also get a service running in the background.

Why would I want to do this?  Well, here are a few of reasons:

• Asynchronous logging service running in every Azure instance (whether a web or worker role); this service might take information from the event log and write it to an Azure table.
• Clean-up operations (i.e. temporary scratch writes, etc.)
• Opening and managing socket connections to the service bus (this is my favorite scenario).

The list could go on.  Hopefully you get the point.

So, how would you do this?  Again, given the flexibility of the platform, there are many ways you can do this.  Below you’ll find one simple way.

1. Create a new cloud services project, and add a web role.

2. Create a new class and inherit from Microsoft.ServiceHosting.ServiceRuntime.RoleEntryPoint.  You’ll have to override the Start and RoleStatus methods.

using Microsoft.ServiceHosting.ServiceRuntime;

using System.Threading;


namespace Web

{

    public class MyWebWorkerRole : RoleEntryPoint

    {

        public override void Start()

        {

            while (true)

            {

                RoleManager.WriteToLog("Information", "The worker role is running.");


                Thread.Sleep(5000);

            }

        }


        public override RoleStatus GetHealthStatus()

        {

            return RoleStatus.Healthy;

        }

    }

}

3. Create a Global.asax page.

4. Create a method where you initialize and start and initialize your class that inherits from RoleEntryPoint.

private void StartWorkerRole()

{

    MyWebWorkerRole myWebWorkerRole = new MyWebWorkerRole();

    myWebWorkerRole.Initialize();

    myWebWorkerRole.Start();

}

5. Create local threading variables that you will use to run your method.

public class Global : System.Web.HttpApplication

{

    System.Threading.ThreadStart ts;

    System.Threading.Thread t;


    ...

5. Update the Application_BeginRequest method to invoke your method on a new thread.  Be sure and check to see if the thread is already running, otherwise it will get started multiple times.

protected void Application_BeginRequest(object sender, EventArgs e)

{

    if (t == null)

    {

        ts = new System.Threading.ThreadStart(StartWorkerRole);

        t = new System.Threading.Thread(ts);

        t.Start();

    }

}

And that should do it.  Now you have a class that will run asynchronously in all your Web Role instances.  And since it inherits from the RoleEntryPoint, you can leverage this technique for both your Web and Worker Role instances.  I’d recommend placing this class in a separate class library and adding a reference to it from your various projects.

Note: It is highly probable that there will be some changes to the APIs and assemblies come PDC.  While these concepts will stay valid, the underlying code will probably change.  If this happens, I’ll be sure and provide an update.

I hope this helps!

When you upload your data into SQL Azure, SQL Azure replicates your data to three different locations in order to provide triple redundancy.  Therefore, it needs a little more time to get the data in the proper places.

One of the things that we found out during a series of Windows Azure Platform Migration Labs held in the Chicago MTC is that you cannot upload hundreds of thousands of records without giving SQL Azure time to catch up.  Consequently, you have to chunk your data and give SQL Azure time to process each chunk before uploading the next chunk of data.

The tool that we used for migrating our customer databases to SQL Azure was the SQL Azure Migration Wizard.  The migration wizard uses BCP to download data from an on premise SQL Server database and then uses BCP to upload the data to SQL Azure.  BCP allows you to specify the first row (-F), the last row (-L), and the batch size (-b).  These options will allow you to chunk the data beginning uploaded to SQL Azure.  For example:

BCP MyDb.dbo.Transactions out Transactions.dat -E -q -n –T 

The above command extracts data from table Transactions in the database MyDb.  At the end of the BCP output, you will find the number of records copied to file (for example: 2,524,520 rows copied).

In order to upload in chunks, you would do something like this:

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F1 –L250000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F250001 –L500000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F500001 –L750000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F750001 –L1000000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F1000001 –L1250000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F1250001 –L1500000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F1500001 –L1750000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F1750001 –L2000000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F2250001 –L2500000 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

BCP  MyDb.dbo.Transactions in  Transactions.dat -E -q -n –b 5000 –F2500001 –L2524520 -S  tcp:azureserver.ctp.database.windows.net -U admin@azureserver -P password

Note, you will have to put some kind of delay between BCP commands to give SQL Azure time to store the data (say 15 seconds).  You will probably find that sometimes the 15 seconds is not enough time and that, during the upload of one of your BCP chunks, SQL Azure might shut it down.  If that happens you will see something like this happen:

5000 rows sent to SQL Server. Total sent: 145000

5000 rows sent to SQL Server. Total sent: 150000

5000 rows sent to SQL Server. Total sent: 155000

SQLState = S1000, NativeError = 21

Error = [Microsoft][SQL Server Native Client 10.0][SQL Server]Warning: Fatal error 40501 occurred at Oct 30 2009  4:15PM. Note the error and time, and contact your system administrator.

BCP copy in failed 

From the above BCP output, you will see that a total of 155,000 rows were sent before SQL Azure closed the connection.  Thus you would have to adjust your next BCP command to start at your –F value + 155000.

While this process works reasonably well, it can make the process of uploading data a little tedious if you have a large number of tables with a large number of records per table.  In order to simplify the process, we have modified the SQL Azure Migration Wizard to do all of this work for you.  It allows you to specify the chunk size, the batch size, and the time to wait between BCP chunks in SQLAzureMW.exe.Config.  It also catch BCP errors and adjust for records processed and then retry.

Try it out, review the source code, and be sure to provide some good feedback!

This past year, the City of Chicago needed to quickly build out an interactive map for the event – and when I say quickly, I mean it.  They needed an interactive mapping experience built and deployed in less than 10 days.  To help make this a reality, the City of Chicago turned to a very capable Microsoft partner, West Monroe Partners (WMP), for assistance. 

The challenges here were pretty clear:

• Build an interactive and immersive website in less than 10 days.
• The website needed to scale massively for the event, but once the event was over they wanted to scale the infrastructure down.
• WMP wanted to leverage their existing skills and tools.

WMP proposed the following – an immersive Silverlight Deep Zoom experience running on Windows Azure (if you’re not familiar with Deep Zoom, take a look at the Hard Rock memorabilia site).  You can still visit the Taste of Chicago interactive map – check it out:

The Windows Azure Platform – which I’ve discussed many times on my blog – is Microsoft’s cloud platform.  It is comprised of the following: Windows Azure, an operating system as a service; SQL Azure, a fully relational database in the cloud; and .NET Services, consumable web-based services that provide both secure connectivity and federated access control for applications.

The City of Chicago’s decision to go with Silverlight and Windows Azure provided a host of very tangible benefits, including:

• Fast, cost-effective development
• Immediate customer satisfaction
• Increased agility
• Dynamic user experience

In fact, this is broken down in detail in the Taste of Chicago case study with WMP and the City of Chicago.

Additionally, Erik Brown – technical lead at WMP – spoke to Microsoft about their experience building the interactive map in Silverlight and on Windows Azure.  I definitely recommend you take a look:

A really great story about how a capable partner can leverage innovative technology to not only dazzle a customer, but provide a valuable service for millions of users.

I hope this helps!

Gabe and Scott from Tech in the Middle recorded and posted each of these talks.  You can find them here:

Jonathan Sapir/Michael Topalovich – Salesforce.com
Video: http://blip.tv/file/2777664

Wade Wegner – Windows Azure Platform
Video: http://blip.tv/file/2786114

Chris McAvoy – Amazon Web Services
Video: http://blip.tv/file/2780311

Don Schwarz – Google App Engine
Video: http://blip.tv/file/2786812

Panel: http://blip.tv/file/2786826

As promised, here is the deck I presented:

If you want to download the entire deck, you can grab it here: Windows Azure Platform at the Day of Cloud.

Thanks for the opportunity; I hope everyone found the presentation useful and had as much fun as I did!

The number one request for the migration wizard was the ability to replicate your data up to SQL Azure (in addition to the SQL schema, which it already does).  Unfortunately, the original SQL Azure CTP didn’t support BCP, and the data migration process was very difficult and required an SSIS package to copy the data into SQL Azure.

With yesterday’s release of SQL Azure CTP 2, however, SQL Azure now supports BCP!

Minutes after CTP 2 went live, George published a new version of migration wizard that takes advantage of BCP to enable you to migrate not only your SQL Server 2005 / 2008 database objects but your data as well!  migration wizard allows you to turn on or off data migration via the application configuration file or during runtime via the options page.  When you select data migration, the export and import process can be quite lengthy.  migration wizard kicks off the export and import process on a back ground thread and will display the BCP results in the program window.  At any time during the process, you can hit the cancel button to cancel the background process.  As migration wizard processes information, it will display the results to the program window.

Here are the release notes for version 1.0 (and 1.1):

• Added data migration via BCP. Note that when you specify your SQL Azure username, specify your user name as "username@server". Also note that data migration only works on the latest release of SQL Azure (Server Location: South Central US).
• Modified App.Config to allow you to specify your Options. For example: If you do not want to migrate data, you can turn this off by modifying the App.Config file and changing ScriptData to false.
• Added a cancel button so that you can cancel while processing.
• Added a scroll toggle so that during processing you can keep the control from scrolling down to the bottom.
• Fixed an error in BCP command to allow the passing of the SQL Server instance name.
• Added color to the SQL results to better identify error messages.

If you’re using SQL Azure, go and grab the new version of the SQL Azure Migration Wizard!  For detailed instructions on how to use the wizard, take a look at the SQL Azure Migration Wizard whitepaper.

I recommend reading the entire announcement on the SQL Azure team’s blog.  Here are some brief notes on the announcement:

• Details
  • CTP 2 (announced yesterday, October 15th) represents the complete set of features that will be available at commercial launch this November at PDC.
  • SQL Azure Database is now running on one of the go-live production clusters.
  • This environment will automatically roll into the fully supported production environment at PDC.
• Key features added in CTP 2
  • Firewall support – You can now specify an allow list of IP addresses, preventing unauthorized users from reaching your SQL Azure databases.
  • Bulk Insert – SqlBulkCopy, or BCP, is now supported.  This makes data migration much faster.
  • Database Edition Selection – You can now select either the Web Edition (1 GB) or Business Edition (10 GB) version of SQL Azure Database.
  • Additional T-SQL support – A host of new functionality has been exposed.  Take a look at Transact-SQL Reference for details.

Also, you no longer get the "SET ANSI NULLS" error when connecting a query window via SSMS!

If you haven’t tried SQL Azure yet, now’s the time!

Before you try this yourself, make sure you satisfy the following dependencies:

• Visual Studio 2008 with SP1
• Windows Azure Tools for Visual Studio
• Microsoft ASP.NET MVC

For those of you that have no desire to watch a four minute video, and would rather have a quick walkthrough, here you go:

1. Create a blank cloud services project.  Do not add any roles to the project.
2. Add a new ASP.NET MVC Web Application to the solution.
3. Add  the ASP.NET MVC Web Application as a web role in the cloud services project.
4. Add the Microsoft.ServiceHosting.ServiceRuntime.dll assembly to the ASP.NET MVC Web Application.
5. Set the following MVC assemblies to Copy Local True.
   • System.Web.Abstractions
   • System.Web.Mvc
   • System.Routing
6. Run the application.

I hope this helps!

Background

The practice of enabling the portability of identity information across otherwise autonomous security domains, called identity federation, is no longer a luxury – it’s a necessity.  The inability to allow users to access resources in different datacenters, with various trading partners, or on the Web, can quickly cripple a companies productivity (not to mention user satisfaction).  Historically, providing for the needs of Web-based single sign on (SSO) and cross-domain resource access has been very difficult to accomplish.  It may have required the replication of identity stores in a host of one-off scenario, or even (gasp!) compromising security best practices in order to satisfy a business need.

More recently, various kinds of identity architecture have made identity federation much easier.  Practices like claims-based authentication, standards like WS-Federation, and so forth allow companies to establish trust domains between different organization and parties much easier.  See the following illustration from InfoQ:

In this picture, the application implicitly trusts tokens that come from the issuer.  Consequently, rather than having to authenticate the users identity, the application can delegate that responsibility to the issuer, and instead focus on parsing the information received in the token.  These tokens contain claims, which are nothing more than bits of information about a person, such as a name, email address, membership in a particular role, and so on.  If your application trusts the issuer of the claim, you can leverage the information without having to query the identity store directly.

While it is possible to build a customer claims issuer (or more appropriately called a security token service), there are a host of solutions available today that make this quite easy.  Microsoft’s Active Directory Federation Services (ADFS) is a great example, and work implicitly with identities stored in active directory.  ADFS allows for federated identity by implementing claims-based authentication and establishing trust between different organizations and parties.

ADFS v2 (which was previously codenamed "Geneva" Server") expands this capability by bringing claims-based identity federation to cloud-based applications that live in on the web, in the enterprise, or across an organization.  The "Geneva" Beta 2 datasheet provides the following description that I think is a great summation of ADFS v2:

“Geneva” is Microsoft’s next generation identity and access management platform built on Active Directory® directory services. “Geneva” provides claims-based access and single sign-on for on-premises and cloud-based applications in the enterprise, across organizations, and on the Web.

“Geneva” leverages claims which describe identity attributes and can be used to drive application and other system behaviors with an open architecture that implements the industry’s shared Identity Metasystem vision.

A few things I’d like to point out about ADFS v2 that make it very powerful:

• Open standards.  ADFS v2 is based on SAML 2.0, so it can interoperate with products from all kinds of vendors and platforms.
• Automation.  ADFS v2 handles the federation of identities by setting up the trust relationships.
• Developer productivity.  Since developers interact with trusted claims, they don’t have to spend time worry about the particulars of the identity provider.

In this post, I want to highlight how you can use ADFS v2 to solve many of these identity challenges as you move to the cloud.  Additionally, I will also highlight how the Windows Identity Foundation (previously codenamed "Geneva" Framework), or WIF, is used to make your applications claims-aware and minimize the amount of work required by developers.

To explore ADFS v2 and WIF in more detail – and I strongly encourage you do! – please take a look at the following resources and blogs:

• Claims Based Identity & Access Control Guide
• Microsoft Code Name "Geneva"
• Claims-Based Identity Whitepaper
• "Geneva" Framework Whitepaper

Now, before you go through this post and start building this solution for yourself, download the Windows Identity Foundation and Windows Azure Passive Federation code.  Run the executable; immediately after the code is installed/copied on to your machine a browser window will open and load the documentation.  Read the entire guide.  There is a ton of good information in the documentation.  Next, run through the whole guide and run the demos.  I’m not going to restate anything mentioned in the guide in this post, since the guide does a fabulous job.  This post assumes that you’ve gone through and leveraged the WIF & WA passive federation guide.

A few additional assumptions I’d like to call out:

• You have an ADFS v2 server (today you’d use "Geneva" Server Beta 2).
• You have installed Windows Identity Foundation.
• You are running Visual Studio 2008 (although 2010 will probably work fine).
• You have installed the Windows Azure SDK and Windows Azure Tools for Visual Studio.
• You have a Windows Azure account and project.

Okay, let’s get started!

Building the Application

For a comprehensive examination of many of the below steps, please refer to the overview and walkthrough installed in the guide you installed above.  For the sake of brevity, I have focused on the execution of the process rather than a thorough explanation of how it works.  The guide provides a lot of valuable information.

1. To start, create your Windows Azure project.  I created a "Federated Identity Demo" project with the service name "fedid".  Be sure and keep track of the service name you choose, as you will use it when creating your certificate.

2. You must now create the certificate that you’ll use for SSL.  Open the folder where you installed the WIF & WA federation guide.  In this folder you will find a folder called assets.  Open a Visual Studio 2008 Command Prompt (choose to runas administrator) and run the command:

CreateCert.cmd <Azure Project service name>

For example, this is what I ran:

Note: you will have to enter the password "abc!123" multiple times.  This is documented in the guide.  Additionally, you will be prompted to install a certificate on your machine – click Yes.

This process will create a number of files in the Assets folder, including:

• fedid.cloudapp.net.cer
• fedid.cloudapp.net.pfx
• fedid.cloudapp.net.pvk
• encoder.out

3. Create a new Visual Studio 2008 solution.  Add a Cloud Service project, and create a Web Role.

4. Update the ServiceDefinition.csdef file to update the following:

• HTTPS protocol
• Port 443
• enableNativeCodeExecution: true

It should look like the following after the update:

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

<ServiceDefinition name="CloudService" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">

  <WebRole name="Web" enableNativeCodeExecution="true">

    <InputEndpoints>

      <!-- Must use port 80 for http and port 443 for https when running in the cloud -->

      <InputEndpoint name="HttpIn" protocol="https" port="443" />

    </InputEndpoints>

    <ConfigurationSettings />

  </WebRole>

</ServiceDefinition>

5. Right-click the Cloud Service project, and choose Properties.  Select the SSL tab.  Enable both checkboxes, and select the certificate you generated from the store.  Here’s what it looks like for me once I finished updating:

6. Add the following references to your Web Role project:

• System.IdentityModel
• Microsoft.IdentityModel
• Microsoft.IdentityModelPlus (this is in the assets folder that was created by the guide)

Make sure to set Copy Local true for Microsoft.IdentityModel and Microsoft.IdentityModelPlus so that they are added to your Windows Azure package.

7. Create a Global.asax file.

8. Update the Global.asax file so that you have the following using statements:

using System.IdentityModel.Selectors;

using System.IdentityModel.Tokens;

using System.Security.Cryptography.X509Certificates;

using Microsoft.IdentityModel;

using Microsoft.IdentityModel.Configuration;

using Microsoft.IdentityModel.Tokens;

using Microsoft.IdentityModel.Web;

using Microsoft.IdentityModel.Web.Configuration;

using Microsoft.IdentityModelPlus.Configuration;

using Microsoft.IdentityModelPlus.Tokens;

9. Add the following "ServiceConfiguration_Created" method:

void ServiceConfiguration_Created(object sender, ServiceConfigurationCreatedEventArgs args)

{

    ServiceConfiguration configuration = args.ServiceConfiguration;

    List<CookieTransform> sessionTransforms = new List<CookieTransform>(new CookieTransform[]

    {

        new DeflateCookieTransform(), new MachineKeyProtectionTransform()

    });

    SessionSecurityTokenHandler sessionHandler = new SessionSecurityTokenHandler(sessionTransforms.AsReadOnly(), new MruSecurityTokenCache());

    configuration.SecurityTokenHandlers.AddOrReplace(sessionHandler);

    MicrosoftIdentityModelPlusSection plusConfiguration = MicrosoftIdentityModelPlusSection.Current;


    if (plusConfiguration != null && plusConfiguration.ServiceCertificate.ElementInformation.IsPresent)

    {

        X509Certificate2 serviceCertificate = plusConfiguration.ServiceCertificate.GetCertificate();

        SecurityToken serviceToken = new X509SecurityToken(serviceCertificate);

        SecurityTokenResolver serviceResolver = SecurityTokenResolver.CreateDefaultSecurityTokenResolver(

            new List<SecurityToken>(new SecurityToken[] { serviceToken }).AsReadOnly(), false);


        configuration.ServiceTokenResolver = serviceResolver;

    }

}

10. Add the following "WSFederationAuthenticationModule_RedirectingToIdentityProvider" method:

void WSFederationAuthenticationModule_RedirectingToIdentityProvider(object sender, RedirectingToIdentityProviderEventArgs e)

{

    Uri reqUrl = Request.Url;

    StringBuilder wreply = new StringBuilder();

    wreply.Append(reqUrl.Scheme);     // e.g. "http"

    wreply.Append("://");

    wreply.Append(Request.Headers["Host"] ?? reqUrl.Authority);

    wreply.Append(Request.ApplicationPath);

    if (!Request.ApplicationPath.EndsWith("/"))

    {

        wreply.Append("/");

    }

    e.SignInRequestMessage.Reply = wreply.ToString();

}

11. Update the "Application_Start" method so that it creates event handlers for the two previous methods:

protected void Application_Start(object sender, EventArgs e)

{

    FederatedAuthentication.ServiceConfigurationCreated += this.ServiceConfiguration_Created;


    FederatedAuthentication.WSFederationAuthenticationModule.RedirectingToIdentityProvider +=

        new EventHandler<RedirectingToIdentityProviderEventArgs>(WSFederationAuthenticationModule_RedirectingToIdentityProvider);

}

12.  You must now make some significant updates to the Web.Config file.  This is probably the most challenging step, as it requires a number of updates.  While I will walk through the details of the updates below, I am also including a copy of my Web.Config file for your review on SkyDrive.  Please feel free to use it as a reference.  Also, please note that (for simplicity) the code shown below includes values that my demo uses.  You will have to update with your own values, and I have tried to call out where this is necessary.

13. Add the following to the <configuration><configSections> … </configSections></configuration>

<section name="microsoft.identityModel" type="Microsoft.IdentityModel.Configuration.MicrosoftIdentityModelSection, Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

<section name="microsoft.identityModelPlus" type="Microsoft.IdentityModelPlus.Configuration.MicrosoftIdentityModelPlusSection, Microsoft.IdentityModelPlus" requirePermission="false" />

14. Add the app key for the federation metadata location.  You will have to update this value with your own XML file published by your ADFS v2 server.

<appSettings>

  <add key="FederationMetadataLocation" value="https://corp2.sts.microsoft.com/FederationMetadata/2007-06/FederationMetadata.xml" />

</appSettings>

15. After connectionStrings, add the following location path.

<location path="FederationMetadata">

  <system.web>

    <authorization>

      <allow users="*" />

    </authorization>

  </system.web>

</location>

16. Add the Microsoft.IdentityModel assembly.

<add assembly="Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

17. Configure the authorization and authentication.  You may have to change existing values.

<authorization>

  <deny users="?" />

</authorization>

<authentication mode="None" />

18. Add the WSFederationAuthenticationModule and SessionAuthenticationModule modules to <httpModules> … </httpModules>.

<add name="WSFederationAuthenticationModule" type="Microsoft.IdentityModel.Web.WSFederationAuthenticationModule, Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

<add name="SessionAuthenticationModule" type="Microsoft.IdentityModel.Web.SessionAuthenticationModule, Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

19. Add the WSFederationAuthenticationModule and SessionAuthenticationModule modules to <modules> … </modules>.

<add name="WSFederationAuthenticationModule" type="Microsoft.IdentityModel.Web.WSFederationAuthenticationModule, Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" preCondition="managedHandler" />

<add name="SessionAuthenticationModule" type="Microsoft.IdentityModel.Web.SessionAuthenticationModule, Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" preCondition="managedHandler" />

20. Add the microsoft.identityModel section.

<microsoft.identityModel>

  <service>

    <audienceUris>

      <add value="https://fedid.cloudapp.net/" />

    </audienceUris>

    <federatedAuthentication>

      <wsFederation passiveRedirectEnabled="true" issuer="https://corp2.sts.microsoft.com/FederationPassive/" realm="https://fedid.cloudapp.net/" requireHttps="true" />

      <cookieHandler requireSsl="true" />

    </federatedAuthentication>

    <applicationService>

      <claimTypeRequired>

        <claimType type="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name" optional="true" />

        <claimType type="http://schemas.microsoft.com/ws/2008/06/identity/claims/role" optional="true" />

      </claimTypeRequired>

    </applicationService>

    <issuerNameRegistry type="Microsoft.IdentityModel.Tokens.ConfigurationBasedIssuerNameRegistry, Microsoft.IdentityModel, Version=0.6.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35">

      <trustedIssuers>

        <add thumbprint="A4010FC094ECEDE6C94EDE36315ADB3EEC876C8A" name="CN=corp2.sts.microsoft.com, OU=IAM, O=Microsoft, L=Redmond, S=wa, C=US" />

      </trustedIssuers>

    </issuerNameRegistry>

  </service>

</microsoft.identityModel>

You will have to make a number of updates:

• Update "fedid" in "https://fedid.cloudapp.net" to your Windows Azure service name.
• Update the wsFederation issuer to your ADFS v2 issuer.
• Update the wsFederation realm so that it uses your Windows Azure service name.
• Ensure that the claimTypeRequired claimTypes are valid.
• Update the trustedIssures so that you have your ADFS v2 thumbprint and name.  I did this by using tools that come with the Windows Identity Foundation tools.  You can right-click an existing ASP.NET Web site project and select "Modify STS Reference…".  This will launch the Federation Utility wizard, and will help construct pieces of the Web.Config.  On the second step, you can select "Use an Existing STS" and point it to your ADFS v2 endpoint.  The tool will then generate a lot of the configuration for you, including the trustedIssuers thumbprint and name (see the image below).

Note: this doesn’t need to be a publicly exposed ADFS server.  In fact, if you don’t have a production IP address to use, you can download one sample (simple) IP STS included in the code downloaded from http://claimsid.codeplex.com/.

21. You need to add the Microsoft.IdentityModelPlus section to the Web.Config file.  The CreateCert.cmd script you ran to generate the script has actually generated this section for you.  You can get it out of the encoder.out file in the assets folder.

<microsoft.identityModelPlus><serviceCertificate><certificate name="fedid.cloudapp.net" password="abc!123" encodedType="pfx" encodedValue="MIIGygIBAzCCBoYGCSqGSIb3DQEHAaCCBncEggZzMIIGbzCCA8AGCSqGSIb3DQEHAaCCA7EEggOtMIIDqTCCA6UGCyqGSIb3DQEMCgECoIICtjCCArIwHAYKKoZIhvcNAQwBAzAOBAg+lz0NqTYEFwICB9AEggKQ/shUmEoIDJpT0uOaQIkOfUsLfLwUNHtkm58I/fFb7OztUkISIHZm5QR3b9yH7mqg7VLj0LndB6r2+T2RZpq5U+jnlptBxyENzz3RAMIt8S7vVtT9L0OwiDXXeMWRXZpBGK/dwfwofMBsCCFV2FeLGyso2sUhqP7tstTWhybjM0JDSzVre9s/HGaQl8R+buPeGZWnZjOCqOYBNIoAxrPD1DjMgt2Q1CChk23rdirKnBFnp2khy+o2sV02PTJI8K4/QFgKTYOm+LbJG8rWuFi3U1aLxF7xUqfwCkNwaEyPodWBcAkhlWnKlbg77tPlhaONbYEJw9XhY4Ekwniu8WrNbl08xsKEVVNUZfTMYU4OnuusFxHsf0weuhrwlMnCQAMQkDUICWqDX2afV/oU5MnvDwYC8HftfaKhR68unfX+D1iS3ZspSpjrtQbdJU3GHsZmruqR1gmjbzwSJa0rf/ch4BWA+D4ciSlVFVFR+WBPB1fbLUbWv+3bLnwDCAmk2vNQ9YFQKWVYU4Ax9PulyX5Mu5ggmb0Hxl5wdaO2syiiIkylKNYmyreQ81WNRLwJmGKSmTZPJAovmT9YgH2kNdaC9K/9ZNbbyJSRTJNQix7zivrG5IS5n9OCLSNwoP9lK56ME3phYOa80F8r/lWsBP4otTaZQFC5g8uRnGcQ1WJcNEEghi1l0q4PM5Mtl3L2zaqQGa8pJqgaAcOyOC85rOTwQtnJEHUquH/yjqyZ8koCo44T9JHd7lVJKKJb2Fnwz1zVOM/rPoUZBwEJTuHBqlnVgyBldZDxUGg56L2My8ozhQ7dYWqsxfFe+fPzDNvjPvpMregGBqhEcP3W8YCzAOSyS0d7QN/MZNi4+6QwypRuckUxgdswEwYJKoZIhvcNAQkVMQYEBAEAAAAwXQYJKwYBBAGCNxEBMVAeTgBNAGkAYwByAG8AcwBvAGYAdAAgAFMAdAByAG8AbgBnACAAQwByAHkAcAB0AG8AZwByAGEAcABoAGkAYwAgAFAAcgBvAHYAaQBkAGUAcjBlBgkqhkiG9w0BCRQxWB5WAFAAdgBrAFQAbQBwADoAYwA2ADkANQA2ADIANAAzAC0AMQAyAGEAMAAtADQAMAA5ADcALQBhADIAOABjAC0AYgA1ADAAMQA3ADEAMQA3ADIAZgA1ADAwggKnBgkqhkiG9w0BBwagggKYMIIClAIBADCCAo0GCSqGSIb3DQEHATAcBgoqhkiG9w0BDAEGMA4ECHcGonbqlG+xAgIH0ICCAmADkVVOEzWeS3cNaqf0Zmv0xIszELOp4G62Bwl0HNd/uoKDnVBekLocMhlvLlgHwko6cCxCZ9LD0Hn7g9mK8P4VTGNk8G2I3CelBTy0nnHFw7DswRZxYluMQ4A4LHLuG6jo4B/rCaV2JaTDXmfiNvIAdIzIkFCV2Ue6ROSW4VdZFcbDdqjxXdZY4b6MuZMBLc3YLPYqKvyMuCfDYPIkA5jNxSJ6ODdV+Ed5DNuDWwO5fOjep7nqVwhU3J3V063SRBcF+KYZwb1RVE+SWxvOEb1nv2uoJdD9GPWIiH5E+3oAFayJU1APOC15jHJ+YXFq/i+/XnXI+JkkxUyVVLrJIDT7uIZSkv7zieVoTJK8Ze8V4gLge081f+wxy2RcQwajeSdR1YKzrVKzxrR7wfGC+R1oH1ldjZM7hw3+2C/UR5R6bHqt7D9C2R9mxfFUufEiFG5SoUItv+ZFHd9/x7Oe8TpcWY/yrwSkHr4UKBDYzfzgB8Q0LmCZfEt8MWWGutKL6OzCfBNZ4QM2Ltn2mrodD5kE2udAcocXBPTp/DAngMFxsIe7iNHpw/ulEjJx8EYPrtDvf8C/2y5APBYdEdqVozHlUMo8MWO2xx39hktyIqTYaMkTIwgFXCAaf3ZyZVOlj5YSqXiZpKmSU1RcNCTnYTN5uPjEurL1U24uPB/jVM6WjNO/azVAp5o+3PU2095I+X/Rtzfbou8o00tGosf42ETVA62A6OrfuKI1kNu5CHoRtr3PsMk3vCRc7FKbq86I5jW7jNmolmqOzQ0w0SxPPzxbouoikPtKFDmmSU81lTlFtzA7MB8wBwYFKw4DAhoEFLq6NYeOz/n0Dmg+5fWFBQZ6cOQRBBQ4290pYD9MhQO1jzFVfX3DeYLNiAICB9A=" /></serviceCertificate></microsoft.identityModelPlus>

Note: this is only necessary because currently you cannot install certificates in Windows Azure.  Expect this to change in the future.

22. Finally, as a way of confirming that everything is working and that the claims you expect are actually sent to your application, update the Default.aspx.cs file so that you iterate through the claims and write them to the browser.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

using Microsoft.IdentityModel.Claims;

using System.Threading;


namespace Web

{

    public partial class _Default : System.Web.UI.Page

    {

        protected void Page_Load(object sender, EventArgs e)

        {

            try

            {

                IClaimsIdentity ici =

                    Thread.CurrentPrincipal.Identity as IClaimsIdentity;


                foreach (Claim c in ici.Claims)

                    Response.Write(c.ClaimType + " - " + c.Value + "<br/>");

            }

            catch (Exception ex)

            {

                Response.Write(ex.ToString());

            }

        }

    }

}

And that’s it!  Assuming that you have correctly followed the above steps, you’re ready to test!

Now, when you hit the endpoint on your ADFS v2 service, you will get redirected to https://fedid.cloudapp.net (or whatever your URL is) because that’s what you specified as the realm for your identity federation.  This means that, to test this locally, you need to update your hosts file so that fedid.cloudapp.net temporarily resolves locally.  Otherwise, it will redirect to the cloud.  I know we’ve spend years abhorring the hosts file, but sometimes it just works.

When you’re ready to run this in the cloud, simply package up your Windows Azure solution and publish.  Remember that you will only be able to successfully test this in production, as the staging account uses a GUID for the URL alias.  Also, if you’ve updated your hosts file, but sure and undo your changes so that you no longer resolve locally.

I hope you found this article valuable.  Good luck!