bradygaster.com

Running SSL with Windows Azure Web Sites Today

Thu, 28 Mar 2013 14:15:48 GMT

If you’re a web developer working with ASP.NET, Node.js, PHP, Python, or you have plans on building your site in C++, Windows Azure Web Sites is the best thing since sliced bread. With support for virtually every method of deployment and with support for most of the major web development models you can’t beat it. Until recently, SSL was the only question mark for a lot of web site owners, as WAWS doesn’t yet support SSL out of the box (trust me, it’s coming, I promise). The good news is that there’s a method of achieving SSL-secured sites now. In this blog post I’ll introduce the idea of a workaround my engineering friends in the Web Sites team call the SSL Forwarder, and to demonstrate how you can get up and running with an SSL-protected Windows Azure-hosted web site in just a few minutes’ work.

Disclaimer

First, I’d like to point out one very important point about the SSL Forwarder solution. This solution works, and we have a handful of community members actively using this solution to provide an SSL front-end for their web sites. So feel comfortable using it, but understand that this isn’t something you’ll have to do forever, as SSL is indeed coming as an in-the-box feature for Web Sites. If you love the idea of Windows Azure Web Sites but the lack of in-the-box SSL support is a deal-breaker for you and your organization, this is a viable option to get you up and running now. However, the SSL Forwarder isn’t an officially supported solution, in spite of one being actively used by numerous customers. So if you set this up and you experience anything weird, feel free to contact me directly via the comment form below, or on Twitter, or by email (and I’ll give you my email address on Twitter if you need it). All that being said, I’ve heard from quite a few in the community who are using this solution that it has mitigated their concern and they appear to be running quite well with this in place.

Architectural Overview

Don’t panic when you see this solution. Do read the introduction, once you see grok how it all works, the SSL Forwarding solution is a whole lot less intimidating. I admit to having freaked out with fear when I first saw this. I’m no expert at most of the things involved in this exercise, but the Web Sites team literally put together a “starter project” for me to use, and it took me 1 hour to get it working. If I can do this, you can do this.

The idea of the SSL Forwarder is pretty simple. You set up a Cloud Service using the Windows Azure portal that redirects traffic to your Windows Azure Web Site. You can use all the niceties of Web Sites (like Git deployment, DropBox integration, and publishing directly to your site using Visual Studio or WebMatrix) to actually build your web site, but the requests actually resolve to your Cloud Service endpoint, which then proxies HTTP traffic into your Web Site.

The diagram to the right shows how this solution works, at a high level. The paragraph below explains it in pretty simple terms. I think you’ll agree that it isn’t that complicated and that the magic that occurs works because of tried-and-true IIS URL Rewrite functionality. In order to obtain the 99.9% uptime as outlined in the Windows Azure SLA, you’ll need to deploy at least 2 instances of the Cloud Service, so the diagram shows 2 instances running. As well, the code provided with this blog post as a starting point is defaulted to start 2 instances. You can back this off or increase it however you want, but the 99.9% uptime is only guaranteed if you deploy the Cloud Service in 2 instances or more (and there’s no SLA in place yet for Web Sites, since it’s still in preview at the time of this blog post’s release, so you can host your Web Site on as many or as few instances as you like).

You map your domain name to your Cloud Service. Traffic resolves to the Cloud Service, and is then reverse-proxied back to your Web Site. The Cloud Service has 1 Web Role in it, and the Web Role consists of a single file, the Web.config file. The Web.config in the Web Role contains some hefty IISRewrite rules that direct traffic to the Web Site in which your content is hosted. In this way, all traffic – be it HTTP or HTTPS traffic – comes through the Cloud Service and resolves onto the Web Site you want to serve. Since Cloud Services support the use of custom SSL certificates, you can place a certificate into the Cloud Service, and serve up content via an HTTPS connection.

Setup

To go along with this blog post, there’s a GitHub.com repository containing a Visual Studio 2012 solution you can use to get started. This solution contains three projects:

A Windows Azure Cloud Project
A web site that’s used as a Web Role for the Cloud Project
A web site that’s deployed to Windows Azure Web Sites (you’ll want to replace this one with the project you’re deploying or just remove it, it’s just there as part of the sample)

Create the Cloud Service and Web Site

First thing is, I’ll need to create a Web Site to host the site’s code. Below is a screen shot of me creating a simple web site myself using the Windows Azure portal.

Obviously, I’ll need to create a Windows Azure Cloud Service, too. In this demo, I’ll be using a new Cloud Service called SSLForwarder, since I’m not too good at coming up with funky names for things that don’t end in a capital R (and when I do, Phil teases me, so I’ll spare him the ammunition). Below is another screen shot of the Windows Azure portal, with the new Cloud Service being created.

If you’re following along at home work, leave your browser open when you perform the next step, if you even need to perform the next step, as it is an optional one.

Create a Self-signed Certificate

This next step is optional, and only required if you don’t already have an SSL certificate in mind that you’d like to use. I’ll use the IIS Manager to create my own self-signed certificate. In the IIS Manager I’ll click the Server Certificates applet, as shown below.

When I browse this site secured with this certificate, there’ll be an error message in the browser informing me that this cert isn’t supposed to be used by the domain name from where it’s being served. Since you’ll be using a real SSL certificate, you shouldn’t have to worry about that error when you go through this process (and I trust you’ll forgive a later screen shot where the error is visible).

Once that applet loads up in the manager, I’ll click the link in the actions pane labeled Create Self-Signed Certificate.

I’ll name my certificate SSLForwarderTesting, and then it appears in the list of certificates I have installed on my local development machine. I select that certificate from the list and click the link in the Actions pane labeled Export to save the cert somewhere as a file.

Then I find the location where I’ll save the file and provide it with a password (which I’ll need to remember for the next step).

Now that this [optional] step is complete I have a *.PFX file I can use to install my certificate in the Cloud Service.

Install the SSL Certificate into a Cloud Service

To activate SSL on the Cloud Service I’ll need to install an SSL certificate into the service using the Windows Azure portal. Don’t panic, this is easier than it sounds. Promise. Five minutes, tops.

Back in my browser, on the Windows Azure portal page, I’ll click the Cloud Service that’ll be answering HTTP/S requests for my site. The service’s dashboard page will open up.

I’ll click the Certificates tab in the navigation bar.

I’m going to want to upload my certificate, so this next step should be self-explanatory.

The next dialog gives me a pretty hard-to-screw-up dialog. Unless I forgot that password.

(cue the sound of hands ruffling through hundreds of post-its)

Once the certificate is uploaded, I’ll click the new cert and copy the thumbprint to my clipboard, maybe paste it into Notepad just for the moment…

Configuring the Cloud Service’s SSL Certificate

With the SSL cert installed and the thumbprint copied, I’ll open up the ServiceConfiguration.cloud.cscfg file in Visual Studio 2012 and set the thumbprint’s configuration. I could also do this using the built-in Windows Azure tools in Visual Studio, but since I’ve got the thumbprint copied this is just as easy to do directly editing the files. Plus, the Web Sites team made it pretty obvious where to put the thumbprint, as you’ll see from the screen shot below.

Configuring the URL Rewrite Rules in the Web Role

Remember the architectural overview from earlier. The main thing this Cloud Service does is to answer HTTP/S requests and then reverse-proxy that traffic back to the Web Site I’m happily hosting in Windows Azure. Setting up this proxy configuration isn’t too bad, especially when I’ve got the code the team handed me. I just look for all the places in the Web.config file from the Web Role project that mentions foo.com or foo.azurewebsites.net or foo…well, you get the idea.

Here’s the Web.config file from the Web Role project before I edit it to comply with the Web Site and Cloud Service I created to demonstrate this solution open in Visual Studio 2012. I’ve marked all the spots you’ll need to change in the screen shot.

Here’s the file after being edited. Again, I’ll indicate the places where I made changes.

Now that the Cloud Service and the Web.config file of the Web Role project’s been configured to redirect traffic to another destination, the proxy is ready for deployment. The solution’s Cloud project is defaulted to run at 2 instances, so that’s something you’ll want to remember – you’ll be paying for 2 instances of the Cloud Service you’ll be using to forward HTTP/S traffic to your Web Site.

Publish the Cloud Service

Within Visual Studio 2012, I right-click the Cloud project and select the Publish context menu item.

A dew dialogs will walk me through the process of publishing the SSLForwarder service into Windows Azure. It may take a few minutes to complete, but once it publishes the Cloud Service will be running in your subscription and ready to respond to HTTP/S requests.

To verify everything’s working, try hitting the Cloud Service URL – in my case sslforwarder.cloudapp.net, to see if it’s answering requests or spewing errors about unreachable hosts, either of which wouldn’t be surprising – we’ve redirected the Cloud Service’s Web Role to a Web Site. That web site probably isn’t set up yet, so you could see some unpredictable results.

If you actually pre-configured your SSLForwarder Cloud Service to direct traffic to a *.azurewebsites.net you’re already running you’re pretty much finished, and you’re probably running behind HTTPS without any problems right now. If not, and the idea of publishing Web Sites from Visual Studio is new to you, you’ll have a chance to use that technique here.

Publish a Windows Azure Web Site

I’ll go back into the Windows Azure portal and go specifically to the SSLForwarder Web Site I created earlier on in the post.

Once the site’s dashboard opens up, I’ll find the link labeled download publishing profile. This file will be used by Visual Studio during publishing to make the process very simple.

Publishing and Browsing an SSL-encrypted Web Site

Once the publish settings file has been downloaded, it’s easy to push the site to Web Sites using Visual Studio 2012 or WebMatrix. With the sample project provided I’ll open up the Web Application project I want to publish to Web Sites. Then, I’ll right-click the web site project and select the Publish menu item.

Then, the publish process will make the remainder of the publishing experience pretty simple.

Remember to thank Sayed Hashimi if you need him out and about, he loves to hear thoughts on publishing and uses suggestions to make the experience an improved one for you. He also has a stupendous team of people working with him to execute great publishing experiences, who love feedback.

The publish process dialogs will walk you through the simple act of publishing your site up to Windows Azure. Once it completes (which usually takes 30-60 seconds for a larger site) the site will open up in a web browser.

Note the URL still shows HTTP, and it also shows the URL of the Windows Azure Web Site you created. You’ll need to manually enter in the URL for the Cloud Service you created.

For me, that’s www.sslforwarder.com. So long as the domain name you enter resolves to Cloud Service you should be alright. You can also opt for the *.cloudapp.net approach too, as the domain name of the site you want to put out. Whatever your preference for solving this particular issue.

I’m going to go ahead and change the domain name and the protocol, so our hit to the site being hosted in Web Sites will respond to it receiving an SSL-encrypted request, then load the site in the browser.

Note – this is when you’ll need to forgive me for showing you something that causes a warning in the browser. It’s just that way since I used a self-signed cert in a Windows Azure service, so we should expect to see an error here. It’s right there in the browser’s address bar, where it says “Certificate Error.” If I’d used a real SSL cert, from a real authority, the error wouldn’t be there.

Summary

So for many months I’ve heard users request SSL on Web Sites, saying everything about it is awesome. Then they stare at me and wait about 3 seconds and usually follow it up with “but you’ve gotta get me SSL man, I’m over here and I gotta have my SSL”. I understand their desire for us to support it, and luckily, the Web Sites team and our engineering organization is so willing to share their solutions publicly. This is a great solution, but it won’t work in every situation and isn’t as good as what the Web Sites teams have in plans for the future. The SSL Forwarder solution is a good stop-gap, a good temporary solution to a problem we’ve had a lot of requests about.

Hopefully this helps in your decision to give Windows Azure Web Sites a shot. If SSL has been your sole reason for not wanting to give it a try, now you have a great workaround in place that you can facilitate to get started right now.

WebMatrix Templates in the App Gallery

Tue, 19 Mar 2013 19:55:20 GMT

If you’ve not yet used WebMatrix, ~~what are you waiting for?!?!?!?~~ you’re missing out on a great IDE that helps you get a web site up and running in very little time. Whether you’re coding your site in PHP, Node.js, or ASP.NET, WebMatrix has you covered with all sorts of great features. One of the awesome features of WebMatrix is the number of templates it has baked in. Starter templates for any of the languages it supports are available, as are a number of practical templates for things like stores, personal sites, and so on. As of the latest release of Windows Azure Web Sites, all the awesome WebMatrix templates are now also available in the Web Sites application gallery. Below, you’ll see a screen shot of the web application gallery, with the Boilerplate template selected.

Each of the WebMatrix gallery projects is now duplicated for you as a Web Site application gallery entry. So even if you’re not yet using WebMatrix, you’ll still have the ability to start your site using one of its handy templates.

Impossible, you say?

See below for a screenshot from within the WebMatrix templates dialog, and you’re sure to notice the similarities that exist between the Application Gallery entries and those previously only available from directly within WebMatrix.

As before, WebMatrix is fully supported as the easiest Windows Azure-based web development IDE. After you follow through with the creation of a site from the Application Gallery template list from within the Windows Azure portal, you can open the site live directly within WebMatrix. From directly within the portal’s dashboard of a new Boilerplate site, I can click the WebMatrix icon and the site will be opened up in the IDE.

Now that it’s open, if I make any changes to the site, they’ll be uploaded right back into Windows Azure Web Sites, live for consumption by my site’s visitors. Below, you’ll see the site opened up in WebMatrix.

If you’ve not already signed up, go ahead and sign up for a free trial of Windows Azure, and you’ll get 10 free sites (per region) to use for as long as you want. Grab yourself a free copy of WebMatrix, and you’ll have everything you need to build – and publish – your site directly into the cloud.

Web Camps Dallas

Tue, 19 Mar 2013 14:58:56 GMT

I wanted to let you know about an event I’ll be speaking at in early April. Along with my good friend and mentor Scott Hunter, “el master’o’ASP.NET,” I'll be presenting at the Web Camps in Dallas, Texas. I’d love to see you there.

Dallas isn’t the only stop for the Web Camps tour. Our other good buddy, Jon Galloway, has worked hard creating this year’s Web Camps content, and has been out on the road promoting all the awesome new stuff we’ve released with the ASP.NET framework and tools. Along with Mr. Hunter, I’ll be presenting demonstrations and content related to all of the awesome topics below:

Keynote: The ASP.NET Web Platform in Context
What’s new in ASP.NET 4.5 and Visual Studio 2012
Building and deploying websites with ASP.NET MVC 4
Creating HTML5 Applications with jQuery
Building a service layer with ASP.NET Web API
Leveraging your ASP.NET development skills to build apps for Office
Building and leveraging social web apps in ASP.NET
Building for the mobile web
Real-time communications with SignalR
Leveraging Windows Azure and Windows Azure Web Sites

So if you’re an ASP.NET developer, or you’ve been thinking about learning more about the new stuff available in the ASP.NET stack, come on out and join Scott Hunter and I on Friday, April 5 in Dallas, TX. We’ve got a whole series of these events lined up lots of other places, so check out the other areas where we’ll be heading and join us at one of those great events, too.

March 20 - Oslo, Norway - Cory Fowler
March 22 – Lisbon, Portugul - Cory Fowler
March 25 – London, UK - Cory Fowler, Steve Sanderson and Stuart Leeks
March 27 – Cambridge, MA - Nathan Totten
April 3 – Copenhagen, Denmark - Jon Galloway and Mads Kristensen
April 5 – Dallas, TX with Brady Gaster and Scott Hunter
April 6 – Istanbul, Turkey - Jon Galloway, Tugberk Ugurlu and Umit Sunar
April 12 – Bellevue, WA - Nathan Totten and Cory Fowler
April 19 – Sunnyvale, CA - Nathan Totten and Jon Galloway
April 26 – San Diego, CA - Jon Galloway

Jon, myself, and the rest of the team welcome you to this great series of events. We hope to see you there!

Solving Real-world Problems with Windows Azure Web Sites

Mon, 25 Feb 2013 19:01:00 GMT

I’ve been asked a lot of great questions about Windows Azure Web Sites since the feature launched in June. Things like on-premise integration, connecting to service bus, and having multiple environments (like staging, production, etc), are all great questions that arise on a pretty regular cadence. With this post, I’m going to kick off a series on solving real-world problems for web site and PaaS owners that will try to address a lot of these questions and concerns. I’ve got a few blog posts in the hopper that will address some of these questions, rather than just cover how certain things are done. Those posts are great and all (and a lot of fun to write), but they don’t answer some real-world, practical questions I’ve been asked this year. Stay tuned to this area of my site, as I’ll be posting these articles over the next few weeks and probably into the new year. As I post each of these solutions I’ll update this post so you have a one-stop shop to go to when you need to solve one of these problems.

Posts in this Series

Multiple Environments with Windows Azure Web Sites
In this post I demonstrate how to have production and staging sites set up for your web site so that you can test your changes in a sandbox site before pushing your production site and potentially causing damage to it (and your reputation). If you’ve wondered how to gate your deployments using Windows Azure Web Sites, this is a good place to start. You’ll learn how to use Windows Azure Web Sites with a GitHub.com repository and some creative branching strategies to maintain multiple environments for a site.

Managing Multiple Windows Azure Web Site Environments using Visual Studio Publishing Profiles
This post takes the same sort of scenario as presented in the first article. Rather than use GitHub.com as a means to executing a series of gated environment deployments it focuses on the awesome features within Visual Studio for web publishing. Specifically, you’ll see how to use publishing profiles to deploy to multiple Windows Azure Web Sites, so that a team of peers responsible for releasing a site can do so without ever needing to leave Visual Studio.

This post also takes a look at the idea of release management and how this solution answers the question of doing proper release management with a cloud-hosted web site. If you’ve wondered how your SDLC could fit in the idea of continuously maintaining a series of environments for gating your releases using Visual Studio’s super-simple publishing features, this is a great place to start.

Connecting Windows Azure Web Sites to On-Premises Databases Using Windows Azure Service Bus
This post introduces the idea creating a hybrid cloud setup using a Windows Azure Web Site and the Windows Azure Service Bus, to demonstrate how a web site hosted in Windows Azure can connect to your on-premises enterprise database. If you’ve been wondering how to save data from your Windows Azure Web Site into your local database but didn’t know how to do it, or if you’re thinking of taking baby steps in your move toward cloud computing, this post could provide some good guidance on how to get started.

Continuous Delivery to Windows Azure Web Sites using TeamCity
My good friend Magnus put together a very extensive and informative blog post on using Windows Azure Web Sites with TeamCity. If you're a CI user, or a TeamCity user, you'll want to check this out, as it is a great recipe for implementing your CI builds against Windows Azure Web Sites. Magnus worked really hard on this blog post and started working on it for his Windows AzureConf talk, and I'm proud to see how it came together for him.

Jim O'Neil's Blog Series on Integrating Windows Azure Web Sites and Notifications
Jim's blog series - part 1, part 2, and part 3 - are great if you're looking into implementing instant messaging with your Windows Azure Web Site. This series is great, and I feel it shows off some amazing potential and adds a whole new dimension to what's possible on the platform. Take a look at these posts, they're quite inspiring.

G. Andrew Duthie’s Series on Back-end Data Services with Windows 8 Applications
The @devhammer himself has created an awesome series on putting your data in the cloud, so your Windows 8 applications have a common place from which to pull the data. In this series, he discusses how to use Windows Azure Web Sites to create an API that can be called by a Windows 8 application. If you’re delving into Windows 8 development and have been wondering how you could use Web Sites to create the APIs you’ll be calling, this series is a must-read.

Maarten Balliauw on Configuring IIS Methods for ASP.NET Web API with Windows Azure Web Sites
My good friend and dedicated MVP Maarten just wrote up a great post on configuring IIS within Windows Azure Web Sites to support additional HTTP methods like HEAD and PATCH using configuration files. If you’re trying to do some deeper Web API functionality and have struggled with getting these types of HTTP methods supported, this could solve your problem.

Branches, Team Foundation Services, and Windows Azure Web Sites
Wouter de Kort covers how to achieve the multiple-environment approach using Team Foundation Services online. If you're using TFS and you want to set up multiple branches that deploy to a variety of web sites, this article will help you get going. This is a great introduction to using TFS for multiple branches with Windows Azure Web Sites.

nopCommerce and Windows Azure Web Sites

Wed, 06 Feb 2013 05:11:43 GMT

This week we announced support for nopCommerce in the Windows Azure Web Sites application gallery. Using the Windows Azure portal and with requiring zero lines of code, you can set up nopCommerce on Web Sites and get your online store up in minutes. You’ll have your very own products database, shopping cart, order history – the works. On the nopCommerce web site you can learn a lot more about the features nopCommerce offers. In this blog post, I’ll show you how to get your own store up and running on Windows Azure Web Sites.

I walked through this process today. As with other entries in the Web Sites application gallery, you really do have to do very little digging to figure out where to go to get started. It’s pretty much “start, new site, from gallery,” as you’ll see from the picture below. It shows you exactly which menu item to click in the Windows Azure portal to get started.

The next step should be pretty self-explanatory. Select nopCommerce from the list of available applications.

The next step will ask you for some database connection information. This is what will be set in your nopCommerce installation once the process is complete. I’m going to create a new database solely for use with my nopCommerce site I’m creating for this demonstration.

The next screen is one that appears in a few other application gallery entries, too. It’s the “where do you want to store your data today?” screen. I’m creating a new SQL Server database in this screen so I need to provide the database name, specify a new server’s creation, and provide the database username and password. Don’t bother writing this down, there’s an ~~app~~ screen for that later in this post.

Once I click OK here, my site is created. First, the portal tells me it’s creating the site:

Once the site is up and running, Windows Azure lets me know:

If I select my nopCommerce site and click the “Browse” button in the Windows Azure portal, the site will open up in a new browser instance and allow me the capability of specifying the database connection string it’ll use.

Now, I’ll go back to the Windows Azure portal’s dashboard for my nopCommerce demo site. In that dashboard page I’ll click the link labeled “View connection strings,” and a dialog will open. In that dialog I’ll see the connection string for my database. I can copy that from the dialog…

… and paste it into the nopCommerce setup window.

Of course, I’ve blocked out my site’s real connection string in this picture, but the idea is – it doesn’t get much easier. Once I click the “Install” button in the nopCommerce setup page, the site and database schema, as well as some sample data points, will be installed automatically and the site configured to access the database. Once the setup process is complete, I’ll be redirected to my very own store site.

In the navigation bar I’ll click on the “My Account” link, login, and then, at the very tip-top of my browser I’ll see a link to get to the Administration panel of my new nopCommerce store site.

The administration portal for the nopCommerce product promises to give me just about everything I’d need to sell some stuff, know how my sales are doing, and so on. I can pretty much do whatever I need to do using their rich, extensive administration functionality.

If you’ve been thinking of setting up a store, with a shopping cart, online, or you’ve been asked to do so and are more interested in getting it up and running quickly than you are with re-inventing the wheel by writing custom code, check out nopCommerce. Get your free Windows Azure trial – which comes with 10 free web sites for free – right here, then set up your own nopCommerce site and have your products selling in your store.

Kicking off Web Camps India

Thu, 24 Jan 2013 08:34:10 GMT

Next week I’ll be speaking at the Web Camps events in India. The web camps series, put together by my trusty teammate Jon Galloway, offers web developers a glimpse into all the new web-related stuff the ASP.NET and Visual Studio teams have been cooking. I’m looking forward to the trip, as I’ve never been further East than Sweden. My team has this habit of coming up with nifty out-of-office emails so I decided to make a map, originally thinking I’d jam the map into an email. The image ending up being pretty huge so I’m sparing the team the extra room in their mailboxes by sharing it here instead.

This should be a pretty neat trip. I’m thankful for the opportunities I get like this to talk about and demonstrate the awesome work the engineers do here. They make that part of the job easy. When you love a product as much as I’ve loved ASP.NET and Visual Studio for this long, the idea of showing folks how to use it and to give them some new tricks is cake. This sort of thing – talking about how awesome our products are and about the awesomer people involved in their creation – is the best part of my job.

What makes that part of job difficult is the missing-of-family while I’m on the road. My wife is the most supportive woman you could have the luck to know and I’m the luckiest guy in the world for having her there to support me. My sons always miss me, so that’s the saddest part of every trip, but they know how it works so they’re usually pretty forgiving, as the code below demonstrates. Coming home to this familiar program is without a doubt the icing on the cake.

So tomorrow I’ll start my first trip to the other side of the globe. Wish me luck, and if you’re in the area, come on out to learn some great stuff about ASP.NET, Windows Azure and Visual Studio!

Connecting Windows Azure Web Sites to On-Premises Databases Using Windows Azure Service Bus

Mon, 26 Nov 2012 17:06:00 GMT

The third post in the Solving Real-world Problems with Windows Azure Web Sites blog series I’ll demonstrate one manner in which a web site can be connected to an on-premises enterprise. A common use-case for a web site is to collect data for storage in a database in an enterprise environment. Likewise, the first thing most customers want to move into the cloud is their web site. Ironically, the idea of moving a whole enterprise architecture into the cloud can appear to be a daunting task. So, if one wants to host their site in the cloud but keep their data in their enterprise, what’s the solution? This post will address that question and point out how the Windows Azure Service Bus between a Windows Azure Web Site and an on-premises database can be a great glue between your web site and your enterprise.

We have this application that’d be great as a cloud-based web application, but we’re not ready to move the database into the cloud. We have a few other applications that talk to the database into which our web application will need to save data, but we’re not ready to move everything yet. Is there any way we could get the site running in Windows Azure Web Sites but have it save data back to our enterprise? Or do we have to move everything or nothing works?

I get this question quite frequently when showing off Windows Azure Web Sites. People know the depth of what’s possible with Windows Azure, but they don’t want to have to know everything there is to know about Windows Azure just to have a web site online. More importantly, most of these folks have learned that Windows Azure Web Sites makes it dirt simple to get their ASP.NET, PHP, Node.js, or Python web site hosted into Windows Azure. Windows Azure Web Sites provides a great starting point for most web applications, but the block on adoption comes when the first few options are laid out, similar to these:

It is costing us increased money and time to manage our web sites so we’re considering moving them into Windows Azure Web Sites
It will it cost us a lot of money to move our database into the cloud
We don’t have the money to rework all the applications that use that database if moving it to the cloud means those applications have to change.
We can’t lose any data, and the enterprise data must be as secure as it already was, at the very least.
Our web sites need to scale and we can’t get them what we need unless we go to Windows Azure Web Sites.

This is a common plight and question whenever I attend conferences. So, I chose to take one of these conversations as a starting point. I invented a customer situation, but one that emulates the above problem statement and prioritizations associated with the project we have on the table.

Solving the Problem using Windows Azure Service Bus

The first thing I needed to think about when I was brought this problem would be the sample scenario. I needed to come up with something realistic, a problem I had seen customers already experiencing. Here’s a high-level diagram of the idea in place. There’s not much to it, really, just a few simple steps.

In this diagram I point out how my web site will send data over to the Service Bus. Below the service bus layer is a Console EXE application that subscribes to the Service Bus Topic the web application will be publishing into the enterprise for persistence. That console EXE will then use Entity Framework to persist the incoming objects – Customer class instances, in fact – into a SQL Server database.

The subscription internal process is also exploded in this diagram. The Console EXE waits for any instance of a customer being thrown in, and it wakes up any process that’s supposed to handle the incoming instance of that object.

The Console EXE that runs allows the program to subscribe to the Service Bus Topic. When customers land on the topics from other applications, the app wakes up and knows what to do to process those customers. In this first case, the handler component basically persists the data to a SQL Server installation on their enterprise.

Code Summary and Walk-through

This example code consists of three projects, and is all available for your perusal as a GitHub.com repository. The first of these projects is a simple MVC web site, the second is console application. The final project is a core project that gives these two projects a common language via a domain object and a few helper classes. Realistically, the solution could be divided into 4 projects; the core project could be divided into 2 projects, one being the service bus utilities and the other being the on-premises data access code. For the purposes of this demonstration, though, the common core project approach was good enough. The diagram below shows how these projects are organized and how they depend on one another.

The overall idea is simple - build a web site that collects customer information in a form hosted in a Windows Azure Web Site, then ship that data off to the on-premises database via the Windows Azure Service Bus for storage. The first thing I created was a domain object to represent the customers the site will need to save. This domain object serves as a contract between both sides of the application, and will be used by an Entity Framework context class structure in the on-premises environment to save data to a SQL Server database.

With the domain language represented by the Customer class I’ll need some Entity Framework classes running in my enterprise to save customer instances to the SQL database. The classes that perform this functionality are below. They’re not too rich in terms of functionality or business logic implementation, they’re just in the application’s architecture to perform CRUD operations via Entity Framework, given a particular domain object (the Customer class, in this case).

This next class is sort of the most complicated spot in the application if you’ve never done much with the Windows Azure Service Bus. The good thing is, if you don’t want to learn how to do a lot with the internals of Service Bus, this class could be reused in your own application code to provide a quick-and-dirty first step towards using Service Bus.

The ServiceBusHelper class below basically provides a utilitarian method of allowing for both the publishing and subscribing features of Service Bus. I’ll use this class on the web site side to publish Customer instances into the Service Bus, and I’ll also use it in my enterprise application code to subscribe to and read messages from the Service Bus whenever they come in. The code in this utility class is far from perfect, but it should give me a good starting point for publishing and subscribing to the Service Bus to connect the dots.

Now that the Service Bus helper is there to deal with both ends of the conversation I can tie the two ends together pretty easily. The web site’s code won’t be too complicated. I’ll create a view that site users can use to input their customer data. Obviously, this is a short form for demonstration purposes, but it could be any shape or size you want (within reason, of course, but you’ve got ample room if you’re just working with serialized objects).

If I’ve got an MVC view, chances are I’ll need an MVC action method to drive that view. The code for the HomeController class is below. Note, the Index action is repeated – one to display the form to the user, the second to handle the form’s posting. The data is collected via the second Index action method, and then passed into the Service Bus.

The final piece of code to get this all working is to write the console application that runs in my enterprise environment. The code below is all that’s needed to do this; when the application starts up it subscribes to the Service Bus topic and starts listening for incoming objects. Whenever they come in, the code then makes use of the Entity Framework classes to persist the Customer instance to the SQL Server database.

Now that the code’s all written, I’ll walk you through the process of creating your Service Bus topic using the Windows Azure portal. A few configuration changes will need to be made to the web site and the on-premise console application, too, but the hard part is definitely over.

Create the Service Bus Topic

Creating a Service Bus topic using the Windows Azure portal is relatively painless. The first step is to use the New menu in the portal to create the actual Service Bus topic. The screen shot below, from the portal, demonstrates the single step I need to take to create my own namespace in the Windows Azure Service Bus.

Once I click the Create a New Topic button, the Windows Azure portal will run off and create my very own area within the Service Bus. The process won’t take long, but while the Service Bus namespace is being created, the portal will make sure I know it hasn’t forgotten about me.

After a few seconds, the namespace will be visible in the Windows Azure portal. If I select the new namespace and click the button at the bottom of the portal labeled Access Key, a dialog will open that shows me the connection string I’ll need to use to connect to the Service Bus.

I’ll copy that connection string out of the dialog. Then, I’ll paste that connection string into the appropriate place in the Web.config file of the web application. The screen shot below shows the Web.config file from the project, with the appropriate appSettings node highlighted.

A similar node also needs to be configured in the console application’s App.config file, as shown below.

In all, there are only two *.config files that need to be edited in the solution to get this working – the console application’s App.config file and the web application’s Web.config file. Both of these files are highlighted in the solution explorer view of the solution included with this blog post.

With the applications configured properly and the service bus namespace created, I can now run the application to see how things work.

Running the Code

Since I’ll be using Entity Framework to scaffold the SQL Server database on the fly, all I’ll need to do to set up my local enterprise environment is to create a new database. The screen shot below shows my new SQL database before running the console application on my machine. Note, there are no tables or objects in the database yet.

The first thing I’ll do to get running is to debug the console application in Visual Studio. I could just hit F5, but I’ll be running the web application in debug mode next. The idea here is to go ahead and fire up the console application so that it can create the database objects and prepare my enterprise for incoming messages.

The console application will open up, but will display no messages until it begins processing Customer objects that land on the Service Bus. To send it some messages, I’ll now debug the web application, while leaving the console application running locally.

When the web site fires up and opens in my web browser, I’ll be presented the simple form used to collect customer data. If I fill out that form and click the Save button, the data will be sent into the Service Bus.

By leaving the console application running as I submit the form, I can see the data coming into my enterprise environment.

Going back into SQL Server Management Studio and refreshing the list of tables I can see that the Entity Framework migrations ran perfectly, and created the table into which the data will be saved. If I select the data out of that table using a SQL query, I can verify that indeed, the data was persisted into my on-premises database.

At this point, I’ve successfully pushed data from my Windows Azure Web Site up into the Service Bus, and then back down again into my local enterprise database.

Summary

One of the big questions I’ve gotten from the community since the introduction of Windows Azure Web Sites to the Windows Azure platform is on how to connect these sites to an enterprise environment. Many customers aren’t ready to move their whole enterprise into Windows Azure, but they want to take some steps towards getting their applications into the cloud. This sort of hybrid cloud setup is one that’s perfect for Service Bus. As you’ve seen in this demonstration, the process of connecting a Windows Azure Web Site to your on-premises enterprise isn’t difficult, and it allows you the option of moving individual pieces as you’re ready. Getting started is easy, cheap, and will allow for infinite scaling opportunities. Find out how easy Windows Azure can be for Web Sites, mobile applications, or hybrid situations such as this by getting a free trial account today. I’m sure you’ll see that pretty much anything’s possible with Windows Azure.

Managing Multiple Windows Azure Web Site Environments using Visual Studio Publishing Profiles

Fri, 23 Nov 2012 07:10:36 GMT

This is the second post in the Real World Problems with Windows Azure Web Sites. The first post summarized how one can manage multiple environments (development, staging, production, etc) using a Git repository with a branching strategy. Not everyone wants to use Git, and most would prefer to stay in their favorite IDE – Visual Studio 2012 – all day to do pretty much everything. My buddy Sayed Hashimi told me about Visual Studio profiles a few weeks ago and I’d been wanting to write up something on how it could work with Windows Azure Web Sites. This post follows up on the idea of managing multiple Windows Azure Web Sites, but rather than do it with Git, I’ll show you how to manage multiple sites with only Visual Studio’s awesome publishing-with-profiles features.

Set Up the Environments

The first step in the process is to have your multiple sites set up so that you have environmental isolation. In this case, I’m being thorough and requiring there are two gates prior to production release. All three of these sites are in the free zone, for this demonstration.

If this was fully realistic, the production zone would probably be at least shared or reserved, so that it had a domain name mapped to it. That’s the only site that would cost money, so the development and staging sites would have no impact on the cost I’ll incur for this setup.

Once the sites have been created I’ll go into each site’s dashboard to download the site’s publish settings profile. The publish settings files will be used from within Visual Studio to inform the IDE how to perform a web deploy up to my Windows Azure Web Site environment.

Once I’ve downloaded each of these files I’ll have them all lined up in my downloads folder. I’ll be using these files in a moment once I’ve got some code written for my web site.

Now that I’ve got all my environments set up and have the publishing settings downloaded I can get down to business and write a little code.

Setting up the Web Application Project

I know I’ll have some environmental variances in the deployment details of this web application. I’ll want to use different databases for each environment, so I’ll need to have three different connection strings each site will have to be configured to use for data persistence. There’ll be application settings and details and stuff, so the first thing I’ll do in this simple ASP.NET MVC project is to prepare the different publishing profiles and the respective configuration for those environments.

To do this, I’ll just right-click my web project and select the Publish menu item. I’m not going to publish anything just yet, but this is the super-easiest way of getting to the appropriate dialog.

When the publishing dialog opens, I’ll click the Import button to grab the first environment’s publish settings files.

I’ll grab the first publish settings file I find in my downloads folder, for the site’s development environment.

Once I click Open, the wizard will presume I’m done and advance to the next screen. I’ll click the Profile link in the navigation bar at this point one more time, to go back to the first step in the wizard.

If, at any point during this process you’re asked if you want to saved the profile, click yes.

I’ll repeat the import process for the staging and production files. The idea here is, to get all of the publish settings files imported as separate profiles for the same Visual Studio web application project. Once I’ve imported all those files I’ll click the Manage Profiles button. The dialog below should open up, which will show me all of the profiles I’ve imported.

This part isn’t a requirement for you or a recommendation, but I don’t typically need the FTP profile so I’ll go through and delete all of the *FTP profiles that were imported. Again, not a requirement, just a preference, but once I’m done with it I’ll have all the web deploy profiles left in my dialog.

I’ll just click Close now that I’ve got the profiles set up. Now that the profiles are setup they’ll be visible under the Properties/PublishProfiles project node in Visual Studio. This folder is where the XML files containing publishing details are stored.

With the profile setup complete, I’m going to go ahead and set up the configuration specifics for each environment. By right-clicking on each *.pubxml file and selecting the Add Config Transform menu item, a separate *.config will be created in the project.

Each file represents the transformations I’ll want to do as I’m deploying the web site to the individual environment sites. Once I’ve added a configuration transformation for each profile, there’ll be a few nodes under the Web.config file I’ll have the opportunity of configuring specific details for each site.

Now that I’ve got the publish profiles and their respective configuration transformation files set up for each profile, I’ll write some code to make use of an application setting so I can check to make sure the per-profile deployment does what I think it’ll do.

Now, if you’re thinking to yourself this isn’t very practical, since I couldn’t allow my developers to have the ability of deploying to production and you’re compelled to blow off the rest of this post since you feel I’ve completely jumped the shark at this point, keep on reading. I bring it back down to Earth and even talk a little release-management process later on.

Environmental Configuration via Profiles

Now I’ll go into the Web.config file and add an appSetting to the file that will reflect the message I want users to see whenever they browse to the home page. This setting will be specific per environment, so I’ll use the transformation files in a moment to make sure each environment has its very own welcome message.

This is the message that would be displayed to a user if they were to hit the home page of the site. I need to add some code to my controller and view to display this message. It isn’t very exciting code, but I’ve posted it below for reference.

First, the controller code that reads from configuration and injects the message into the view.

Then I’ll add some code to the view to display the message in the browser.

When I browse the site I’ll get the obvious result, a simple hello message rendered from the configuration file on my local machine.

I’ll go into the development configuration profile file and make a few changes – I strip out the comments and stuff I don’t need, and then I add the message appSetting variable to the file and set the transformation to perform a replace when the publish happens. This basically replaces everything in the Web.config file with everything in the Web.MySite-Dev - Web Deploy.config file that has a xdt:Transform attribute set to Replace.

I do the same thing for the staging profile’s configuration file…

… and then for the production profile’s configuration file.

With the environmentally-specific configuration attributes set up in the profile transformations and the publish profiles set up, everything should work whenever I need to do a deployment to any of the environments. Speaking of which, let’s wrap this up with a few deployments to our new environments!

Deployment

The final step will be to deploy the code for the site into each environment to make sure the profile configuration is correct. This will be easy, since I’ve already imported all of my environments’ configuration files. I’ll deploy development first by right-clicking the project and again selecting the Publish context menu item. When the publish wizard opens up I need to select the development environment’s profile from the menu.

Once the publish process completes the site will open up in my browser and I can see that the appropriate message is being displayed, indicating the configuration transformation occurred properly based on the publish profile I’d selected to deploy.

Next, I right-click the project and select Publish again, this time selecting the staging environment.

When the publish completes, the staging welcome message is displayed.

If I repeat the same steps for production, the appropriate message is displayed there, too.

In a few short steps, I’m able to set up a series of environments and publish profiles, that work together to allow me separate deployment environments, with little extra work or overhead. Since the profiles are linked to the configuration transformations explicitly, it all just works when I deploy the site.

Release Management

As promised earlier in that blockquote up there, I want to stay with the “these are real world scenarios as much as possible based on my real-world experiences and questions I’ve been asked” mantra, I feel it’s necessary to get into the idea of release management insomuch as how it’d apply here. In the previous example I was using Git branches to gate releases. In this example, I’m not using any centralized build solution, but rather assuming there’s a source control environment in between the team members – developers, testers, release management, and so on – but that the whole team just chooses to use the Web Deploy awesomesauce built into Visual Studio.

Think of a company with aggressive timelines but who still take care to gate releases but choose not (for whatever reason) to set up a centralized build system. This company still feels strongly about managing the release process and about maintaining separate chains of testing and signoff responsibility as code is moved through the environments on the way to a production release, but they love using Visual Studio and Web Deploy to get things into the environments as quickly as possible.

The diagram below demonstrates one potential release cycle that could make use of the publish profile method of gating deployments through a series of environmental gates.

Assume the team has come to a few conclusions and agreements on how their release cycle will execute.

All the team members are relatively technical and comfortable using Visual Studio with web application projects
The team uses a source control method to share source code and to distribute it internally between team members
The web application project checked into source control has with it the publish profile for deploying the site into the development Windows Azure Web Site
Testers maintain copies of the staging publish profile setting, are regarded as the owners of the staging environment, and are the only team members who can deploy code to the staging Windows Azure Web Site
Release managers maintain copies of the production publish settings files, are regarded as the owners of the production releases, and are the only team members who can deploy code to the production environment
As developers, testers, and RM’s complete their respective testing phases in the environments they own and are ready to sign off, they escalate the deployment process to the next level
Following escalation, the first general step is to test the previous environment for verification purposes, then to deploy to the next environment and to begin testing of the deployment in that environment

Luckily, this sort of situation is quite possible using publish profiles and free Windows Azure Web Sites used as environmental weigh stations on the way to be deployed to a production site that’s deployed to multiple large reserved instances (for instance).

Summary

The convenient partnership between web publishing and Windows Azure Web Sites shouldn’t be regarded as an indicator of it creating the potential for cowboy coding, but more considered a tool that when coupled with a responsible release cycle and effective deployment gating can streamline and simplify the entire SDLC when your business is web sites.

I hope this post has introduced you to a method of controlling your deployment environments, while also allowing you to do the whole thing from within Visual Studio. Later on, I’ll follow up this post with an example of doing this sort of thing using Team Foundation Services.

Hopefully, you have enough ammunition to get started with your very own Windows Azure Web Site account today, for free, and you feel confident you’ll be able to follow your very own release management process, without the process or architecture slowing you down. If you have any questions about this approach or the idea in general, feel free to use the comments form below.

Happy coding!

Multiple Environments with Windows Azure Web Sites

Wed, 21 Nov 2012 18:50:31 GMT

This is the first post in the Real World Problems with Windows Azure Web Sites blog series, as it intends to answer one of the most common questions I receive when I’m doing presentations about Windows Azure Web Sites. This situation demonstrates a typical setup, wherein a site owner has multiple environments to which they push their web site. This setup is extremely valuable for staging site releases and for delivering solid web applications or for doing A-B testing of a site’s changes. In order to make sure your changes are okay, it helps to have a staging and production environment to use to make sure things are good before one makes their changes live in a production environment. My good friend and colleague Cory Fowler blogged about continuous deployment with Windows Azure Web Sites, and my other good buddy Magnus Martensson did a great presentation at Windows AzureConf on the topic. I’ve done countless demonstrations of continuous deployment with Web Sites, but one question always comes up, that this post intends to answer.

That’s all well and good and I know I can deploy my site automatically each time I make a change, but that’s not realistic. It’s like, if I use Windows Azure Web Sites to host my site, it’ll be deployed each time I check in code – even when I didn’t want to deploy the site. How do I control what gets deployed and control the deployment and maintain quality?

That’s a great question, and it’s one that most have struggled to answer. It’s also a barrier for many who are thinking of using Windows Azure Web Sites but who don’t want to manage their site like they’re running their company out of a garage. This “happy path” deployment mantra isn’t real-world, especially for site owners who want to stage changes, test them out, and be certain their changes won’t cause any problems following a hasty deployment process.

Multiple Sites for Multiple Environments

As with any multiple-environment setup, the first thing I need to do to support having multiple environments is to create multiple sites in Windows Azure Web Sites. Using the portal, this is quite simple. The screen shot below shows you what this would look like. Note, I’ve got a “real” site, that’s my production site area, and I’ve also added a staging site to the account.

In particular, take note of how both of these sites are in the “free” tier. Let’s say you’ve got a production site in the “non-free” zone because you want to map your domain name to it, scale it up or out, or whatever else. I’ll leave my staging site in the free tier and not incur any charges on it.

Why is this important? Because I won’t need to pay anything additional for having multiple sites. Since most users won’t have the staging URL, or it won’t matter what it is since it’ll just be for testing purposes, I don’t need to map a domain name to it, scale it, or anything like that. It’s just there for whenever I need to do a deployment for testing purposes or verification purposes. This setup won’t require you to spend any more money.

Using GitHub.com for Continuous Deployment

In this example, I’ll be using GitHub.com to manage my source code. You don’t have to use GitHub.com for this, so if you’re new to Git don’t freak out, you have other options like CodePlex, BitBucket, or TFS. Heck, you could even automate an FTP deployment if you want to.

The first step in setting up GitHub.com integration with a web site is to load up the site’s dashboard and to click the Quick Link labeled “Set up Git publishing” as is illustrated in the screen shot below.

Once the repository setup completes, the portal will allow me to specify what type of Git repository I want to connect to my site. I’ll select GitHub.com from the list of options, as you’ll see below.

If this is the first time I’ve tried to connect a GitHub.com repository to a web site, I’ll be asked to allow the partnership to take place.

By clicking the Allow button, I let GitHub.com know I’m okay with the partnership. The final step in tying a repository to a site is to select the repository I want to be associated with the site, which you’ll see in the screen shot below.

I’ll repeat this process for the staging site, too, and I’ll associate it with the exact same repository. This is important, as I’ll be pushing code to one repository and wanting the deployment to happen according to which site I want to publish.

Two Sites, One Repository? Really?

Sounds weird, right? I’ve got two sites set up now, one for the production site, the other for the staging site, but I’ve associated both sites with the same repository. Seems a little weird, as each time I push code to the repository, I’ll be deploying both sites automatically. The good part is, there’s this awesome feature in Git that I can use to make sure I’m deploying to the right spot. That feature is called branching, and if you’re acquainted with any modern source control management product, you probably already know about branching. You probably already use branching to control deviations in your code base, or to fix features and bugs. With Windows Azure Web Sites’ support for branches, you can use them for environmentally-specific deployment practices too. The best part is, it’s quite easy to set up, and that’s just what I’ll show you next.

Configuring Branch Associations

Before I write any code, I’ll need to set up the branch “stuff” using the portal. To do this, I’ll go into my production site’s dashboard and click the Configure link in the navigation bar. Scrolling down about half way, I can see that the production site’s set up to use the master branch. The master branch is the default branch for any Windows Azure Web Site, but as you’ll see here, the portal gives me the ability to change the branch associated with an individual web site.

Now, I’ll go into my staging site and I’ll set the associated branch for that site to staging. This means that, each time I check code into the master branch, it’ll be deployed to the production site, and each time I check code into the staging branch, it’ll be deployed to the staging site.

With the setup out of the way I’ll be able to write some code that’ll be deployed automatically when I need it to be deployed, and to the right place.

Code, Commit, Deploy

Now that my sites are all configured and pointing to the right branches I’ll need to set up local Git repository, write some code, and check that code into the repository. Once that’s all done I’ll create a second branch called staging that I’ll use to push code to my staging site.

The first step is, obviously, to write some code. I won’t do much complicated stuff for this demo. Instead I’ll just make a simple MVC site with one view. In this view I’ll just put a simple message indicating the site to which I intend to deploy the code.

Now, I’ll open up Powershell to do my Git stuff. As Phill Haack points out in this epic blog post on the topic, posh-git is a great little tool if you’re a Powershell fan who also uses Git as a source control method.

I’ll initialize my Git repository using git init, then I’ll tell the Git repository where to push the code whenever I do a commit using the git remote add origin [URL] command. Finally, I’ll use the git add and git commit commands to push all of my changes into my local repository. All of the files in this changeset will scroll up the screen, and when the commit completes I’ll push the changes back up to GitHub.com, to the master branch, using the git push origin [branch] command.

Once the commit finishes and the code is pushed up to GitHub.com, Windows Azure Web Sites will see the commit and perform a deployment. If you’re watching the portal when you do the commit you’ll see the deployment take place [almost magically].

If I click the Browse button at the bottom of the portal the site will open up in a browser and I can verify that the change I just committed was deployed. So far, so good.

Setting Up the Staging Branch

Now that the production site’s been deployed I need to set up the staging environment. To do this, I’ll go back into my favorite Git client, Powershell, and I’ll create a new branch using the git checkout –b [branch] command. This will create a new branch in my local Git repository. Then, it’ll switch to that repository and make it active. If I type git branch in Powershell, it’ll show me all the branches in my local repository. The green line indicates the branch I’m currently working on.

Now that the branch has been created, I’ll make some small change in the code of the site. Once this change has been made I’ll be pushing it up to GitHub.com again, but this time I’ll be pushing it into the newly-created staging branch, so the production branch code in the master branch is safe and sound.

Switching back to Powershell, I’ll commit the changes to the staging branch in my local repository. Then, I’ll push that code back up to GitHub.com, this time specifying the staging branch in my git push command.

This time, I’ll watch the staging site in the portal. As soon as the publish is complete, the portal will reflect that a deployment is taking place.

Once the deployment completes, I can check the changes by clicking the Browse button at the bottom of the portal page. When the staging site opens up, I can see that the changes were pushed to the site successfully.

If go back to the production site, it still says Production on it. Pushing to the staging site didn’t affect my production site, and vice-versa. I’ve got dual-environment deployments, based on source code branches, and I’m able to test things out in one environment before pushing those changes to production. Everyone wins!

Local Git Branch Niftiness

One of the neat things about using Git branches (at least it was nifty to me), is that all the code for all the branches is stored in your local repository. Switching between branches automatically results in the source code being restored on your local drive. The whole thing happens automatically. Demonstrating how this works is as easy as switching branches while you have a source code file open in Visual Studio.

So let’s say I still have the staging branch set as my working branch and I’ve got the source code open up in Visual Studio. If I got to my Powershell client again and switch the branch using the git checkout [branch] command, Git changes the branch on the fly for me. In so doing, all the files in the local directory are replaced with the files from the newly-selected branch.

The moment I switch back to Visual Studio, it warns me that the file has changed on disk and asks me if I’d like to reload it.

If I click the Yes button and then look at my file, I’ll see that the file has been changed to the one resident in the new branch.

In this way, Git keeps all the branches of my source code in my local repository, so I can make changes to the branches as needed and then commit those changes back to the local repository. Once I’m ready, I can push those files back up to the origin (in this case, GitHub.com), and everything’s cool.

Summary

Web site environments are a real-world method of controlling, gating, and reverting deployments. Using multiple environments, development shops can make sure their changes took place properly before crashing a production site with poor changes. Windows Azure Web Sites is a real-world web hosting platform that can be used to solve real web site challenges. With a little thought and planning, it’s easy to use Windows Azure Web Sites to host multiple versions of a web site. Testing can happen live, without affecting production deployments. I hope this post has introduced a good method of achieving separate site environments, and that you can see yet another way Windows Azure Web Sites can help you get your site up and running, keep it continually deployed, and reduce your concerns over the nature of continuously deploying to a production web site environment using simple tricks like Git branches.

AzureConf Reflections

Wed, 21 Nov 2012 07:53:43 GMT

I had a great opportunity last week to work with some Windows Azure community leaders in Redmond at Channel 9 studios to put on Windows AzureConf. These community members travelled from all over the world to put on some great presentations. This post summarizes the event and thanks some folks for all their hard work. The event was a great day, and really gave me an opportunity to do my favorite thing in this role – work with the community to create awesome content for the community.

Thanks for the Inspiration

My good friend and teammate Jon Galloway inspired a lot of us with what he made possible through aspConf, so we followed he and his team’s been able to do with that event and drew inspiration from the idea during the planning of AzureConf. We had a smaller-sized goal in mind for the first (and hopefully not last) AzureConf than what Jon was able to achieve with aspConf, especially this past year, which was a huge event featuring tons of sessions and presenters.

aspConf was, absolutely, the inspiration behind AzureConf, so when I brought the idea to Jon he had tons of great experience from which I learn, and as always, Jon was happy and eager to give me some advice. I’d like to thank him, Eric, and Javier, and all the other aspConf presenters and organizers for their hard work. Your output was an inspiration to me and the team of people who put on AzureConf, and we thank you for setting an amazing standard to work towards and for all the wisdom and advice you provided during AzureConf’s planning.

Thanks for the Support

Scott Guthrie, Channel 9, and countless other people at Microsoft and in the community made AzureConf possible and successful. All along the way, various folks helped in so many ways. Mark Brown gathered videos for filler breaks, Cory Fowler and Chris Risner managed the question/answer features, Hanselman mentioned the event at //build/, James Conard believed I would be able to pull it off and had faith in me to do so, Scott Cate helped with the facilitation, the community blogged and tweeted about the event to build steam...

The list goes on and on and on and I could never name anyone, but you get the point. The team of people who worked to put on AzureConf and make it a success were absolutely vital to it happening. No one who works for Microsoft or who does business with Microsoft is unbusy, so I want to let everyone know who helped, how much I appreciate your doing so. Time is something none of us seem to have any more, but so many people stepped up in so many ways to make the event a success.

Whether you spoke, tweeted, forward a meeting invitation, or mentioned it in your own speaking engagements to help drum up support for the event, your contribution to the event is something that was absolutely vital to the event, so thank you for your time and your help.

Thanks for the Effort

Giving our community members a stage to do what they do for a larger audience than normal was the driving force for me behind AzureConf. They work so, so, so hard volunteering to keep the Windows Azure brand’s growth continuing, and we wanted to give them one of those bucket list moments with Windows AzureConf. Anyone who loves Microsoft’s development world probably loves or at least has some interest in what happens on Channel 9, so we figured the best way to thank someone for all the work they do evangelizing Windows Azure would be…

Give them free reign in Channel 9 for a day to evangelize about Windows Azure! Brilliant, right?

We thought so, and brilliance is a good word for what all these guys did. You can see for yourself on the Windows AzureConf Channel 9 event page, where we have all the content* posted for your on-demand viewing pleasure.

For now, I’d like to thank all the amazing speakers who took time out of their work schedules (many lost billable time, too), sacrificed time with their families, and travelled great distances for 1-2 hours in the studio to talk about one of the things they love using – Windows Azure.

You guys totally rocked out all day, you were a joy to work with, and you made the event a success with your enthusiasm and willingness to deliver such awesome sessions. Thanks so, so much for all you put into your presentations, and for coming all the way to Redmond to deliver them in person.

* Johnny’s talk was eaten by the hungry honey badgers that roam the Channel 9 studios hunting for prey. We’re going to have him back in the studio on his next trip to Redmond to re-record the session. When it’s done it’ll be posted on the event page.

Thanks to the Community

Finally, this post wouldn’t be complete without thanking you guys for watching, tweeting, and lifting us up. The event trended on Twitter for a little while, got some amazing feedback, and overall seemed to have a great, positive impact in the community. I’m so proud of you guys for helping us spread the word about the event. It made it all worthwhile, and sure does bring a smile to my face to have had such great support from the community.

Introducing Windows AzureConf

Thu, 01 Nov 2012 14:59:00 GMT

The best part of my job as a Technical Evangelist is working with the community members. Hands down, this is the best way for any evangelist to learn about their product and how it is being used in the wild. The Windows Azure community is a great one, with huge technical depth and experience, and it is my honor to be working on a great community event that highlights what real developers are doing with Windows Azure. I’d like to introduce you to Windows AzureConf, the first all-community Windows Azure event executed by the community at Channel 9 Studios.

What is AzureConf?

On November 14, 2012, Microsoft will be hosting Windows AzureConf, a free event for the Windows Azure community. This event will feature a keynote presentation by Scott Guthrie, along with numerous sessions executed by Windows Azure community members. Streamed live for an online audience on Channel 9, the event will allow you to see how developers just like you are using Windows Azure to develop applications on the best cloud platform in the industry. Community members from all over the world will join Scott in the Channel 9 studios to present their own ideas, innovations inventions and experiences. These presentations will provide you the opportunity to see how your peers in the community are doing great things using Windows Azure offerings like Mobile Services, Web Sites, Service Bus, virtual machines, and more. Whether you’re just learning Windows Azure or you’ve already achieved success on the platform, you won’t want to miss this special event. For more information on Windows AzureConf or to register for the event, please visit http://www.windowsazureconf.net.

Some great community members will be participating in the event, and they’ve got some mind-blowing sessions lined up that demonstrate everything from attaching the Netduino microcontroller to Windows Azure, to writing your very own Windows 8 application that uses Windows Azure as a data-storage layer or middle tier. Here’s a run-down of the speakers who will be presenting and the topics you’ll get to see at this event.

Build Speedy Azure Applications with HTML 5 and Web Sockets Today
Rick Garibay

In the world of HTML5 development, interoperability is king. Unfortunately, sometimes interoperability can be at the expense of performance. With support for bi-directional, full-duplex messaging simply out of the reach of the HTTP protocol, messaging support in HTML5 can be severely limited. Fortunately, standards groups including the W3C and IETF are hard at work on a standard specification called WebSockets which aims to bring these much needed capabilities to the masses.

Come learn how Microsoft is leading the innovation behind this exciting capability with an interactive presentation covering Microsoft’s implementation of the HTML5 WebSockets API and how you can provide the performance and functionality required to deliver great user experiences with HTML5, ASP.NET, WCF, Node.js and Windows Azure today.

Building Cross-Platform Media Apps using Windows Azure Media Services
Eric Boyd

Applications with rich video and audio are increasing popular, but preparing and delivering this media to consumers has historically required lots of costly infrastructure and setup. Windows Azure Media Services enables you to outsource your media management to the cloud to let you focus on developing your applications instead of this costly infrastructure. In this session, Eric will walk through building a cross-platform HTML5 media application for the web, Windows 8 and other devices you may use day-to-day.

Building Elastic, Autoscalable Solutions with Windows Azure
Mihai Tataran

In this session you will learn how to implement true elasticity for your Windows Azure solutions. You will see how to automate the scaling of your Worker/Web Role instances depending on predictable usage patterns. Whether you expect high load during business hours and low load during the nights, or have different resource allocation needs, this session on using the Enterprise Library Integration Pack for Windows Azure's Autoscale Application Block will show you how your Windows Azure solutions can achieve higher levels of elasticity.

Continuous Delivery Zen with Windows Azure
Magnus Martensson

Ever felt that you spend more time packing deployments, configuring test environments and deploying the latest build in order to please the testers than you spend writing actual code? Had your flow interrupted by the boss wanting a demo environment set up for a customer demo? Fortunately built into the Windows Azure Platform there is great support for Continuous Delivery of the greatness that you just built. With little work, you can set up automated builds, test runs and deployments so that you may focus on what’s important - your next delivery. If you want full control of your whole process you can use third-party continuous integration options with Windows VMs. Through Power Shell there is support for any scenario. For those who are really brave you can even set up push from your development box via Git to live production environments with no downtime! In this word of high demand for delivery and agility everything that can be automated must be automated. Automate, automate, automate!

Elevating Windows Azure Deployments
Michael Collier

One of the core tenet for working with cloud services is automation. When it comes to deploying our new cloud solutions, we want to automate the process as much as possible. Though Visual Studio and the Windows Azure online management portal make deployments pretty easy, they don't automate the deployment process. This session will demonstrate techniques like PowerShell, TFS, and more, for handling the automated updating of cloud services. Coming away from this session you'll have a solid understanding, backed by practical real-world examples, of handling service deployments and updates.

How Mural.ly Achieves Great Performance for a Low Cost
Johnny Halife

Come on and see how we are serving 80K request per hour per server on only two small instances. We'll share our secrets on how Mural.ly uses a canonical operation model that converts into MongoDB statements that it uses to keep the murals updated while sorting out concurrency issues. Throughout the sessions we'll show the different patterns that we've applied to achieve this and we'll share all our secrets on how to optimize for performance on the client/server interaction. By the end of the session you will understand how we built mural.ly from Client/Server/DB I/O interaction, and which tools and metrics, you can use to understand what's going on.

JavaScript, Meet Cloud: Node.js on Windows Azure
Sasha Goldshtein

Node.js is an incredibly popular open-source framework for writing event-based server applications in JavaScript. With hundreds of modules and vibrant ecosystem, Node.js is quickly catching up to other server-based frameworks, and makes it extremely easy to deploy Web applications. The June 2012 refresh introduces Node.js support on Windows Azure. In this talk we'll build a Node.js application from scratch and deploy it to Windows Azure in a matter of seconds. We'll use Node, express, nstore, SQL Azure, MongoDB, and might even see a glimpse of integration with Windows Azure Mobile Services.

Solving Security and Compliance Challenges with Hybrid Clouds
Eric Boyd

When considering public clouds, many industries and companies have concerns about security, intellectual property and regulatory compliance challenges. The good news is a hybrid cloud can often solve these challenges. In this session, Eric D. Boyd will teach you how to use Windows Azure and still protect sensitive information and achieve regulatory and compliance mandates, like PCI compliance, by combining on-premise data centers and private clouds with the Windows Azure public cloud. There are a number of ways to achieve this using messaging and networking technologies and during this presentation Eric will walk through the options and provide you with guidance on when to choose each.

Windows Azure + Twilio == A Happy Tale to Tell
Panagiotis Kefalidis

Taking advantage of Twilio’s awesomeness and Windows Azure’s scalability, we decided to build a phone and SMS center in the cloud. It was finished with some salt from ASP.NET MVC Web API and bonded with SignalR and knockout.js. The end result was tasty and I’m here to share the tale and the recipe of creating a highly scalable phone and SMS Solution using only but cloud services.

Windows Azure and Embedded Devices
Andy Cross

This talk will demonstrate the Internet of Things with Windows Azure. Using embedded devices that interact with Windows Azure cloud technologies, the Internet of Things ideology is enabled with scalable and resilient cloud systems that imbue the resource constrained devices with elastic, on-demand additional computing power that allows any network connected device to achieve amazing computational feats. The talk features three main device/cloud interactions: persisting unbounded data from sensors, communicating through resilient channels and interacting directly with the Windows Azure cloud to provision and control cloud based infrastructure.

Windows Azure Mobile Services - Backend for Your Windows 8, iOS, and Android Apps
Sasha Goldshtein

Mobile app developers don't need to care about servers and clouds, push notification services and databases. Windows Azure Mobile Services is a cloud-based offering that provides a complete backend for mobile apps including data access and push notifications, enabling you to focus on the mobile app infrastructure and code and forget about the server management intricacies. In this talk we'll build a backend for a Windows 8 app, an iOS app, and an Android app -- all accessing the same data store and server-side triggers.

Windows Azure Services Throttling and Fault Handling
Mihai Tataran

In this session you will understand how Windows Azure components being exposed as services from a multi-tenant environment can throttle or generate transient faults because of heavy loads on the resources in Microsoft’s datacenters, or because of networking problems. Then you will find out how to deal with those situations using Transient Fault Handling Application Block, part of Enterprise Library Integration Pack for Windows Azure.

Real Windows Azure Solutions, by Real Windows Azure Users

If you’re wondering how you can roll Windows Azure into your own enterprise, or if you’re a startup wondering how it can help you bootstrap your young business, Windows AzureConf is for you. You’ll see how other community members are making use of Windows Azure to be more successful than ever, and how they’re solving real-world problems by using cloud computing.

Build a Location API Using Entity Framework Spatial and Web API, on Windows Azure Web Sites

Tue, 30 Oct 2012 05:32:29 GMT

As announced by Scott Guthrie recently, Windows Azure Web Sites now supports the .NET Framework 4.5. Some awesome ASP.NET features are now available to web developers who want to host their ASP.NET applications on Windows Azure following the web sites offering getting support for .NET 4.5. One feature I’m especially excited about is Entity Framework Spatial support. Only available in .NET 4.5, EF Spatial is something that gives developers who want to build location-aware applications the ability to easily save and retrieve location data without having to invent crazy solutions using SQL code. I’ve implemented the Haversine formula using a SQL stored procedure in the past, and I can speak from experience when I say that EF Spatial is about 10,000 times easier and more logical. Don’t take my word for it, though. Take a look at the sample code I’ll show you in this blog post, which demonstrates how you can develop a location-aware API using ASP.NET Web API, EF Spatial, and host the whole thing on Windows Azure Web Sites.

Creating the Site in Windows Azure

Before diving into code I’ll go out to the Windows Azure portal and create a new web site. For this API example, I create a site with a database, as I’ll want to store the data in a Windows Azure SQL Database. The screen shot below shows the first step of creating a new site. By simply selecting the new web site option, then selecting “with database,” I’m going to be walked through the process of creating both assets in Windows Azure in a moment.

The first thing Windows Azure will need to know is the URL I’ll want associated with my site. The free Windows Azure Web Sites offer defaults to [yoursitename].azurewebsites.net, so this first step allows me to define the URL prefix associated with my site.

Simultaneously, this first step gives me the opportunity to define the name of the connection string I’ll expect to use in my Web.config file later, that will connect the site to the Windows Azure SQL Database I’ll create in a moment.

The last steps in the site creation process will collect the username and SQL Server information from you. In this example, I’m going to create a new database and a new SQL Server in the Windows Azure cloud. However, you can select a pre-existing SQL Server if you’d prefer during your own setup process.

I specifically unchecked the “Configure Advanced Database Settings” checkbox, as there’s not much I’ll need to do to the database in the portal. As you’ll see in a moment, I’ll be doing all my database “stuff” using EF’s Migrations features.

Once I’ve entered the username I’d like to use, the password, and selected (or created) a SQL server, I click the check button to create the site and the SQL database. In just a few seconds, both are created in Windows Azure, and I can get started with the fun stuff – the c0d3z!

Preparing for Deployment

Just so I have a method of deploying the site once I finish the code, I’ll select the new site from the Windows Azure portal by clicking on it’s name once the site-creation process completes.

The site’s dashboard will open up in the browser. If I scroll down, the Quick Glance links are visible on the right side of the dashboard page. Clicking the link labeled Download Publish Profile will do just that – download a publish settings file, which contains some XML defining how Visual Studio or WebMatrix 2 (or the Web Deploy command line) should upload the files to the server. Also contained within the publish settings file is the metadata specific to the database I created for this site.

As you’ll see in a moment when I start the deployment process, everything I need to know about deploying a site and a database backing that site is outlined in the publish settings file. When I perform the deployment from within Visual Studio 2012, I’ll be given the option of using Entity Framework Migrations to populate the database live in Windows Azure. Not only will the site files be published, the database will be created, too. All of this is possible via the publish settings file’s metadata.

Building the API in Visual Studio 2012

The code for the location API will be relatively simple to build (thanks to the Entity Framework, ASP.NET, and Visual Studio teams). The first step is to create a new ASP.NET MVC project using Visual Studio 2012, as is shown below. If you’d rather just grab the code than walk through the coding process, I’ve created a public GitHub.com repository for the Spatial Demo solution, so clone it from there if you’d rather view the completed source code rather than create it from scratch.

Note that I’m selecting the .NET Framework 4.5 in this dialog. Previous to the 4.5 support in Windows Azure Web Sites, this would always need to be set at 4.0 or my deployment would fail. As well, I would have had compilation issues for anything relating to Entity Framework Spatial, as those libraries and namespaces are also only available under .NET 4.5. Now, I can select the 4.5 Framework, satisfy everyone, and keep on trucking.

In the second step of the new MVC project process I’ll select Web API, since my main focus in this application is to create a location-aware API that can be used by multiple clients.

By default, the project template comes with a sample controller to demonstrate how to create Web API controllers, called ValuesController.cs. Nothing against that file, but I’ll delete it right away, since I’ll be adding my own functionality to this project.

Domain Entities

The first classes I’ll add to this project will represent the entity domains pertinent to the project’s goals. The first of these model classes is the LocationEntity class. This class will be used in my Entity Framework layer to represent individual records in the database that are associated with locations on a map. The LocationEntity class is quite simple, and is shown in the gist below.

Some of the metadata associated with a DbGeography object isn’t easily or predictably serialized, so to minimize variableness (okay, I’m a control freak when it comes to serialization) I’ve also created a class to represent a Location object on the wire. This class, the Location class, is visible in the following gist. Take note, though, it’s not that much different from the typical LocationEntity class aside from one thing. I’m adding the explicit Latitude and Longitude properties to this class. DbGeography instances offer a good deal more functionality, but I won’t need those in this particular API example. Since all I need is latitude and longitude in the API side, I’ll just work up some code in the API controller I’ll create later to convert the entity class to the API class.

Essentially, I’ve created a data transfer object and a view model object. Nothing really new here aside from the Entity Framework Spatial additions of functionality from what I’ve done in previous API implementations which required the database entity be loosely coupled away from the class the API or GUI will use to display (or transmit) the data.

Data Context, Configuring Migrations, and Database Seeding

Now that the models are complete I need to work in the Entity Framework “plumbing” that gives the controller access to the database via EF’s magic. The first step in this process is to work up the Data Context class that provides the abstraction layer between the entity models and the database layer. The data context class, shown below, is quite simple, as I’ve really only got a single entity in this example implementation.

Take note of the constructor, which is overridden from the base’s constructor. This requires me to make a change in the web.config file created by the project template. By default, the web.config file is generated with a single connection string, the name of which is DefaultConnection. I need to either create a secondary connection string with the right name, change the default one (which I’ve done in this example), or use Visual Studio’s MVC-generation tools to create an EF-infused controller, which will add a new connection string to the web.config automatically. Since I’m coding up this data context class manually, I just need to go into the Web.config and change the DefaultConnection connection string’s name attribute to match the one I’ve added in this constructor override, SpatialDemoConnectionString. Once that’s done, this EF data context class will use the connection string identified in the configuration file with that name.

During deployment, this becomes a very nifty facet of developing ASP.NET sites that are deployed to Windows Azure Web Sites using the Visual Studio 2012 publishing functionality. We’ll get to that in a moment, though…

EF has this awesome feature called Migrations that gives EF the ability of setting up and/or tearing down database schema objects, like tables and columns and all indexes (oh my!). So the next step for me during this development cycle is to set up the EF Migrations for this project. Rowan Miller does a great job of describing how EF Migrations work in this Web Camps TV episode, and Robert Green’s Visual Studio Toolbox show has a ton of great content on EF, too, so check out those resources for more information on EF Migrations’ awesomeness. The general idea behind Migrations, though, is simple – it’s a way of allowing EF to scaffold database components up and down, so I won’t have to do those items using SQL code.

What’s even better than the fact the EF has Migrations is that I don’t need to memorize how to do it because the NuGet/PowerShell/Visual Studio gods have made that pretty easy for me. To turn Migrations on for my project, which contains a class that derives from EF’s data context class (the one I just finished creating in the previous step), I simply need to type the command enable-migrations into the NuGet package management console window.

Once I enable migrations, a new class will be added to my project. This class will be added to a new Migrations folder, and is usually called Configuration.cs. Within that file is contained a constructor and a method I can implement however I want called – appropriately – Seed. In this particular use-case, I enable automatic migrations and add some seed data to the database.

Enabling automatic migrations basically assumes any changes I make will automatically be reflected in the database later on (again, this is super-nifty once we do the deployment, so stay tuned!).

Quick background on what types of locations we’ll be saving… My wife and I moved from the Southeast US to the Pacific Northwest region recently. Much to our chagrin, there are far fewer places to pick up great chicken wings than there were in the Southeast. So, I decided I needed to use our every-Sunday-during-football snack of chicken wings as a good use-case for a location-based app. What a better example than to give you a list of good chicken wing restaurants listed in order of proximity? Anyway, that’s the inspiration for the demo. Dietary recommendation is not implied, BTW.

The API Controller Class

With all the EF plumbing and domain models complete, the last step in the API layer is to create the API controller itself. I simply add a new Web API controller to the Controllers folder, and change the code to make use of the plumbing work I’ve completed up to now. The dialog below shows the first step, when I create a new LocationController Web API controller.

This controller has one method, that takes the latitude and longitude from a client. Those values are then used in conjunction with EF Spatial’s DbGeography.Distance method to sort the records from closest in proximity, then the first five records are returned. The result of this call is that the closest five locations are returned with a client provides its latitude and longitude coordinates to the API method. The Distance method is used again to determine how far away each location is from the provided coordinates. The results are then returned using the API-specific class rather than the EF-specific class (thereby separating the two layers and easing some of the potential serialization issues that could arise), and the whole output is formatted to either XML or JSON and sent down the wire via HTTP.

At this point, the API is complete and can be deployed to Windows Azure directly from within Visual Studio 2012 using the great publishing features created by the Visual Studio publishing team (my buddy Sayed Hashimi loves to talk about this stuff, so ping him on Twitter if you have any questions or suggestions on this awesome feature-set).

Calling the Location API using an HTML 5 Client

In order to make this a more comprehensive sample, I’ve added some HTML 5 client code and Knockout.js-infused JavaScript code to the Home/Index.cshtml view that gets created by default with the ASP.NET MVC project template. This code makes use of the HTML 5 geospatial capabilities to read the user’s current position. The latitude and longitude are then used to call directly the location API, and the results are rendered in the HTML client using a basic table layout.

The final step is to deploy the whole thing up to Windows Azure Web Sites. This is something I wasn’t able to do until last week, so I’m super-stoked to be able to do it now and to share it with you on a demo site, the URL of which I’ll hand out at the end of this post.

One Last NuGet to Include

Entity Framework Spatial has some new data types that add support for things like… well... latitude and longitude, in this particular case. By default, these types aren’t installed into a Windows Azure instance, as they’re part of the database SDK. Most times, those assemblies aren’t needed on a web server, so by default you won’t have them when you deploy. To work around this problem and to make Entity Framework Spatial work on the first try following your deployment to Windows Azure, install the Microsoft.SqlServer.Types NuGet package into your project by typing install-package Microsoft.SqlServer.Types in the Package Manager Console or by manually finding the package in the “Manage NuGet References” dialog.

Thanks to Scott Hunter for this extremely valuable piece of information, which I lacked the first time I tried to do this. This solution was so obvious I hid in my car with embarrassment after realizing how simple it was and that I even had to ask. NuGet, again, to the rescue!

Once this package is installed, deploying the project to Windows Azure will trigger automatic retrieval of that package, and the support for the location data types in SQL Server will be added to your site.

Publishing from Visual Studio 2012 is a Breeze

You’ve probably seen a ton of demonstrations on how to do deployment from within Visual Studio 2012, but it never ceases to amaze me just how quick and easy the team has made it to deploy sites – with databases – directly up to Windows Azure in so few, simple steps. To deploy to a site from within Visual Studio 2012, I just right-click the site and select – get this – Publish. The first dialog that opens gives me the option to import a publish settings file, which I downloaded earlier just after having created the site in the Windows Azure portal.

Once the file is imported, I’m shown the details so I have the chance to verify everything is correct, which I’ve never seen it not be, quite frankly. I just click Next here to move on.

This next step is where all the magic happens that I’ve been promising you’d see. This screen, specifically the last checkbox (highlighted for enthusiasm), points to the database I created earlier in the first step when I initially created the “site with database” in the Windows Azure portal. If I check that box, when I deploy the web site, the database schema will be automatically created for me, and the seed data will be inserted and be there when the first request to the site is made. All that, just by publishing the site!

Can you imagine anything more convenient? I mean seriously. I publish my site and the database is automatically created, seeded, and everything wired up for me using Entity Framework, with a minimal amount of code. Pretty much magic, right?

Have at it!

Now that the .NET 4.5 Framework is supported by Windows Azure Web Sites, you can make use of these and other new features, many of which are discussed or demonstrated on at www.asp.net’s page set aside just on the topic of ASP.NET 4.5 awesomeness. If you want to get started building your own location API’s built on top of Entity Framework Spatial, grab your very own Windows Azure account here, that offers all kinds of awesomeness for free. You can take the sample code for this blog, or copy the gists and tweak them however you want.

Happy Coding!

Gallery Server Pro and Windows Azure Web Sites

Mon, 15 Oct 2012 16:42:35 GMT

The Windows Azure Web Sites team has added another web application to the growing list of options available for pre-configured web sites and applications you can use to get your site up and running in minutes. Today’s addition is Gallery Server Pro, a web-based tool for managing your image or video library. This post will walk you through the process of getting Gallery Server Pro running in Windows Azure Web Sites, so if you have a huge collection of images you’d like to post online, you won’t want to miss this post.

The Gallery

Windows Azure Web Sites makes it easy to get started with a new web site, and you can’t beat the price and the ability to upgrade your horsepower whenever you need (or to downgrade whenever you don’t need it). The web application gallery in the Windows Azure portal adds the sugary sweet ability to get up and running with a completely-built and pre-configured application in seconds. In most cases you won’t even need to write a line of code. Think of all those hours of your life you’ve spent configuring a CMS or blogging tool to get it working on your server – the gallery provides point-and-click creation and deployment of many of these types of tools.

Below, for instance, you can see how easy it is for me to start building a brand new blog using Gallery Server Pro in Windows Azure. Just click the New button at the bottom of the portal, then select the From Gallery option, and select Gallery Server Pro from the list of applications available.

Once you select Gallery Server Pro and click the Next button, you’ll be asked to give the site a name and to provide the username and password for the administrative user.

Once the application is selected, a new site will be provisioned using the Gallery Server Pro application code. Within a minute, the application is created and your new online gallery will be ready for images.

Using Gallery Server Pro

As far as web gallery applications are concerned, Gallery Server Pro is a breeze to use. The screen shot below shows the application running on Windows Azure Web Sites. The menu system makes the process of creating and editing galleries a snap. Below, you’ll see an empty gallery in the application’s administration console.

In under 5 minutes, I was able to create a brand new online image gallery, into which I uploaded a few sample pictures. Note, I’d never used Gallery Server Pro prior to this, and it was super-simple to get up and running. I didn’t even need to read the help file for the application, the process was so lightweight and easy to use.

Whether you're just posting pictures of your family or you’re an aspiring artist or designer who wants to publish their photos and artwork online for people to see, Gallery Server Pro is a great choice. Their web site offers documentation and an extensive user guide and administration reference, and the product promises to continue adding new features and functionality. With Windows Azure Web Sites now as the easiest hosting option around for creating these types of sites and with deployment never being as easy as it is using the web sites application gallery, now is a good time to try out Gallery Server Pro for your online gallery needs.

Start Simple. Scale Up as Needed

If you haven’t tried Windows Azure yet, you can get started right now, for free, and stay free for a year if all you really need is a gallery site. In 5 minutes you’ll have your own online gallery up and running, without writing a single line of code or performing any complex configuration tasks. When you pair the ease of setup and deployment Windows Azure Web Sites and the application gallery provide with the simplicity Gallery Server Pro provide, you can’t go wrong.

BlogEngine.NET and Windows Azure Web Sites

Fri, 12 Oct 2012 07:04:23 GMT

The Windows Azure Web Sites team has been hard at work looking at various applications and working with vendors and community contributors to add some great applications to the web sites gallery. If you’re a blogger and you’d like to get started for free with a simple, yet extensible blogging tool, you might want to check this out. Starting this week you can install BlogEngine.NET into a free instance of a Windows Azure Web Site. I’ll walk you through the process in this post.

The Gallery

Windows Azure Web Sites makes it easy to get started with a new web site, and you can’t beat the price and the ability to upgrade your horsepower whenever you need (or to downgrade whenever you don’t need it). The web application gallery in the Windows Azure portal adds the sugary sweet ability to get up and running with a completely-built and pre-configured application in seconds. In most cases you won’t even need to write a line of code. Think of all those hours of your life you’ve spent configuring a CMS or blogging tool to get it working on your server – the gallery provides point-and-click creation and deployment of many of these types of tools.

Below, for instance, you can see how easy it is for me to start building a brand new blog using BlogEngine.NET in Windows Azure.

Installing BlogEngine.NET

Once you select BlogEngine.NET and click the next arrow button, the gallery installer will need to get some pretty basic information from you and provision the site. The next step in the installation process gets your site’s name, which will serve as the prefix in the [prefix].azurewebsites.net manner.

Since BlogEngine.NET’s default storage mechanism doesn’t require a database (but you can, of course, customize your installation later to use SQL if you’d like), but that’s basically the last step in the process. Two steps, and a brand new BlogEngine.NET blog will be created and deployed into Windows Azure Web Sites. Below you’ll see how the portal reflects the status of the deployment.

In a few moments, the site will be completely deployed, and by clicking on the browse button at the bottom of the portal when you’ve got your freshly-deployed blog selected…

You’ll be impressed at how easy the process is when you’re running BlogEngine.NET on Windows Azure Web Sites. In seconds, your new blog will be ready, deployed, and willing to record your every contemplation.

Using BlogEngine.NET

BlogEngine.NET is great, the administrative interface a breeze, and the whole experience painless when you install it this way. I’ve not used the product in a number of years. Though I don’t recall the installation and configuration process as a difficult one, it sure as heck wasn’t this easy the last time I installed it on a server.

The first thing you’ll want to do is to log in as admin (password by default is also admin), according to the BlogEngine.NET installation documentation, and change your password. The administration dashboard is quite simple, and blogging using the product is a breeze.

As simple as BlogEngine.NET is on the surface, it has a great community and huge list of extensions and resources available. The extensions page in the BlogEngine.NET administration console should give you an idea of what’s available for your use if you’re into the idea of customizing the functionality.

So in seconds – it literally took me less than 1 minute on the first try – you can have a brand new blog running in Windows Azure Web Sites, for free or for however much you need whenever you need it, that’s simple to use and extensible with a great plug-in model.

Start Simple. Go Big When You Need To

If you haven’t tried Windows Azure yet, you can get started right now, for free, and stay free for a year if all you really need is a BlogEngine.NET site. In 5 minutes you’ll have your own site up and running, without writing a single line of code or performing any complex configuration tasks. When you pair the ease of setup and deployment Windows Azure Web Sites and the application gallery provide with the blogging simplicity and elegance BlogEngine.NET provide, you can’t go wrong.

Eurotrip 2012

Tue, 02 Oct 2012 15:44:28 GMT

Last week I had the pleasure of attending a few community events in Europe. The trip was fantastic, with some talks to be done in front of various groups throughout Belgium and Sweden. In this post I will summarize the event, provide some links to the slides I created, and thank all the great people who made the trip one of the more memorable.

Belgium Nerd Dinner & User Group

I flew from Seattle to Belgium Sunday/Monday, and arrived to find my new friend Panagiotis awaiting my arrival at the airport. Panos is not only an amazing Windows Azure developer with skills to make even the most hardened cloud developer whimper in terror, but he’s a certifiable race car driver. The Belgium User Group is one of the most hospitable I’ve had the pleasure of knowing, and Panos is the welcoming party for their group. He picked me up, drove me to dinner, between meetings, and all the while talked Windows Azure.

Our first stop was dinner at a local brewery (yes, we did eat dinner) known throughout the region and beyond for its well-cooked meals and of course, Belgian brews. We sipped a few, talked about the upcoming conferences, and of course, discussed various things we’re all doing or wanting to do using Windows Azure and ASP.NET. Some of my favorite Tweeple (forgive me) were in attendance at the dinner and the user group meeting Tuesday night. Mike Martin and Kris van der Mast, who I need to thank for bringing me over and for putting on such a great event were there to support me at the event, as well as Kristof Rennen, Bram de Buyser, and Xavier Decoster, who I found myself talking with about MyGet throughout the remainder of the week. MyGet is an awesome service that extends the already-awesome NuGet service by adding in build functionality, private and subscription-based feeds, and all other sorts of good stuff. My chat with Xavier inspired me to really take a deeper look at MyGet throughout the week, and their level of support and commitment to helping me understand and implement as many of its features as possible is amazing.

The topic of the Belgium User Group on Tuesday night was a deep dive into Windows Azure Web Sites. I recounted some of the lessons Nir Mashkowski has taught me from hosting him on Web Camps TV, and answered quite a few questions about the Shared tier enhancements. The deck contained a few links to these shows and other resources, and as usual some of my own humor (or whatever you call it). If you’d like to peek at the deck, download it here.

Sweden .NET User Group

On Wednesday morning I flew from Belgium to Stockholm, Sweden, to give a developer-focused talk on Windows Azure Web Sites. Hosted at the gorgeous Connecta office in Stockholm, Sweden, the Sweden .NET User Group was full of programmers who are learning how to use Windows Azure Web Sites to solve their web development and hosting challenges. I was greeted by Jimmy Engstrom, who shares a hand in leading the group. Jimmy is delving into all sorts of interesting areas with embedded technology, so he and I found ourselves talking about Netduino, .NET Gadgeteer, and shared stories of our inventions and ideas with one another. The other half of probably the most adorable geek-couples I’ve met, Jessica Engstrom, was also in attendance at the event. Together they told a great story of sitting in front of their computers frantically trying to get tickets to this year’s Build conference. The Engstroms and myself, along with my new Finnish friends Karl Ots and Teemu Tapanila, talked until late in the evening after the user group about Windows Azure, Windows Phone, new hardware, and all other kinds of geekery. I’m sure Jimmy, Karl, and Teemu and I will be trading embedded-development tricks over email from now on.

The presentation went well and the participants allowed me to go a little longer in the presentation than I’d planned (thanks!). Like the Belgian User Group, this group had many questions and suggestions on how Windows Azure Web Sites could be improved and gave me some great insight into what how our community is enjoying the Web Sites offering and also gave me some ideas on how it can be an even greater platform. I showed off some interesting new features for Visual Studio 2012 web developers my good friend Sayed Hashimi is putting together, and got some great feedback for the publishing team on new feature ideas. If you’d like to grab a copy of the slides I used for the talk, you can grab them here.

CloudBurst 2012

Thursday and Friday in Stockholm would provide a great ending to an already-inspirational tour, at the CloudBurst 2012 conference. Organized by Magnus Martensson and Alan Smith and hosted at the Microsoft Sweden office in Stockholm, CloudBurst was absolutely full of amazing presentations that were streamed live by Swedish-based, Windows Azure-backed StreamShed. Alan Smith put on an amazing talk in which he used 256 cores in Windows Azure to do ray-tracing, and he tied in a Kinect device to add to the awesomeness of his demonstration. A video explaining his solution is available on Channel 9 if you’re interested in how he achieved amazing results in a multiple-instance Windows Azure Cloud Service. His talk, along with a few amazing data-centric talks by the ever-eloquent (and hilarious) Nuno Godinho, a pair of absolutely inspirational talks on enterprise architectural patterns by Charles Young, a great Service Bus presentation by Christian Weyer, and the final talk of the event by Magnus on Continuous Delivery with Windows Azure Web Sites, all demonstrated for me that the European community is pushing the envelope of what’s possible with Windows Azure. The most comical session of all was put on by my good friend Maarten Balliauw, who covered how to Brew Beer with Windows Azure. Maarten also helped me work through a few MyGet questions throughout the week and maintained the level of support I’ve already raved about. He also saved the day, as my alarm clock decided to go into “silent mode” the last day of the trip. I awoke to the sound of Maarten banging on my door saying “dude we’re having breakfast where are you?!?!?!” (Thanks, buddy!)

I had a demo explosion during my session right at the end, but the audience was gracious enough to hang out during the break between my session and the next so that I could reboot and re-run the code (I’d locked up some processes, apparently). My session outlined the development of a Cloud Service monitoring application, which was released just yesterday as the newest Windows Azure Evangelism Team code sample, known as CloudMonitR. If you’d like to grab a copy of the slides I used during the talk, you can download them here.

The enthusiasm and motivation on the part of these conference attendees to really raise the level of understanding in their communities around Windows Azure is inspiring. I engaged in quite a few conversations during the event that indicated to me just how excited everyone is around Microsoft’s new commitment to being open in the cloud computing space. These communities are genuinely appreciative of our direction with Windows Azure, Windows Phone, and so many other areas. I anticipate much more from the CloudBurst team and look forward to – hopefully – being a part of CloudBurst 2013 next year.

Summary

This trip was inspiring. I am continually motivated when I attend these community events, as I get to see how Windows Azure is being used by our creative community members. The enthusiasm these folks have for Microsoft is contagious, and my involvement with these community leaders and technologists is definitely the best part of my job. This tour, along with so many other sessions and meetings with our dedicated community members, reminds me of what’s possible when we work together to create the best products in the marketplace. It is easy to succeed when you have the best communities in the marketplace, who support us and educate us, and welcome us with such enthusiasm.

Thanks, Europe! Keep staying classy!

The CloudMonitR Sample

Mon, 01 Oct 2012 22:58:13 GMT

The next Windows Azure code sample released by the Windows Azure Evangelism Team is the CloudMonitR sample. This code sample demonstrates how Windows Azure Cloud Services can be instrumented and their performance analyzed in real time using a SignalR Hub residing in a web site hosted with Windows Azure Web Sites. Using Twitter Bootstrap and Highcharts JavaScript charting components, the web site provides a real-time view of performance counter data and trace output. This blog post will introduce the CloudMonitR sample and give you some links to obtain it.

Overview

Last week I had the pleasure of travelling to Stockholm, Sweden to speak at a great community-run conference, CloudBurst 2012 (as well as a few other events, which will be covered in a future post very very soon). I decided to release a new Windows Azure code sample at the conference, and to use the opportunity to walk through the architecture and implementation of the sample with the participants. As promised during that event, this is the blog post discussing the CloudMonitR sample, which you can obtain either as a ZIP file download from the MSDN Code Gallery or directly from its GitHub.com repository.

Below, you’ll see a screen shot of CloudMonitR in action, charting and tracing away on a running Windows Azure Worker Role.

The architecture of the CloudMonitR sample is similar to a previous sample I recently blogged about, the SiteMonitR sample. Both samples demonstrate how SignalR can be used to connect Windows Azure Cloud Services to web sites (and back again), and both sites use Twitter Bootstrap on the client to make the GUI simple to develop and customizable via CSS.

The point of CloudMonitR, however, is to allow for simplistic performance analysis of single- or multiple-instance Cloud Services. The slide below is from the CloudBurst presentation deck, and shows a very high-level overview of the architecture.

As each instance of the Worker (or Web) Role you wish to analyze comes online, it makes an outbound connection to the SignalR Hub running in a Windows Azure Web Site. Roles communicate with the Hub to send up tracing information and performance counter data to be charted using the Highcharts JavaScript API. Likewise, user interaction initiated on the Windows Azure Web Sites-hosted dashboard to do things like add additional performance counters to observe (or to delete ones no longer needed on the dashboard) is communicated back to SignalR Hub. Performance counters selected for observation are stored in a Windows Azure Table Storage table, and retrieved as the dashboard is loaded into a browser.

Available via NuGet, Too!

The CloudMonitR solution is also available as a pair of NuGet packages. The first of these packages, the simply-named CloudMonitR package, is the one you’d want to pull down to reference from a Web or Worker Role for which you need the metrics and trace reporting functionality. Referencing this package will give you everything you need to start reporting the performance counter and tracing data from within your Roles.

The CloudMonitR.Web package, on the other hand, won’t bring down a ton of binaries, but will instead provide you with the CSS, HTML, JavaScript, and a few image files required to run the CloudMonitR dashboard in any ASP.NET web site.

The SiteMonitR Sample

Mon, 27 Aug 2012 23:15:00 GMT

The newest sample from the Windows Azure Evangelism Team (WAET) is a real-time, browser-based web site monitor. The SiteMonitR front-end is blocked out and styled using Twitter Bootstrap, and Knockout.js was used to provide MVVM functionality. A cloud service pings sites on an interval (10 seconds by default, configurable in the worker’s settings) and notifies the web client of the sites’ up-or-down statuses via server-side SignalR conversations. Those conversations are then bubbled up to the browser using client-side SignalR conversations. The client also fires off SignalR calls to the cloud service to manage the storage functionality for the URL’s to be monitored. If you’ve been looking for a practical way to use SignalR with Windows Azure, this sample could shed some light on what’s possible.

Architectural Overview

The diagram below walks through the various method calls exposed by the SiteMonitR SignalR Hub. This Hub is accessed by both the HTML5 client application and by the Cloud Service’s Worker Role code. Since SignalR supports both JavaScript and Native .NET client connectivity (as well as a series of other platforms and operating systems), both ends of the application can communicate with one another in an asynchronous fashion.

Each tier makes a simple request, then some work happens. Once the work is complete, the caller can call events that are handled by the opposite end of the communication. As the Cloud Service observes sites go up and down, it sends a message to the web site via the Hub indicating the site’s status. The moment the messages are received, the Hub turns around and fires events that are handled on the HTML5 layer via the SignalR jQuery plug-in. Given the new signatures and additional methods added in SignalR 0.5.3, the functionality is not only identical in how it behaves, the syntax to make it happen in both native .NET code and JavaScript are almost identical, as well. The result is a simple GUI offering a real-time view into any number of web sites' statuses all right within a web browser. Since the GUI is written using Twitter Bootstrap and HTML5 conventions, it degrades gracefully, performing great on mobile devices.

Where You Can Get SiteMonitR

As with all the other samples released by the WAET, the SiteMonitR source code is available for download on the MSDN Code Gallery site. You can view or clone the source code in the GitHub.com repository we set up for the SiteMonitR source. Should you find any changes or improvements you’d like to see, feel free to submit a pull request, too. Finally, if you find anything wrong with the sample submit an issue via GitHub’s issue tab, and we’ll do what we can to fix the issues reported. The GitHub.com repository contains a Getting Started document that walks you through the whole process – with screen shots – of setting up the SiteMonitR live in your very own Windows Azure subscription (if you don’t have one, get a free 90-day trial here).

Demonstration Video

Finally, the video below walks you through the process of downloading, configuring, and deploying the SiteMonitR to Windows Azure. In less than 10 minutes you’ll see the entire process, have your very own web site monitoring solution running in the cloud, and you’ll be confident you’ll be the first to know when any of your sites crash since you’ll see their statuses change in real-time. If the video doesn't load properly for you, feel free to head on over to the Channel 9 post containing the video.

Updates

A few days after the SiteMonitR sample was released, Matias Wolowski added in some awesome functionality. Specifically, he added in the ability for users to add PhantomJS scripts that can be executed dynamically when sites statuses are received. Check out his fork of the SiteMonitR repository on GitHub.com. I'll be reviewing the code changes over the next few days to determine if the changes are low-impact enough that they can be pulled into the main repository, but the changes Matias made are awesome and demonstrate how any of the Windows Azure Evangelism Team's samples can be extended by the community. Great work, Matias!

Windows Azure Web Sites Log Cleaner

Thu, 09 Aug 2012 03:29:00 GMT

Windows Azure Web Sites customers who run web sites in shared instance mode have a generous amount of storage space to use for multiple web sites. The 1GB limit for free customers is more than enough to get a site up and running with lots of room left over for storage. A site’s log files contribute to the amount of space being used by a site. If a site has a lot of traffic, the log files could grow and eat into the space available for the important assets for a site – the HTML, executables, images, and other relevant assets. That’s the sole purpose for the Windows Azure Web Sites Log Cleaner, a NuGet utility you can grab and use in your site with little impact or work.

Potential Impacts of Not Backing Up Logs

Log analysis is important. It can show all sorts of things, from how much traffic you have to each section of your site, or if you’re getting strange requests that indicate some sort of intrusion. If your logs are important to you, there are some important things to remember about Windows Azure Web Sites:

Once the logs reach 35mb in size, logging will be disabled
If a site’s logging functions are toggled off, it could take a few minutes for the logging to re-activate (or deactivate). So if logging is turned off because you exceeded 35mb, then you realize it and clean out your log files, it might take a few seconds for the service to start logging again, resulting in visitors you don’t capture in your logs
If your site starts to spew unhandled exceptions, the failed request and exception logging logs will reflect extensive information about each request, on a file-per-request basis. If the log count – as in number of files – exceeds 50 for either of these types of logs, the logging service for the type of log exceeding 50 (failed request or exception logging, specifically) will be disabled.

For these reasons, it’s very helpful to set up a utility such as this to automatically backup and clean out your log files. This utility makes that a snap, and since you can fire it via the execution of a simple URL, there are countless scheduling options, which I introduce later on in this post. For now, let’s take a look at how to get started.

How to Set it Up

Given the convenient features made available via the NuGet team, the installation of this package will make a few changes to your Web.config file. An appSetting node will be added to your file, and an HTTP handler will be registered. The handler, which by default answers requests at the URL /CleanTheLogs.axd, will zip up your log files in a flattened ZIP file, then send that ZIP file into Windows Azure Blob Storage in a conveniently-named file for as long as you’ll need it and delete the files from your sites’ storage space. All you need to do is to hit the URL, and magic happens.

All you need to do is to create a storage account using the Windows Azure Web Sites portal and to put the account name and key into the your Web.config file. The NuGet package adds placeholders to the file to point out what you’ll need to add on your own. Once it’s configured, you could set up a scheduled task to hit the URL on intervals, and you back up your logs and keep your sites tidy.

Sounds too easy? If you have any issues or want a little more detailed explanation of exactly what happens, check out the video below. It’ll walk you through the whole process, from creating a site to peeking at the downloaded ZIP file.

Scheduling

There are a multitude of methods you could use to schedule the call to the URL and execute the log cleanup process. You could script a Powershell cmdlet to do it, write some C# code, or use a separate Cron Job service to run the task routinely for you. Nathan Totten wrote a great blog post on how to achieve task scheduling using a Cron Job service. Whatever your choice, one call to a URL does the entire job of saving and clearing your logs.

I can’t guide you on how often you should schedule your logs; each site is different. The guarantee is, if you put a site out there, you’ll get some traffic even if it’s only robot or search engine traffic, and with traffic comes log data. If you’re getting a lot of traffic it stands to reason you could reach the 35mb limit in very little time. With a scheduled job like the one Nathan demonstrates in his post, you could set the log backup URL to be called as often as every 10 minutes.

Summary

You’ve got a lot more room in Windows Azure Storage space than you do in your web site folders, and you can use that space to store your logs permanently without using up your web site space. Hopefully this utility will solve that problem for you. If you have any issues setting it up, submit a comment below or find me on Twitter.

Update

The Windows Azure Web Sites Log Cleaner source code has been published into a GitHub.com public repository. If you want to see how it works, or you have an interest in changing the functionality in some way, feel free to clone the source code repository.

PhluffyFotos on Windows Azure

Tue, 07 Aug 2012 22:32:12 GMT

In keeping with the Windows Azure Evangelism Team’s mission of providing samples that demonstrate how to use various aspects of the Windows Azure platform, I’d like to introduce you to the PhluffyFotos application. The idea behind PhluffyFotos is to offer an image-sharing application that allows users to upload, tag, and share images on line. The MyPictures application sample introduced you to the idea of storing images in Windows Azure Blob Storage via Web API, but PhluffyFotos takes the idea of an image-sharing application a few steps further architecturally. Take a look at this sample if you want to see how various Windows Azure components – Web Sites, Cloud Services, and Windows Azure Storage – to see how to add background processing to your web application, all hosted in the cloud.

Architecture

The PhluffyFotos application runs as a Windows Azure Web Site used to let visitors upload images. Those images and their metadata are sent over to Windows Azure for processing. The Cloud Service picks up information stored in Windows Azure Storage Queues, and processes that information so it can be stored in Windows Azure Table Storage. The image content itself, like was done in MyPictures, is stored in binary blobs using Windows Azure Blob Storage. The web site allows for multiple user profiles, which are stored in a Windows Azure SQL Database and accessed using the Universal Profile Providers, which are available via NuGet. Everything image-centric is actually stored in Windows Azure Storage, once it has been processed via the Cloud Service.

Links and Video

As with all the other Windows Azure Evangelism Team samples and demonstrations, the source code for PhluffyFotos is stored in its very own GitHub.com repository. If you notice any issues with the code, please feel free to use repository’s Issues feature to let me know what you find. Likewise, if you feel you have a change that’d improve the sample, feel free to make your own fork in which you can change the code, and submit a pull request. The sample is available on the MSDN samples site, too, so you can use that link to submit questions and to download a zip file containing the code for the sample. I’ve also published a Channel9 video that demonstrates how you can get the sample running, step-by-step.

I and the rest of the Windows Azure Evangelism Team hope you enjoy this example of what's possible with Windows Azure! Happy Coding!

Running Nancy on Windows Azure Web Sites

Thu, 26 Jul 2012 22:43:35 GMT

I’m a huge fan of finding cleaner ways to build web applications. Simplicity is a really good thing. Nancy is a simple little web framework inspired by Ruby’s Sinatra. Nancy is open source, hosted on GitHub.com, and distributed like any other awesome .NET open source library – via NuGet packages. When a coding challenge landed on my desk this week that I’ll be responsible for prototyping, Nancy seemed like a good option, so I’ve taken the time to tinker with it a little. I’ll spare you the details of the coding assignment for this post. Instead, I’ll focus on the process of getting Nancy working in your own Windows Azure Web Site.

To start with, I’ve created an empty web site using the Windows Azure portal. This site won’t use a database, so I just logged into the portal and selected New –> Web Site –> Quick Create and gave it a pretty logical name.

Once the site was finished cooking, I grab the publish profile settings from the site’s dashboard.

Getting Started with Nancy

First, I create an empty ASP.NET web application. To make sure everything’s as clean as it could be, I remove a good portion of the files and folders from the site. Since I’ll be creating the most basic level functionality in this example, I don’t need a whole lot of extraneous resources and functionality in the site. The project below shows what I have left over once I ransacked the project’s structure. Take note of the Uninstall-Package command I made in the Package Manager Console. I ran similar commands until I had as bare-bones a project structure as possible. Then I removed some stuff from the Web.config until it literally was quite minimalistic.

To run Nancy on Windows Azure Web Sites, I’ll need to install 2 packages from NuGet. The first of these is the Nancy core package. The second package I’ll need is the package that enables Nancy hosting on ASP.NET.

In my web project I create a new folder called NancyStuff and add a new class called HelloWorldModule.

This class is a very basic Nancy Module, and I learned how to create it by perusing the Nancy project’s GitHub.com Wiki. I basically want to have a route that, when called, will just say hello to the user. You don’t get much simpler than this for assigning functionality to a given route. When the user requests the /hello route using an HTTP GET request, the message Hello World is rendered to the response stream. The HelloWorldModule class will extend NancyModule. In Nancy, routes are handled by classes which inherit from NancyModule. According to the Nancy documentation, Modules are the lynchpin of any given Nancy application.

At this point, everything should work, so I’ll go ahead and deploy the web site up to Windows Azure. To do this, I select the Publish context menu item from within Visual Studio 2012.

Then, I import the publish settings file using the Import feature on the publishing dialog.

Once I find the .publishsettings file I downloaded from the Windows Azure portal and import it, I’m ready to publish. Clicking the publish button in the dialog at this point will result in the site being deployed up to my Windows Azure Web Site.

The site will open once the deployment has completed and will probably present me with a 404 error, indicating there’s no route configured to answer requests to the root of the site. Changing the URL to hit /hello will result with the module answering the request and doing what I expected it to do:

Enabling Static File Browsing

With this first module functioning properly I want to create a static file from which the Nancy module could be called using jQuery on the client. The idea is, now that I have this Nancy module working, I might want to make calls to it using some AJAX method to display the message it returns to the user. So I add a new static HTML page to my solution.

The problem here is that, since Nancy’s handing requests to my site and using the modules I create to respond to those requests, the ability to browse to static files is… well… sort of turned off. So attempts to hit a seemingly innocent-enough page results with a heinous – yet adorable in a self-loathing sort of way - response.

Thanks to the Nancy documentation, it was pretty easy to find a solution to this behavior. See, Nancy basically starts intercepting requests to my site, and it takes precedence over the default behavior of “serving up static files when they’re requested.” Nancy’s routing engine listens for requests and if one’s made to the site for which no module has been created and routed, the site has no idea how to handle the request.

To solve this problem, I need to create another class that extends the DefaultNancyBootstrapper class. This class, explained pretty thoroughly in the GitHub.com Nancy Wiki’s article on managing static content, is what I’ll need to use to instruct Nancy on how to route to individual static files. For now I’m only in need of a class to handle this one particular static file, but setting up a bootstrapper to allow static browsing in a directory is possible. Other options exist too, such as routes that use regular expressions, but that’s something I’ll look at in a later episode of this series. For now, I just want to tell Nancy to serve up the page Default.html whenever a request is made to /Default.html. I’m also enabling static file browsing out of the /scripts folder of the site. The main thing to look at here is the call to the StaticContentsConventions.Add method, into which I pass the name of the file and the route on which it should be served up.

Now, I’ll add some jQuery code to the static page that calls the HelloWorldModule and displays whatever it responds with in an HTML element on the page.

When the static file loads up in the browser, the jQuery code makes an AJAX request back to the server to the /hello route, and then drops the response right into the page. When I deploy the site again to Windows Azure Web Sites and hit the Default.html file, the behavior is just what I’d expected it would be; the page loads, then the message is obtained via AJAX and displayed.

Hopefully this introduction has demonstrated the support Windows Azure Web Sites has for Nancy. Since Nancy can be hosted under ASP.NET, and since Windows Azure Web Sites support the ASP.NET pipeline, everything works. I’ll continue to tinker with Nancy from here as I work on the coding project for which I chose it to be a puzzle piece. Hopefully during that development work I’ll learn more about Nancy, have the time to demonstrate what I learn, and ease someone’s day when they decide to move their Nancy site over to Windows Azure Web Sites.

Happy coding!