Nico's .NET blog

Allow Silverlight to access clipboard after having clicked “NO” before

2011-12-30T17:04:00.001+01:00

Silverlight applications can put information into the computer’s clipboard. But only when the user grants the application access to it.

So while using Silverlight apps online you might have come across this dialog:

I accidentally clicked “no” once and had lots of trouble to reverse this step because I haven’t been prompted this question again.

Even google was no help in this case. Neither was re-installing Silverlight.

Finally a heroic search in the registry gave a solution. There is a place in the registry where Silverlight places the information about clipboard access.
HKEY_CURRENT_USER\Software\AppDataLow\Software\Microsoft\Silverlight\Permissions

Inside that Key is a subfolder for each Silverlight application that has prompted this question. If you delete the proper folder, you will be prompted again the next time.

Setting environment variables on Windows Azure: easy way

2011-11-14T16:11:00.001+01:00

A few hours after writing the last post, I discovered that one can specify environment variables in the .csdef file:

<Runtime>
  <Environment>
    <Variable name="a" value="b" />
  </Environment>
</Runtime>

Don't know yet, if this does the same as my code in the last post. I might investigate on that...

Setting environment variables in Windows Azure

2011-11-14T15:17:00.001+01:00

At the latest when you want to run java applications on Windows Azure you need to set several environment variables. Since there are startup tasks you may perform before your Role is being started, this obviously is the place where to set these variables. But there are some difficulties:

Setting environment variables Intentional-Style

Setting environment variables using the well known set command line tool works on Windows Azure like on premise:

set MYPATH=C:\Directory\

BUT:

This only works for one command shell session

This only works for the current user

The variables set should be available all time and for all users. So they need to be set as system variables. And system variables may only be set by an administrator.

Setting environment variables correctly

Make sure your startup script is run with elevated permissions.
Check your .csdef file to look similar to this:

<Startup>
  <Task commandLine="Startup.cmd" 
        executionContext="elevated" 
        taskType="simple" />
</Startup>

Use the setx command line tool with the /M parameter to set system variables:

setx MYPATH C:\Directory\ /M

If you need the variables set to use them in your startup script, you need to set them with the set command again.
- set works for the current session (the startup script)
- setx works for all session started after setting the variables

References:

How to use the setx command: http://ss64.com/nt/setx.html

Sending e-mails using IIS SMTP Server on Windows Azure

2011-10-25T13:59:00.001+02:00

If you want to send emails from a Windows Azure Role, there’s the possibility to use the built-in SMTP Server of IIS 6.0. Here is a guide how to use startup scripts and PowerShell commands to set up a SMTP server in the cloud.

Before you start make sure that you’re running a Windows 2008 Server R2 in the cloud by setting the osFamily Attribute to osFamily=”2” in the ServiceConfiguration.cscfg file.

Setup the SMTP

Here is a guide that shows how to set up the SMTP server manually. Those are the same steps we’re going to do here using scripts. It helped me to understand what’s necessary to do. Just deploy any Azure Project to the Cloud, RDP in, install the SMTP-Server feature and do the steps described in that guide.

But now to the automated setup scripts:

1. Create a new startup task in the ServiceConfiguration.cscfg

<Startup>
  <Task commandLine="Startup.cmd" executionContext="elevated" taskType="simple" />
</Startup>

2. The startup file first needs to install the SMTP-Server feature automatically. To gain this it uses the PowerShell 2.0. After that it calls a VBScript that configures the SMTP-Server.

The Startup.cmd:

powershell -command "Set-ExecutionPolicy Unrestricted"
powershell .\InstallSmtp.ps1
cscript ConfigSmtp.vbs

The InstallSmtp.ps1 PowerShell script:

Import-Module Servermanager
Add-WindowsFeature SMTP-Server

3. Now we need to create the VBScript that configures the SMTP server: We need to add all IP addresses that are allowed to send mails through this SMTP server to the grant list. Assuming only applications running on the same server are allowed to send emails we’re going to add 127.0.0.1 to that list.

The ConfigSmtp.vbs

Option Explicit
Dim smtpServer, relayIpList
// Get the default instance of the SMTP server
Set smtpServer = GetObject("IIS://localhost/smtpsvc/1")
// Get the IPList
Set relayIpList = smtpServer.Get("RelayIpList")
// Add localhost to that list
relayIpList.GrantByDefault = false
relayIpList.IpGrant = "127.0.0.1"
// Save changes
smtpServer.SetInfo

4. Deploy to the cloud

Use the SMTP from C# code

To use the local SMTP server from within your C# code use the following lines:

var client = new System.Net.Mail.SmtpClient("localhost");
client.Send("from@domain.tld",
            "to@domain.tld",
            "This is my subject",
            "Hello, this is a mail from the cloud!");

Don’t get blacklisted

Even Steve Marx recommended not to use the SMTP server feature on Windows Azure instances because they soon would be blacklisted. To avoid getting on a blacklist you could use a smart host to deliver your emails with.

If you want to use a smart host in your deployment, you need to extend the ConfigSmtp.vbs:

// set the outbound connector to a smart host
smtpServer.SmartHostType = 2
smtpServer.SmartHost = "smtp.mysmarthost.tld"
// use basic authentication
smtpServer.RouteAction = 264
smtpServer.RouteUserName = "myName"
smtpServer.RoutePassword = "myPassword"
// save changes
smtpServer.SetInfo

In this case I have been using the SMTP relay services offered by http://dyn.com which worked just fine. Depending on what service you’re about to use, the settings might differ.

References

the IIS WMI documentation gives help when trying to find out what properties can be used in the VBScript:
http://msdn.microsoft.com/en-us/library/ms525265(v=VS.90).aspx

Here are some sample scripts for IIS
http://www.thescriptlibrary.com/default.asp?Action=Browse&Level=Category2&ScriptLanguage=VBScript&Category1=IIS&Category2=IIS%206.0

IIS Metabase Property Reference (here with the RouteAction enumeration)
http://technet.microsoft.com/en-us/library/cc757175

Installing updates manually on Windows Azure

2011-10-24T11:38:00.001+02:00

While trying to manually install the PowerShell 2.0 update on a Windows Azure Role I ran into the following error message:

“Installer encountered an error: 0x80070422”

In order to solve this problem:

Open the Server Manager: Start > Right Click on “Computer” > Manage
Navigate to Configuration > Services
Enable the Background Intelligent Transfer Service and start it
Enable the Windows Update Service and start it
Now you can manually install updates.

I Got this hint from: Came Too Far

How To: Look inside the Service Package file

2011-09-25T13:43:00.001+02:00

If you ever wanted to see what’s inside a published .cspkg file: here is a small guide how to achieve this…

First there is to say that a .cspkg-file is only a ZIP file with extensions changed. But the contents are encrypted. But there is a way to create unencrypted Service Packages:

Close Visual Studio
Shut down Windows Azure Compute Emulator
Go to Control Panel > System and Maintenance > System
Click on “Advanced Settings” in the pane on the left
Switch to the “Advanced” tab and click on the “Environment Variables” Button.
The “Environment Variables” dialog appears.
Check for a System Variable named _CSPACK_FORCE_NOENCRYPT_
If there is no such variable, create it.
Set the value of the _CSPACK_FORCE_NOENCRYPT_ variable to “true”
Start Visual Studio again and publish a Cloud Service Project.

Note: When publishing without encryption, Visual Studio warns you with the following message in the output window
CloudServices44 : Forcing creation of unencrypted package...

To sneak inside the package do the following steps:

Rename your <cloudservice>.cspkg file to <cloudservice>.zip
Unpack that .zip folder
Inside the uncompressed folder there is a file named after your web role <WebRole><Guid>.cssx
Rename the .cssx file to .zip
Since you performed the steps before, this .zip file is unencrypted now. Unzip it.
Find the content of your package in the “sitesroot” folder.

Caution: Although either encrypted and unencrypted packages can be deployed to the cloud, it’s highly recommended to only use encrypted packages for security issues.

Issue: change physical path of site named “Web”

2011-09-25T13:15:00.001+02:00

In earlier posts I showed how to use multiple sites within a single WebRole. This required to use the physicalDirectory attribute within the ServiceDefinition file. If you tried to use this attribute you might have run into this issue:

The default site in a WebRole is named “Web”. When you set the physicalDirectory attribute to point to any location – no change will happen.

It seems as if a site named “Web” ignores the physicalDirectory attribute.

But if you change the name to any other name: the physicalDirectory attribute will be used!

For further explanation have a look at the following xml snippets from the .csdef file:

<Site name="Web">
  <Bindings>
    <Binding name="Endpoint1" endpointName="Endpoint1" />
  </Bindings>
</Site>

This will use the default content.

<Site name="Web" physicalDirectory="C:\Code\WebApplication2">
  <Bindings>
    <Binding name="Endpoint1" endpointName="Endpoint1" />
  </Bindings>
</Site>

This will still use the default content.

<Site name="Web1" physicalDirectory="C:\Code\WebApplication2">
  <Bindings>
    <Binding name="Endpoint1" endpointName="Endpoint1" />
  </Bindings>
</Site>

This will use content from WebApplication2.

msshrtmi.dll - Hybrid Applications: Running in the cloud AND on premise

2011-08-26T09:16:00.000+02:00

Recently I tried to deploy an application that was originally designed for the cloud on an in-house server. The only cloud capability the application used was the Windows Azure Blob Storage.

So in advance I changed the application to differ between

being run in the cloud and using the Blob Storage and
being run on premise and using the local disk storage

by using the following flag as an indicator:

  1: RoleEnvironment.IsAvailable

In both scenarios the deployment contains the Microsoft.WindowsAzure.StorageClient.dll. This works perfectly in the cloud but raised the following error on premise:

Exception type: FileNotFoundException
Exception message: File or assembly "msshrtmi, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", or one of its dependencies, was not found.
at Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment.InitializeEnvironment()
at Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment..cctor()

There are two possible ways to solve this issue:

Copy the msshrtmi.dll manually to your on premise deployment.
For example in the \bin folder next to the WindowsAzure.StorageClient.dll.

Install the Windows Azure SDK on your in-house server.

Windows Azure Web Role Accelerator

2011-07-18T11:33:00.001+02:00

Deploying new WebSites to Windows Azure or updating existing ones used to take a lot of time. And the Windows Azure Team worked hard on this issue making it more comfortable for developers.

And the result of this effort is the “Windows Azure Accelerator for Web Roles” announced a few days ago. That is a new Project Template generating an Azure Project containing a WebRole and a website project for management purposes. Here you can define how many instances of your website are to be created in the cloud. After deploying this project template Windows Azure will create the instances you requested. Then you can create websites in the management website and publish other websites in less than 30 seconds to the cloud. Those websites will immediately be available on all instances. The template uses your Windows Azure Storage account for this feature.

Here is a short demo video of the Web Role Accelerator:

Download the Web Role Accelerator from codeplex here: http://waawebroles.codeplex.com/

Backlink to the Windows Azure Team Blog: NOW AVAILABLE: Windows Azure Accelerator for Web Roles

tangible.AzureIO - small sample

2011-07-03T01:16:00.000+02:00

Because I’m short on time at the moment, I’ll just post a tiny little sample on the AzureIO library. I promise to publish a larger sample soon. Maybe I can think of something really useful, we’ll see…

For the moment it’s just a simple WPF application that allows the user to select a file (#1 in the picture) and upload it to the Windows Azure BlobStorage (#2). As a proof that the file was really uploaded, the application displays the url of the blob where the file can be viewed in the browser.

There’s not a lot of code behind this sample. At first it’s to mention that the AzureIO library requires a configuration setting in the app.config file. The connection string to the StorageAccount needs to be set there.

  1: <configuration>
  2:   <appSettings>
  3:     <add key="StorageCredentials" value="UseDevelopmentStorage=true"/>
  4:   </appSettings>
  5: </configuration>

This configuration makes the application use the development storage of the Windows Azure SDK. To upload the file to the blob storage those three lines of code suffice:

  1: var fileName = System.IO.Path.GetFileName(txtFile.Text);
  2: var content = System.IO.File.ReadAllBytes(txtFile.Text);
  3: tangible.AzureIO.File.WriteAllBytes(fileName, content);

Voilà – that’s it. Copy the displayed URL to your browser and get your file from the cloud!

Download the sample code here: AzureIOSample.zip

tangible.AzureIO - Accessing BlobStorage like System.IO

2011-07-01T00:44:00.000+02:00

Writing and reading blobs to and from the Windows Azure BlobStorage isn’t as comfy as one could wish. So why not dealing with Files transferred to the cloud as if they were files we are used to work with?

Nothing looks smoother than this simple call to create a new file and write some bytes in it:

  1: System.IO.File.WriteAllBytes("MyFile.ext", new byte[] { ... });

Doing the same in the cloud requires connections to the CloudStorage, creating a BlobClient, dealing with containers and different BlobTypes … A huge overhead to what one really needs in this case. But how about this call doing exactly the same as shown above in the local file system – only in the cloud:

  1: tangible.AzureIO.File.WriteAllBytes("File.ext", new byte[] { ... });

Easy, isn’t it?

The tangible.AzureIO library contains nearly all functionality offered by System.IO for the cloud. A must have for developers who want to move their applications to the cloud with least changes! Find pendants to System.IO.Path in tangible.AzureIO.Path, System.IO.Directory in tangible.AzureIO.Directory and so on…

I spent a lot of time on this project and finally may publish a first beta version here. The library for download below is delivered “as is” – without any warranty and claims neither completeness nor faultlessness. All right reserved. You may use it in any of your projects – but it’s still a beta and subject to change.

I appreciate any comments and reviews on this library! So feel free to leave a comment to this blog post or send me an email to nico[at]zehage.net.

Download tangible.AzureIO here: tangible.AzureIO.zip

CloudNinja project: Multi tenancy and metering sample

2011-06-19T12:22:00.001+02:00

Few days ago version 2.0 of the Cloud Ninja project was published on the CodePlex platform. This sample project demonstrates how some of Windows Azure’s capabilities can be used to implement common cloud features.

The features shown in the sample are:

Multi tenancy where each tenant has his own SQLAzure database
Metering the usage of each tenant’s resources
Auto scaling methods
Task scheduling
Federated Identity to allow customers to adapt the look of the application

To draw interest on this project have a look at the application design of CloudNinja as shown on CodePlex…

On CodePlex sample source code, application design, documentation and a user guide are downloadable. Visit the project site here: http://cloudninja.codeplex.com

Kinect for Windows SDK beta now available!

2011-06-16T21:54:00.000+02:00

For all of you who awaited this moment as longing as I did: Since today the beta of the Kinect for Windows SDK is available for download. Enjoy!

Download here…

Ensuring only one WorkerRole instance performs a task at a time

2011-06-10T15:40:00.000+02:00

As a developer in a cloud environment one has to deal with several issues. Using multiple instances that can be shut down and transferred to other devices, up- and downscaling make it impossible to identify a single instance and be sure that it’s up and running. The cloud environment only ensures that the necessary amount of instances is available all the time.

Thinking of a scenario where special tasks are to be performed regularly or where those tasks may only be performed by a single machine at a time, it is essential to identify a “master” that will execute the tasks. So how to deal with this?

This example shows how to solve this problem with a file lock approach. Each instance wakes up after a given period of time and checks if it can become the “master” instance that will perform the necessary tasks. If this instance can be the “master” it puts a lock file into the cloud storage, performs the tasks and deletes this lock file again.
If an instance finds an existing lock file when checking for becoming the “master”, it does not perform any task.

Here is how you can implement this behavior step by step:

Create a new Windows Azure Project in Visual Studio 2010 and add a single WorkerRole to this project.

Inside the WorkerRole.cs, prepare to connect to the cloud storage by declaring three static members containing information about where to place the lock file and how this file is to be named:

  1: public class WorkerRole : RoleEntryPoint
  2: {
  3:     /// <summary>
  4:     /// Determines the container where the block file will be placed
  5:     /// in the cloud storage
  6:     /// </summary>
  7:     private static string blockFileContainer = "tasksample";
  8:     /// <summary>
  9:     /// Determines the name for the block file
 10:     /// </summary>
 11:     private static string blockFile = "block.ext";
 12:     /// <summary>
 13:     /// Represents the full path to the block file
 14:     /// </summary>
 15:     private static string blockFilePath = blockFileContainer + "/" + blockFile;
 16: 
 17:     ...
 18: }

In the same file create an CloudBlobClient to access the storage.

  1: public class WorkerRole : RoleEntryPoint
  2: {
  3:     ...
  4:     /// <summary>
  5:     /// Client to access the blob storage
  6:     /// </summary>
  7:     private CloudBlobClient blobClient = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudBlobClient();
  8:     
  9:     ...
 10: }

Now we need to define for each instance in what interval it will check for becoming the “master” and performing the tasks. Since the development fabric is quite fast and all instances will startup nearly at the same time, initializing a randomizer by time won’t work here. In the real cloud it might be different.
As a workaround we’re going to initialize a randomizer depending on the ID of the instance it belongs to. The typical ID of an instance in the development fabric is for example “deployment(19).MyProject.WorkerRole.0” where the 0 determines that this instance is the first one in the deployment. So the randomizer for this instance will be initialized with 0 as a seed.
Then we choose a random value between 10 and 30 seconds.
The code looks as follows:

  1: public class WorkerRole : RoleEntryPoint
  2: {
  3:     ... 
  4: 
  5:     /// <summary>
  6:     /// Numeric ID of this instance (might only work in development fabric)
  7:     /// </summary>
  8:     private static int instanceID = int.Parse(RoleEnvironment.CurrentRoleInstance.Id.Substring(RoleEnvironment.CurrentRoleInstance.Id.LastIndexOf(".") + 1));
  9:     /// <summary>
 10:     /// Milliseconds this instance needs to wait until trying to perform task
 11:     /// </summary>
 12:     private static int millisecondsToWait = new Random(instanceID).Next(10000, 30000);
 13: 
 14:     ...
 15: }

Visual Studio prepares the WorkerRole.cs file so the the method “OnStart” already is overwritten in the template. In this method we need to make sure that the container where we want to store the lock file exists.

  1: public class WorkerRole : RoleEntryPoint
  2: {
  3:     ...
  4: 
  5:     public override bool OnStart()
  6:     {
  7:         ...
  8: 
  9:         // make sure that the file lock container exists!
 10:         blobClient.GetContainerReference(blockFileContainer).CreateIfNotExist();
 11: 
 12:         return base.OnStart();
 13:     }
 14:     
 15:     ...
 16:  }

The “Run” method is also already implemented. Here we need to execute our logic: At first the instance goes to sleep for the determined amount of time. After waking up, it will check if it can perform the tasks. If yes it will block other instances, perform the tasks and then delete the lock again.

  1: public class WorkerRole : RoleEntryPoint
  2: {   
  3:     ... 
  4:     public override void Run()
  5:     {
  6:         // This is a sample worker implementation. Replace with your logic.
  7:         Trace.WriteLine("ProcessWorker entry point called", "Information");
  8: 
  9:         while (true)
 10:         {
 11:             // wait
 12:             Trace.WriteLine("Waiting for " + millisecondsToWait + "ms", "Information");
 13:             Thread.Sleep(millisecondsToWait);
 14: 
 15:             // check if this instance should perform the task
 16:             // by trying to get a file lease in the cloud storage
 17:             if (CanPerformTask())
 18:             {
 19:                 // block other instances from performing the task
 20:                 BlockOtherInstances();
 21: 
 22:                 // perform the task
 23:                 PerformTask();
 24: 
 25:                 // release block to allow other instances to perfrom the task
 26:                 ReleaseBlock();
 27:             }
 28:             else
 29:             {
 30:                 // we are not allowed to perform this task
 31:                 Trace.WriteLine("May not perform task!", "Information");
 32:             }
 33:         }
 34:     }
 35:     ...
 36: }

The function “CanPerformTask” checks if the given lock file exists in the blob storage by trying to fetch its attributes. If the attributes can be retrieved this file exists, otherwise an exception will be thrown.

  1: /// <summary>
  2: /// This function determines if this instance can perform the task
  3: /// by checking if any other instance is 
  4: /// </summary>
  5: /// <returns></returns>
  6: private bool CanPerformTask()
  7: {
  8:     Trace.WriteLine("Checking...", "Information");
  9:     // check if the locking file exists
 10:     try
 11:     {
 12:         // try to get the attributes from the lock file
 13:         // to check if the file exists
 14:         blobClient.GetPageBlobReference(blockFilePath).FetchAttributes();
 15:     }
 16:     catch
 17:     {
 18:         // the lock file does not exist -> this instance may perform the task
 19:         return true;
 20:     }
 21: 
 22:     // the blob exists -> this instance may not perform the task atm
 23:     return false;
 24: }

In the method “BlockOtherInstances” we create new PageBlob with the size of 0 bytes and store in a metadata attribute which instance created this blob. That way we make sure that only the same instance that created a lock file can delete it again.

  1: /// <summary>
  2: /// This method blocks other instances from performing the task
  3: /// by creating the file lock.
  4: /// </summary>
  5: private void BlockOtherInstances()
  6: {
  7:     Trace.WriteLine("Blocking other instances", "Information");
  8: 
  9:     // create a new blob at the lock file url with size 0
 10:     // and note in the properties that this instance created the lock file
 11:     var block = blobClient.GetPageBlobReference(blockFilePath);
 12:     block.Create(0, new BlobRequestOptions() { BlobListingDetails = BlobListingDetails.All });
 13:     block.Metadata["CreatingInstance"] = RoleEnvironment.CurrentRoleInstance.Id;
 14:     block.SetMetadata();
 15: }

When releasing the lock again in the “ReleaseBlock” method, we check if the instance that intends to delete the lock is the same that created this lock. If the instances match, we delete the page blob again.

  1: /// <summary>
  2: /// This method releases the lock file so that other instances
  3: /// can perform the task.
  4: /// </summary>
  5: private void ReleaseBlock()
  6: {
  7:     // get the block file and its attributes
  8:     var block = blobClient.GetPageBlobReference(blockFilePath);
  9:     block.FetchAttributes();
 10: 
 11:     // check if this instance created the block
 12:     if (block.Metadata["CreatingInstance"] == RoleEnvironment.CurrentRoleInstance.Id)
 13:     {
 14:         Trace.WriteLine("Deleting block file", "Information");
 15:         // this instance created the block > delete it
 16:         block.Delete();
 17:     }
 18: }

Last but not least: performing a task in this example means writing a message to the trace and waiting for 5 seconds.

  1: /// <summary>
  2: /// This method represents the task that may only be performed by a single
  3: /// instance at a time.
  4: /// </summary>
  5: private void PerformTask()
  6: {
  7:     // for demonstration purpose as a task
  8:     // we only write an information to the trace.
  9:     Trace.WriteLine(String.Format("Performing the task at {0}", DateTime.Now.ToString()), "Information");
 10:     Thread.Sleep(5000);
 11: }

Now feel free to set up as many instances as you wish and see how this example works. Here is a screenshot running two instances. The first one has an interval of 24,5 seconds and the second one waits 14,9 seconds before trying to perform the task. Both instances perform the tasks until the first one finds an existing file lock from the other instance, which is already performing the task at 13:27:22. So it goes to sleep again…

You can download the source code of this example project here: PerformingSingleTask.zip

Multiple Sites in a single CloudProject: Using Host Headers

2011-06-04T08:20:00.000+02:00

The last and – for me – most interesting way to host multiple websites in a single Windows Azure deployment is to use Host Headers. This allows you to map for example www.mydomain.tld and www.anotherdomain.tld to the same cloud deployment (http://myproject.cloudapp.net) via DNS and host their content in the cloud.

Create a new Cloud Project in Visual Studio and add a ASP.NET WebRole to this project.

Then, add a new ASP.NET Application to the same solution. Your solution explorer should then look like this:

The key is again the ServiceDefinition.csfg file: But this time we need to add another <Site> element to the default <WebRole>’s <Sites> tag. The new <Site> needs an arbitrary name in its attribute name.
The physicalDirectory attribute needs to contain the path to where Visual Studio can find the files of this website to publish it to the cloud. This path can either be set as an absolute path or as an relative one. A relative path must be set relative to the ServiceDefinition.csdef file.

This new <Site> needs to be bound to the proper host header and the default <Site> also needs a host header to be set. So copy the <Binding> from the default <Site> and paste it inside the new <Site> element. Make sure that those bindings have different host headers. Otherwise you’ll get a compilation error.

After all the ServiceDefinition-file looks like this:

  1: <ServiceDefinition name="MultiSitesByHostHeader" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  2:   <WebRole name="WebRole1">
  3:     <Sites>
  4:       <Site name="Web">
  5:         <Bindings>
  6:           <Binding name="Endpoint1" endpointName="Endpoint1" hostHeader="www.mydomain.tld" />
  7:         </Bindings>
  8:       </Site>
  9: 
 10:       <Site name="TheOtherApplication" physicalDirectory="../WebApplication1">
 11:         <Bindings>
 12:           <Binding name="Endpoint1" endpointName="Endpoint1" hostHeader="www.anotherdomain.tld"/>
 13:         </Bindings>
 14:       </Site>
 15:     </Sites>
 16: 
 17:     <Endpoints>
 18:       <InputEndpoint name="Endpoint1" protocol="http" port="80" />
 19:     </Endpoints>
 20:     ...
 21:   </WebRole>
 22: </ServiceDefinition>

But before you can run this Cloud Project and test it, you need to map the hostheaders to the cloud project in your DNS. For testing locally in the Azure computing simulator, you need to add the following lines to your HOSTS-file:

127.0.0.1     www.mydomain.tld
127.0.0.1     www.anotherdomain.tld

Open a notepad with elevated permissions (in administrator mode) and open in C:\Windows\System32\drivers\etc the HOSTS-file. Insert the two lines and save the file again.

Now run the cloud project. Don’t panic when the default URL http://127.0.0.1:81 returns a 404. Browse to http://www.mydomain.tld:81/ and find the first application there. On http://www.anotherdomain.tld:81/ there is the other one.

Download the sample code here: MultiSitesByHostHeader.zip

Multiple Sites in a single Cloud Project: Using Virtual Directories

2011-05-28T16:47:00.000+02:00

The third way to host multiple websites in a single Windows Azure deployment is similar to the one using virtual applications. While virtual applications allow to run ASP.NET web applications virtual directories aim at less dynamic content.

So you could use a virtual directory to store resources like icons, pictures or styles that are shared by multiple websites. Instead of copying those resources to each website, they access them via virtual directories.

According to virtual applications, in this example the main website should be accessible at

http://myproject.cloudapp.net and the resources at
http://myproject.cloudapp.net/virtualdirectory

Create a new Windows Azure Cloud Project and add a ASP.NET WebRole to this project. After that, create a new WebSite (not a web application) in the solution folder or add an existing one to the solution. The solution explorer should look like this:

For this example, I created a new WebSite named “VirtualDirectory” in the solution folder and added a picture “circle.png” in a folder named “Images”.

Now open the ServiceDefinition.csdef file and add to the XML element <WebRole> inside its default <Site> tag a <VirtualDirectory> element. This element has two attributes name and physicalDirectory.
The name attribute contains the string that needs to be appended to the root URL of our website to access the second website within the WebRole. So if we want the resources to be accessible at http://myproject.cloudapp.net/virtualdirectory, we need to set the name attribute to “virtualdirectory”.
The physicalDirectory attribute needs to contain the path to where Visual Studio can find the files of this website to publish it to the cloud. This path can either be set as an absolute path or as an relative one. A relative path must be set relative to the ServiceDefinition.csdef file.

After adding the <VirtualDirectory> tag the ServiceDefinition-file looks like this:

  1: <ServiceDefinition name="MultiSitesByVirtualDirectory" xmlns="...">
  2:   <WebRole name="WebRole1">
  3:     <Sites>
  4:       <Site name="Web">
  5:         <VirtualDirectory name="virtualdirecotry" physicalDirectory="../VirtualDirectory" />
  6:         <Bindings>
  7:           <Binding name="Endpoint1" endpointName="Endpoint1" />
  8:         </Bindings>
  9:       </Site>
 10:     </Sites>
 11:     <Endpoints>
 12:       <InputEndpoint name="Endpoint1" protocol="http" port="80" />
 13:     </Endpoints>
 14:     ...
 15:   </WebRole>
 16: </ServiceDefinition>

You can download the source of this example here: MultiSitesByVirtualDirectory.zip

Multiple Sites in a single Cloud Project: Using Virtual Applications

2011-05-21T22:14:00.000+02:00

Another very simple way to host multiple websites in a single Windows Azure deployment is to integrate a website into an existing WebRole as a virtual application. You might want to chose this way when you need to quickly integrate an existing website to your cloud deployment.

Virtual applications have the same “look and feel” as known from on premise IIS applications. In this example we are going to publish a WebRole at

http://myproject.cloudapp.net and integrate another website at
http://myproject.cloudapp.net/application

At first, create a new Windows Azure Cloud Project in Visual Studio and add a ASP.NET WebRole to this project. Your solution explorer should then look like this:

After that you either chose to add a new Web Project to that solution or add an existing one. In the example I created a new ASP.NET Web application inside the Solution folder. This results in the solution folder looking like this:

This time connecting the second website to an endpoint cannot be done in the WebRole’s properties page but needs to be set manually in the ServiceDefinition.csdef file.

By default inside the service definition there is a single <WebRole> element containing a single <Site> named “Web”. Within this <Site> tag we can add a <VirtualApplication> element. This element has two attributes that need to be set: name and physicalDirectory.
The name attribute contains the string that needs to be appended to the root URL of our website to access the second website within the WebRole. So if we want our second website to be accessible at http://myproject.cloudapp.net/application, we need to set the name attribute to “application”.
The physicalDirectory attribute needs to contain the path to where Visual Studio can find the files of this website to publish it to the cloud. This path can either be set as an absolute path or as an relative one. A relative path must be set relative to the ServiceDefinition.csdef file.

After adding the <VirtualApplication> tag the ServiceDefinition-file looks like this.

  1: <ServiceDefinition name="MultiSitesByVirtualApplication" xmlns="...">
  2:   <WebRole name="WebRole1">
  3:     <Sites>
  4:       <Site name="Web">
  5:         <VirtualApplication name="application" physicalDirectory="../WebApplication1" />
  6:         <Bindings>
  7:           <Binding name="Endpoint1" endpointName="Endpoint1" />
  8:         </Bindings>
  9:       </Site>
 10:     </Sites>
 11:     <Endpoints>
 12:       <InputEndpoint name="Endpoint1" protocol="http" port="80" />
 13:     </Endpoints>
 14:     ...
 15:   </WebRole>
 16: </ServiceDefinition>

You can download the source of this example project here: MultiSitesByVirtualApplication.zip

Multiple Sites in a single Cloud Project: Using Ports

2011-05-14T14:24:00.000+02:00

One of the most frequently asked questions I get is: “How can I manage to run multiple websites in a single Windows Azure deployment?” And the answer is that there are multiple ways to achieve this goal. So this blog post and the next upcoming three posts will show four ways to host multiple websites.

The easiest way is to create two WebRoles and to make them accessible via different endpoints using different ports. The result in the browser address bar would look like this:

http://myproject.cloudapp.net for the first WebRole
http://myproject.cloudapp.net:8080 for the second WebRole

It’s important to know that you can access a WebRole by more than one endpoints but you cannot access multiple WebRoles by the same endpoint!

The step by step walkthrough is simple: When creating a new Windows Azure Cloud Project, add two WebRoles to the new project.

Your solution explorer should look like this after creating the cloud solution:

And in this case Visual Studio already did all the work for you. When looking at the WebRoles’ properties pages you can see in the “Endpoints” tab that WebRole1 has an Endpoint mapped to port 80 and WebRole2 has an Endpoint mapped to port 8080.

for WebRole1 for WebRole2

Of course, you may change the Public Port settings to whatever port number serves you best.

You might want to have a look at the CloudProject’s ServiceDefinition-file. This file becomes important in the other ways solving the multiple sites issue.
Inside the definition file there is a <WebRole> block for each web role you created in the project. This block contains in the <Endpoints> child the information about how the role can be accessed. You can find your port settings there in the XML attribute port.

  1: <ServiceDefinition name="MultiSitesByPort" xmlns="...">
  2:   <WebRole name="WebRole1">
  3:    ...
  4:     <Endpoints>
  5:       <InputEndpoint name="Endpoint1" protocol="http" port="80" />
  6:     </Endpoints>
  7:     ...
  8:   </WebRole>
  9: 
 10:   <WebRole name="WebRole2">
 11:    ...
 12:     <Endpoints>
 13:       <InputEndpoint name="Endpoint1" protocol="http" port="8080" />
 14:     </Endpoints>
 15:    ...
 16:   </WebRole>
 17: </ServiceDefinition>

How to efficiently read messages from a CloudQueue

2011-04-12T16:26:00.001+02:00

While staying at the MVP summit in Redmond I could exchange ideas of code patterns in Windows Azure. One new pattern to me was to save money by reducing calls to a CloudQueue.

On first thought one would try to check for new messages on a queue every few seconds. But if there are many messages in the queue, waiting for several seconds makes you loosing expensive computing time. On the other hand, checking for new messages instantly without waiting results in many unnecessary (and expensive) calls to the Storage.

So there needs to be a way in between those two extremes. And there is one:
After having read a message from the queue, you instantly check again for another new message. If there are new messages, no unnecessary calls are made and all computing time is used for processing those messages.
If there are no new messages, you wait a little and check again. If there is still nothing in the queue, you wait a little longer and check again. Still nothing? Then wait even a little longer as the last time, because it seems unlikely that a new message will show up immediately. Step by step the waiting time is increased to a given maximum. This results in less calls when there is nothing to do.

And here is a code example:

  1: var maxPause = 60000;
  2: var minPause = 1;
  3: var pause = minPause;
  4: 
  5: 
  6: while (true)  
  7: {  
  8:     // read from queue
  9:      Console.Write("Reading from Queue... "); 
 10:      var msg = queue.GetMessage(); 
 11:      
 12:      if (msg == null) 
 13:      { 
 14:         // no message could be read, so wait 
 15:         Console.WriteLine("nothing -> wait " + pause.ToString()); 
 16:         System.Threading.Thread.Sleep(pause); 
 17: 
 18:          
 19:         // update waiting time 
 20:         if (pause < maxPause) pause *= 2;
 21:      } 
 22:      else 
 23:      { 
 24:         Console.WriteLine("read."); 
 25:          
 26:         // reset waiting time 
 27:         pause = minPause; 
 28:   
 29:         // proccess message 
 30:      } 
 31: }
 32:

While writing this blog entry, I invented a class QueueSupervisor, that supervises a queue in the background and raises an event when a new message appears in the queue. You can download this class here: QueueSupervisor.zip

Windows Azure SDK 1.4 Released

2011-04-09T09:59:00.000+02:00

Microsoft just released the newest version over the Windows Azure SDK and the Windows Azure Tools on their download platform. Get it here!

Looking forward to check out the newest features and maybe show some of the coolest ones here…

Global MVP Summit 2011

2011-03-05T21:34:00.001+01:00

Yesterday at 6:30 pm I arrived back at Stuttgart airport from my very first visit in the United States and my very first Microsoft MVP summit at Microsoft campus in Redmond, Washington.

It was pure fun and a very exciting experience for me, and I wished to stay even longer there. I met a lot of other German MVPs – a great thing, because I haven’t seen any of them yet – and my MVP lead Katrin Letzel, to whom I only talked to at the telephone so far.

In the expertise group sessions I got to know many other Windows Azure MVPs and people from the Windows Azure product group. It was fascinating to meet people, who I could only see in recordings of past sessions at PDC or MIX. There were also Robert Duffner and Alejandra Jimenez who made it possible for me to attend the MVP summit!

Thank you again and again, that you made it possible for me to attend this year’s summit!

Even one of the Keynotes was held by Steve Ballmer. So i saw him the first time in reality there! Wow!

I got lot’s of information about the future of Windows Azure, the Azure platform and many other Microsoft products. It’s great to know where things are going to and what we have to be prepared for!

I really enjoyed my visit at Redmond and I am really looking forward to the MVP summit 2012. Hopefully I will be able to travel to Microsoft campus again.

Complete Azure Storage Samples

2011-02-23T13:14:00.000+01:00

David Pallmann created an Azure Storage Sample project on CodePlex. There are two implementations available that show how all the functionality of Azure’s storage can be used. One invoking methods by using a REST client and the other one using the .NET Storage client library.

Check it out here: http://azurestoragesamples.codeplex.com/

PageBlobs with arbitrary size

2011-01-24T19:18:00.001+01:00

PageBlobs have many useful advantages. For example: suspend able uploads can be realized with them or one might receive parts of the blob without having to download the whole blob.
But PageBlobs have some restrictions like that their contents have to be of a size that is a multiple of 512 bytes. In this sample, I would like to show you how to use PageBlobs for files of any file size.

At first we need a function that converts a file size up to the next multiple of 512 bytes.

private long GetPageBlobSize(long size)
{
  // determine how many pages are needed
  var numberOfPages = size / 512;
  // if there are any bytes left, we need one more page
  if (size % 512 != 0)
    numberOfPages += 1;

  return numberOfPages * 512;
}

Then we have to create a method that creates a PageBlob in the cloud, stores the actual file size in the metadata of the PageBlob, fills up the file with zero-bytes to create a file that has a size as a multiple of 512 and uploads the data.

// client initialization set aside
private CloudStorageAccount _storageAccount;
private CloudBlobClient _blobClient;

public void UploadFile(Stream filestream, string blobUrl)
{
  // create the blob with proper blob size
  var blob = _blobClient.GetPageBlobReference(blobUrl);
  var blobPageSize = GetPageBlobSize(filestream.Length);
  blob.Create(blobPageSize);

  // note in the blob what the real file size is
  var realFileSize = filestream.Length;
  blob.Metadata.Add(“contentlength”, 
                    realFileSize.ToString());
  blob.SetMetadata();

  // store how many bytes need to be “filled up”
  // to complete the last page
  var bytesToFillUp = blobPageSize – realFileSize;

  long offset = 0;
  var buffer = new byte[512];
  while (fileStream.Read(buffer, 0, buffer.Length) == 512)
  {
    // a “full” page has been read
    var pageContent = new MemoryStream(buffer);

    // write this page to the blob
    blob.WritePages(pageContent, offset);
    pageContent.Close();
    pageContent.Dispose();
    
    offset += buffer.Length;
  }

  // now there is either no page to read (file was 512 aligned)
  // or the rest of the file has been loaded
  if (bytesToFillUp > 0)
  {
    // there is still data left
    var restContent = new MemoryStream(buffer);

    // ! there are bytes left from the last “full” page read
    // ! in the buffer. these should be replaced by zeroes
    // ! that will be removed on reading the blob
    restContent.Seek(bytesToFillUp, SeekOrigin.End);
    while (restContent.Position != content.Capacity)
      restContent.WriteByte(0);
    
    // write the rest to the blob
    blob.WritePages(restContent, offset);
    restContent.Close();
    restContent.Dispose();
  }
}

And finally a method that downloads the file, removes the zero-bytes again and returns the proper content of the file.

public Stream DownloadFile(string blobUrl)
{
  // get the blob reference and its metadata from the storage
  var blob = _blobClient.GetPageBlobReference(blobUrl);
  blob.FetchAttributes();

  // get proper file size
  var realFileSize = long.Parse(blob.Metadata[“contentlength”]);
  
  var blobStream = blob.OpenRead();
  var blobPageSize = blobStream.Length;

  var pages = blobPageSize / 512;

  // create a memory stream to be returned
  var returnStream = new MemoryStream((int)realFileSize);

  // read all pages but the last one
  var buffer = new byte[512];
  while (pages > 1)
  {
    bs.Read(buffer, 0, buffer.Length);
    returnStream.Write(buffer, 0, buffer.Length);

    pages--;
  }
  
  // now read the last page and write only necessary bytes
  bs.Read(buffer, 0, buffer.Length);
  returnStream.Write(buffer, 0, (int)(512 – bytesToIgnore));

  return returnStream;
}

FTP-Server on Windows Azure from scratch

2010-12-19T14:26:00.001+01:00

Using the new Windows Azure 1.3 SDK and the RDP support, you can create your own FTP server in the cloud within less than 30 minutes! Here is a little guide how to do so:

The three major steps are to open the necessary FTP ports to the virtual server, enable RDP on the virtual server and configure the FTP server role on the virtual server.

Download and install the Windows Azure 1.3 SDK
Create a new Windows Azure Project in Visual Studio 2010 and add a Role to that project. In fact it doesn’t matter what kind of role you add to the project. I started by adding a ASP.NET Web Role.
In the Solution Explorer, right click on the WebRole and choose Properties
In the Endpoints tab on the Properties page add a second endpoint that uses the public port 21 (which is the default port for FTP)
Now right click on the Cloud Project in the Solution Explorer and choose Publish
In the publishing dialog select the option “Deploy your Windows Azure project to Windows Azure” and select the credentials, the deployment environment and the storage account you want to use for the deployment. Then click on “Configure Remote Desktop connections…”
Check the option “Enable connections for all roles”, select or create a certificate that will be used for the RDP connection and provide a user name and password. This user name and password will grant you administrative rights via remote desktop on the server.
Close the dialog and publish your Windows Azure project to the cloud.
After the publishing visit the Windows Azure Management Portal, select the server instance of your Windows Azure project and click on the Remote Desktop Connect button.

You can either open the .rdp file directly or save it to your computer for later use without having to go to the Management Portal again.
Login to the server with the user name and password you provided in step #7.
Hint: use “\<yourUserNameHere>” to remove domain information for the login
On the server you first need to remove the binding to port 21 from the IIS default website. Go to: Start > Administrative Tools > Internet Information Services (IIS) Manager, navigate to the only web site in the tree on the left and click on the “Bindings…” link in the Actions pane on the right.
Remove the binding to port 21.
Close the bindings window and close the IIS Manager
Go to: Start > Administrative Tools > Server Manager
Navigate to the Web Server (IIS) Role in the tree on the left and click on “Add Role Services” in the right part of the window.
Select the role service “FTP Publishing Service”. This should select the services “FTP Server” and “FTP Management Console” automatically, too. If not, select all three manually.
If necessary, add required role services pointed out by the wizard.
Click “Next” and then “Install”.
Go to: Start > Administrative Tools > Internet Information Services (IIS) 6.0 Manager
This tool is used to manage FTP on the server.
Expand the tree on the left to the “Default FTP Site”, right click the Default site and
Start the FTP Default Site

When the IIS6 Manager asks you if it should start the FTP Publishing Service, click “Yes”.
To check if your FTP server is working, open a Command Shell (either on the server or on your local machine) and connect to your server. Use the same credentials for the FTP connection as for the RDP login.
You can find the address of your FTP server in the title bar of the RDP window.

Issues:

For using passive FTP functionality you need to open up more FTP related ports.
When the cloud fabric decides to shut down your server, reboot it or move it to another physical machine, all changes you made via RDP are lost!
You might solve this by creating startup scripts or upload a pre-configured server image.
When your server is restarted or moved all locally stored files are deleted, too. So you need to store the FTP uploads somewhere persistently.

Win $500 at Azure app contest

2010-12-02T16:35:00.001+01:00

Microsoft and Perficient run a Windows Azure app contest. If you submit any application that uses some part of Windows Azure by 11:00 PM ET on December 25, 2010, you can win up to $500.
More information on the contest can be found here. So start coding today ;)

Advent Calendar for Windows Azure

2010-11-30T22:33:00.000+01:00

While searching for a Advent Calendar for my girlfriend who resides in Austria for her studies, the idea of a cloud advent calendar came into my mind. Ten hours later http://adventcalendar.cloudapp.net was born: A scalable calendar using Windows Azure Blob Storage and Silverlight technologies.

This advent calendar is not only for my girlfriend but everyone can create his own one there. I admit usability and design suffered a little bit from the pressure of time (Dec 1st is tomorrow!") but it really works! Give it a try: Go to http://adventcalendar.cloudapp.net, click the “New Calendar” button and build your own windows azure cloud advent calendar.

Here is a screenshot:

Use the Management-Link to add images, music and text to the calendar and its items.
Give the Calendar-Link to those who should get the calendar.

I’ll post the code here, soon.

PDC 2010: Windows Azure Storage Deep Dive

2010-11-01T14:36:00.000+01:00

The first session that caught my attention is a talk from Jai Haridas on Windows Azure Storage. He gives a great overview of the current state and functionality of Blob Storage, Table Storage, Queue Storage and Cloud Drives. This session has a focus on the scalability of Windows Azure Storage using partitioning and load balancing. A MUST for everyone who creates “real” applications for the cloud.

A nice give-away is the part on best practices with Windows Azure Storage. Jai shows how to

support scalability by avoiding the common “append-only” pattern
optimize queries to the Table Storage
use continuation tokens
(e.g. request more than 1000 rows from Table Storage)
deal with poisoned queue messages

Check out his full speech at http://bit.ly/bfu1iw.

Catching Up on Microsoft PDC 2010

2010-10-30T19:56:00.000+02:00

The annual Microsoft “newsflash” took place over the last two days. It’s a long way from Stuttgart, Germany to Redmond, USA and far too expensive for a student like me. So the next few days I’m going to catch up on the new things presented there and watch the recorded sessions on http://microsoftpdc.com.
Of course, I’ll let you know about all interesting stuff about Windows Azure & Co that can be found there!

Microsoft MVP Award

2010-10-02T21:11:00.000+02:00

Yesterday, I was awarded with the Microsoft MVP Award for my contribution to technical communities on Windows Azure. My gratitude to the ones responsible for the MVP awards in Germany who chose me as a MVP. I am trying to use all advantages of my status as a MVP to stay up to date on Windows Azure topics and enlarge my activities in Microsoft’s communities.

Nico (now MVP)

Customized Web Roles: Hosted Web Core in Windows Azure

2010-09-18T14:40:00.000+02:00

Web roles in Windows Azure strictly limit to a developer what he may and what he may not do. And you may only run one web role per cloud project. On his blog, Steve Marx presents a possibility to use a worker role to behave like a web role by using a Hosted Web Core process. This is similar to what Windows Azure does, when you start up a web role but gives you more power to your web application. Be careful: you also have to take responsibility for the stuff you do!

Read the full article here on Steve Marx’ blog and download the code.

How to check if a BlobContainer or a Blob exists

2010-08-02T17:18:00.001+02:00

Earlier versions of the Windows Azure SDK provided two methods DoesContainerExist() and DoesBlobExist() to determine whether a given BlobContainer or Blob already exists. In the current release of the SDK those methods have been omitted, because they seduced developers to write inefficient code.

Using DoesContainerExist() and DoesBlobExist() meant more roundtrips to the storage server as necessary. In order to check the existence of Blobs or Containers it’s recommended now to check if its attributes can be retrieved. If the Blob or Container does not exist, this operation fails and throws an exception. To implement this, use the following code which needs only one roundtrip to the server (though it’s not a great style…):

var container = blobClient.GetContainerReference(path);
try
{
    container.FetchAttributes();
    // the container exists if no exception is thrown
}
catch (StorageClientException ex)
{
    // the container does not exist
}

The same works for Blobs.

This blog on technorati.com

2010-07-27T11:28:00.001+02:00

This code is posted to verify that I am the author of this blog…

66TDYEHUKMTG

Cloud Cover Video series on Channel9

2010-07-23T17:27:00.001+02:00

Today I stumbled over a great video series on Windows Azure: Ryan Dunn and Steve Marx have been leading through the Windows Azure platform in over 18 episodes now! Those episodes can be viewed on channel9.

Let’s see if I can provide a full list of topics they covered after having watched the series myself!

Here is the link to the channel9 show: http://channel9.msdn.com/shows/Cloud+Cover/

Put Your App in the Cloud in only 5 Minutes!

2010-07-22T15:29:00.000+02:00

Hello again. In early February 2009 I did release the first round of Azure How-do-I-videos. Since launch a lot has changed. In particular the Migration to the Cloud has been a lot smoother. Today you can take a ASP.NET Application upload the database to SQL Azure, change the connection string and you are almost done.

See the 5-Minute Migration Videos and run your own app in the cloud using the free Windows Azure Test-Accounts available in Germany by simply writing an email to azurenow@microsoft.com

Also I highly recommend the Trainings provided in German that outline Migration of ASP.NET, Silverlight, Java, PHP Apps and discuss Security, SQL Azure, AppFabric
and ADFS in detail.
Source: http://msdn.microsoft.com/de-de/windowsazure/ff770837.aspx

Windows Azure: Cloud App talks to local SAP System

2010-07-22T15:21:00.001+02:00

I wanted to highlight a stunning example of how a Cloud Application can talk to a local SAP System using the Windows Azure AppFabric.

Tim Fischer from Microsoft has expanded his Cool Blue Time Tracker Sample for Silverlight (which uses a modified version of my change tracking T4 Template for SL3) to run in the cloud and talk to a local SAP System.

You can see the full demo and get the source code here
http://www.microsoft.com/germany/net/WindowsAzure/EventPlayer.aspx
(Bottom right corner of Trainingsmap):

Silverlight & Azure Tips&Tricks: WCF Data Services Relative Path, Default Button, Tooltips

2010-07-22T15:07:00.001+02:00

While using Silverlight 4, WCF Data Services and Windows Azure I wanted to share some of the tricks I needed to apply:

1) To make WCF Data Services Tick correctly on Windows Azure you need to add a “/” after the path to the WCF Data Service in the Client due to the load-balancer.

2) If you need tooltips in Silverlight try this How do I video:
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_40503 [German]

3) If you need a default button in Silverlight try this How do I video:http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_39850

SQL Azure Administration Console “Houston” CTP1

2010-07-21T19:00:00.000+02:00

Project Code Named “Houston” provides a mySQL like Admin Console for SQL Azure. It is currently deployed in North US Data Center so it is only quick if your DB also sits there.

You can use it using this URL, if your SQL Azure firewall allows access from Windows Azure.

https://manage.sqlazurelabs.com/. (Login with your SQL Azure Login)

You can change the database tables using the design view

And you can also change the content of the database

How to use ToolTips in Silverlight applications

2010-07-20T17:31:00.000+02:00

Another Silverlight CodeClip deals with ToolTips. It demonstrates how to use them in a simple, advanced and professional way.

In the simplest case, ToolTips display some informative text to the user hovering over a control:
But ToolTips can be more powerful:
Or even contain dynamic data:

Watch the CodeClip here [German]: http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_40503

Get the How-To-Guide [German]: http://www.microsoft.com/germany/msdn/solve/knowhow/howto/webentwicklung/WieKannIchToolTipsInSilverlightVerwenden.mspx

Windows Azure SDK (June 2010)

2010-07-20T17:13:00.000+02:00

If you want to host .NET 4 based services in Windows Azure, you need to download the newest release of the Windows Azure Software Development Kit. This Update also enables Support for IntelliTrace, which allows you to debug Windows Azure services.

Go to the download page here:
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=21910585-8693-4185-826e-e658535940aa

Architecture of a Windows Azure Business App

2010-07-14T18:06:00.000+02:00

When you really put a Business Application into the Cloud you will get several requirements from your customers. I will show you in this post how to address these requirements:

a) Single-Sign-On: Can be achieved using ADFS and WIF

b) ERP-System Integration can be accomblished using Windows Azure AppFabric
Services Bus to connect both.

c) Storing relational data can be done in SQL Azure

d) Security of ASP.NET can be implemented via Single-Sign-On and IPFilters (see codeplex for a sample)

e) Session Management: You need to make sure that session data is persisted to SQL Azure by using the SQL Session Provider for ASP.NET

Free Windows Azure test accounts

2010-07-12T19:44:00.000+02:00

If you’re tired of running your Windows Azure applications in your development fabric only and would like to see how it’s doing in “the real world”, request one of Microsoft’s free Windows Azure test accounts.

Those accounts only run for 14 days but provide full functionality!
Just write an email to azurenow@microsoft.com.

Webcast on Running Java & PHP on Windows Azure

2010-07-10T18:19:00.000+02:00

Holger Sirtl has posted a Video that shows how to run Java and PHP on Windows Azure.

In addition I want to note that there are great tools for Eclipse that PHP and Java developers can use to directly develop from inside Eclipse.

Video [German]
http://blogs.msdn.com/b/hsirtl/archive/2010/06/18/webcast-zur-interoperabilit-228-t-mit-windows-azure.aspx

Windows Azure Platform Training Kit

2010-07-10T17:09:00.000+02:00

For all developers who are new to the Windows Azure platform or those who want to get even more insight to Windows azure – there is a new training kit available on Microsoft’s download center.

The June update consists of presentations, hands-on labs and even videos and demos designed to help developers understand Windows Azure and to learn using the Windows Azure platform. The current release includes updated resources for Visual Studio 2010.

Here is one of the basic videos of the training kit that answers the fundamental question “What is Windows Azure?”:

For a deep dive into Windows Azure get the Training kit:
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=413e88f8-5966-4a83-b309-53b7b77edf78

PHP on Windows Azure

2010-07-09T18:15:00.000+02:00

Holger Sirtl has posed great German blog post on running Windows Azure on PHP

Here is his post:

http://blogs.msdn.com/b/hsirtl/archive/2010/06/07/interoperabilit-228-t-mit-windows-azure-ausf-252-hrung-von-php-anwendungen-auf-windows-azure.aspx

Free(!) Windows Azure Book

2010-07-08T17:20:00.000+02:00

Windows Azure team blog announced a free Book about Windows Azure written by developers for developers. “Windows Azure Platform: Articles from the Trenches Volume 1” can be downloaded as PDF for free.

Visit http://bit.ly/downloadazurebookvol1 and download it!

The book is also available on slideshare.net:

Windows Azure Platform: Articles from the Trenches, Volume One

View more documents from Eric Nelson.

And for those who like to read books the traditional way: buy a hardcopy from lulu.com.

What does Azure provide and how fast are servers?

2010-07-08T16:35:00.000+02:00

I get typically three questions, I want to provide answers on:

a) Why Azure – how does it make my life easier?
Here is the answer http://msdn.microsoft.com/de-de/ff728566(en-us).aspx

b) What is the expected performance?
Here are a set of benchmarks that help you estimate the performance of the infrastructure provided by azure
http://azurescope.cloudapp.net/BenchmarkTestCases.aspx

c) What is the data transfer to and from my computer and Azure?

Microsoft Research has released a throughput analyser that shows you the upload/download performance
http://research.microsoft.com/en-us/downloads/5c8189b9-53aa-4d6a-a086-013d927e15a7/default.aspx

The best Windows Azure Apps

2010-06-03T16:16:00.000+02:00

Windows Azure has now 10.000 customers and you might think ok but do I really need to build an application myself or isn’t there some app available I just download the application package for an run it in the cloud? Yes, there is!

Microsoft Germany puts together a list of applications and tools a new Azure Gallery:
http://www.microsoft.com/germany/net/WindowsAzure/Gallery.aspx

I have reviewed the apps and tools listed there and even added a few
of my own favorite ones:

a) Use Windows Azure Storage as an encrypted network drive with Gladient Cloud Tools
http://gladinet.blogspot.com/2010/01/map-drive-and-backup-to-windows-azure.html
http://gladinet.blogspot.com/2010/03/secure-backup-to-windows-azure-blob.html

b) Run Wordpress on Azure
http://wordpress.visitmix.com/

c) Get a Cash-Register for your business or home-business
http://rentapos.com/

d) Use Windows Azure based MonitorGrid Solution to monitor your home server
http://monitorgrid.com/

e) Use a Collaboration Software in the Cloud
http://www.dreamfactory.com/

f) Search E-Books on Windows Azure
http://docjax.cloudapp.net/home/index.shtml

g) Mapping Solution for Windows Azure
http://visualfusion.cloudapp.net/

h) Find Friends via Bluehoo Mobile App
http://bluehoo.cloudapp.net/

According to Microsoft also Umbraco now runs on Azure. I am waiting to get the download.

Using Default-Buttons in Silverlight

2010-06-02T18:01:00.000+02:00

My today’s msdn-solve CodeClip is about porting a standard behavior of applications to Silverlight 4. When filling out a form (either in the web or in a .NET application or elsewhere) users tend to hit the <Return> key and hopefully the application deals with the data entries as intended. But how to implement this in a Silverlight environment?

The key is to use triggers from the Microsoft Expression SDK and automation peers. Triggers can be added to any elements in the XAML markup and listen to a given event. In the CodeClip a trigger is added to the “KeyDown” event of a TextBox. When the event occurs some code is triggered that checks if the pressed key is the <Return> key. If so, an automation peer simulates a click on a given button.
Voilà: default button behavior – at your service!

CodeClip [German]: http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_39850

How-To-Guide [German]: http://www.microsoft.com/germany/msdn/solve/knowhow/howto/webentwicklung/WieKannIchInSilverlightInDialogenEinenDefaultButtonFestlegen.mspx

Mastering the Master-Detail View with WCF Data Services in Silverlight 4

2010-05-25T14:52:00.000+02:00

In this show how do I Video I discuss several uses of WCF Data Services to realize Master-Detail Views over OData Providers and how to master the client change tracking,

How to realize Master-Detail Views with Silverlight 4 on top of WCF Data Service
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_39769 [German Video]

Consuming WCF Data Services in .NET 4

2010-05-12T14:58:00.000+02:00

Based on popular request here is also a how do I video showing how to access WCF Data Services from within a .NET 4 Application.

Video: Consume WCF Data Services in .NET 4
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_39672 [German]

Using WCF Data Services in Silverlight 4

2010-05-05T14:47:00.000+02:00

ADO.NET Data Services has been renamed to WCF Data Services in Silverlight 4 and .NET 4. The protocol that is talked between Client and Server has also been renamed and is now known as OData Protocoll. You can get a variety of clients and providers that speak “OData” from http://Odata.org.

OData and WCF Data Services is my favorite technology for data transfer for 3-Tier Architectures because it allows me to retrieve, change and update data on the client without requiring me to write additional server side code that handles queries and the like. In addition Silverlight 4 now supports change tracking on the client which makes my T4 Templates I wrote for Silverlight 3 kind of non-any longer needed.

Here is a how do I video that shows you how to expose an existing Database via OData and access it from Silverlight

Video: Expose Database via WCF Data Services
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_39621 [German]

Video: Consume WCF Data Service in Silverlight 4
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_39672 [German]

Windows Azure SDK (Feb. 2010)

2010-01-10T16:10:00.000+01:00

Stay up to date with the new Windows Azure SDK ready for download at Microsoft download center:
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=dba6a576-468d-4ef6-877e-b14e3c865d3a

Videos from the Windows Azure Launch in Germany

2009-11-30T12:53:00.000+01:00

The launch event of Windows Azure in Germany end of November was really nice with a lot of partner case-studies and on-site stands. It was good to see that the Cloud becomes a reality. You can checkout the German videos here.

Official Introduction Document to Windows Azure

2009-11-27T15:55:00.000+01:00

Microsoft rampup released a six-paged document on Windows Azure describing

a) Resources offered by Windows Azure

b) Windows Azure architecture

c) Developing Issues for the Cloud.

Download the article here: http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=96d08ded-bbb9-450b-b180-b9d1f04c3b7f

Get Windows Azure SDK v1.0

2009-11-15T18:28:00.000+01:00

Microsoft released version 1.0 of the Windows Azure Software Development Kit. Besides the Development Fabric, the Development Storage and other basics for developing applications on the Windows Azure platform it contains

a) a Diagnostics library to enable logging using standard .NET APIs

b) Certificate Management to support SSL certificates in Windows Azure

c) Persistent local resource storage during role recycle

and more great features. Even the samples have been updated and show new features. Both in C# and VB.NET.

Go for it!
Download the SDK here.

Windows Azure Service Management API

2009-09-19T16:41:00.000+02:00

Yesterday, the Windows Azure team introduced an API that allows developers to manage Azure Services without using the Azure development portal.

Accessing the service management via its REST-services requires usage of X509 client certificates. View the full blog post at the Windows Azure Team Blog.

Windows Azure Architecture for massive scalable Websites & Porting of a Startpage Portal

2009-02-28T13:37:00.000+01:00

The Windows Azure Platform provides SQL based and Windows Azure based Storage Services. The Windows Azure based Storage Services are useful in scenarios where you need massive scalability e.g. like for a start-page ala pageflakes or google/IG.

I had the chance to do a series for How Do I Videos that show how to build a massively scalable website based on azure.

The first Video shows how to build an azure app: http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_31344 [German]

The second Video shows how to store binary data in Windows Azure Storage
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_31346 [German]

The third Video shows how to store Entites in Windows Azure Table Storage using ADO.NET Data Services
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_31350 [German]

Then finally I show how to migrate the Startpage Portal www.dropthings.com to Windows Azure and Windows Azure Table Storage
http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_31352 [German]

Change Tracking and Conflict Management with ADO.NET Data Services

2009-01-26T16:38:00.000+01:00

Today the msdn-solve portal released a new CodeClip of mine about Change Tracking and Conflict Management with ADO.NET Data Services.

In ADO.NET Data Services a data context needs to be notified about any changes applied to the tracked entities. It’s easy to do so when you have full control over the entity. But when the entities are bound to e.g. a DataGrid, things get more and more complicated.
View the CodeClip [German] or read the how-to-guide to learn how to use the PropertyChanged-Event to notify changes on entities.

In multi-user scenarios data is usually manipulated by many users simultaneously. How does your application know if there is new data available when trying to update the data source? Both, the clip and the guide demonstrate how eTags (timestamps) can be used to deal with conflicts using the “Optimistic Concurrency” princible.

CodeClip [German]: http://www.microsoft.com/germany/msdn/solve/codeclips/library.aspx?id=msdn_de_31212

How-To-Guide [German]: http://www.microsoft.com/germany/msdn/solve/knowhow/howto/sql/WieKannIchMitADONETDataServicesAenderungsverfolgungRealisierenUndDatenkonflikteLoesen.mspx