Friday, 28 May 2010
This post is a bit overdue: Steve threatened to blog it himself, so I figured I should get moving. In one of our Cloud Cover episodes, we covered how to host WCF services in Windows Azure. I showed how to host both publically accessible ones as well as how to host internal WCF services that are only visible within a hosted service.
In order to host an internal WCF Service, you need to setup an internal endpoint and use inter-role communication. The difference between doing this and hosting an external WCF service on an input endpoint is mainly in the fact that internal endpoints are not load-balanced, while input endpoints are hooked to the load-balancer.
Hosting an Internal WCF Service
Here you can see how simple it is to actually get the internal WCF service up and listening. Notice that the only thing that is different is that the base address I pass to my ServiceHost contains the internal endpoint I created. Since the port and IP address I am running on is not known until runtime, you have to create the host and pass this information in dynamically.
public override bool OnStart()
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
private void StartWCFService()
var baseAddress = String.Format(
var host = new ServiceHost(typeof(EchoService), new Uri(baseAddress));
host.AddServiceEndpoint(typeof(IEchoService), new NetTcpBinding(SecurityMode.None), "echo");
Consuming the Internal WCF Service
From another role in my hosted service, I want to actually consume this service. From my code-behind, this was all the code I needed to actually call the service.
protected void Button1_Click(object sender, EventArgs e)
var factory = new ChannelFactory<WorkerHost.IEchoService>(new NetTcpBinding(SecurityMode.None));
var channel = factory.CreateChannel(GetRandomEndpoint());
Label1.Text = channel.Echo(TextBox1.Text);
private EndpointAddress GetRandomEndpoint()
var endpoints = RoleEnvironment.Roles["WorkerHost"].Instances
.Select(i => i.InstanceEndpoints["EchoService"])
var r = new Random(DateTime.Now.Millisecond);
return new EndpointAddress(
endpoints[r.Next(endpoints.Count() - 1)].IPEndpoint)
The only bit of magic here was querying the fabric to determine all the endpoints in the WorkerHost role that implemented the EchoService endpoint and routing a request to one of them randomly. You don't have to route requests randomly per se, but I did this because internal endpoints are not load-balanced. I wanted to distribute the load evenly over each of my WorkerHost instances.
One tip that I found out is that there is no need to cache the IPEndpoint information you find. It is already cached in the API call. However, you may want to cache your ChannelFactory according to best practices (unlike me).
Hosting Public WCF Services
This is all pretty easy as well. The only trick to this is that you need to apply a new behavior that knows how to deal with the load balancer for proper MEX endpoint generation. Additionally, you need to include a class attribute on your service to deal with an address filter mismatch issue. This is pretty well documented along with links to download the QFE that contains the behavior patch out on the WCF Azure Samples project on Code Gallery in Known Issues. Jim Nakashima actually posted about this the other day as well in detail on his blog as well, so I won't dig into this again here.
Lastly, if you just want the code from the show, have at it!