I ran across an interesting blog about “Creating, Configuring, and Consuming a WCF Service in IIS”. 60 steps later and you had something to play with…. http://blogs.msdn.com/zainnab/archive/2008/04/30/creating-configuring-and-consuming-a-wcf-service-in-iis-7.aspx

As much as we love .NET development, we can hardly call this productive. What I am going to show you is how Aware Server can take your developers to the next level, and increase their productivity by 67%. Not only do you get an huge boost in development productivity, you also save an enormous amount of time and gain tremendous number of features for Operations (deployment, provisioning, and monitoring of your services).

It’s a no brainier, be more productive, deploy and provision your services to any number of machines. Aware Server gives you everything, and picks up where VS.NET drops off. So let’s get started.  Also this entry is quite long because I included every screenshot as I did things. 

Create and Debug an Aware Service (4 steps – 5^th step is if you do not trust me)

1. Run VS.NET as Admin.

2. Start a new project – As you can see, we are going to use an Aware Template. One of the many templates is the “Aware Distributed Service”. This is what we will use today for our comparison.

3. Enter your Aware Service information.

4. Debug your new service. Hit F5 – Now the Aware Service Invoker starts up (no more test harness app's needed) and allows you to test your service immediately. Go ahead and click the “SomeOperation” function on the left tree, then click the “Invoke” button. You will see the Results, Request, and Response messages. By default the Aware Distributed Service template creates the “SomeOperation” method for you so that is what you will test. Now all you need to do is code your own operations.

5. Just for kicks, I’ll add in a step to let you verify your service was up and running fine. Just open up the Aware Enterprise Manager and while you are debugging you will see that your service is running. By default on net.TCP.

Deploy an Aware Service (3 steps – 4^th step is if you do not trust me)

1. Now since we do not need a testharness any more we actually eliminate about 11 steps. That said, we will walk through the overall process that leads you to create a client application. This will let you see how easy it is to consume and use Aware Services from ANYWHERE.

Before we call this service, we will deploy and provision the service. Aware Server is based on Environments. You deploy to environments, and then provision your services to run within those environments. Now you may say that this is actually more work than using the VS.NET “WCF Service” template which automatically deployed and provisioned it to your local IIS. What we are actually doing is eliminating about 20 of the other steps that happen later on to configure and use different endpoints, and in our case, we automagically do this for any machine that our service is provisioned for.

So let’s get started, and deploy this service. In the Solution Explorer, open the Deployments directory, and double click the ServiceDeployment_Debug.aware file.

2. This will open the Aware Deployment File Viewer for you which you should then see the following viewer (Deployment Settings). Now to deploy your service, click the “publish now” button. Notice that there is an “Auto Publish” option here if you wish to automatically publish this service on each build.

3. After you click the “Publish Now” button you will see the “Deploy to Environment”. By default your current environment is selected, but you may choose any environment that you have security access too. For or example just click deploy and your service will be deployed to your default environment.

4. Lets validate that it was deployed. Return to the Aware Enterprise Manager and then navigate to the “Deployment” tab at the very top. You will see all of the services deployed in your environment, one of which is the service you just deployed (Easy Aware Services).

Provision an Aware Service (3 steps – 4^th for info, 5^th step is if you do not trust me)

1. Now that we deployed our service, let’s provision it to run in our environment. Return to the Aware Enterprise Manager again, and now click on the “Service Provisioning Polices” tab at the top. You will see all of the policies in your environment.

2. Let’s go ahead and create one for our new service, so click the “Create New” in the tool bar. You will see the Service Provisioning Policy Editor pop up. Give your policy a name, application name, and description, and then click on the “Included Service Manifests” tab.

3. Once you are on the “Included Service Manifests” tab, click the “Add Service Manifest button and you will get a list of all services deployed in that environment. Select your “Easy Aware Service” and click “OK”. At this point you could click “Save” on the policy and be done (defaults will be used).

4. At this point we could click the “Save” and our services would start running, but we will review some additional options you have for our policy. Now remember how we talked about the default protocol used is net.TCP, you can easily change that here, or just add as many wish to use (from TCP to REST). No code changes, no configuration night mare. Click Cancel here and we will continue with the default setup.

Not let’s set the “Conditions / Exclusions” that will be used to determine what machines the service will run on. By default conditions are set to Any/Any. Click the “Add Condition” button and you will see you can specify any type of condition (from machine names, to only machines running with 2 processors, or machines that only have 4gig of Ram). For this example well just use the defaults.

Another option that you have is to set time windows of when your service should run. This allows you the flexibility that if you have some services that are heavily used in the early mornings you can schedule them to run on more machines to handle the heavy peak loads, but then during the day stop those services so that they do not interfere with daily operations.

Click “Save” and you should see your newly created policy enabled and running. Note that by mousing over the policy it will tell you the details.

5. We created the policy; now let’s verify that our policy is doing what we asked it to do. Return to the Aware Enterprise Manager and select the “Services” tab again. Just as we saw before during F5 development, we see our service running, but now it is running due to the policy being applied.

Call an Aware Service (4 steps – 5^th step is if you do not trust me)

1. Now that we have developed, deployed, and provisioned our service to run. Let’s put together a little client application to call our service. Create a new project. Just like before you get the project selection window. This time we will use the “Aware Console Application”, give it a name of “MyFirstAwareClient” and then click OK.

2. Now proceed to add Aware Server References by right clicking on the project and “Manage Aware Server References…”

3. You will see the “Aware Service and Business Process References” pop up screen. All you need to do is select your service, then click “Add”. Now click “Apply” and you are ready to call your service. No URL is needed.

4. Aware Server automatically adds all of the proper references (downloading shared contracts) and generates the client proxy to make your calls. What it boils down to is TWO lines of code; create the client, make the call.

   1:  using(EasyAwareServicesClient client = new EasyAwareServicesClient() 

   2:  { 

   3:      Console.WriteLine("What is 2 + 3? {0}", client.AddNumbers(2,3)); 

   4:  } 

5. Hit F5 and you should see.

Zero configuration, no URL’s to know. So how does Aware know where my service is? That is the magic and simplicity of Aware Server and its Service Virtualization capability based on the Service Location Protocol. Our goal was to make using services as easy and simple as possible.

Summary of Aware Server development vs. VS.NET 2008

To find out more please visit www.gridgistics.net and go to the learn section.