• Use standard HTTP verbs: GET, POST, PUT, PATCH, DELETE, and HEAD.
• You can use either HTTP or HTTPS.
• Use standard security to authenticate your REST calls via OAuth 2.0.
• Serialize your data in either XML or JSON format.

Force.com provides this capability out-of-the-box (OOTB) for objects you create and supports standard CRUD (create, read, update, and delete) against your objects. While this is great, there are a few scenarios that are not supported OOTB in Force.com – complex data queries (i.e. joins) via the API, custom logic or rules, and anonymous access.

In this post I’ll show you how you can create REST APIs using Apex REST in order to anonymous access to your APIs.

Following is a detailed tutorial:

1. Start by creating a new Force.com developer account. Why create a new account? Well, why not? It provides a good sandbox for testing things out and you can have as many as you want. Note that the although the login you create looks like an email address it doesn’t have to be your email address – it’s simply a login. You can create a nonsensical login – i.e. anonymous@restcall.com – and just throw it away when you’re done.

2. Let’s create a custom object. Under App Setup click Schema Builder. Click the Elements tab and drag an Object into the schema canvas.

3. For the Label choose “Widget”, for the Plural Label choose “Widgets”, and for the Record Name choose “Name”. Click Save.

4. It’s time to create the Apex REST API. Close the Schema Builder and under App Setup expand Developer and click Apex Classes. Click New to create a new class.

5. Past the following code into Apex Class Editor:

@RestResource(urlMapping='/Widgets/*')
global class WidgetController {

    @HttpGet
    global static List<Widget__c> getWidgets() {
        List<Widget__c> widgets = [SELECT Name from Widget__c];
        return widgets;
    }

    @HttpPost 
    global static String createNewWidget(String Name) {
        Widget__c w = new Widget__c();
        w.Name = Name;
        insert w;

        return 'Done';
   }

    @HttpDelete
    global static String deleteWidgetById() {
        String Id = RestContext.request.params.get('Id');
        List<Widget__c> w = [ Select ID from Widget__c where Id= :Id];

        delete w;

        return 'Deleted Widget';
    }

    @HttpPut
    global static String updateWidget(String Id, String NewName) {
        Widget__c w = [ Select ID, Name from Widget__c where Id= :Id];

        w.Name = NewName;
        update w;

        return 'Widget Updated';
    }
}

6. To access these APIs we have to create a site and provide access to this Apex class. Force.com sites enable you to create public websites and applications. Under App Setup expand Develop and click Sites.

7. Choose a Force.com domain name. Ensure it is available, click the checkbox, then click Register My Force.com Domain.

8. Once your site is registered click the New button.

9. Give yourself a Site Label, Site Name, and choose an Active Site Home Page. Since no one will use this site as a website I’ve chosen FileNotFound. Click the Save button.

10. By default the site is not active. Click the Activate button or else you will not be able to access your APIs.

11. Next we have to grant anonymous access to our Apex REST API. Click the Public Access Settings button.

12. Scroll down the Custom Object Permissions and click the Edit button underneath the Widgets.

Scroll down again to Custom Object Permissions (yeah, I know …) and check all the boxes. Click Save.

13. Scroll down to Enabled Apex Class Access and click the Edit button. Select the WidgetController and click the Add button. Click Save.

14.Browse to http://www.hurl.it/. This is a great website for making HTTP requests and will let us test the GET, POST, PATCH, and DELETE.

15. Right now our object doesn’t have any data. Before we make a Get request let’s add some data. Enter https://wadeapitest-developer-edition.na15.force.com/services/apexrest/Widgets in the URL (note: the first part of this URL is from step 7 above). Change to POST (and if necessary click the set post body link. Add the following text into the body:

{"Name":"Widget1"}

Click + add header and enter “Content-Type” for the name and “application/json; charset=UTF-8” for the value. Click the Send button.

You should get a response like the following:

16. Change from POST to GET and click Send. You should get the following response:

Copy the Id value – we’ll use this in a moment.

17. Change from GET to PUT, enter the following information in the body, and click Send.

{"Id":"a00i0000001RdL4AAK","NewName":"Widget1a"}

You should get the following response:

If you quickly flip back to GET and click Send you’ll see that your record has been updated.

18. Finally, let’s delete the record. Change the URL to https://wadeapitest-developer-edition.na15.force.com/services/apexrest/Widgets?Id=a01i0000000Z4jzAAC (again, use your site name and the proper Id value), change from PUT (or GET) to DELETE, and click Send. Now the record is gone!

That’s it!

The beauty of this technique is that any platform or language that can communicate over this HTTP methods – i.e. GET, POST, PUT, and DELETE – can execute CRUD operations against your custom object without having to authenticate. Pretty cool!

Now, should you always allow for CRUD over an anonymous set of APIs? Probably not. Just because I’ve shown you how to do it doesn’t mean you should. However, I’m sure you can think of some scenarios when the aforementioned capabilities are useful.

I hope this helps!

During the hack day I acquired a few tips for getting started. Nothing earthshattering but useful nonetheless.

1. Setup a developer account. It’s quick, easy, and free. You can get a lot of them.
2. Don’t use your production account for development. This may sound trite but I can tell you from first-hand experience that you don’t want to start hacking in production. The Salesforce.com development lifecycle has process for deploying from one environment to another. Use it. Today I didn’t follow this advice and it cost me quite a bit of time. See tip #1 for getting a proper developer account.
3. Simplify the password requirements for your developer account. First, under your name, choose Setup.

   Then type “password” in the search box and click Password Policies.

   

   Choose some less restrictive policies. It’s up to you – personally, I don’t want my developer account password expiring all the time. Note: I do not recommend you do this on your production account.

   

4. Change the default IP Restrictions. Again, for my developer account, I don’t want the platform continually challenging me if I log in from different places. After you browse to Setup search for Profile. Click on Profiles.

   Scroll down until your see System Administrators and select it.

   

   Scroll down to IP Address Ranges and click New. Enter default ranges 0.0.0.0 to 255.255.255.255 and click Save.

   

That’s all for now. For those of you who are pro’s on the platform this is likely not new or exciting. I’m sure there are more tips I’ll learn over time and, when I do, I’ll try to update this list.

I hope this helps!

Coming from a Windows Azure focus at Microsoft my natural tendency has been to approach most problems with solutions in Windows Azure. It’s amazing how versatile Windows Azure is as a platform; with a little bit of elbow grease there are few problems you can’t solve. That said, what I’ve come to release is, regardless of any platforms merits, there are always cases when you need to leave your comfort zone. For me, this has manifested itself with customers that – for a great many reasons – look to either Amazon Web Services or SalesForce.com for solutions.

Don’t get me wrong. I’m still a huge fan of Windows Azure and incredibly excited by what the platform offers. (And not just because I spent five years of my life working on it!) Just look at the evolution Windows Azure has taken over the last year:

• Introduced IaaS capabilities last year
• Introduced Windows Azure Websites
• Introduced Windows Azure Mobile Services
• Introduced Media Services

… and so much more. There’s never been a better time to build on Windows Azure.

That said, it’s interesting to talk to CIOs and technology leaders at various companies. I’ve found a great many different mental models people have for the cloud. Generally speaking, it appears that when talking to a technical person the cloud is synonymous with AWS; when talking to a businessperson the cloud is synonymous with SalesForce.com. We all ignore these platforms at our own peril. The same can be said for folks focused entirely on AWS or SalesForce.com – you ignore Windows Azure at your own peril.

At the end of the day, no one platform ever has all the answers. If we’re honest with ourselves we have to admit that it’s both worthwhile and important to understand other platforms as well. The desire to learn and to branch out into new areas is natural; furthermore, and most importantly, the needs of customers comes first.

All of this is a way of saying that you’ll start to see me blog more about other cloud platforms – certainly AWS and SalesForce.com, but it’s possible I’ll go even beyond these two. There’s a lot to learn from platforms like Heroku, Google Cloud, and others.

None of this is surprising or revolutionary. Consequently, you may ask yourself, why a long blog post? Well, primarily it’s because I don’t want to give the impression that I’ve given up on Windows Azure. In fact, I’m more excited about the future of Windows Azure than ever before. There’s a lot of opportunity just around the corner.

So … to the cloud(s)!

There are certainly a few things missing below: scripts for scaling up/down, scripts for running Windows update, and so forth. I’ll tackle these in future posts. My point here is to highlight a different way to look at tackling a common problem.

What are some of the advantages to this approach?

• Near instant deployment.
• Fully automated.
• Consistent development model with other platforms.
• Consistent deployment model with other platforms.

I’m sure there are more. There are some limitations as well – in particular, you’re bound by the number of roles you can have in your Cloud Service, which today is (I think) 25. This means that, at most, you can only scale out to 25 virtual machines. I imagine this limitation will be removed at some point (or perhaps you could get around it by using virtual networks).

Regardless, give it a try.

Note: You can find the PowerShell scripts used below in this gist here: https://gist.github.com/wadewegner/5080142.

Image Preparation

In this first step you’ll create and customize a virtual machine that you’ll then sysprep and turn into a disk that we’ll use later on.

Create the Base Virtual Machine

This first part takes the longest. This is because you’re preparing the disk you’ll use moving forward. Note that you only do it once – this is not something you have to do over and over again.

1. Create a Virtual Machine.
 

2. Enter the VM information. Use the default “Windows Server 2012 Datacenter” image. Size doesn’t matter. This VM will sysprepped and used as a disk image for creating future virtual machines.

• Be sure to note the location you use.
• Be sure and remember the password. You’ll need it.

3. Start the VM.

• Note: Notice that VMs create a Cloud Service. Each VM is actually a role within

4. RDP into the VM once it has provisioned and started.

5. Click to Add roles and features.

6. Leave defaults and click Next until you get to Server Roles.

7. Choose Application Server and Web Server (IIS). Click Next.

8. Under Features be sure to select ASP.NET 4.5.

9. Click Next until you get to Role Services under Web Server Role (IIS).

10. Add ASP.NET 4.5 under Application Development. This will add the other default values.

11. Click Next until you get to the last step. Click Install. Wait until the operation completes.

Install and Use Windows Azure PowerShell Cmdlets

12. From the machine, download the Windows Azure PowerShell Cmdlets. These can be found at: http://www.windowsazure.com/en-us/downloads/.

13. Install the cmdlets. This can take 5-15 minutes.

14. Create the folder c:\\Scripts.

15. Run the following script in Windows PowerShell ISE to download your publish settings file:

Get-AzurePublishSettingsFile

16. Save or move this file into the c:\\Scripts folder and rename to credentials.publishsettings.

17. Run the following script in Windows PowerShell ISE to change the execution policy:
Set-ExecutionPolicy Unrestricted

Setup Web Deploy

18. Download Web Deploy 3.0 from the following link: http://download.microsoft.com/download/1/B/3/1B3F8377-CFE1-4B40-8402-AE1FC6A0A8C3/WebDeploy_amd64_en-US.msi. Do not install. To simplify, download to C:\\.

19. Open a Command Prompt.

20. Run the following command:

C:\\>msiexec /I webdeploy_amd64_en-us.msi /passive ADDLOCAL=ALL LISTENURL=http://+:8080/

Configure Firewall Settings

21. Run Windows Firewall with Advanced Security.

22. Select Inbound Rules and click New Rule.

23. Select Port and click Next.

24. Level TCP selected and enter 8080 for the Specific local ports.

25. Keep the defaults and click Next until prompted to give a name. Choose a name (e.g. Web Deploy Port) and click Finish.

System Preparation

26. Open a Command Prompt as an administrator.

27. Change the directory to: %windir%\\system32\\sysprep

28. Run sysprep.exe.

29. Ensure the following options are selected:

• Enter System Out-of-Box Experience (OOBE)
• Generalize
• Shutdown
  

Capture the Virtual Machine

30. Return to your Virtual Machine Instances tab in the portal: https://manage.windowsazure.com/#Workspace/VirtualMachineExtension/vms.

31. Wait until you see that the status of your virtual machine is Stopped.

32. Capture the image by clicking the CAPTURE button below.

33. Select an image name (e.g. WS2012-WebFarmImage) and check that you have sysprepped the machine. Click the button.

34. When the capture operation completes you’ll see the disk image available under Images in the portal: https://manage.windowsazure.com/#Workspaces/VirtualMachineExtension/images

Virtual Machine Deployment

You’ll run these steps from your own PC.

1. Open the Windows PowerShell ISE to run the following scripts. It’s always a good idea to save them somewhere to use later.

2. You might need to import your publish settings. If so, download your publish settings file, save it, then import it.

Get-AzurePublishSettingsFile

Import-AzurePublishSettingsFile C:\\credentials.publishsettings

3. Get the subscription name to which you’ll deploy. Run the following script:

Get-AzureSubscription -Current

4. You need to get the storage account that contains your disk image. You’ll need to use the same storage account for the disks attached to the web servers in your web farm. Select the Images tab under Virtual Machines on the portal. Find your image and look at the location. The first part of the URL is the storage account name.

5. It’s now time to deploy your web farm using the disk image you created in the previous section. Review the following script and update appropriately.

$imgname = 'WS2012-WebFarmImage'
$cloudsvc = 'DemoWebFarm'
$pass = 'Password'
$subscriptionName = 'Windows Azure MSDN - Visual Studio Ultimate'
$storageAccount = 'portalvhds9dvbvvff5hdg3'
$location = 'East US'

Set-AzureSubscription -SubscriptionName $subscriptionName -CurrentStorageAccount $storageAccount

$iisvm1 = New-AzureVMConfig -Name 'iis1' -InstanceSize Small -ImageName $imgname |
    Add-AzureEndpoint -Name web -LocalPort 80 -PublicPort 80 -Protocol tcp -LBSetName web -ProbePath '/' -ProbeProtocol http -ProbePort 80 |
    Add-AzureEndpoint -Name webdeploy -LocalPort 8080 -PublicPort 8080 -Protocol tcp | 
    Add-AzureProvisioningConfig -Windows -Password $pass
    
$iisvm2 = New-AzureVMConfig -Name 'iis2' -InstanceSize Small -ImageName $imgname |
    Add-AzureEndpoint -Name web -LocalPort 80 -PublicPort 80 -Protocol tcp -LBSetName web -ProbePath '/' -ProbeProtocol http -ProbePort 80 |
    Add-AzureProvisioningConfig -Windows -Password $pass
    
$iisvm3 = New-AzureVMConfig -Name 'iis3' -InstanceSize Small -ImageName $imgname |
    Add-AzureEndpoint -Name web -LocalPort 80 -PublicPort 80 -Protocol tcp -LBSetName web -ProbePath '/' -ProbeProtocol http -ProbePort 80 |
    Add-AzureProvisioningConfig -Windows -Password $pass    
    
New-AzureVM -ServiceName $cloudsvc -VMs $iisvm1, $iisvm2, $iisvm3 -Location $location

Notes on script:

• $imgname: This is the name of the disk image you created.
• $cloudsvc: When you deploy it will create a cloud service. This is the name for the cloud service.
• $pass: This is the password for the virtual machine you created.
• $subscriptionName: This is your subscription name.
• $location: The datacenter you want to deploy into. Note: this has to be the same data center as your storage account.

It is important to note that the setup for $iisvm1 is different than $iisvm2 and $iisvm3. That’s because we’re adding an additional endpoint named webdeploy on 8080. We’ll use this public port for deploying via web deploy. It is not opened on the other machines.

6. It’s time to run the script. Note: the script does not rollback. If you have values that are incorrect you’ll have to clean them up manually. If all goes well, you’ll see progress indicators like the following:

7. You can now look in the portal and you’ll see the following machines Running/Provisioning.

8. You can browse the URL, for example: http://demowebfarm.cloudapp.net. You’ll get the standard IIS page:

Setup Synchronization across Virtual Machines

1. Remote into iis1. From the portal, select iis1 under Virtual Machine Instances and click the CONNECT button. This will download an RDP file. Save this and use it for connecting to the machine later.

2. Open Windows PowerShell ISE.

3. Click New to create a new script.

4. Copy the following script and save it as C:\\Scripts\\Sync.ps1. DO NOT RUN IT.

$subscriptionName = 'Windows Azure MSDN - Visual Studio Ultimate'
$storageAccount = 'portalvhds9dvbvvff5hdg3'
$cloudsvc = ' DemoWebFarm' 
$publishSettings = 'C:\\Scripts\\credentials.publishsettings'

Import-Module 'C:\\Program Files (x86)\\Microsoft SDKs\\Windows Azure\\PowerShell\\Azure\\Azure.psd1'

Import-AzurePublishSettingsFile $publishSettings
Set-AzureSubscription -SubscriptionName $subscriptionName -CurrentStorageAccount $storageAccount

$publishingServer = (gc env:computername).toLower()

Get-AzureVM -ServiceName $cloudsvc | foreach { 
    if ($_.Name.toLower() -ne $publishingServer) {
       $target = $_.Name + ":8080"
       $source = $publishingServer + ":8080"

       $exe = "C:\\Program Files\\IIS\\Microsoft Web Deploy V3\\msdeploy.exe"
       [Array]$params = "-verb:sync", "-source:contentPath=C:\\Inetpub\\wwwroot,computerName=$source", "-dest:contentPath=C:\\Inetpub\\wwwroot,computerName=$target";

        & $exe $params;
    }   
}

Create a Scheduled Task

5. Open Task Scheduler.

6. Click Create Task …

7. On the General tab set the Name and Run wehather user is logged on or not.

8. On the Triggers tab click New. Create a Daily trigger and Repeat task every 2 minutes. Click OK.

9. On the Actions tab click New. Set the following values:

Program/script: C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe
Add arguments: -File C:\\Scripts\\Sync.ps1

10. You should now see this as a scheduled task.

11. You can wait for this to run or run it manually. It should run successfully.

Deploy a Website through Web Deploy

1. Create a new ASP.NET MVC 4 Web Applications. (In actually it can be anything.) Choose an Internet Application.

2. Update the HomeController.cs code:

public ActionResult Index()
{
    string machineName = Environment.MachineName;
    ViewBag.Message = "Computer Name: " + machineName;

    return View();
}

3. Right-click on your application and click Publish.

4. In the dropdown select New.

5. Give your publish profile a name. Click OK.

6. Update all the fields:

• Server: This is the DNS name of the cloud service with port 8080.
• Site name: This needs to be “Default Web Site”.
• User name: This is the administrator account.
• Password: The password you set.
• Destination URL: The same as server without the ports.

7. Click Publish.

8. In Visual Studio you should see that it deployed successfully.

WARNING: Don’t be alarmed if the browser opens and you don’t see your site. Remember that we set synchronization at two minutes and you have a 66% chance of hitting iis2 or iis3.

9. If you go back to your RDP session with iis1 and browse to C:\\inetpub\\wwwroot you’ll see all your content has been deployed.

10. Either way two minutes or manually invoke your synchronization task. Hit the website again and start refreshing:

That’s it!

Yeah, that might seem like a lot but realize that most of the work detailed here – such as the image preparation – you’ll only have to do one time. The rest of the time you’re using tools like PowerShell and Visual Studio.

Enjoy!

It’s disappointing this happened but highlights a pretty common situation. This has nothing to do with the merits of the Windows Azure storage service or any other parts of the platform – this is an operations management issue, plain and simple. The irony is that, as a number of folks including Lars Wilhelmsen have pointed out, there are tools like Microsoft SCOM that provide a Certificate Management Pack that can notify operations of expiring certificates. I can’t imagine the operations team at Windows Azure doesn’t use some kind of tool to manage expiring certificates.

As a developer, I found myself curious to see just how hard it is to determine the expiration of a certificate by checking the URI. Turns out, it’s pretty simple by using System.Net.ServicePoint which provides connection management for HTTP/S connections.

private string GetSSLExpiryDate()
{
    string url = "https://www.aditicloud.com/";
    var request = WebRequest.Create(url) as HttpWebRequest;
    var response = request.GetResponse();

    if (request.ServicePoint.Certificate != null)
    {
        return request.ServicePoint.Certificate.GetExpirationDateString();
    }
    else
    {
        return string.Empty;
    }
}

Pretty simple. What’s hard is the practice of managing and tracking these sorts of things.

I would expect that Microsoft will ensure that this kind of problem never happens again. It’s embarrassing yet solvable. Yet it exposes an issue that most of us will also have to account for – expiring certificates. If it can happen to Microsoft, it can happen to us too.

Today I wanted to do two things.

1. Get an ID specific to the application.
2. Get an ID specific to the device/hardware (also called App Specific Hardware ID or ASHWID).

There are a lot of different reasons for wanting this information. For me, I’m storing this information in a Windows Azure table along with a Windows Notification Service (WNS) Channel URI so that I can choose the right application and device to send notifications.

While trying to figure out how to get the Application ID wasn’t particularly difficult – that is, if you find the RTM documentation – I did struggle to figure out how to get the device/hardware ID. Finally, I found an answer on Stack Overflow that helped.

Here’s how to get the application ID with C#:

string appId = CurrentApp.AppId.ToString();

Note that during development the GUID comes back as “00000000-0000-0000-0000-000000000000″. Once released through the Windows Store you will get a specific value.

Getting the ASHWID is a bit more difficult. Prior to the RTM release a lot of folks created their own GUID and stored it in the Windows.Storage.ApplicationData.Current.LocalSettings. This is a reasonable hack but of course the user can delete local storage and then your application would change the value – not good if you’re depending on something unique.

Fortunately the RTM release includes the GetPackageSpecificToken class that can return the ASHWID. Of course, I looked at some guidance and MSDN method documentation on getting the ASHWID and never found a good sample on how to get the ASHWID and store it as a string. Consequently, I hope this short snippet – again, found on Stack Overflow, helps:

private string GetHardwareId()
{
    var token = HardwareIdentification.GetPackageSpecificToken(null);
    var hardwareId = token.Id;
    var dataReader = Windows.Storage.Streams.DataReader.FromBuffer(hardwareId);

    byte[] bytes = new byte[hardwareId.Length];
    dataReader.ReadBytes(bytes);

    return BitConverter.ToString(bytes);
}  

From here you can just load it into a string and do whatever you desire.

string deviceId = GetHardwareId(); 

Now you’ll get a value that’s something like 03-00-F0-7E-03-00-76-F3-05-00-5C-54-05-00-8A-DE-06-00-01-00-04-00-54-49-04-00-C2-4A-04-00-DE-4D-01-00-A4-52-02-00-2E-B2-09-00-42-88 that you can store for future use.

Nothing groundbreaking here but hopefully this saves you a few minutes.

Pretty compelling.

Despite the use of JSON – and great frameworks like JSON.NET and SimpleJson – I always struggled with creating my C# classes when working with an existing web service that returned JSON. It can take a long time to create these C# classes correctly, and often time I’d take a lazy approach and either use the JObject or an IDictionary such that I didn’t have to have a C# class – something like:

var json = (IDictionary<string, object>)SimpleJson.DeserializeObject(data);

Yesterday I stumbled upon a tool that makes this SO amazingly easy. In many ways I’m bothered by the fact that it’s taken me so long to find it – has this been one of the best kept secrets on the Internet or did I just miss it?

http://json2csharp.com/

This website is as simple as it is powerful. Simply paste your JSON into the textbox, click Generate, and voilà you have C# objects!

Take a look. Here’s some JSON returned back from the Untappd API:

{
  "meta": {
    "code": 200,
    "response_time": {
      "time": 0.109,
      "measure": "seconds"
    }
  },
  "notifications": [],
  "response": {
    "pagination": {
      "next_url": "http://api.untappd.com/v4/thepub?max_id=11697698",
      "max_id": 11697698,
      "since_url": "http://api.untappd.com/v4/thepub?min_id=11697724"
    },
    "checkins": {
      "count": 2,
      "items": [
        {
          "checkin_id": 11697724,
          "created_at": "Wed, 22 Aug 2012 12:56:41 +0000",
          "checkin_comment": "",
          "user": {
            "uid": 205218,
            "user_name": "asiahobo",
            "first_name": "Bum",
            "last_name": "",
            "location": "",
            "url": "0",
            "relationship": null,
            "bio": "0",
            "user_avatar": "https://untappd.s3.amazonaws.com/profile/7d21ba831edb33341b98f86e09795ed7_thumb.jpg",
            "contact": {
              "twitter": "asiahobo",
              "foursquare": 31652652
            }
          },
          "beer": {
            "bid": 9652,
            "beer_name": "Maredsous 8° Brune",
            "beer_label": "https://untappd.s3.amazonaws.com/site/beer_logos/beer-maredsous.jpg",
            "beer_style": "Belgian Dubbel",
            "auth_rating": 0,
            "wish_list": false
          },
          "brewery": {
            "brewery_id": 6,
            "brewery_name": "Abbaye de Maredsous (Duvel Moortgat)",
            "brewery_label": "https://untappd.s3.amazonaws.com/site/brewery_logos/brewery-AbbayedeMaredsousDuvelMoortgat_6.jpeg",
            "country_name": "Belgium",
            "contact": {
              "twitter": "",
              "facebook": "www.facebook.com/pages/Abbaye-De-Maredsous/208016262548587fine",
              "url": "www.maredsous.be/"
            },
            "location": {
              "brewery_city": "",
              "brewery_state": "Denée",
              "lat": 50.3044,
              "lng": 4.77149
            }
          },
          "venue": [],
          "comments": {
            "count": 0,
            "items": []
          },
          "toasts": {
            "count": 0,
            "auth_toast": null,
            "items": []
          },
          "media": {
            "count": 0,
            "items": []
          }
        },
        {
          "checkin_id": 11697723,
          "created_at": "Wed, 22 Aug 2012 12:56:35 +0000",
          "checkin_comment": "",
          "user": {
            "uid": 137722,
            "user_name": "Mjoepp",
            "first_name": "Christoffer",
            "last_name": "",
            "location": "Linköping",
            "url": "",
            "relationship": null,
            "bio": "",
            "user_avatar": "http://gravatar.com/avatar/f1672535a7caa3bd686267257d33c588?size=100&d=https%3A%2F%2Funtappd.s3.amazonaws.com%2Fsite%2Fassets%2Fimages%2Fdefault_avatar.jpg",
            "contact": {
              "foursquare": 25958771
            }
          },
          "beer": {
            "bid": 12145,
            "beer_name": "Chocolate",
            "beer_label": "https://untappd.s3.amazonaws.com/site/beer_logos/beer-ChocolatePorter_12145.jpeg",
            "beer_style": "English Porter",
            "auth_rating": 0,
            "wish_list": false
          },
          "brewery": {
            "brewery_id": 844,
            "brewery_name": "Meantime Brewing Company",
            "brewery_label": "https://untappd.s3.amazonaws.com/site/brewery_logos/brewery-MeantimeBrewingCompanyLimited_844.jpeg",
            "country_name": "England",
            "contact": {
              "twitter": "MeantimeBrewing",
              "facebook": "http://www.facebook.com/meantimebrewing",
              "url": "http://www.meantimebrewing.com"
            },
            "location": {
              "brewery_city": "London",
              "brewery_state": "",
              "lat": 51.5081,
              "lng": -0.128005
            }
          },
          "venue": [],
          "comments": {
            "count": 0,
            "items": []
          },
          "toasts": {
            "count": 0,
            "auth_toast": null,
            "items": []
          },
          "media": {
            "count": 0,
            "items": []
          }
        }
      ]
    }
  }
}

I’m sad to admit that, in the past, I’d like create my C# objects by hand and then either conform to the JSON or map between the two. It requires a TON of time and is extremely error prone. With http://json2csharp.com/ all I do is paste this into the textbox and click Generate. I’ll get the following output:

public class ResponseTime
{
    public double time { get; set; }
    public string measure { get; set; }
}

public class Meta
{
    public int code { get; set; }
    public ResponseTime response_time { get; set; }
}

public class Pagination
{
    public string next_url { get; set; }
    public int max_id { get; set; }
    public string since_url { get; set; }
}

public class Contact
{
    public string twitter { get; set; }
    public int foursquare { get; set; }
}

public class User
{
    public int uid { get; set; }
    public string user_name { get; set; }
    public string first_name { get; set; }
    public string last_name { get; set; }
    public string location { get; set; }
    public string url { get; set; }
    public object relationship { get; set; }
    public string bio { get; set; }
    public string user_avatar { get; set; }
    public Contact contact { get; set; }
}

public class Beer
{
    public int bid { get; set; }
    public string beer_name { get; set; }
    public string beer_label { get; set; }
    public string beer_style { get; set; }
    public int auth_rating { get; set; }
    public bool wish_list { get; set; }
}

public class Contact2
{
    public string twitter { get; set; }
    public string facebook { get; set; }
    public string url { get; set; }
}

public class Location
{
    public string brewery_city { get; set; }
    public string brewery_state { get; set; }
    public double lat { get; set; }
    public double lng { get; set; }
}

public class Brewery
{
    public int brewery_id { get; set; }
    public string brewery_name { get; set; }
    public string brewery_label { get; set; }
    public string country_name { get; set; }
    public Contact2 contact { get; set; }
    public Location location { get; set; }
}

public class Comments
{
    public int count { get; set; }
    public List<object> items { get; set; }
}

public class Toasts
{
    public int count { get; set; }
    public object auth_toast { get; set; }
    public List<object> items { get; set; }
}

public class Media
{
    public int count { get; set; }
    public List<object> items { get; set; }
}

public class Item
{
    public int checkin_id { get; set; }
    public string created_at { get; set; }
    public string checkin_comment { get; set; }
    public User user { get; set; }
    public Beer beer { get; set; }
    public Brewery brewery { get; set; }
    public List<object> venue { get; set; }
    public Comments comments { get; set; }
    public Toasts toasts { get; set; }
    public Media media { get; set; }
}

public class Checkins
{
    public int count { get; set; }
    public List<Item> items { get; set; }
}

public class Response
{
    public Pagination pagination { get; set; }
    public Checkins checkins { get; set; }
}

public class RootObject
{
    public Meta meta { get; set; }
    public List<object> notifications { get; set; }
    public Response response { get; set; }
}

Pretty amazing! Now, note that it’s not perfect – there’s both a Contact and Contact2 class, but that’s easy to fix by merging the two and updating references. I’ll gladly perform this little bit of cleanup given the hours this tool just saved me.

Now that I have these classes, it’s really easy to use JSON.NET to load them with data.

RootObject publicFeed = new RootObject();

using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
    data = reader.ReadToEnd();

    publicFeed = JsonConvert.DeserializeObject<RootObject>(data);
}

Now it’s a simple matter of using my RootObject within my applications.

I feel like I may be the last person to have heard of this tool, in which case I’m both embarrassed and bitter – couldn’t you all have told me about this years ago?

I hope this helps!

I’ve been waiting for almost a year to write this blog post.

Keynote with Scott Guthrie

In order to get this post out quickly I decided to share my rough notes from the keynote. Over the coming days and weeks I will certainly expand this with more information.

Scott Guthrie:

• Today’s release “elevates Windows Azure to a new level”
• Capabilities like Windows Azure Web Sites and open source libraries open the platform to many more developers
• Three pillars of Windows Azure:
• Flexible
• Open
• Solid
• Windows Azure has pioneered Platform-as-a-Service
• Today we’re enabling Infrastructure-as-a-Service (IaaS)
• Support of Linux is how we’re embracing openness in a new way
• Supporting more languages, protocols, and SDKs
• Open-source libraries and SDKs on Github under the Apache 2.0 license

Demo: New Windows Azure website

• There’s a new Linux and Mac installer for Node.js
• Spent time optimizing the portal to work across platforms
• Full monitoring and statistics through the portal
• Everything done through the portal is communicating to APIs thereby allowing you to do everything through the command line
• IaaS
• Create a new virtual machine
• Anything installed on the machine will persist; full durable VM
• Image gallery
• Linux distribution built into the portal
• We have a number of SDKs to download, including Mac
• installs an Azure utility and wires up a BASH shell
• including ASCII art
• SSH’d into Ubuntu machine
• Virtual Networks
• Not just upload VMs into the cloud
• Integrate into your existing networks and VMs you already have
• Shipping virtual private networking
• A wizard to create an address space and subnet; we’ll virtualize these addresses
• You can provide DNS servers in the cloud or on-premises

Scott Guthrie on VMs:

• Virtual machine portability
• Between the cloud and different environments
• All VMs are running a VHD format which is an open spec
• Because it’s the same file format you can take a VM and move to Windows Azure or even move it back; you don’t have to export or convert the VHDs
• This allows you to run in your data center, other service providers, or within Windows Azure: flexibility, portability, and no lock-in
• VM persistent drive
• Mount durable drives to the virtual machines
• Reliable and consistent
• When you mount a drive the disk is backed with the Windows Azure storage system
• Triple replicate the content; no interruption of service if there’s a failure
• Continuous storage and geo-replication

Partner: RightScale

• Michael Crandell, CEO
• Mission: to build a broad cloud management platform
• Web-based environment that allows companies to manage everything from development to delivery of applications running on cloud infrastructures
• Think of us as a bridge between the apps and the infrastructures you want to run on (public, private, or hybrid)
• Partner: worked with the Windows Azure team to interact with the new IaaS APIs
• Brought to Windows Azure the full set of RightScale capabilities
• When run by RightScale the solution includes auto scale
• Why Windows Azure?
• Microsoft knows how to run global cloud infrastructure with a high degree of operational excellence
• IaaS + PaaS is an industry first – provides an entire environment for the development and deployment of apps that are compelling, from simple to complex
• Openness – a clear commitment of openness at multiple levels

Scott Guthrie on Web sites:

• Benefits
• Build with ASP.NET, Node.js, or PHP
• Deploy in seconds with FTP, Git, or TFS
• Start for free, scale up as your traffic grows
• Bill Staples demo
• Opposite end of the cloud spectrum
• don’t want to focus on the platform; don’t want to install the frameworks
• Visual Studio & .NET
• Quickly created a website
• Downloaded a publishing profile that includes all the connection information
• Opens up Visual Studio and ASP.NET MVC 4
• Import the profile and publish
• Support in both VS 20120 and VS 2012
• Built and published into the cloud in just a few seconds
• Updated a string and republished
• Preview shows the deltas between local and cloud
• Just push the change
• Mac with Node.js
• Instead of the portal use the commandline
• Use the azure command
• Uses git to deploy
• One update connects to Mongo running in a Linux VM
• Sometimes it’s nice to build an application without writing code
• Best of Windows Azure and the power of open source
• MySQL: worked with ClearDB to provide MySQL as a service
• Scale
• Scale out
• By default, website is running as a Shared Website
• You can increase instance count
• Scale up
• Move from Shared to Reserved
• Only my websites are routed
• 10 free shared websites

Scott Guthrie on Cloud Services:

• Another model for building infinitely scalable applications and services
• The traditional PaaS offering that Windows Azure has had since release
• Creates a multi-tier applications using the website Bill created and adding a worker role
• Process
• Upload a service package (which is essentially a zip file) into the cloud
• Fabric controller provisions the machines and deploys my bits and brings it into rotation through load balancer

Scott Guthrie on Building Blocks:

• Overall message is to enable developers to focus on applications and less about infrastructure
• Application building blocks
• big data
• database
• storage
• traffic
• caching
• messaging
• identity
• media
• CDN
• networking
• Delivered by MSFT and partners
• Language support for: .NET, Node.JS, Java, PHP, Python
• Libraries you can consume natively
• Libraries on Github under Apache2
• SQL Database
• Relational SQL database
• Clustered for high availability
• Fully managed service
• SQL Reporting support
• Blob storage
• Features
• Highly available, scalable and secure file system
• Blobs can be exposed publically over http
• Continuous geo-replication across datacenters
• Real-time data showed in portal
• SQLs surfaced in the portal
• Cache
• implementing Memcached protocol support
• Use the distributed service or run it in your own instances
• Identity
• Integrate with enterprise identity
• Enable single sign-on within your apps
• Enterprise Graph REST API
• 93% of Fortune 1000 use Active Directory
• Service Bus
• Secure messaging and relay capabilities
• Easily build hybrid apps
• Enable loosely coupled solutions
• Cross platform SDKs
• Media Service
• Create, manage, and distribute content
• Target any device or media format
• Ingest, Encode, Protect, Stream
• Marketplace integration
• Azure in 89 countries and territories

In my opinion, there are three significant components of today’s announcements worth delving into deeper:

• New Infrastructure-as-a-Service (IaaS) capabilities.
• Free (or low-cost) hosting with Windows Azure Websites.
• Enhanced cloud networking capabilities that support VPN connections between an on-premises corporate network and Windows Azure.

Until now, Microsoft has never competed directly with Amazon EC2 with respects to IaaS nor with cloud platforms like Heroku. The new IaaS and Websites capabilities, combined with the ability to extend on-premises networks to the cloud, provides a number of ways that Windows Azure can now distinguish itself from other platforms and—in my opinion—will drive many new enterprises and a large number of developers to adopt Windows Azure.

Infrastructure-as-a-Service

Windows Azure has long had the concept of a “Virtual Machine role” but the fundamental problem has been the inability to persist changes made to the virtual machine image provided by the customer (i.e. the guest VM) during reboots or recycling. Supporting VM persistence in Windows Azure means that the guest VM will not lose these updates. This unlocks many workloads that previously did not work in Windows Azure – certainly products like SharePoint and SQL Server but also custom line-of business applications that previously were difficult to move to Windows Azure.

In addition to VM persistence, Windows Azure will also give customers the ability to run Linux VMs. There’s been a lot of interest and speculation regarding Microsoft’s strategy moving forward with Linux and open source. I think Microsoft recognizes that their customers run more than just Windows in their enterprise, and this is an opportunity for Windows Azure to run as many workloads as possible. We’ve seen this shift in Microsoft in a number of different ways – support for Node.js and Java in Windows and Windows Azure, the creation of a new interoperability subsidiary, and many more. The cloud provides a way to make it easier to connect all of these different platforms and technologies, and my take is that Microsoft is trying to make Windows Azure the best and simplest place to run your applications regardless of the platform or technology.

Windows Azure Websites

It’s exciting to see Microsoft continue to evolve its strategy with Windows Azure to make it increasingly accessible to the breadth of developers out there.
Windows Azure Websites is a hosting platform for web applications. It provides a number of different deployment and runtime options beyond the existing Web Role, including:

• Target both Microsoft and non-Microsoft technologies already running in the environment, including SQL Azure, MySQL, PHP, Node.js, and (of course) .NET.
• Deploy via Git, Web Deploy, FTP, or TFS.
• Run in a high-density / multitenant VM for little-to-no cost or choose a dedicated deployment path.

In addition to providing simpler and more consistent ways to deploy applications across different hosting platforms (e.g. Windows Azure, Windows Server, and hosting providers), Windows Azure Websites provides a way for Microsoft to bring thousands—perhaps even hundreds of thousands—of new developers to the platform with the offer of little-to-no cost hosting.

Cloud Networking

Windows Azure Virtual Networks allows a company to connect their cloud applications and solutions to their local network. This occurs at the networking layer through standard VPN devices. Coupled with IaaS support, this provides a ton of flexibility with respects to the kinds of workloads a customer moves to Windows Azure. Don’t want to move your sensitive SQL Server database? You don’t need to. Setup a VPN to your applications in Windows Azure and let them communicate directly back to your applications that live on-premises.

There’s certainly a lot more to talk about – new services, portal, SDK, tools, and so much more! These thoughts are pretty early—in fact, I write this before today’s MEET Windows Azure event—and there’s so much more to talk about!

The primary value of this is to decrease the number of storage transactions when reading from your queue, and therefore reduce both bandwidth and transaction costs.

There are plenty of other good posts on this topic that provide a lot more detailed justification and rationale for this approach:

• Advanced scenarios with Windows Azure Queues
• Cloud Lesson Learned: Exponential Backoff
• Windows Azure : Messaging with the queue – Patterns for message processing

The logic and approach is deceptively simple and I thought I’d share a really simple, yet effective, example. (Incidentally, credit goes to Steve for very quickly putting together the basis of this really simple example.)

Here’s the code:

   string queueName = "queuetest";

   int minInterval = 1;
   int interval = minInterval;

   int exponent = 2;
   int maxInterval = 60;

   CloudStorageAccount account = CloudStorageAccount.DevelopmentStorageAccount;
   CloudQueueClient queueClient = account.CreateCloudQueueClient();
   CloudQueue queue = queueClient.GetQueueReference(queueName);
   queue.CreateIfNotExist();

   while (true)
   {
      var msg = queue.GetMessage();
      if (msg != null)
      {
         // do something
         queue.DeleteMessage(msg);
         interval = minInterval;

         Trace.WriteLine(string.Format("Interval reset to {0} seconds", interval));
      }
      else
      {
         Trace.WriteLine(string.Format("Sleep for {0} seconds", interval));
         Thread.Sleep(TimeSpan.FromSeconds(interval));
         interval = Math.Min(maxInterval, interval * exponent);
      }
   }

As I said, really simple. The magic is in the last line where we check to see which is smaller – the maximum interval or the product of the interval and the exponent. At some point the product of the interval and exponent grows larger than the maximum interval, and consequently the interval value is set to the maximum interval.

Here’s the output in the Windows Azure Compute Emulator:

   Sleep for 1 seconds 
   Sleep for 2 seconds 
   Sleep for 4 seconds 
   Sleep for 8 seconds 
   Sleep for 16 seconds 
   Sleep for 32 seconds 
   Sleep for 60 seconds 
   Sleep for 60 seconds 
   ...

Now, the application will continue to sleep until it finds a message in the queue, at which point the interval is reset back to one. To test this I used the Azure Storage Explorer and created a new queue message.

Once the message is created the output is as follows:

   Interval reset to 1 seconds 
   Sleep for 1 seconds
   Sleep for 2 seconds
   Sleep for 4 seconds
   Sleep for 8 seconds
   ...

And so forth.

You can find all the source code for this sample in my CappedExponentialBackOff repository on GitHub.

Pretty simple but quite useful. I hope this helps!