Windows Azure - WCF in the Worker Role

// Create the host
ServiceHost host = new ServiceHost(typeof(MessengerService));

// Read config parameters
string hostName = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["port"].IPEndpoint.Address.ToString();
int port = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["port"].IPEndpoint.Port;
int mexport = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["mexport"].IPEndpoint.Port;

// Create Metadata
ServiceMetadataBehavior metadatabehavior = new ServiceMetadataBehavior();
host.Description.Behaviors.Add(metadatabehavior);

Binding mexBinding = MetadataExchangeBindings.CreateMexTcpBinding();
string mexendpointurl = string.Format("net.tcp://{0}:{1}/MessengerServiceMetadata", hostName, 8001);
host.AddServiceEndpoint(typeof(IMetadataExchange), mexBinding, mexendpointurl, new Uri(mexendpointurl));

// Create end point
string endpointurl = string.Format("net.tcp://{0}:{1}/MessengerService", hostName, 9001);
host.AddServiceEndpoint(typeof(IMessengerService), new NetTcpBinding(SecurityMode.None), endpointurl, new Uri(endpointurl));

// Open the host
host.Open();

// Trace output
Trace.WriteLine("WCF Listening At: " + endpointurl);
Trace.WriteLine("WCF MetaData Listening At: " + mexendpointurl);

return base.OnStart();
}

The code performs the following:

• Create Service Host

• Read the Port number

• Add the Metadata behaviour

• Add the endpoints

• Opens the Host

Note: The attached source code contains the working application.

Step 2: Test the application

Now we can test the application by executing it. If successfully executed we can see the trace from the Output window.



You can see two addresses from the above screen:

• The actual service end point

• The metadata end point

We can also see the trace from the load development machine. The Windows Azure Compute Emulator can be used for this purpose.



On invoking the Show Computer Emulator UI we can see the following window.



The above window contains the same trace output with the end point urls. You may try adding reference to the metadata end point using the metadata url. We are going to deploy the service to cloud and test it.

Step 3: Deploy to the cloud

Now our application is working fine and we can deploy it to the online cloud. For this right click on the project and click the Package menu item.



In the appearing dialog box, choose the default options and click the Package button.



Now sign in to the Windows Azure portal and click on the New Hosted Service button from the top ribbon.



In the appearing dialog box enter the details as shown below.



Choose the option "Deploy to production environment"

Locate the package and configuration files from your application bin folder.
(Eg: ..\WCFInWorkerRole\bin\Debug\app.publish)

Please note that the URL prefix should be a unique name. If the URL prefix entered is already in use you need to change it.

After that click the Ok button of the dialog box. (You have to scroll down to see the button)

If any warning box appears, click Yes button to continue. Wait for a few minutes and your deployment will be ready in a few minutes as shown below.



Select the Deployment 2 row and from the properties window you can get the url of the worker role. Now we just need the host name. In this case wcfinworkerrole.cloudap.net



Step 4: Create the Client

Now we are ready to create the client application and test the deployed online cloud WCF service.

Create a new console application into the existing Azure project and name it as TestClient.

Use the add service reference option of the console application and in the appearing dialog enter the constructed service url as shown below.

Constructed Url: net.tcp://wcfinworkerrole.cloudapp.net:8001/MessengerServiceMetadata

Please note that we added the following:

• Protocol as net.tcp

• Host Name from previous step

• Port number as 8001

• Metadata Context Name

Click the Go button and after seeing the MessengerService item populated, Click the Ok button to continue.

Modify the main method in the Program.cs as following:

static void Main(string[] args)
{
ServiceReference1.MessengerServiceClient client = new ServiceReference1.MessengerServiceClient();
string result = client.SendMessage("Kent");

Console.WriteLine(string.Format("Invoking WCF Service Result: {0}", result));

Console.ReadKey(false);
}


Modify the configuration file with the url of the Messenger Service. Please note that the messenger service url is having different port number and context.

<client>
<endpoint
address="net.tcp://wcfinworkerrole.cloudapp.net:9001/MessengerService"
binding="netTcpBinding"
bindingConfiguration="NetTcpBinding_IMessengerService"
contract="ServiceReference1.IMessengerService"
name="NetTcpBinding_IMessengerService" />
</client>

Now set the console application as the start project and execute the application.

You can see the following results.



You can see the result Hello Kent. How do you do? from the WCF service.

This concludes our article on WCF service deployment as worker role and the testing.

Multiple End Point

I would like to add a note on the 2 end points we created for the WCF service.

net.tcp://wcfinworkerrole.cloudapp.net:8001/MessengerServiceMetaData \
net.tcp://wcfinworkerrole.cloudapp.net:9001/MessengerService

You can see that there are 2 differences in the above urls:

• Port

• Context

Note: WCF with HTTP Port 80 endpoint configuration done as explained here.

Summary

In this article, we have seen how to host a WCF service using the Worker Role and deploy it to the cloud. This service is self hosted and experiments the service creation, hosting, metadata end point adding, deploying and testing with the client. The source code is attached and the application name in the url has to be changed according to your application name.