This week we released some great updates to Windows Azure that make it significantly easier to develop mobile applications that use the cloud. These new capabilities include:

• Mobile Services: Custom API support
• Mobile Services: Git Source Control support
• Mobile Services: Node.js NPM Module support
• Mobile Services: A .NET API via NuGet
• Mobile Services and Web Sites: Free 20MB SQL Database Option for Mobile Services and Web Sites
• Mobile Notification Hubs: Android Broadcast Push Notification Support

All of these improvements are now available to use immediately (note: some are still in preview).  Below are more details about them.

Mobile Services: Custom APIs, Git Source Control, and NuGet

Windows Azure Mobile Services provides the ability to easily stand up a mobile backend that can be used to support your Windows 8, Windows Phone, iOS, Android and HTML5 client applications.  Starting with the first preview we supported the ability to easily extend your data backend logic with server side scripting that executes as part of client-side CRUD operations against your cloud back data tables.

With today’s update we are extending this support even further and introducing the ability for you to also create and expose Custom APIs from your Mobile Service backend, and easily publish them to your Mobile clients without having to associate them with a data table. This capability enables a whole set of new scenarios – including the ability to work with data sources other than SQL Databases (for example: Table Services or MongoDB), broker calls to 3rd party APIs, integrate with Windows Azure Queues or Service Bus, work with custom non-JSON payloads (e.g. Windows Periodic Notifications), route client requests to services back on-premises (e.g. with the new Windows Azure BizTalk Services), or simply implement functionality that doesn’t correspond to a database operation.  The custom APIs can be written in server-side JavaScript (using Node.js) and can use Node’s NPM packages.  We will also be adding support for custom APIs written using .NET in the future as well.

Creating a Custom API

Adding a custom API to an existing Mobile Service is super easy.  Using the Windows Azure Management Portal you can now simply click the new “API” tab with your Mobile Service, and then click the “Create a Custom API” button to create a new Custom API within it:

Give the API whatever name you want to expose, and then choose the security permissions you’d like to apply to the HTTP methods you expose within it.  You can easily lock down the HTTP verbs to your Custom API to be available to anyone, only those who have a valid application key, only authenticated users, or administrators.  Mobile Services will then enforce these permissions without you having to write any code:

When you click the ok button you’ll see the new API show up in the API list.  Selecting it will enable you to edit the default script that contains some placeholder functionality:

Today’s release enables Custom APIs to be written using Node.js (we will support writing Custom APIs in .NET as well in a future release), and the Custom API programming model follows the Node.js convention for modules, which is to export functions to handle HTTP requests.

The default script above exposes functionality for an HTTP POST request. To support a GET, simply change the export statement accordingly.  Below is an example of some code for reading and returning data from Windows Azure Table Storage using the Azure Node API:

After saving the changes, you can now call this API from any Mobile Service client application (including Windows 8, Windows Phone, iOS, Android or HTML5 with CORS).

Below is the code for how you could invoke the API asynchronously from a Windows Store application using .NET and the new InvokeApiAsync method, and data-bind the results to control within your XAML:

    private async void RefreshTodoItems() {

        var results = await App.MobileService.InvokeApiAsync<List<TodoItem>>("todos", HttpMethod.Get, parameters: null);

        ListItems.ItemsSource = new ObservableCollection<TodoItem>(results);

    }   

Integrating authentication and authorization with Custom APIs is really easy with Mobile Services. Just like with data requests, custom API requests enjoy the same built-in authentication and authorization support of Mobile Services (including integration with Microsoft ID, Google, Facebook and Twitter authentication providers), and it also enables you to easily integrate your Custom API code with other Mobile Service capabilities like push notifications, logging, SQL, etc.

Check out our new tutorials to learn more about to use new Custom API support, and starting adding them to your app today.

Mobile Services: Git Source Control Support

Today’s Mobile Services update also enables source control integration with Git.  The new source control support provides a Git repository as part your Mobile Service, and it includes all of your existing Mobile Service scripts and permissions. You can clone that git repository on your local machine, make changes to any of your scripts, and then easily deploy the mobile service to production using Git. This enables a really great developer workflow that works on any developer machine (Windows, Mac and Linux).

To use the new support, navigate to the dashboard for your mobile service and select the Set up source control link:

If this is your first time enabling Git within Windows Azure, you will be prompted to enter the credentials you want to use to access the repository:

Once you configure this, you can switch to the configure tab of your Mobile Service and you will see a Git URL you can use to use your repository:

You can use this URL to clone the repository locally from your favorite command line:

> git clone https://scottgutodo.scm.azure-mobile.net/ScottGuToDo.git

Below is the directory structure of the repository:

As you can see, the repository contains a service folder with several subfolders. Custom API scripts and associated permissions appear under the api folder as .js and .json files respectively (the .json files persist a JSON representation of the security settings for your endpoints). Similarly, table scripts and table permissions appear as .js and .json files, but since table scripts are separate per CRUD operation, they follow the naming convention of <tablename>.<operationname>.js. Finally, scheduled job scripts appear in the scheduler folder, and the shared folder is provided as a convenient location for you to store code shared by multiple scripts and a few miscellaneous things such as the APNS feedback script.

Lets modify the table script todos.js file so that we have slightly better error handling when an exception occurs when we query our Table service:

todos.js

tableService.queryEntities(query, function(error, todoItems){
    if (error) {
        console.error("Error querying table: " + error);
        response.send(500);
    } else {
        response.send(200, todoItems);
    }       
});

Save these changes, and now back in the command line prompt commit the changes and push them to the Mobile Services:

> git add .

> git commit –m "better error handling in todos.js"

> git push

Once deployment of the changes is complete, they will take effect immediately, and you will also see the changes be reflected in the portal:

With the new Source Control feature, we’re making it really easy for you to edit your mobile service locally and push changes in an atomic fashion without sacrificing ease of use in the Windows Azure Portal.

Mobile Services: NPM Module Support

The new Mobile Services source control support also allows you to add any Node.js module you need in the scripts beyond the fixed set provided by Mobile Services. For example, you can easily switch to use Mongo instead of Windows Azure table in our example above. Set up Mongo DB by either purchasing a MongoLab subscription (which provides MongoDB as a Service) via the Windows Azure Store or set it up yourself on a Virtual Machine (either Windows or Linux). Then go the service folder of your local git repository and run the following command:

> npm install mongoose

This will add the Mongoose module to your Mobile Service scripts.  After that you can use and reference the Mongoose module in your custom API scripts to access your Mongo database:

var mongoose = require('mongoose');

var schema = mongoose.Schema({ text: String, completed: Boolean });

 

exports.get = function (request, response) {

    mongoose.connect('<your Mongo connection string> ');

    TodoItemModel = mongoose.model('todoitem', schema);

    TodoItemModel.find(function (err, items) {

        if (err) {

            console.log('error:' + err);

            return response.send(500);

        }

        response.send(200, items);

    });

};

Don’t forget to push your changes to your mobile service once you are done

> git add .

> git commit –m "Switched to use Mongo Labs"

> git push

Now our Mobile Service app is using Mongo DB!

Note, with today’s update usage of custom Node.js modules is limited to Custom API scripts only. We will enable it in all scripts (including data and custom CRON tasks) shortly.

New Mobile Services NuGet package, including .NET 4.5 support

A few months ago we announced a new pre-release version of the Mobile Services client SDK based on portable class libraries (PCL).

Today, we are excited to announce that this new library is now a stable .NET client SDK for mobile services and is no longer a pre-release package. Today’s update includes full support for Windows Store, Windows Phone 7.x, and .NET 4.5, which allows developers to use Mobile Services from ASP.NET or WPF applications.

You can install and use this package today via NuGet.

Mobile Services and Web Sites: Free 20MB Database for Mobile Services and Web Sites

Starting today, every customer of Windows Azure gets one Free 20MB database to use for 12 months free (for both dev/test and production) with Web Sites and Mobile Services.

When creating a Mobile Service or a Web Site, simply chose the new “Create a new Free 20MB database” option to take advantage of it:

You can use this free SQL Database together with the 10 free Web Sites and 10 free Mobile Services you get with your Windows Azure subscription, or from any other Windows Azure VM or Cloud Service.

Notification Hubs: Android Broadcast Push Notification Support

Earlier this year, we introduced a new capability in Windows Azure for sending broadcast push notifications at high scale: Notification Hubs.

In the initial preview of Notification Hubs you could use this support with both iOS and Windows devices.  Today we’re excited to announce new Notification Hubs support for sending push notifications to Android devices as well.

Push notifications are a vital component of mobile applications.  They are critical not only in consumer apps, where they are used to increase app engagement and usage, but also in enterprise apps where up-to-date information increases employee responsiveness to business events.  You can use Notification Hubs to send push notifications to devices from any type of app (a Mobile Service, Web Site, Cloud Service or Virtual Machine).

Notification Hubs provide you with the following capabilities:

• Cross-platform Push Notifications Support. Notification Hubs provide a common API to send push notifications to iOS, Android, or Windows Store at once.  Your app can send notifications in platform specific formats or in a platform-independent way. 

• Efficient Multicast. Notification Hubs are optimized to enable push notification broadcast to thousands or millions of devices with low latency.  Your server back-end can fire one message into a Notification Hub, and millions of push notifications can automatically be delivered to your users.  Devices and apps can specify a number of per-user tags when registering with a Notification Hub. These tags do not need to be pre-provisioned or disposed, and provide a very easy way to send filtered notifications to an infinite number of users/devices with a single API call.  

• Extreme Scale. Notification Hubs enable you to reach millions of devices without you having to re-architect or shard your application.  The pub/sub routing mechanism allows you to broadcast notifications in a super-efficient way.  This makes it incredibly easy to route and deliver notification messages to millions of users without having to build your own routing infrastructure.

• Usable from any Backend App. Notification Hubs can be easily integrated into any back-end server app, whether it is a Mobile Service, a Web Site, a Cloud Service or an IAAS VM.

It is easy to configure Notification Hubs to send push notifications to Android. Create a new Notification Hub within the Windows Azure Management Portal (New->App Services->Service Bus->Notification Hub):

Then register for Google Cloud Messaging using https://code.google.com/apis/console and obtain your API key, then simply paste that key on the Configure tab of your Notification Hub management page under the Google Cloud Messaging Settings:

Then just add code to the OnCreate method of your Android app’s MainActivity class to register the device with Notification Hubs:

gcm = GoogleCloudMessaging.getInstance(this);

String connectionString = "<your listen access connection string>";

hub = new NotificationHub("<your notification hub name>", connectionString, this);

String regid = gcm.register(SENDER_ID);

hub.register(regid, "myTag");

Now you can broadcast notification from your .NET backend (or Node, Java, or PHP) to any Windows Store, Android, or iOS device registered for “myTag” tag via a single API call (you can literally broadcast messages to millions of clients you have registered with just one API call):

var hubClient = NotificationHubClient.CreateClientFromConnectionString(
                  “<your connection string with full access>”,
                  "<your notification hub name>");

hubClient.SendGcmNativeNotification("{ 'data' : {'msg' : 'Hello from Windows Azure!' } }", "myTag”);

Notification Hubs provide an extremely scalable, cross-platform, push notification infrastructure that enables you to efficiently route push notification messages to millions of mobile users and devices.  It will make enabling your push notification logic significantly simpler and more scalable, and allow you to build even better apps with it.

Learn more about Notification Hubs here on MSDN .

Summary

The above features are now live and available to start using immediately (note: some of the services are still in preview).  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using them today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

Windows Azure provides a great environment for dev/test.  This is true both for scenarios where you want to dev/test in the cloud and then run the production app in the cloud, as well as for scenarios where you want to dev/test in the cloud and then run the production app using an existing on-premises Windows Server environment.

Windows Azure’s new IaaS and Virtual Networking capabilities make it really easy to enable enterprise development teams to use the cloud to do this.  Using the cloud for dev/test enables development teams to work in a flexible, agile, way without ever being bottlenecked waiting for resources from the IT department.  Development teams can instead use the cloud in a self-service way to spin up or down resources in minutes.  And then when they are ready to deploy their apps they can choose to do so using their existing on-premises servers.  This makes it really easy to start leveraging the cloud even without having to fully bet on it yet for production scenarios.

Today we are announcing a number of enhancements to Windows Azure that make it an even better environment in which to do dev/test:

• No Charge for Stopped VMs
• Pay by the Minute Billing
• MSDN Use Rights now supported on Windows Azure
• Heavily Discounted MSDN Dev/Test Rates
• MSDN Monetary Credits
• Portal Support for Better Tracking MSDN Monetary Credit Usage

Below are details on each of the above improvements.  The combination enables an amazing Dev/Test cloud solution, and an unbeatable offer for all MSDN customers.

No Charge for Stopped VMs

Prior to today, when you stopped a VM on Windows Azure we kept a reserved deployment spot for it inside one of our compute clusters, and continued to bill you for the VM compute unless you explicitly deleted the deployment.  Now, with today’s update, when you stop a VM we no longer charge you any compute time for it while it is stopped – yet we still preserve the deployment state and configuration.  This makes it incredibly easy to stop VMs when you aren’t actively using them to avoid billing charges, and then restart them when you want to use them again.

This is great for a variety of scenarios (including production app scenarios).  It is especially useful for Dev/Test scenarios, though, where you often want to cycle down environments in the evenings or on weekends if they aren’t actively being used.  Now you can do so and not incur any hourly billing fees.

Pay by the Minute Billing

Prior to today, our pricing model for compute resources on Windows Azure billed at the per-hour granularity.  This meant if you ran a VM for 6 minutes in an hour and then turned it off, we would still charge you for a full hour of usage.  Now, with today’s update, we are billing at a per-minute granularity.  So if you run a VM (or Cloud Service, or Web Site, or Mobile Service) for only 6 minutes in an hour, we now only charge you for the actual 6 minutes of compute usage (we pro-rate the hourly price – so the billed price is num_minutes * (hr rate)/60). 

This is great for a variety of scenarios (including production app scenarios).  It is especially useful for Dev/Test scenario where you are often cycling up/down resources in a very elastic way.  Now you can do so and save more money.

MSDN Use Rights now Supported on Windows Azure

Prior to today, it wasn’t (legally) possible to use the dev/test server licenses provided with MSDN subscriptions in a hosted cloud environment.  The product usage rights of the MSDN server licenses didn’t allow them to be used in either our cloud nor anyone else's cloud environment.

Today we are announcing that we are changing the MSDN use-rights so that you can now use your MSDN dev/test software licenses on Windows Azure.  This allows you to install and use your MSDN dev/test server images for SQL Server, SharePoint, BizTalk, etc at no extra charge within Windows Azure VMs.

Heavily Discounted MSDN Dev/Test Rates

In addition to extending MSDN Use-Rights to Windows Azure, we are also today announcing a fantastic new billing rate for customers who have MSDN subscriptions.  You can now spin up any number of Windows Server, SQL Server, SharePoint Server, and BizTalk Server VMs for Dev/Test scenarios using Windows Azure and pay only 6 cents/hr when running them (or if you run them less than an hour the pro-rated per-minute equivalent).

This enables you to yield massive cost savings for Dev/Test scenarios compared to any other cloud option in the market:

The above savings are available to all MSDN customers – and can applied to any number of Windows Server VMs being used for Dev/Test purposes.  We will automatically apply these savings when you create a VM using one of the standard VM images in the Windows Azure VM Gallery (either through the portal or command-line options like PowerShell) and run it using a new Windows Azure MSDN Subscription.

MSDN Monthly Monetary Credits

We are making the above discounted rates even more compelling by also giving every MSDN subscriber up to $150 per month of monetary credits that can be used to run any Windows Azure resource for Dev/Test purposes.  MSDN Professional Subscribers will be provided with $50/month, MSDN Premium Subscribers with $100/month, and MSDN Ultimate Subscribers with $150/month.

These monetary credits can be applied towards any Windows Azure resource being used for Dev/Test purposes.  This includes: Virtual Machines (both Windows and Linux), SQL Databases, Cloud Services, Web Sites, Mobile Services, Hadoop Clusters, BizTalk Services, Storage, Media and more.  The previous per-unit restrictions in place with the old MSDN offer are also being removed – instead you now have a monetary credit that can be applied and mixed/matched on resources however you want.

Below are just a few examples of how a MSDN Premium customer (who will now gets $100/month of credits with their MSDN subscription) could use the monetary credit:

1) A MSDN Premium subscriber can now run 3 Windows Server VMs for 16 hours a day (at 6 cents/hr) every day of the month.  And he or she can run SQL Server Enterprise, BizTalk Server, or SharePoint Server in them using their MSDN use-rights at no additional charge.  And if they ran these 3 VMs for 16 hours a day for 31 days in the month they’d still have $10.32 in credit left over to spend on something else! :-)

2) Alternatively the $100/month credit could be applied towards spinning up 80 Windows Server VMs (with SQL, BizTalk, SharePoint, etc) to use in a load-test for 20 hours:

3) Or the $100 credit could be used to spin up 50 Hadoop cluster nodes for 10 hours of a dev/test MapReduce run:

4) Or the $100 credit could be used to dev/test 100 web-sites with a SQL Database:

The above examples provide just a flavor of the different options now available with this program.  The great thing about the monetary credits is that you can use them with any Windows Azure resource – so you have the flexibility to apply them in whatever combination you want.  The credits themselves reset every month (meaning if you are a MSDN Premium customer the credits will reset to $100/month every month).  So every month you also have the opportunity to change how you allocate them however you want. 

You can optionally choose to pay additional money on top of the monetary credit (meaning if you need $200 of resources in a month, the MSDN Premium Monetary Credit will cover the first $100 of usage and then you can pay the rest).  Note that any overages will still take advantage of the MSDN Discount Rate (meaning the VMs will only be charged at 6 cents/hr) so you still benefit from a major price discount on that as well. 

By default we enable a “spending limit of $0” on MSDN based subscriptions to ensure that customers are never accidentally billed for usage above their MSDN credits.  You can turn this of if you want to use more resources than the built-in credits support and pay for overages.

Portal Support for Better Tracking MSDN Monetary Credit Usage

One of the asks we’ve had in the past from Windows Azure Free Trial and MSDN customers has been for us to enable integrated UI support within the Windows Azure Management Portal that makes it easy for customers to better track where they are with their free credit usage.

Today’s release now makes it easy for Windows Azure customers to track their monetary credit usage.  The top of the Windows Azure Management Portal now includes “Credit Status UI” that enables customers to quickly check their current status:

Clicking the Credit Status UI will display a summary status within the portal that shows how much credit remains (and how many days until the credit will expire):

Clicking the “View More Details” link in the UI above will then take you to a detailed usage page that shows the usage so far during the month, as well as estimated remaining credit based on current usage patterns:

The above support is now available to both MSDN subscription customers as well as those signing up with our Free Trial, and should make it much easier to track free benefit resources.

Summary

The above enhancements make Windows Azure a fantastic environment in which to do dev/test, and an unbeatable option for all MSDN customers.  All of these improvements are now available to start using immediately.

If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  If you are a MSDN subscriber make sure to sign-up using the same Microsoft ID (formerly LiveID) that is registered with your MSDN subscription.  The Windows Azure sign-up wizard will then detect that you are a MSDN subscriber and automatically setup a subscription with the above improvements for you to use. 

If you already have an existing MSDN Subscription on Windows Azure you will be automatically migrated to the new benefits above in August.  If you wish to opt-into using the new benefits before August you can visit the accounts center on the www.windowsazure.com web-site, and next to your subscription you’ll find the option to transfer to it earlier.  If you’d prefer to continue using the existing MSDN benefits offer, you can also optionally opt-out of the automatic conversion and elect to continue to use that for the next 12 months.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

This morning we released some fantastic enhancements to Windows Azure:

• Dev/Test in the Cloud: MSDN Use Rights, Unbeatable MSDN Discount Rates, MSDN Monetary Credits
• BizTalk Services: Great new service for Windows Azure that enables EDI and EAI integration in the cloud
• Per-Minute Billing and No Charge for Stopped VMs: Now only get charged for the exact minutes of compute you use, no compute charges for stopped VMs
• SSL Support with Web Sites: Support for both IP Address and SNI based SSL bindings on custom web-site domains
• Active Directory: Updated directory sync utility, ability to manage Office 365 directory tenants from Windows Azure Management Portal
• Free Trial: More flexible Free Trial offer

There are so many improvements that I’m going to have to write multiple blog posts to cover all of them!  Below is a quick summary of today’s updates at a high-level:

Dev/Test in the Cloud

Windows Azure provides a great environment for dev/test.  This is true both for scenarios where you want to dev/test in the cloud and then run the production app in the cloud, as well as for scenarios where you want to dev/test in the cloud and then run the production app using an existing on-premises server environment.

Windows Azure’s new IaaS and Virtual Networking capabilities make it really easy to enable enterprise development teams to use the cloud to do this.  Using the cloud for dev/test enables development teams to work in a flexible, agile, way without ever being bottlenecked waiting for resources from their IT department.  Development teams can instead use Windows Azure in a self-service way to spin up or down resources in minutes.  And then when they are ready to deploy their apps they can choose to do so either in the cloud or using their existing on-premises servers.  This later option makes it really easy to start leveraging the cloud even without having to fully bet on it yet for production scenarios.

Today we are announcing a number of enhancements to Windows Azure that make it an even better environment in which to do dev/test:

• No Charge for Stopped VMs
• Pay by the Minute Billing
• MSDN Use Rights now supported on Windows Azure
• Heavily Discounted MSDN Dev/Test Rates
• MSDN Monetary Credits
• Portal Support for Better Tracking MSDN Monetary Credit Usage

The combination enables an amazing Dev/Test cloud solution, and an unbeatable offer for all MSDN customers.  Read my detailed blog post on the new Dev/Test offering to learn more.

BizTalk Services

I’m excited to announce a new Windows Azure service we are launching into preview today - Windows Azure BizTalk Services.

Windows Azure BizTalk Services provides Business-to-Business (B2B) and Enterprise Application Integration (EAI) capabilities for cloud and hybrid integration solutions.  It includes built-in support for managing EDI relationships between partners, as well as EAI bridges with on-premises assets – including built-in support for integrating with on-premises SAP, SQL Server, Oracle and Siebel systems.  You can also optionally integrate Windows Azure BizTalk Services with on-premises BizTalk Server deployments – enabling powerful hybrid enterprise solutions.

BizTalk Services runs on a secure, dedicated per tenant, environment that you can provision on demand in a matter of minutes.  It does not require any upfront license, and supports a pay only for what you use billing model.  Click here to learn more about how to setup and starting using the Windows Azure BizTalk Services preview today.

Per Minute Billing and No Charge for Stopped VMs

Prior to today, when you stopped a VM on Windows Azure we kept a reserved deployment spot for it inside one of our compute clusters, and continued to bill you for the VM compute unless you explicitly deleted the deployment.  Now, with today’s update, when you stop a VM we no longer charge you any compute time for it while it is stopped – yet we still preserve the deployment state and configuration.  This makes it incredibly easy to stop VMs when you aren’t actively using them to avoid billing charges, and then restart them when you want to use them again.

Prior to today, our pricing model for compute resources on Windows Azure billed at the per-hour granularity.  This meant if you ran a VM for 6 minutes in an hour and then turned it off, we would still charge you for a full hour of usage.  Now, with today’s update, we are billing at a per-minute granularity.  So if you run a VM (or Cloud Service, or Web Site, or Mobile Service) for only 6 minutes in an hour, we now only charge you for the actual 6 minutes of compute usage (we pro-rate the hourly price – so the billed price is num_minutes * (hr rate)/60). 

These two changes are great for a variety of scenarios.  They are especially useful for scenarios where you are often cycling up/down resources in a very elastic way (for example: Dev/Test or other elastic workloads).  Now you can do so and save more money.

SSL Support with Web Sites

With today’s update, Windows Azure Web Sites now support Secure Sockets Layer (SSL) for custom domains.

SSL encryption is the most commonly used method of securing data sent across the internet, and you can now upload your own SSL Certificate that you can use to enable with custom domains hosted via Windows Azure Web Sites.  With today’s release we now support the ability to setup both IP Address Based SSL Bindings as well as SNI Based SSL Bindings. 

Active Directory: Directory Sync Tool, Manage existing Directories

Today’s update brings a number of improvements to Windows Azure Active Directory. 

Among the more significant updates is a free new directory sync utility that you can download.  It makes it super easy to sync existing on-premises Active Directory deployments with Windows Azure Active Directory.  The directory sync tool works with Windows Server 2003 and above, and enables you to securely sync your directory without having to setup ADFS.  This dramatically simplifies the steps required to enable your directory in the cloud.

Today’s update also includes support to manage an existing Windows Azure Active Directory (such as the one that your organization already uses with Office 365) with a Windows Azure account.  Included as part of this support is the ability to manage an existing Active Directory with a Windows Azure account that is setup using a Microsoft ID account (assuming you have also been made an admin of the active directory tenant).  This makes it even easier to integrate your Windows Azure and Office 365 resources together.

Free Trial

With today’s update we are also updating our Windows Azure Free Trial to provide an even simpler and more flexible free trial experience.

Prior to today, our free trial used to include a fixed quantity of individual resources (for example: 750 compute hours).  We heard feedback from trial users that:

• Trial users had to keep track of usage for each of these resources
• If they went over one of the resource quotas, their subscription was disabled
• Inadequate notifications were given when they were about to exceed their quotas

With today’s release we are making substantial changes to how Windows Azure Free Trials are experienced by customers. With a free trial, you now get a monthly Windows Azure credit of $200. This credit can be applied to any service of your choice. This makes it much easier to try out the services of your choice – and means there are no individual resource quotas on what you can do.  You can instead spend the $200 however and on anything you want.

Both the Windows Azure Management Portal as well as Accounts Center will also now provide built-in UI that lets you know the current status of your remaining Windows Azure Credit balance and the number of days remaining to use your free credit.  This makes it really easy to see what you’ve consumed so far, and how much you have to go before it is all used up. 

Summary

I am really excited about today’s release – there a ton of great new improvements for everyone to take advantage of.  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

For the past five years, Microsoft has been working with a diverse group of companies to develop the Advanced Message Queuing Protocol (AMQP) standard. The group of 20+ companies consisted of tech vendors, including Red Hat and VMware, and enterprises like JPMorgan Chase and Credit Suisse. The goal has been to build an open, wire-level protocol standard for messaging that enables easy interoperability between different vendor products. Back in October 2012, the OASIS standards organization announced the approval of AMQP 1.0 as an OASIS Standard and, on the same day, we released a preview implementation of it with Windows Azure Service Bus.

Today, I’m pleased to announce that AMQP 1.0 support in Windows Azure Service Bus has been released as a general availability (GA) feature – and it is ready for production use, and backed by an enterprise SLA.

Interoperable Messaging

This release is a big deal. With support for AMQP 1.0, you can now use Windows Azure Service Bus to build applications using a variety of messaging libraries written using different languages and running on different operating systems – that can now all communicate using an efficient, binary, wire-level protocol.

Because AMQP 1.0 defines a portable data representation, it means that a message sent to Service Bus from a .NET program can be read from a Java program or Python/Ruby/PHP script without losing any of the structure or content of the message. For Java, the standard Java Message Service (JMS) API is supported so it’s straightforward to port an existing Java application to Service Bus from any another JMS provider.

The end result is really powerful middleware that can be used to build distributed systems, and glue together applications that span on-premises/cloud environments or run across multiple cloud providers.

Walkthrough of How to Build a Pub/Sub Solution using AMQP

To highlight how easy it is to use this new messaging support, I’m going to walkthrough how to create a simple .NET console app that sends messages using a publish/subscribe messaging pattern to receiver apps written in Java, Python and PHP.  The Windows Azure Service Bus now provides all of the pub/sub messaging support necessary to facilitate this using the open AMQP protocol and existing messaging frameworks.

The .NET sender app will post the messages to a Service Bus “Topic” – which is a durable messaging intermediary.  Unlike Queues, where each message to a Queue is processed by a single consumer app, Topics provide a one-to-many form of communication using a publish/subscribe pattern.  It is possible to register multiple subscriptions to a topic – and when a message is sent to the topic, it is then made available to each subscription to handle/process independently.

You can think of each subscription as a virtual durable queue that receives copies of the messages that were sent to the topic. You can then optionally register filter rules for a topic on a per-subscription basis, which allows you to filter/restrict which messages to a topic are received by which topic subscriptions.  This enable you to scale to process a very large number of messages across a very large number of users and applications.

 

For this scenario we are going to have the .NET console app post messages to a “scottmessages” topic, and then setup separate subscriptions for three app listeners – one written in Java, Python and PHP – to receive and process the messages.

Step 1: Create a Service Bus Topic and 3 Subscriptions

Our first step will be to create a Service Bus Topic using the Windows Azure portal. 

We’ll create a Topic named “scottmessages” in a “scottgu-ns” namespace.  The Windows Azure Management Portal makes this easy to do – just click the New button and navigate to the App Services->Service Bus->Topic->Quick Create option (you can also create this programmatically and from the command-line):

Once the “scottmessages” topic is created, we can drill into it to see a familiar Windows Azure dashboard monitoring view of it:

We’ll then create three subscriptions for the Topic – one for each of our app listeners.  We’ll name these “java”, “python”, and “php” to correspond to the language that each app is written in (note: we could name them whatever we wanted to – I am using these names just to make it clearer which maps to which). We can do this programmatically, or by clicking the “Create Subscription” button in the portal command bar.  This will launch a dialog that allows us to name the subscription we want to create:

The second screen of the dialog allows us to set custom subscription properties like the default message time to live (how long it will remain queued before being deleted), lock and session settings, etc:

Clicking the ok button will create a subscription for our Topic.  We’ll can then repeat this step to create two more subscriptions so that we have all three we want:

After we’ve done this, whenever a message is posted to the “scottmessages” topic it will be durably queued for each subscription.  Durably queued means that a consumer app doesn’t need to be actively listening on the subscription at the time the message is posted.  The message will be automatically queued up for the subscriber app to process whenever they connect later.  This enables a very robust, loosely coupled application architecture that allows you to scale the processing of a large number of messages across a very large number of users and applications.

Step 2: Writing the .NET Sender App

Now that we have the Service Bus Topic and Subscriptions created, we’ll write a simple .NET program to send messages to the Topic.

The AMQP support is Service Bus is available in the latest version of the Service Bus .NET client library which you can retrieve via NuGet - http://nuget.org/packages/WindowsAzure.ServiceBus/. Version 2.1.0 or later is required.  Just type “Install Package WindowsAzure.ServiceBus” to download and add it to your .NET application.

The code below is a simple .NET console application that prompts users of the console app to type messages, and then the app uses the Service Bus .NET API to post each message the user types to the “scottmessages” Service Bus Topic we created above:

using System;
using System.Configuration;
using Microsoft.ServiceBus.Messaging;

namespace SendToScott
{
    class Program
    {
        static void Main(string[] args)
        {
            string connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];

            TopicClient topicClient = TopicClient.CreateFromConnectionString(connectionString, "scottmessages");

            Console.WriteLine("Type messages you wish to post to the Topic:");

            while (true)
            {
                Console.Write("> ");
                string messageText = Console.ReadLine();

                topicClient.Send(new BrokeredMessage(messageText));
            }
        }
    }
}

.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

The above code uses NET’s ConnectionManager class to pull in configuration settings from an app.config file. I’m using this approach to retrieve the connection string to our Service Bus Topic (and to avoid hard coding it into the code).  Here’s the App.config file I’m using to specify this:

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

 

  <startup>

    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

  </startup>

  <appSettings>

    <add key="Microsoft.ServiceBus.ConnectionString"

value="Endpoint=sb://scottgu-ns.servicebus.windows.net/;SharedSecretIssuer=owner;SharedSecretValue=sSDdaewGUo3/wsaewtjhELlCi1y3SRwjFMX01tz2c/AXw=;TransportType=Amqp" />

  </appSettings>

 

</configuration>

Note: You can retrieve the connection string of a Service Bus Topic from the Windows Azure Portal by selecting the Topic and then clicking the “Access Key” button in the command bar at the bottom of the portal.  Note that to configure the .NET client library to use AMQP, I appended “;TransportType=Amqp” to the connection string. 

Running the Console App

Now let’s run the .NET console app. Hitting F5 produces a console app and we can now type messages to send to the Topic. Here’s some sample input:

Each message entered above was posted to our Service Bus Topic – which will in turn durably queue a copy of the message for each of the three Subscriptions we’ve setup to process.

Step 3: Writing a Java App Listener

Now let’s write a java app that will connect to one of the Subscriptions and process the messages.

The standard API for messaging in Java is JMS - the Java Message Service. JMS doesn’t specify anything about the underlying transport so different JMS products use different protocols under the covers to talk to their respective messaging brokers. I’m going to use a standard JMS Provider from Apache that uses AMQP 1.0 as the underlying protocol. Using this library, Windows Azure Service Bus becomes an open standards JMS Provider!

You can obtain the Apache AMQP provider at http://people.apache.org/~rgodfrey/qpid-java-amqp-1-0-client-jms.html. The following four JAR files from the distribution archive need to be added to your Java CLASSPATH when building and running applications that use it:

• geronimo-jms_1.1_spec-1.0.jar
• qpid-amqp-1-0-client-[version].jar
• qpid-amqp-1-0-client-jms-[version].jar
• qpid-amqp-1-0-common-[version].jar

We can then write the following Java code which uses the standard JMS messaging API to connect to our Service Bus subscription and process messages in it:

// ReceiveScottsMessages.java

 

import javax.jms.*;

import javax.naming.Context;

import javax.naming.InitialContext;

import java.util.Hashtable;

 

public class ReceiveScottsMessages implements MessageListener {

    public static void main(String[] args) {

        try {

            Hashtable<String, String> env = new Hashtable<String, String>();

            env.put(Context.INITIAL_CONTEXT_FACTORY,   

                "org.apache.qpid.amqp_1_0.jms.jndi.PropertiesFileInitialContextFactory");

            env.put(Context.PROVIDER_URL, "servicebus.properties");

            Context context = new InitialContext(env);

 

            ConnectionFactory cf = (ConnectionFactory) context.lookup("SBCF");

            Topic topic = (Topic) context.lookup("EntityName");

            Connection connection = cf.createConnection();

            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

            TopicSubscriber subscriber = session.createDurableSubscriber(topic, "java");

            subscriber.setMessageListener(new ReceiveScottsMessages());

            connection.start();

 

            System.out.println("Receiving messages. Press enter to stop.");

            System.in.read();

 

            System.out.println("Shutting down.");

            connection.stop();

            subscriber.close();

            session.close();

            connection.close();

        } catch (Exception e) {

            System.err.println("Caught exception. Exiting.");

            System.exit(1);

        }

    }

 

    @Override

    public void onMessage(Message message) {

        try {

            System.out.println("Message From Scott > " + ((TextMessage) message).getText());

        } catch (JMSException e) {

            System.err.println("Caught exception receiving message: " + e);

        }

    }

}

Note that the Apache JMS provider uses a simple file based JNDI provider to configure the JMS “Administered Objects”, including the connection details and the logical to physical name mappings of the messaging entities. Here’s the servicebus.properties file I’m using to embed the connection string details to our Windows Azure Service Bus Topic:

connectionfactory.SBCF = amqps://owner:sSDdaYGUo3%2FwpewtjhELlCi1y4SSwjFGX01tz2c%2FAXw%3D@scottgu-ns.servicebus.windows.net

topic.EntityName = scottmessages

This properties file defines a ConnectionFactory called “SBCF” which contains the constituent parts from the Service Bus connection string. The format is as follows:

amqps://[username]:[password]@[namespace].servicebus.windows.net

In the format above, the [username] corresponds to the issuer name, [password] is a URL-encoded form of the issuer key. You must URL-encode the issuer key manually. A useful URL-encoding utility is available at http://www.w3schools.com/tags/ref_urlencode.asp.

Running the Java App

When we run this Java app it will connect to the “Java” subscription on our Service Bus Topic and produce the output below:

Receiving messages. Press enter to stop.

Message From Scott > Red Shirts are cool

Message From Scott > Cross-platform messaging is so simple with AMQP and Service Bus

Message From Scott > Windows Azure Rocks!

 

Shutting down.

Note how the messages we sent to the Topic using .NET were seamlessly consumed from the Java app!

Popular Java frameworks like Spring and JEE use JMS to integrate different messaging systems – you can now write components using these frameworks and have the messaging system powered by the Windows Service Bus, and seamlessly interoperate and integrate with other languages and frameworks as well.

Step 4: Creating a Python App Listener

Let’s now write a Python app that will connect to another of the Subscriptions and process the messages.  We’ll host this Python app in a Linux VM.

We can create the Linux VM very easily using Windows Azure.  Just select the New command in the portal and use the Compute->Virtual Machine->Quick Create option to create a CentOS virtual machine:

Once the VM is provisioned we can SSH into it to configure and setup.

Installing the Proton Library on our Linux VM

For both the Python and PHP apps, we’ll use the Proton client libraries from Apache which are available for download from http://qpid.apache.org/proton/download.html. The Proton library provides a AMQP 1.0 compliant library that we’ll be able to use to communicate with the Windows Azure Service Bus.  The README file in the Proton distribution details the steps required to install the dependencies and build Proton. Here’s a summary of the steps I took using the command-line of the Linux VM:

1) Edit the yum config file (/etc/yum.conf) and comment out the exclusion for updates to kernel headers (# exclude=kernel*). This is necessary to install the gcc compiler

2) Install the various pre-requisite packages:

>> yum install gcc cmake libuuid-devel

>> yum install openssl-devel

>> yum install swig python-devel ruby-devel php-devel java-1.6.0-openjdk

>> yum install epydoc

3) Download the Proton library

>> wget http://www.bizdirusa.com/mirrors/apache/qpid/proton/0.4/qpid-proton-0.4.tar.gz

4) Extract the Proton code from the distribution archive

>> tar -xvf qpid-proton-0.4.tar.gz

5) Build and install the code using the following steps, taken from the README file

From the directory where you found this README file:

mkdir build

cd build

# Set the install prefix. You may need to adjust depending on your

# system.

cmake -DCMAKE_INSTALL_PREFIX=/usr ..

# Omit the docs target if you do not wish to build or install

# documentation.

make all docs

# Note that this step will require root privileges.

sudo make install

Following all this, Proton will be installed on the machine and ready for you to use. Here’s the Python code I wrote to receive messages from the “python” subscription on our Windows Azure Service Bus Topic:

import sys

from proton import Messenger, Message

 

broker = "amqps://owner:sSDdaYHUo3/wpewtjhEDlCi1y6SRwjFMX01tz2c/AXw=@scottgu-ns.servicebus.windows.net"

entityName = "scottmessages/Subscriptions/python"

 

messenger = Messenger()

messenger.subscribe("%s/%s" % (broker, entityName))

messenger.start()

 

msg = Message()

while True:

  messenger.recv(10)

  while messenger.incoming:

    try:

      messenger.get(msg)

    except Exception, e:

      print e

    else:

      print "Message From Scott > %s" % msg.body

 

messenger.stop()

print "Done"

A couple of things to note above:

• The connection string for the broker is of the form
  amqps://[issuer-name]:[issuer-key]@[namespace].servicebus.windows.net
• The entityName that we’re receiving messages from is of the form
  [topic-name]/Subscriptions/[subscription-name].

And now when we run the above python script (from our Linux VM) we will connect to the Windows Azure Service Bus using AMQP and see the messages we published from our .NET app:

One of the really cool things about the app above is that it is running in a Linux VM using Python, and leverages an open source AMQP library that communicates with the Windows Azure Service Bus messaging system using only the open AMQP protocol.

Step 5: Creating a PHP App Listener

Let’s now finish by writing a PHP app that connects to our final topic subscription and processes the messages.  We’ll host this PHP app in the same Linux VM we used above, and use the same Proton library that we used with Python.  Here is the code to use it from PHP:

<?php

 

include("proton.php");

 

$broker = "amqps://owner:sSDdaGGUo3/cpewtjhELlCi1y5SRwjFMX01tz2c/AXw=@scottgu-ns.servicebus.windows.net";

$entityName = "scottmessages/Subscriptions/php";

 

$messenger = new Messenger();

$messenger->start();

$messenger->subscribe("$broker/$entityName");

 

$msg = new Message();

while (true) {

  $messenger->recv(10);

  while ($messenger->incoming) {

    try {

      $messenger->get($msg);

    } catch (Exception $e) {

      print "$e\n";

      continue;

    }

    print "Message From Scott > $msg->body\n";

  }

}

 

$messenger->stop();

?>

And here is the output when we run it from the command-line in our Linux VM:

.

Summary

The above sample demonstrates how easy it is to connect to the Windows Azure Service Bus using the open AMQP protocol and the existing AMQP 1.0 libraries already supported by various communities. 

The new AMQP support in the Windows Azure Service Bus will make it even easier to build powerful distributed applications that can span and interoperate across multiple systems.  One cool thing to note with the same above is how the message has been preserved as it is exchanged between the different languages. This example used a simple text string for the body but the same is true for more complex message formats including lists and maps. This is achievable due to the portable data representation of AMQP 1.0. 

Here are a few links to some more information on the Service Bus support for AMQP 1.0:

• Windows Azure Service Bus
• Latest Service Bus .NET client library on NuGet
• AMQP 1.0 support in Windows Azure Service Bus
• How to use AMQP 1.0 with the Service Bus .NET API
• Service Bus AMQP 1.0 Developer's Guide
• David Ingham’s presentation on Service Bus and AMQP 1.0 from the 2012 //build/ conference
• Apache Qpid AMQP 1.0 JMS library
• Apache Qpid Proton

If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today. 

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

I’m excited to announce the release of WebMatrix 3.  WebMatrix is a free, lightweight web development tool we first introduced in 2010, and which provides a great, focused web development experience for ASP.NET, PHP, and Node.js.  

Today’s release includes a ton of great new features.  You can easily get started by downloading it, and watching an introduction video:

Some of the highlights of today’s release include deep Windows Azure integration, source control tooling for Git and TFS, and a new remote editing experience. 

Windows Azure Integration

With WebMatrix 3, we are making it really easy to move to the cloud. 

The first time you launch WebMatrix 3, there’s an option to sign into Windows Azure.  You can sign in using the same credentials you use with the Windows Azure Management Portal:

Once you are signed-in your Windows Azure account and subscriptions are integrated directly within WebMatrix.  You have the option to create up to 10 free sites on Windows Azure: 

You can use the My Sites”button to browse and edit the web sites you already have hosted on Windows Azure.  You can also use the New button to directly create and host new web sites on Windows Azure – and create either a blank new site, or a site created from the Windows Azure Web App Gallery (which lets you start with templates like Umbraco, WordPress, Drupal, etc):

In this case we’ll create a new web site using the popular Umbraco CMS solution – one of the templates in the Windows Azure Web Site Gallery:

When you select this template, WebMatrix can help you create a new Web Site to host it on Windows Azure, and associate all of the publishing information you need to publish it and keep it in sync with your editing environment within WebMatrix:

Once created you get a tailored experience within WebMatrix that provides integrated Umbraco (or WordPress or Drupal, etc) editing functionality inside the tool:

And WebMatrix provides the ability to open/edit any appropriate files in it with editing/ and code intellisense support:

And when you are done you can one-click publish the site to Windows Azure using the Publish command in top left of the tool.  WebMatrix will provide real-time feedback as it uploads and publishes the site:

The end result is a simple, fast and super effective way to edit your sites locally and host and manage them in Windows Azure. 

Watch this great video as Eric build a site with WebMatrix 3 and deploys it to Windows Azure.

Source Control with Git and TFS

One of the most requested features in WebMatrix 2 was support for version control.  WebMatrix 3 now supports both Git and TFS.  The source control experience is extensible, and we’ve worked with several partners to include rich support for Team Foundation Service, CodePlex and GitHub:

The Git tooling works with your current source repositories, configuration, and existing tools.  The experience includes support for commits, branching, multiple remotes, and works great for publishing Web Sites to Windows Azure:

The TFS experience is focused on making common source control tasks easy.  It matches up well with Team Foundation Service, our hosted TFS solution that provides free private Git and TFS repositories.

Watch these great videos of Justin giving a tour of the Git and TFS integration in WebMatrix 3

Remote Editing

In WebMatrix 2, we added the ability to open your Web Site directly from the Windows Azure Management Portal.  With WebMatrix 3, we’ve rounded out that experience by providing an amazing developer experience for live remote editing of your sites.   The new My Sites gallery now allows you to open existing web sites on your local machine, or to remotely edit sites that are hosted in Windows Azure:

While working with the remote site, IntelliSense and the other tools work as though the site was on your local machine.  But when you save changes it pushes them directly to the remote hosted site.  This makes it ideal for when you want to make quick changes in a hurry.

If you want to work with the site locally, you can click the ‘download’ button to install and configure any runtime dependencies, and work with the site on your machine:

Watch this video of Thao showing you how to edit your live site on Windows Azure using WebMatrix 3

Summary

WebMatrix 3 includes a seamless experience for working with sites in Windows Azure, source control support for working with Git and TFS, and a vastly improved remote editing experience.  These are just a few of the hundreds of improvements throughout the application, including an extension for PHP validation and Typescript support. 

You can easily get started with WebMatrix by downloading it for free, and watching an introduction video about it:

We look forward to seeing what you build with the new release!

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

This morning we released the v2.0 update of the Windows Azure SDK for .NET. This is a major refresh of the Windows Azure SDK with some really great new features and enhancements.  These new capabilities include:

• Web Sites: Visual Studio Tooling updates for Publishing, Management, and for Diagnostics
• Cloud Services: Support for new high memory VM sizes, Faster Cloud Service publishing & Visual Studio Tooling for configuring and viewing diagnostics data
• Storage: Storage Client 2.0 is now included in new projects & Visual Studio Server Explorer now supports working with Storage Tables
• Service Bus: Updated client library with message pump programming model support, support for browsing messages, and auto-deleting idle messaging entities
• PowerShell Automation: Updated support for PowerShell 3.0, and lots of new PowerShell commands for automating Web Sites, Cloud Services, VMs and more.

All of these SDK enhancements are now available to start using immediately and the SDK can now be downloaded from the Windows Azure .NET Developer Center.  Like all of the other Windows Azure SDKs we provide, the Windows Azure SDK for .NET is a fully open source project (Apache 2 license) hosted on GitHub.

Below are more details on the new features and capabilities released today:

Web Sites: Improved Visual Studio Publishing

With today’s release we’ve made it even easier to publish Windows Azure Web Sites.  Just right-click on any ASP.NET Web Project (or Web Site) within Visual Studio to Publish it to Windows Azure:

This will bring up a publish profile dialog the first time you run it on a project: 

Clicking the import button will enable you to import a publishing profile (this is a one-time thing you do on a project – it contains the publishing settings for your site in Windows Azure). 

With previous SDK releases you had to manually download the publish profile file from the Windows Azure Management Portal.  Starting with today’s release you can now associate your Windows Azure Subscription within Visual Studio – at which point you can browse the list of sites in Windows Azure associated with your subscription in real-time, and simply select the one you want to publish to (with no need to manually download anything):

Then just select the Web Site on Windows Azure that you want to deploy your app to, hit ok, and your app will be live on Windows Azure in seconds.  You can then quickly republish again (also in seconds) without having to configure anything (all of the publish profile settings are persisted for later use). 

Web Sites: Management Support within the Visual Studio Server Explorer

Today’s SDK release also adds new support for managing Web Sites, deployed in the cloud with Windows Azure, through the Visual Studio Server Explorer.  When you associate your Windows Azure subscription with Visual Studio, you’ll now see all of your running web sites within Windows Azure in the Visual Studio Server Explorer:

In addition to listing your sites, you can also perform common operations on them like Starting/Stopping them (just right click on one to do this).  You can also use the View Settings command on a site to retrieve the live site configuration settings from Windows Azure:

When you do this you’ll be able to view and edit/save the live settings of the Web Site directly within Visual Studio.  These settings are being pulled in real-time from the running Web Site instance in the cloud within Windows Azure:

Changes you save here will be persisted immediately into the running instance within Windows Azure.  No need to redeploy the application nor even open the Windows Azure Management Portal. 

Web Sites: Streaming Diagnostic Logs

One of the really awesome new features in today’s release is support that enables you to stream your Windows Azure Web Site’s application logs directly into Visual Studio.  This is a super useful feature that enables you to easily debug your Web Site when it is running up in the cloud in Windows Azure. 

How to Enable Live Streaming of Diagnostic Logs

To try out this feature, we’ll first add a Trace statement to an ASP.NET Web application and publish it to Windows Azure (as a Web Site).  We’ll add the trace statement to our app using the standard System.Diagnostics tracing API in .NET.  We’ll use the Trace.TraceError() method to write out an error:

By default when we hit the Web Site this method will do nothing – because tracing is disabled by default on Web Sites. 

If we want to enable tracing on our Web Site (in order to debug something) we can do that through the Windows Azure Management Portal (click the Configuration tab within a Web Site to enable this in the portal).  Or alternatively we can now do this directly within Visual Studio using the View Settings command within Server Explorer (like we saw above):

Notice above how we are enabling Application Logging for our Web Site, and turning it on so that it logs all “Error” trace events.  Make sure “Error” is selected and then click the “Save” button to persist the setting to Windows Azure – at which point we can hit our Web Site again and this time our Trace Error statements will be saved.

To view the trace statements inside Visual Studio we then simply need to click on our Web Site within the Server Explorer and select the View Streaming Logs in Output Window command:

This will open our Visual Studio output window – which will display the Trace.TraceError() statements as they execute in our live site (there is only a ~2 second delay from the time it executes to the point it shows up in our Visual Studio output window – which is super convenient when trying to debug something):

When you are done debugging the issue, just right-click on the Web Site again and choose the Stop Viewing Logs command to stop the logs being sent to VS (and when you are done with the issue itself make sure to turn off logging entirely by going back to the settings window and disabling it):

The above support is super useful and makes it much easier to debug issues that only occur in a live Windows Azure environment.  For more information on this feature (and how to use it from the command-line) check out this blog from Scott Hanselman.

Note: You must have a /LogFiles/Application directory in your Windows Azure Web Site before you can stream the application logs to Visual Studio. This gets created the first time a trace statement gets written to disk – so you’ll want to make sure you execute a Trace statement first before opening up the log streaming view inside Visual Studio.  We’ll be making an update to Windows Azure Web Sites in the next week or two which will cause this directory to be automatically created for you – both for existing and new web sites.  This will enable you to start streaming the logs even before a trace operation has occurred.  Until then just make sure you have written one trace statement before you start the log streaming window in VS.

Cloud Services: Support for High Memory VM Instances

Two weeks ago we announced the general availability of our Windows Azure IaaS release.  Included as part of that release was support for creating large memory IaaS VMs using our new 4 core x 28GB RAM (A6) and 8 core x 56GB RAM (A7) VM sizes.

Starting with today’s Windows Azure SDK 2.0 for .NET release, you can also now deploy your Cloud Services to these same VM sizes:

For details on the VM sizes please refer to: http://msdn.microsoft.com/en-us/library/windowsazure/dn197896.aspx

Cloud Services: Faster Deployment Support with Simultaneous Update Option

Today’s release includes a number of enhancements to improve the deployment and update times of Cloud Services.

One of the new deployment options we now support is the ability to do a “Simultaneous Update” of a Cloud Service (we sometimes also refer to this as the “Blast Option”).  When you use this option we bypass the normal upgrade domain walk that is done by default with Cloud Services (where we upgrade parts of the Cloud Service sequentially to avoid ever bringing the entire service down) and we instead upgrade all roles and instances simultaneously. With today’s release this simultaneous update logic now happens within Windows Azure (on the cloud side).  This has the benefit of enabling the Cloud Service update to happen much faster.

Note that because it updates all roles simultaneously you want to be careful about using it in production for normal updates (otherwise users will experience app downtime).  But it is great for scenarios where you want to quickly update a dev or test environment (and don’t care about a short period of downtime between your updates), or if you need to blast out a critical app update fast in production and you are ok with a short availability impact.

To perform a Simultaneous Update using Visual Studio, select the “Advanced Settings” tab within the Cloud Service Publish wizard and choose the “Settings” link next to the Deployment Update checkbox:

This will launch a new dialog.  Within it you can now select the new “Simultaneous Update” option:

Once saved, the updates to this Cloud Service will be performed using this option and all roles and instances will be updated simultaneously.

Cloud Services: Improved Diagnostics Support

Today’s release also includes some major enhancements to our diagnostics support with Cloud Services.

Easily Configure Diagnostics

Visual Studio has enabled Windows Azure Diagnostics for several versions. With today’s Windows Azure .NET SDK release we are making it even easier to start with the right diagnostics collection plan and leverage the data it provides to find errors and other useful information about your live service.

You can right-click on a Cloud Service role within Visual Studio’s Solution Explorer to pull up Configuration about it:

Today’s SDK release includes an updated Diagnostics section within it:

You can use this updated Diagnostics section to configure how you want to collect and store errors captured by the default .NET trace listener and your Trace.TraceError() code – all without having to write any glue code to setup or initialize.  You can specify the collection plan you want to use at runtime: Errors Only [default], All Information or a Custom Plan.  The custom plan is pretty rich and enables fine grain control over error levels, performance counters, infrastructure logs, collection intervals and more.

The diagnostics plan you configure through the configuration UI above is persisted in a diagnostics.wadcfg XML file.  If you open the Cloud Service role node within the Server Explorer you can find it and optionally edit the settings directly within the text editor:

Because the file is saved with your source code it can be managed under source control. It is also deployed with your cloud service and can be changed post deployment without requiring an application redeploy (I cover how to enable this live update below).

View Diagnostics on a Live Service

With today’s release we are also making it really easy for developers to review the live diagnostics data from their Cloud Services directly within Visual Studio – as well as dynamically turn on or off more detailed diagnostic capturing on their Cloud Services without having to redeploy the Cloud Service (which makes it much easier to quickly debug live production issues).

For any published Cloud Service, you can now view a quick summary of live service errors and other important status by clicking the View Diagnostics Data command in Visual Studio – which is surfaced off of each role node within a Cloud Service in the Visual Studio Server Explorer:

Executing this command will query the diagnostics table for the Cloud Service within Windows Azure and list a quick summary view of recent data within it.  In the example below we can see that we forgot to update the app’s configuration pointing to our SQL DB and therefore our stored procedure calls are failing in the deployed service:

Even more detailed diagnostics data has been gathered and stored in the Cloud Service’s Diagnostics Storage account. Click the View all Data link to drill into it. This loads a new Windows Azure Storage Table viewer. You can make use of the Query Builder support in it to refine your view over the diagnostics data. In the following example we are filtering a window of time occurring after 5:48pm by querying over the TimeStamp(Virtual). This refers to the time it occurred in the service rather than the time the data was collected and transferred.

This makes it much easier for you to look through historical logs to try and identify what the issue is.

Update Diagnostics Settings on a Live Service

Visual Studio also now enables you to configure and update the diagnostics settings for running Cloud Service directly from Server Explorer.  Diagnostic configuration can be updated at any time without the need to add code to your project and without having to redeploy the Cloud Service (which makes it much easier to quickly debug live production issues).

To do this, use the Server Explorer –> Windows Azure Compute node to select a running role instance in Windows Azure, and then click the Update Diagnostics Settings command on it to configure the runtime diagnostics settings for it:

Selecting this command will bring up a dialog that allows you to view and edit the Diagnostics Settings for the role.  Note that we can dynamically change the application log collection settings, event logs, performance counters, Infrastructure logs (like IIS, etc), and more:

In this example we will collect information about available memory + CPU + Requests/sec on the role from a performance counter. We’ll do this by selecting the Performance Counters tab and selecting the appropriate counter within it.  In addition to selecting the performance counters we want to track, we also need to set a Transfer period (in minutes) and Buffer size (MB).  We’ll set these to be 1 minute and 1024 MB (if we don’t set these then the logs won’t be copied to our storage account):

When we click OK, the collection plan will immediately be applied to the live role instances, and we’ll start collecting the new data we specified.  Within about a minute we’ll see a new WADPerformanceCountersTable created in our storage account, and our performance monitor data will start to be collected in it:

Double clicking the above table would enable us to browse and review the performance monitor data. 

Being able to dynamically turn on/off this functionality at runtime (without having to redeploy the Cloud Service) is super useful.  If we wanted to change the collection plan long term for every subsequent deployment, we can just apply the configuration changes we make at runtime back in the role designer for the cloud service project (or check it into source control).  That way new Cloud Service deployments will get it by default.

More Information

The above diagnostics support is really powerful, and can be used to capture diagnostic data from any number of roles and instances within a Cloud Service (including both web and worker roles).  And it makes it even easier to debug and analyze issues within multi-tier deployments.

Note that the .NET Diagnostics Listener support to output trace statements to Windows Azure’s diagnostics agent is enabled by default when you create new Cloud Service projects within Visual Studio.  If you start with an existing ASP.NET Web Project and then later convert it to be a Cloud Service you’ll want to manually add the below trace listener registration code to your web.config file in order to enable the above diagnostics support:

<system.diagnostics>
  <trace>
    <listeners>
      <add type="Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener, Microsoft.WindowsAzure.Diagnostics, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
        name="AzureDiagnostics">
        <filter type="" />
      </add>
    </listeners>
  </trace>
</system.diagnostics>

Storage: Visual Studio Table Explorer

With the previous Windows Azure SDK 1.8 release we revamped the Visual Studio tooling support for Windows Azure Storage. This previous release focused on read/write features for the Windows Azure Storage Blob and Queue services.

With today’s Windows Azure SDK 2.0 release, you can also now create and delete Windows Azure Tables, and add/edit/delete table entities in them from the Visual Studio Server Explorer.  This saves you time and allows you to easily use Visual Studio to build apps that use Windows Azure Storage Tables.

Within the Visual Studio Server Explorer, simply right-click within the Windows Azure Storage node to create and name a new Table:

Once you have the table created, you can then optionally add entities to it directly within Visual Studio (just click the “Create Entity” button on the table designer):

You can also edit/delete existing entities within Tables:

We also now make it much easier to build Table queries - without requiring expertise with OData syntax - using a new Query Builder available as part of the Table tooling:

The above features make it much easier to use Windows Azure Storage Tables.

Service Bus: Updated Client Library

Today’s release also includes an updated Service Bus client library with several great new features:

• Message Browse Support: Message browsing enables you to view available messages in a queue without locking the message or performing an explicit receive operation on it. This is very useful for debugging scenarios, and in scenarios that involve monitoring.

• New Message Pump Programming Model: Today’s release also adds support for a new message pump programming model.  The Message Pump programming semantics are similar to an event-driven, or “push” based processing model and provides an alternative to the receive loop which we support today. This approach supports concurrent message processing, and enables processing messages at variable rates.

• Auto-delete for Idle Messaging Entities: Auto-delete enables you to set an interval after which an idle queue, topic, or subscription is automatically deleted.

PowerShell: Tons of new Automation Commands

With today’s release, Windows Azure PowerShell (which is a separate download) has moved to support PowerShell 3.0.  Today’s release also includes numerous new PowerShell cmdlets that enable you to automate Windows Azure Web Sites, Cloud Services, Virtual Machines, as well as application services including Service Bus and the Windows Azure Store. You can find the full change log here.

Below are a few examples of some of the new functionality provided:

Web Sites

You can now get streaming logs for both http and application logs from your PowerShell console via the following command:

>>> Get-AzureWebsiteLog <your website> –Tail 

Cloud Services

You can now use a faster deployment option by opting into a simultaneous upgrade option which will upgrade all web and worker roles in parallel:

>>> Set-AzureDeployment –Mode Simultaneous

Virtual Machines

You can now use the new high memory virtual machine A6 & A7 images with these two commands:

>>> New-AzureVM

>>> New-AzureQuickVM 

We also enabled PowerShell Remoting by default when you create a VM via PowerShell to enable you to easily run your PowerShell cmdlets or scripts against your newly created virtual machines in Azure.

Service Bus

You can now manage Service Bus namespaces via newly added cmdlets which allow you to create, list and remove Service Bus namespaces.

Windows Azure Store

You can now manage your Azure Store add-ons from PowerShell. You can list the available add-ons, purchase an add-on, view your purchased add-ons and also upgrade the plan on a purchased add-on.

For example, the below command would create and deploy a MongoDB service from MongoLab (one of our Windows Azure Store partners):

>>> New-AzureStoreAddOn myMongoDB –AddOn mongolab –plan free –Location “West US”

Storage

We now support blob CRUD operations via PowerShell which allow you to manage Storage blob containers, upload/download blob content, and copy blobs around. This enables you to create scripts to seed some initial data for your applications or check what is in your storage account quickly when you are developing your application.

Scaffolding cmdlets for Web/Worker Role

We have also added new cmdlets for scaffolding. You can now use Add-AzureWebRole and Add-AzureWorkerRole to create projects for general web/worker role. You can use New-AzureRoleTemplate to generate a customized role template which you can use in Add-AzureWebRole or Add-AzureWorkerRole via the –TemplateFolder parameter.

More Information

A few other updates/changes with today’s release:

• WindowsAzure.Diagnostics.dll no longer depends on WindowsAzure.StorageClient.dll. You will now be able to import and use the WindowsAzure.Storage 2.0 NuGet package in your application without introducing conflicts with Diagnostics.

• Windows Azure SDK 2.0 supports side by side with Windows Azure SDK 1.8 and 1.7 while dropping support for side by side with Windows Azure SDK 1.6. Therefore you will not be able to debug an SDK 1.6 service if SDK 2.0 is installed on the same machine.

• WindowsAzure.ServiceRuntime.dll, WindowsAzure.Configuration.dll and the caching assemblies are now built against the .Net framework 4.0 runtime. Therefore you will have to retarget your framework 3.5 application to 4.0 after migrating to Windows Azure SDK 2.0.

• We also recently published Windows Azure Cloud Service Support Policy which you can view in detail at http://support.microsoft.com/gp/azure-cloud-lifecycle-faq.

Learn More

You can also learn more about today’s SDK release, and see some demos of it in action, from my visit to this week’s latest Cloud Cover Show on Channel9:

Summary

Today’s release includes a bunch of great features that enable you to build even better cloud solutions.  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  Then visit the Windows Azure .NET Developer Center to learn more about how to build apps using today’s SDK release.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

This morning we released some great enhancements to Windows Azure. These new capabilities include:

• Virtual Networks: New Point-to-Site Connectivity (very cool!), Software VPN Device and Dynamic DNS Support
• Virtual Machines: Remote PowerShell and Linux SSH provisioning enhancements
• Cloud Services: Enable Remote Desktop Support Dynamically on Web/Worker Roles
• Ruby SDK: A new Windows Azure SDK support for Ruby

All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:

Virtual Networks: New Point-to-Site Connectivity and Software VPN Device support

Last week we announced the general availability of Virtual Network support as part of our IaaS release.

Virtual Networking allows you to create a private, isolated network in Windows Azure and treat it as an extension of your on-premises datacenter. For example, you can assign private IP addresses to virtual machines inside a virtual network, specify a DNS, and securely connect it to your on-premises infrastructure using a VPN device in a site-to-site manner.

Here’s a visual representation of a typical site-to-site scenario through a secure Site-To-Site VPN connection:

Today, we are excited to announce that we’re expanding the capabilities of Virtual Networks even further to enable three new scenarios:

New Point-To-Site Connectivity

With today’s release we’ve added an awesome new feature that allows you to setup VPN connections between individual computers and a Windows Azure virtual network without the need for a VPN device. We call this feature Point-to-Site Virtual Private Networking. This feature greatly simplifies setting up secure connections between Windows Azure and client machines, whether from your office environment or from remote locations. 

It is especially useful for developers who want to connect to a Windows Azure Virtual Network (and to the individual virtual machines within it) from either behind their corporate firewall or a remote location. Because it is point-to-site they do not need their IT staff to perform any activities to enable it, and no VPN hardware needs to be installed or configured.  Instead you can just use the built-in Windows VPN client to tunnel to your Virtual Network in Windows Azure.  This tunnel uses the Secure Sockets Tunneling Protocol (SSTP) and can automatically traverse firewalls and proxies, while giving you complete security.

Here’s a visual representation of the new point-to-site scenarios now enabled:

In addition to enabling developers to easily VPN to Windows Azure and directly connect to machines, the new Point-to-Site VPN support enables some other cool new scenarios:

• Small businesses (or departments within an enterprise) who don’t have existing VPN devices and/or network expertise to manage VPN devices can now rely on the Point-to-Site VPN feature to securely connect to their Azure deployments. Because the VPN software to connect is built-into Windows it is really easy to enable and use.

• You can quickly set up secure connections without the involvement from the network administrator, even if your computers are behind a corporate proxy or firewall. This is great for cases where you are at a customer site or working in a remote location (or a coffee shop). 

How to Enable the Point-to-Site Functionality

With today’s release we’ve updated the Virtual Network creation wizard in the Portal so that you can now configure it to enable both ‘Site-to-Site’ and ‘Point-to-Site’ VPN options.  Create a Virtual Network using the “Custom Create” option to enable these options:

Within the Virtual Network Custom Create wizard you can now click a checkbox to enable either the Point-To-Site or Site-To-Site Connectivity options (or both at the same time):

On the following screens you can then specify the IP address space of your Virtual Network.  Once the network is configured, you will create and upload a root certificate for your VPN clients, start the gateway, and then download the VPN client package.  You can accomplish these steps using the “Quick Glance” commands on the Virtual Network dashboard as well as the “Create Gateway” button on the command-bar of the dashboard.  Read this tutorial on how to “Configure a Point-to-Site VPN in the Management Portal” for detailed instructions on how to do this.

After you finish installing the VPN client package on your machine, you will see a new connection choice in your Windows Networks panel.  Connecting to this will establish a secure VPN tunnel your Windows Azure Virtual Network:

Once you connect you will have full IP level access to all virtual machines and cloud services hosted in your Azure virtual network!  No hardware needs to be installed to enable it, and it works behind firewalls and proxy servers.  Additionally, with this feature, you don’t have to enable public RDP endpoints on virtual machines to connect to them - you can instead use the private IP addresses of your virtual private network to RDP to them through the secure VPN connection.

For details instructions on how to do all of the above please read our Tutorial on how to “Configure a Point-to-Site VPN in the Management Portal”

Software VPN Device support for Site-to-Site

With today’s release we are also adding software VPN device support to our existing ‘Site-to-Site VPN’ connectivity solution (which previously required you to use a hardware VPN device from Cisco or Juniper). Starting today we also now support a pure software based Windows Server 2012 ‘Site-to-Site’ VPN option.  All you need is a vanilla Windows Server 2012 installation. You can then run download and run a PowerShell script from the Windows Azure Management Portal that enables the Routing and Remote Access Service (RRAS) on the Windows Server and configures a Site-To-site VPN tunnel and routing table on it.  Sandrino Di Mattia has a step-by-step tutorial on how to do this here.

This allows you to enable a full site-to-site VPN tunnel that connects your on-premises network and machines to your virtual network within Windows Azure - without having to buy a hardware VPN device.

Dynamic DNS Support

With today’s release we have also relaxed restrictions around DNS server setting updates in virtual networks. You can now update the DNS server settings of a virtual network at any time without having to redeploy the virtual network and the VMs in them. Each VM in the virtual network will pick up the updated settings when the DNS is refreshed on that machine, either by renewing the DNS settings or by rebooting the instance.  This makes updates much simpler.

If you’re interested further in Windows Azure Virtual Networks, and the capabilities and scenarios it enables, you can find more information here.

Virtual Machines: Remote PowerShell and Linux SSH provisioning enhancements

Last week we announced the general availability of Virtual Machine support as part of our IaaS release. With today’s update we are adding two nice enhancements:

Support for Optionally Enabling Remote PowerShell on Windows Virtual Machines

With today’s update, we now enable you to configure whether remote PowerShell is enabled for Windows VMs when you provision them using the Windows Azure Management Portal. This option is now available when you create a Virtual Machine using the FROM GALLERY option in the portal:

The last step of the wizard now provides a checkbox that gives you the option of enabling PowerShell Remoting:

When the checkbox is selected the VM enables remote PowerShell, and a default firewall endpoint is created for the deployment.  This enables you to have the VM immediately configured and ready to use without ever having to RDP into the instance.

Linux SSH Provisioning

Previously, Linux VMs provisioned using Windows Azure defaulted to using a password as their authentication mechanism – with provisioning Linux VMs with SSH key-based authentication being optional. Based on feedback from customers, we have now made SSH key-based authentication the default option and allow you to omit enabling a password entirely if you upload a SSH key:

Cloud Services: Enabling Dynamic Remote Desktop for a Deployed Cloud Service

Windows Azure Cloud Services support the ability for developers to RDP into web and worker role instances.  This can be useful when debugging issues.

Prior to today’s release, developers had to explicitly enable RDP support during development – prior to deploying the Cloud Service to production.  If you forgot to enable this, and then ran into an issue in production, you couldn’t RDP into it without doing an app update and redeploy (and then waiting to hit the issue again).

With today’s release we have added support to enable administrators to dynamically configure remote desktop support – even when it was not enabled during the initial app deployment.  This ensures you can always debug issues in production and never have to redeploy an app in order to RDP into it.

How to Enable Dynamic Remote Desktop on a Cloud Service

Remote desktop can be dynamically enabled for all the role instances of a Cloud Service, or enabled for an individual role basis.  To enable remote desktop dynamically, navigate to the Configure tab of a cloud service and click on the REMOTE button:

This will bring up a dialog that enables you to enable remote desktop – as well as specify a user/password to login into it:

Once dynamically enabled you can then RDP connect to any role instance within the application using the username/password you specified for them.

Windows Azure SDK for Ruby

Windows Azure already has SDKs for .NET, Java, Node.js, Python, PHP and Mobile Devices (Windows 8/Phone, iOS and Android).  Today, we are happy to announce the first release of a new Windows Azure SDK for Ruby (v0.5.0).

Using our new IaaS offering you can already build and deploy Ruby applications in Windows Azure.  With this first release of the Windows Azure SDK for Ruby, you can also now build Ruby applications that use the following Windows Azure services:

• Storage: Blobs, Tables and Queues
• Service Bus: Queues and Topics/Subscriptions

If you have Ruby installed, just do a gem install azure to start using it.  Here are some useful links to learn more about using it:

• Ruby Developer Center
• GitHub repository
• Ruby gem
• Rdoc

Like all of the other Windows Azure SDKs we provide, the Windows Azure SDK for Ruby is a fully open source project hosted on GitHub. The work to develop this Ruby SDK was a joint effort between AppFog and Microsoft. I’d like to say a special thanks to AppFog and especially their CEO Lucas Carlson for their passion and support with this effort.

Summary

Today’s release includes a bunch of nice features that enable you to build even better cloud solutions.  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  Then visit the Windows Azure Developer Center to learn more about how to build apps with it.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

This Tuesday, April 23, we’ll be hosting Windows AzureConf – a free online event for and by the Windows Azure community.  It will be streamed online from 9:00 AM - 5:00 PM PST via Channel 9, and you can watch it all for free.

I’ll be kicking off the event with a Windows Azure keynote in the morning (a great way to learn more about Windows Azure if you haven’t used it yet!). Following my talk the rest of the day will be full of excellent presentations from members of the Windows Azure community.  You can ask questions from them live and I think you’ll find the day an excellent way to learn more about Windows Azure – as well as hear directly from developers building solutions on it today.

Last year’s Windows AzureConf was a great success, and brought some awesome community members together to deliver some great content around Windows Azure. All of the sessions are available for on-demand viewing on the Windows AzureConf 2012 event page on Channel 9. Sessions from Windows AzureConf 2012 are still available for viewing online.

For more information including a schedule, speaker list or to register visit the Windows AzureConf website.

Hope to see you there!

Scott

P.S. We will also make the presentations available for download after the event in case you miss them.

We’ve seen a huge adoption of ASP.NET Web API since its initial release.  In February we shipped the ASP.NET and Web Tools 2012.2 Update – which added a number of additional enhancements to both Web API and the other components of ASP.NET. 

The ASP.NET Team has been hard at work on developing the next set of features (lots of cool stuff coming).  One of the great things about this work has been how the team has used the open source development process – which we announced we were adopting last spring - to collaborate even more closely with the community to both validate the features early, as well as enable developers in the community to directly contribute to the development of them.

Below are some updates on two of the great features coming to ASP.NET Web API – which were developed and contributed by ASP.NET MVP Brock Allen and Tim McCall (of attributerouting.net fame):

CORS support for ASP.NET Web API

Cross-origin resource sharing (CORS) is a W3C standard that allows web pages to make AJAX requests to a different domain. This standard relaxes the same-origin policy implemented in web browsers that restricts calls to the domain of the resource that makes the call. The CORS specification defines how the browser and server interact to make cross-origin calls.

The following image shows the ASP.NET Web API Test Tool (running on http://xyz123.azurewebsites.net/) making a cross domain call to the Contoso domain. When you click Send, a cross-origin request is made. Because the Contoso site is not configured to support CORS, an error dialog is displayed.

The CORS error appears on the Console tab of the IE F12 tools.

For security reasons, the web browser doesn’t allow calls from the azurewebsites domain to the Contoso domain. With the new ASP.NET Web API CORS framework, Contoso.com can be configured to send the correct CORS headers so the browser will accept cross-origin calls.

MVP Brock Allen contributed his CORS source to the ASP.NET Webstack repository. Brock worked with Yao Huang Lin (a developer on the ASP.NET team), to refine and iterate the design and then to get it pulled into the Webstack repository. Brock Allen, Dan Roth, and Yao discuss Brock’s CORS contribution in this Channel 9 video.

The CORS support for ASP.NET Web API page shows how to get started with this new feature.

Attribute-Based Routing in ASP.NET Web API

We recently published in the ASP.NET Web API roadmap our intention to support attribute- based routing in ASP.NET Web API. Route attributes bring the URL definition closer to the code that runs for that particular URL, making it easier to understand which URL must be called for a particular block of code and simplifying many common routing scenarios.

For example, let’s say you want to define a Web API that has the standard set of HTTP actions (GET, POST, PUT, DELETE, and so on) but you also want to have an additional custom action, such as Approve. Instead of adding another route to the global route table for the Approve action, you can instead just attribute the action directly:

    public class OrdersController : ApiController

    {

        public IEnumerable<Order> GetOrders() {…}

        public Order GetOrder(int id) {…}

        public Order Post(Order order) {…}

        [HttpPost("orders/{id}/approve")]

        public Order Approve(int id) {…}

    }

An extended route template syntax makes it simple to specify default values and constraints for route values. For example, you can now easily create two actions that are called based on parameter type. In the following People controller, the id parameter of the GetByID action takes only int values. The GetByName action method contains a default name of “Nick”.

    public class PeopleController : ApiController

    {

        [HttpGet("{name=Nick}")]

        public string GetByName(string name) {…}

 

        [HttpGet("{id:int}")]

        public string GetById(int id) {…}

    }

You can also define common route prefixes for your web APIs. For example, you can use route prefixes to set up a resource hierarchy:

    [RoutePrefix("movies")]

    [RoutePrefix("actors/{actorId}/movies")]

    [RoutePrefix("directors/{directorId}/movies")]

    public class MoviesController : ApiController

    {

        public IEnumerable<Movie> GetMovies() {…}

        public IEnumerable<Movie> GetMoviesByActor(int actorId) {…}

        public IEnumerable<Movie> GetMoviesByDirector(int directorId) {…}

    }

Or, you can use route prefixes to handle multiple versions of your web API:

    [RoutePrefix("api/v1/customers")]

    public class CustomersV1Controller : ApiController {…}

   

    [RoutePrefix("api/v2/customers")]

    public class CustomersV2Controller : ApiController {…}

Similar to the new CORS support in ASP.NET Web API, the new support for attribute-based routing is largely a contribution from the community. We are working closely with Tim McCall of attributerouting.net fame to bring many of the features of his AttributeRouting project directly into ASP.NET Web API.

It’s really exciting to see how these collaborations across the ASP.NET Team and the community are helping to move the ASP.NET platform forward!

Hope this helps,

Scott

P.S. In addition to blogging, I use Twitter to-do quick posts and share links. My Twitter handle is: @scottgu

This morning we announced the general availability release of our Infrastructure as a Service (IaaS) support for Windows Azure – including our new Virtual Machine and Virtual Network capabilities.  This release is now live in production, backed by an enterprise SLA, supported by Microsoft Support, and is ready to use for production apps.  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using it today.

In addition to supporting all of the features and capabilities included during the preview, today’s IaaS release also includes some great new enhancements:

• New VM Image Templates (including SQL Server, BizTalk Server, and SharePoint images)
• New VM Sizes (including Larger Memory Machines)
• New VM Prices (we’ve reduced prices 21%-33% for IaaS and PaaS VMs)

Below are more details on today’s release and some of the new enhancements.  You can also read Bill Hilf’s blog post to learn about some of the customers who are already using the IaaS capabilities in production.

Windows Azure Virtual Machines

Windows Azure Virtual Machines enable you to deploy and run durable VMs in the cloud.  You can easily create these VMs from an Image Gallery of pre-populated templates built-into the Windows Azure Management Portal, or alternatively upload and run your own custom-built VHD images.  Our built-in image gallery of VM templates includes both Windows Server images (including Windows Server 2012, Windows Server 2008 R2, SQL Server, BizTalk Server and SharePoint Server) as well as Linux images (including Ubuntu, CentOS, and SUSE Linux distributions).

Windows Azure uses the same Hyper-V virtualization service built-into Windows Server 2012, which means that you can create and use a common set of VHDs across your on-premises and cloud environments.  No conversion process is required as you move these VHDs into or out of Windows Azure – your VMs can be copied up and run as-is in the cloud, and the VMs you create in Windows Azure can also be downloaded and run as-is on your on-premise Windows 2012 Servers.  This provides tremendous flexibility, and enables you to easily build hybrid solutions that span both cloud and on-premises environments.

Easy to Get Started

You can quickly create a new VM in only a few seconds using the Windows Azure Management Portal.  Just click the New command on the bottom left of the portal, and then use the Virtual Machine->Quick Create option to instantiate a new Virtual Machine anywhere in the world (if you want to do this via the command line you can also download our command-line-tools for Windows-based PowerShell users or for Linux/Mac users).

Once you create a new VM instance you can easily Remote PowerShell, SSH, or Terminal Server into it in order to customize the VM however you want (and optionally capture your own custom image snapshot of it to use when creating new VM instances).  This provides you with the flexibility to run pretty much any workload within Windows Azure.

Integrated Management and Monitoring

In addition to enabling you to create VMs, the Windows Azure Management Portal also provides built-in management and monitoring support of them once they are running:

Durable Data Disks

Virtual Machines in Windows Azure can optionally attach and use data disks for storage (each disk can be up to 1 TB in size):

Once attached, these disks look like standard disks/devices to a Virtual Machine, and you can format them using whatever disk format you want (e.g. NTFS for Windows, ext3 or ext4 for Linux, etc).  The disks are both persistent and highly durable, and are implemented on top of Windows Azure Blob Storage (which ensures that each drive is maintained in triplicate for high availability).

Built-in Load Balancer Support

Virtual Machines in Windows Azure can also optionally utilize a network load-balancer (LB) at no extra charge – enabling you to distribute traffic sent to a single IP address/port to multiple VM machine instances.  You can use the load balancer to both both scale out your apps, as well as provide better fault tolerance when a VM is down or you are performing maintenance on it.  The load balancer can automatically remove the machine from rotation when this happens:

Setting up load-balancing across VMs is easy – just click the the Endpoints tab within a VM in the Windows Azure Management Portal and then choose to add an endpoint to the VM (for the first VM you want to add), and then select “load-balance traffic on an existing endpoint” for the subsequent VM instances:

You can find more details on how to configure a set of load-balanced VMs in this common task on load-balanced sets.

Windows Azure Virtual Networks

Along with the general availability of Windows Azure Virtual Machines, we are also today announcing the general availability of Windows Azure Virtual Networks.  Windows Azure Virtual Networks enable you to accomplish the following tasks:

• Create a virtual private network with persistent private IPs: You can bring your preferred private IPv4 space (10.x, 172.x, 192.x) to Windows Azure using a Virtual Network. Furthermore, Virtual Machines within a Virtual Network will have a stable private IP address, even across hardware failures.

• Cross-premises connectivity over site-to-site IPsec VPNs: You can extend your on-premises network to Windows Azure and treat Virtual Machines in Windows Azure as a part of your organization’s existing network using a Virtual Network gateway to broker the IPSec connection. We support standard VPN hardware devices from Cisco and Juniper to enable this.

• Configure custom DNS servers: Using a Virtual Network, you can point your Virtual Machines to a DNS server on-premises or a DNS server running in Windows Azure on the same Virtual Network. This also enables running a Windows Server Active Directory domain controller on Windows Azure.

• Extended trust and security boundary: Deploying Virtual Machines into a Virtual Network will extend the trust boundary to that Virtual Network. You can create several Virtual Machines and Cloud Services within a single Virtual Network and have them communicate using the private address space. This allows simple communication between different Virtual Machines or even Virtual Machines and web/worker roles in separate Cloud Services, without having to go through a public IP address. Furthermore, Virtual Machines outside the Virtual Network have no way to identify or connect to services hosted within Virtual Network, providing an added layer of isolation to your services.

Creating a Virtual Network

Creating a virtual network in Windows Azure is easy, just click the New command on the bottom left of the portal, and then use the Networks>Virtual Network->Quick Create (or Custom Create) option to instantiate a new Virtual Network:

Virtual Networks can be created and used in Windows Azure for free. The only thing we charge extra for is if you enable the VPN gateway support – at which point we charge a per hour + bandwidth usage fee.  You can find more information on Virtual Network and how it complements our Virtual Machine offering here.

New VM Image Templates (including SQL Server, BizTalk, and SharePoint images)

Today’s Windows Azure release includes several new VM image templates that you can use to easily create and run new Virtual Machines.  These include several new SQL Server 2012 images (including standard and enterprise edition templates), new BizTalk Server 2013 images (including Evaluation, Standard and Enterprise editions), and a new SharePoint Server 2013 image:

Hourly Billing Support

In addition to making it easier and faster to get started, these SQL Server and BizTalk Server images also enable an hourly billing model which means you don’t have to pay for an upfront license of these server products – instead you can deploy the images and pay an additional hourly rate above the standard OS rate for the hours you run the software.  This provides a very flexible way to get started with no upfront costs (instead you pay only for what you use).  You can learn more about the hourly rates here.

More Details on SQL Server, BizTalk and SharePoint Server

More details on deploying SQL Server in Windows Azure Virtual Machines can be found here and details on BizTalk Server can be found here. 

This week we are also releasing a SharePoint deployment guide as well as PowerShell Scripts that make it easy to get started with SharePoint on Windows Azure – and to enable the automation of a complete SharePoint farm.  Once deployed, you can also administer SharePoint 2013 directly using PowerShell.

New VM Sizes (including Larger Memory Options)

With today’s Windows Azure release we are also adding two new VM size options to the existing 5 VM sizes we supported during the public preview.  These two new VM sizes include a new 4 core x 28GB RAM configuration as well a 8 core x 56GB RAM configuration.  You can now select these options when you create a new VM:

These new VM sizes enable you to run even larger workloads with Windows Azure.  More details on the different sizes and their capabilities can be found here.

New VM Prices (including a price drop of 21% to 33%)

With today’s Windows Azure release we are also announcing significant price reductions to our Windows Azure compute options.  This new pricing delivers a 21% price reduction from the previously announced pricing of Windows Azure Virtual Machines (IaaS), and a 33% price reduction for solutions deployed using our Windows Azure Cloud Services (PaaS) model.  Our new VM pricing also matches Amazon’s on-demand VM pricing for both Windows and Linux VMs.

New Windows Azure Virtual Machine Compute Pricing

Below are the new hourly on-demand rates for Windows Azure Virtual Machines:

Size Name

# of CPU Cores

Memory

Windows VM Pricing

Linux VM Pricing

ExtraSmall

Shared

768 MB

$0.02 per hour

$0.02 per hour

Small

1

1.75 GB

$0.09 per hour

$0.06 per hour

Medium

2

3.5 GB

$0.18 per hour

$0.12 per hour

Large

4

7 GB

$0.36 per hour

$0.24 per hour

ExtraLarge

8

14 GB

$0.72 per hour

$0.48 per hour

A6

4

28 GB

$1.02 per hour

$0.82 per hour

A7

8

56 GB

$2.04 per hour

$1.64 per hour

Note that the above prices are for hourly on-demand usage (meaning there is no commitment to use them for more than an hour and you pay only for what you consume).  Complete pricing details for Windows Azure Virtual Machines can be found here.

Commitment Pricing Discounts

You can also optionally take advantage of our 6 Month and 12 Month commitment plans to obtain significant discounts on the standard pay as you go rates.  With a commitment plan you commit to spend a certain amount of money each month and in return we give you a discount on any Windows Azure resource you use that money on (and the more money you commit to use the bigger the discount we give).

One of the nice aspects of our Windows Azure commitment plans is that they don’t lock you into having to specify upfront the number of VMs or specific VM sizes you want to use (or which regions or availability zones you want to use them in).  Instead you simply commit to spend a certain amount of money each month and we’ll give you a discount on any Windows Azure resource you use that money on.  This provides you with the flexibility to change your VM deployment sizes dynamically without having to worry about being locked into a particular configuration, as well as the option to spend the commitment on both IaaS + PaaS based services (and take advantage of a discount on both).  You can learn more about our commitment pricing plans here.

Other Improvements

Today’s Windows Azure release also includes a number of other small VM enhancements including:

• Increased default OS disk size: During the preview our default OS disk partition size was 30GB.  Based on customer feedback all of our new images now default to 127GB in size for the OS partition.

• Ability to customize the Administrator username: We now enable you to customize the login name of the administrator account when creating VM images.  This enables you to avoid always having a well known username on your VMs (a good security best practice).

• Remote PowerShell Enabled By Default: When deploying your Virtual Machine using PowerShell, we now enable remote PowerShell by default in all Windows Server OS images - including the SQL Server, BizTalk Server, and SharePoint images.  This makes it easier to automate setting up VMs without having to ever login interactively to a newly deployed instance.

Summary

We are really excited about today’s release – we know people have been looking forward to this release for awhile.  We’d like to say a special thanks to everyone who used it during the preview and gave us feedback on it. 

Today’s release now allows everyone to build better cloud solutions than ever before.  These solutions can now integrate IaaS and PaaS together, use both Windows and Linux based software together, and deliver value faster than ever before.  We are really looking forward to the solutions you build with it.

If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

On April 27, something very cool is happening. A bunch of Windows Azure MVP's and community activists are organizing a Global Windows Azure Bootcamp. This is a completely free, one-day training event for Windows Azure, all organized by the community, and presented in person all over the World.

I’m not sure if this is the largest community event ever - it is very cool to see how many places this event is happening.  Below is the location map as it stands today – and new locations are being added daily. Right now there are almost 100 locations and several thousand attendees already registered to take part.  Browse the location listings to find a location near you.

If you are interested in learning about Windows Azure or want more info, checkout the Global Windows Azure Bootcamp website to learn more about the bootcamps.  Then find a location near you, sign-up and attend the event for free, and get involved with the Windows Azure community near you!

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

Today we released some great enhancements to Windows Azure. These new capabilities include:

• Active Directory: General Availability release of Windows Azure AD – it is now ready for production use!
• Backup Service: New Service that enables secure offsite backups of Windows Servers in the cloud
• Web Sites: Monitoring and Diagnostic Enhancements

All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:

Active Directory: Announcing the General Availability release

I’m excited to announce the General Availability (GA) release of Windows Azure Active Directory!  This means it is ready for production use.

All Windows Azure customers can now easily create and use a Windows Azure Active Directory to manage identities and security for their apps and organizations.  Best of all, this support is available for free (there is no charge to create a directory, populate it with users, or write apps against it).

Creating a New Active Directory

All Windows Azure customers (including those that manage their Windows Azure accounts using Microsoft ID) can now create a new directory by clicking the “Active Directory” tab on the left hand side of the Windows Azure Management Portal, and then by clicking the “Create your directory” link within it:

Clicking the “Create Your Directory” link above will prompt you to specify a few directory settings – including a temporary domain name to use for your directory (you can then later DNS map any custom domain you want to it – for example: mycompanyname.com):

When you click the “Ok” button, Windows Azure will provision a new Active Directory for you in the cloud.  Within a few seconds you’ll then have a cloud-hosted Directory deployed that you can use to manage identities and security permissions for your apps and organization:

Managing Users within the Directory

Once a directory is created, you can drill into it to manage and populate new users:

You can choose to maintain a “cloud only” directory that lives and is managed entirely within Windows Azure.  Alternatively, if you already have a Windows Server Active Directory deployment in your on-premises environment you can set it up to federate or directory sync with a Windows Azure Active Directory you are hosting in the cloud.  Once you do this, anytime you add or remove a user within your on-premises Active Directory deployment, the change is immediately reflected as well in the cloud.  This is really great for enterprises and organizations that want to have a single place to manage user security.

Clicking the “Directory Integration” tab within the Windows Azure Management Portal provides instructions and steps on how to enable this:

Enabling Apps

Starting with today’s release, we are also greatly simplifying the workflow involved to grant and revoke directory access permissions to applications.  This makes it much easier to build secure web or mobile applications that are deployed in the cloud, and which support single-sign-on (SSO) with your enterprise Active Directory.

You can enable an app to have SSO and/or richer directory permissions by clicking the new “Integrated Apps” tab within a directory you manage:

Clicking the “Add an App” link will then walk you through a quick wizard that you can use to enable SSO and/or grant directory permissions to an app:

Programmatic Integration

Windows Azure Active Directory supports several of the most widely used authentication and authorization protocols.  You can find more details about the protocols we support here.

Today’s general availability release includes production support for SAML 2.0 – which can be used to enable Single Sign-On/Sign-out support from any web or mobile application to Windows Azure Active Directory.  SAML is particularly popular with enterprise applications and is an open standard supported by all languages + operating systems + frameworks. 

Today’s release of Windows Azure Active Directory also includes production support of the Windows Azure Active Directory Graph – which provides programmatic access to a directory using REST API endpoints.  You can learn more about how to use the Windows Azure Active Directory Graph here.

In the next few days we are also going to enable a preview of OAuth 2.0/OpenID support which will also enable Single Sign-On/Sign-out support from any web or mobile application to Windows Azure Active Directory.

For a more detailed discussion of the new Active Directory support released today, read Alex Simons’ post on the Active Directory blog.  Also review the Windows Azure Active Directory documentation on MSDN and the following tutorials on the windowsazure.com website.

Windows Azure Backup: Enables secure offsite backups of Windows Servers in the cloud

Today’s Windows Azure update also includes the preview of some great new services that make it really easy to enable backup and recovery protection with Windows Server.

With the new Windows Azure Backup service, we are adding support to enable offsite backup protection for Windows Server 2008 R2 SP1 and Windows Server 2012, Windows Server 2012 Essentials, and System Center Data Protection Manager 2012 SP1 to Windows Azure. You can manage cloud backups using the familiar backup tools that administrators already use on these servers - and these tools now provide similar experiences for configuring, monitoring, and recovering backups be it to local disk or Windows Azure Storage. After data is backed up to the cloud, authorized users can easily recover backups to any server. And because incremental backups are supported, only changes to files are transferred to the cloud. This helps ensure efficient use of storage, reduced bandwidth consumption, and point-in-time recovery of multiple versions of the data. Configurable data retention policies, data compression, encryption and data transfer throttling also offer you added flexibility and help boost efficiency.

Managing your Backups in the Cloud

To get started, you first need to sign up for the Windows Azure Backup preview.

Then login to the Windows Azure Management Portal, click the New button, choose the Recovery Services category and then create a Backup Vault:

Once the backup vault is created you’ll be presented with a simple tutorial that will help guide you on how to register your Windows Servers with it:

Once the servers are registered, you can use the appropriate local management interface (such as the Microsoft Management Console snap-in, System Center Data Protection Manager Console, or Windows Server Essentials Dashboard) to configure the scheduled backups and to optionally initiate recoveries. You can follow these tutorials for these:

• Tutorial: Schedule Backups Using the Windows Azure Backup Agent This tutorial helps you with setting up a backup schedule for your registered Windows Servers. Additionally, it also explains how to use Windows PowerShell cmdlets to set up a custom backup schedule.

• Tutorial: Recover Files and Folders Using the Windows Azure Backup Agent This tutorial helps you with recovering data from a backup. Additionally, it also explains how to use Windows PowerShell cmdlets to do the same tasks.

Within the Windows Azure Management Portal, you can drill into a backup value and click the SERVERS tab to see which Windows Servers have been configured to use it.  You can also click the PROTECTED ITEMS tab to view the items that have been backed up from the servers,

Web Sites: Monitoring and Diagnostics Improvements

Today’s Windows Azure update also includes a bunch of new monitoring and diagnostic capabilities for Windows Azure Web Sites.  This includes the ability to easily turn on/off tracing and store trace + log information in log files that can be easily retrieved via FTP or streamed to developer machines (enabling developers to see it in real-time – which can be super useful when you are trying to debug an issue and the app is deployed remotely).  The streaming support allows you to monitor the “tail” of your log files – so that you only retrieve content appended to them – which makes it especially useful when you clicking want to check something out without having to download the full set of logs.

The new tracing support integrates very nicely with .NET’s System.Diagnostics library as well as ASP.NET’s built-in tracing functionality.  It also works with other languages and frameworks.  The real-time streaming tools are cross platform and work with Windows, Mac and Linux dev machines.

Read Scott Hanselman’s awesome tutorial and blog post that covers how to take advantage of this new functionality.  It is very, very slick.

Other Cool Things

In addition to the features above, there are several other really nice improvements added with today’s release. These include:

• HDInsight: We launched our new HDInsight Hadoop Service 3 weeks ago.  Today’s update adds the ability to see diagnostic metrics for your HDInsight services in the Windows Azure Management Portal (they are surfaced in the dashboard view now – just like every other service).  This makes it really easy to monitor the number of active map and reduce tasks your service currently is processing.

• Operation Logs: The Windows Azure operation audit logs (which you can view by clicking the “Settings” tab on the left of the Windows Azure Management Portal) now shows the user account name who performed each operation on the account.  This makes it much easier to track who did what on your services.

• Media Services: You can now choose from a wider variety of presets when encoding video content with the portal. 

• Virtual Machines: We have increased the default OS disk size for new VMs that are created, and now allow you to specify the default user name for the VM.

Summary

The above features are now available to start using immediately (note: some of the services are still in preview).  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using them today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it!

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

We launched the Microsoft Accelerator for Windows Azure, powered by TechStars, to give early stage startups full access to Windows Azure and to help them succeed by connecting each company to leading technical and business mentors. I’m happy to share that the new spring 2013 class features a healthy mix of exciting solutions and an impressive list of founders whose feedback will directly inform future Windows Azure releases.

Today, the ten new teams in the Microsoft Accelerator for Windows Azure, powered by TechStars, moved into their South Lake Union office space.

This spring’s Windows Azure class includes:

• 1Track—Bellevue, WA. 1Track enhances the consumer in-store shopping experience and drives sales for retailers.
• Airpost.io—Toronto, CA. Airpost unifies cloud storage services to allow people to access files from anywhere.
• Azuqua—Bellevue, WA. Azuqua helps companies build integrated cloud-based enterprise apps in ten minutes or less.
• Beehive Biometrics—Austin, TX. Beehive is a service that enables developers to incorporate biometric matching into apps with a single line of code.
• Boxella—Redmond, WA. Boxella helps retailers sell add-on products through an app that tracks individual customer inventory.
• Builders Cloud—Bellevue, WA. Builders Cloud is a file-sharing and mobile collaboration platform for the construction industry.
• Factor.io—Portland, OR. Factor.io makes it easy for engineering teams to build their continuous integration and deployment pipeline.
• GiftGiv—Redmond, WA. GiftGiv makes business gifting simple while retaining the personal touch.
• nuMVC—Denver, CO. nuMVC is a content distribution platform that automates delivery of relevant content anywhere on the web.
• ScanMyList—Everett, WA. ScanMyList is a mobile app empowering businesses to efficiently utilize BI from sales and order information.

The Fall 2012 class has been busy since Demo Day and is leaving big shoes for the new class to fill.

• MetricsHub—the company behind Active Cloud Monitoring and automated cloud performance management—was recently acquired by Microsoft.
• Realty Mogul—crowdfunding for real estate—won the HATCH Pitch Competition at SXSW, made its service generally available, and just closed a $500,000 seed round of funding.
• Staq—a real-time analytics engine for games—joined email engagement experts Embarke in the Windows Azure Store.

I have high expectations for this class and look forward to the new and exciting ways these startups will use Windows Azure to iterate rapidly and deliver memorable customer experiences.

Keep an eye out for periodic updates as the teams approach Demo Day on June 26th.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

Today we released a number of great enhancements to Windows Azure. These new capabilities include:

• Mobile Services: HTML5/JS (CORS) Client + PhoneGap + Windows Phone 7.5 + .NET Portable Library support
• Web Sites: Mercurial Source Control + Dropbox Deployment support
• HDInsight: New service that enables you to easily deploy and manage Hadoop Clusters on Azure

All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:

Mobile Services: HTML5/JS Client (CORS), PhoneGap, Windows Phone 7.5

Today we are adding support to enable pure HTML5/JS clients (and PhoneGap apps) as well as Windows Phone 7.5 clients to use Windows Azure Mobile Services as a backend.  This comes in addition to the new Android SDK for Windows Azure Mobile Services we released two weeks ago (as well as the Windows 8, Windows Phone 8 and iOS support we had earlier).

HTML5/JS Clients

You can now connect both HTML5 web client apps as well as Apache Cordova/PhoneGap apps to your Mobile Services, and use Windows Azure for both data storage and authentication.  We are delivering this via:

• New Mobile Services web client library that supports IE8+ browsers, current versions of Chrome, Firefox, and Safari, plus PhoneGap 2.3.0+. It offers the same data querying and storage APIs support we have in other native SDKs, and allows easy user authentication via any of the four identity providers supported by Mobile Services (Microsoft Account, Google, Facebook, and Twitter). Please use the GitHub issue tracker to report any issues, and our forum to get help.

• Cross Origin Resource Sharing (CORS) support to enable your Mobile Service to accept cross-domain Ajax requests. You can now configure a whitelist of allowed domains for your Mobile Service using the Windows Azure management portal.

To get started, create a mobile service in the Windows Azure Management Portal and open the Quickstart tab. You can now select “HTML” and find the steps to create a new HTML5/JS client or add a backend to an existing one:

You can then continue with this tutorial for the remaining steps and build a simple HTML5 todo list app (that runs entirely in a browser) in under 5 minutes.

When deploying the HTML5 front-end app to a production environment, make sure to add the host name of the website you use to host it to your Windows Azure Mobile Services’ Cross-Origin Resource Sharing (CORS) whitelist using the Configure tab as shown below:

Visit the Windows Azure Mobile dev center and read this tutorial to learn more about working with server-side data, or this one if you want to learn more about authenticating users.

Windows Phone 7.5 Support and a new C# Client Library on NuGet

A few days ago we published a preview of our next version of the Mobile Services C# client library on NuGet.  The goal of this pre-release is to give Mobile Services developers an early look at the new features we are planning for our next C# SDK update and an opportunity to try them out ahead of time. Some of the great new features we have added include:

• Portable Library Support: We have consolidated our Windows 8 and Windows Phone 8 clients on top of a single codebase using Portable Libraries. This enables us to reach a variety of new client platforms, as well as enable you to call Mobile Services from your ASP.NET and .NET server backend.

• Windows Phone 7.5 support: With the move to Portable Libraries, we are also enabling support for Windows Phone 7.5

• Json.NET and HttpClient: We migrated our implementation to use the latest and most flexible HTTP components to enable maximum robustness and extensibility.

Note: Today’s drop is a pre-release. For production apps we recommend continuing to use the “stable” Mobile Service client libraries for .NET available for download here. 

Keep Giving Us Feedback

Please continue to visit our uservoice page to let us know what you’d like to see added next (today’s release added 3 of the top 5 asks in uservoice!). Email us to show off your app, and ask questions in our forum whenever you run into a problem. 

Web Sites: Mercurial and Dropbox Deployment Support

Today’s release also includes a number of deployment/publishing enhancements to Windows Azure Web Sites:

Mercurial Source Control Support

You can now use Mercurial (Hg) repositories when setting up continuous deployment of your Websites from your CodePlex or Bitbucket repositories.  This is in addition to the TFS, CodePlex, Git and GitHub source control provider support that we previously supported. 

Today’s release also includes improved UI that makes it even easier to setup deployment from source-control.  Simply click the “Setup deployment from source control” link on your web-site dashboard, and a new wizard will appear that makes it trivial to walkthrough setting up publishing endpoints using a variety of source control providers and sites.  For example, below is how you could choose to enable source code deployment from a public or private Mercurial (Hg) repository you might have on Bitbucket:

Dropbox Deployment Support

Windows Azure also now supports site/app deployment from Dropbox to Web sites, making website deployment as easy as copying files to a folder on your local computer.  To enable this from the Windows Azure management portal, click the “Set up deployment from source control” link on your Web site dashboard, choose Dropbox and authorize the connection, and then choose a Dropbox sub-folder to synchronize:

 

You can then simply copy your source files to the Dropbox sub-folder on your local computer and press the “Sync” button in the Windows Azure Portal to deploy the files.  Windows Azure will automatically build sources as needed, similar to Git or TFS based deployments.  Also, the deployment history tab in the portal will keep track of your deployments and enables you to re-deploy any previous deployment with the click of a button.

Watch this 2 minute screencast to see how easy it now is to deploy web sites to Windows Azure using Dropbox.

Improved UI for Managing Source Control Deployments

In addition to the new setup wizard for source control deployment, today’s Windows Azure release also includes some other nice enhancements to the source control UI.  Deployment history in the management portal now accurately reflects which source control provider is connected for continuous deployment, such as TFS, CodePlex, GitHub, or Bitbucket.  It is also now possible to disconnect from an already connected source provider on a web-site in order to set up a different one (previously you had to delete the site to do this).

TFS Certificate Renewal

It’s also now possible to renew the certificate used by Team Foundation Service for continuous deployment directly from the Windows Azure management portal. To do this, click the “Renew TFS certificate” link on either the Dashboard or Quick Start page.

Support for Regenerating the Publish Profile

Today you can download a publish profile from the Web Sites dashboard. Once that profile is downloaded, the credentials are basically good forever. We understand that this is not optimal. To address this, with today’s release we are introducing a new quick glance command in the dashboard called Reset publish profile credentials. When clicked, you will get a confirmation for resetting the credentials and the credentials are regenerated.

New HDInsight Server: Deploy and Manage Hadoop Clusters on Azure

Today we also released a public preview of the new HDInsight Service for Windows Azure. HDInsight provides everything you need to quickly deploy, manage and use Hadoop clusters running on Windows Azure.

If you have a Windows Azure account you can request access to the HDInsight Preview and then easily create an HDInsight cluster within the Windows Azure Management Portal. Within the Windows Azure Management Portal click the New button and select the new HDInsight service to create a Hadoop cluster.  Specify a name for the cluster, a password for logging into the cluster and the size of cluster you need:

Note: a storage account is required to create a cluster and in the current public preview the storage account must reside in the East US region. The Azure Storage account you associate with your cluster is where you will store the data that you will analyze in HDInsight.

HDInsight Clusters

A cluster will take a few minutes to create (as part of creating it will configure the necessary Virtual Machines that together make up your Hadoop cluster). The Hadoop components installed as part of an HDInsight cluster are outlined here. Once the cluster is created, you can drill into the dashboard view to see the cluster quick glance screen. This quick glance allows you to see the basic information about your cluster and gives you a simple method to connect to the cluster (just click the Manage button at the bottom of the dashboard).

When you connect to the cluster you’ll see a page that contains a number of tiles that provide information about the cluster and can be used to perform additional tasks:

The Create Job tile opens a MapReduce job submission form that you can use to submit MapReduce jobs as JAR files. The Interactive Console tile opens a console that lets you execute Javascript and Hive queries directly against your cluster.  The Samples title includes samples that you can use to get started.

Summary

The above features are now available to start using immediately (note: some of the services are still in preview).  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using them today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it!

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

This past weekend we released a number of enhancements to Windows Azure. These new capabilities include:

• Mobile Services: Android support, East Asia Region Support, iOS dev content
• SQL Reporting Services: Support in the management portal
• Active Directory: Support in the azure management portal, user and domain management
• Availability Monitoring for Cloud Services. Virtual Machines, Web Sites, and Mobile Services
• Service Bus: New configuration tab and metrics
• Storage: Ability to download blobs directly in management portal
• Media Services: New monitoring metrics and quickstart experience
• Cloud Services: Support for .cer certificate files upload
• Localization support for five new languages
• Windows Azure Store Support in 22 Additional Countries

All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:

Mobile Services: Android, East Asia Region, iOS Content

With the initial public preview of Windows Azure Mobile Services, we promised that we would deliver first-class support for developers building Windows 8, Windows Phone 8, iOS and Android apps. We launched last year with Windows 8 support and shortly after added Windows Phone, and the iOS support.

Android Support

Today I’m happy to announce Mobile Services support for the Android platform. The Android Client SDK is available on GitHub under the Apache 2.0 license and we welcome community contributions.

To create a new Android app or connect an existing Android app to your Windows Azure Mobile Service, simply select the “Android” tab within the Quick Start view of a Mobile Service, and then follow either the “Create a new Android app” or “Connect to an existing Android app” link below it:

Clicking either of these links will expand and display step-by-step instructions for how to build an Android application connected with your Windows Azure Mobile Service.

Read this getting started tutorial to walkthrough how you can build (in less than 5 minutes) a simple Android “Todo List” app that stores data in Windows Azure.

Android Push Notifications

Windows Azure Mobile Services makes it easy to add push notification support to your apps without headaches. To send push notifications to your Android device, register for Google Cloud Messaging using https://code.google.com/apis/console and obtain your API key, then simply paste that key on the Mobile Services ‘Push’ tab:

After you’ve entered your API key, you can then send a notification from any server script under the ‘Data’ tab using the following code:

push.gcm.send(registrationId, 'A new Mobile Services task', {
     success: function(response) {
          console.log('Push notification sent: ', response);
     },
     error: function(error) {
          console.log('Error sending push notification: ', error);
     }
});

Visit the Windows Azure Mobile dev center for the full Android tutorials that cover:

• Getting started with data
• Authenticating users
• Sending push notifications

After you get up to speed with Android on Mobile Services, I encourage you to take a look at two additional Android samples for Mobile Services: TicTacToe Leaderboard and Feedback.

Mobile Services Availability in the East Asia Region

With this week’s release we also added the ability to deploy your Mobile Services to the East Asia region of Windows Azure in order to reduce latency for applications with customers in Asia.

As always, remember to deploy your Mobile Service and Windows Azure SQL database to the same data center in order to minimize latency.

Great iOS Developer Content

Earlier in November we released Windows Azure Mobile Services support for iOS. We recently invited Brent Simmons, the well-known iOS developer and creator of NetNewsWire to give Mobile Services a try.

If you haven’t tried Mobile Services yet, join Brent and follow his great video series on building iOS applications with Mobile Services.

Keep the Feedback Coming

This week’s Mobile Services updates are the direct result of your feedback. Please visit our uservoice page to let us know what you’d like to see added next, email us to show off your app, and ask questions in our forum whenever you run into a problem.

SQL Reporting Services Management

You can now create and manage SQL Reporting Services from within the Windows Azure management portal (previously this was not supported in the new HTML portal).  The SQL Reporting Service lets you upload pre-created reports, view metrics over reports that you manage, manage permissions for users accessing reports, data sources and folders. To get started, create a SQL Reporting service by selecting NEW -> SQL REPORTING -> QUICK CREATE.

Once created, the QUICK START tab provides useful information for you to get started including links to tools and helpful articles on MSDN:

You can monitor the average and maximum number of reports processed in the dashboard view of your SQL reporting service.  You can add users and manage permissions using the Users and Items tabs.

Active Directory Integration

We have made some great improvements with this week’s release in bringing enterprise level identity management to Windows Azure.  Companies who sign up for Windows Azure as organizations (by creating a new Windows Azure Active Directory or signing up for Windows Azure with their Office 365 identity) will now find several new capabilities in the Windows Azure Management Portal:

• Ability to create and manage user accounts in your Windows Azure Active Directory.
• Phone based two factor authentication for users who are Global Administrators in Windows Azure AD.
• Ability to sync users from an on-premise Active Directory. 
• Ability to establish single sign with Azure (and other Microsoft Services like Office 365) using Active Directory Federation Services.

The Active Directory tab within the Windows Azure Management Portal now allows you to see all directories that your account is managing, as well as create and manage users, domains and directory integration settings:

For a more detailed discussion of the new Active Directory support, read Alex Simons’ post on the Azure Blog.  You’ll see this AD support get even better in the months ahead.

Availability Monitoring for Cloud Services, Websites, Mobile Services, and VMs

With this week’s release we are enabling a new preview feature that will let you monitor the availability of your web applications. Web availability monitoring helps you understand the response time and availability of your web application from different locations around the world. This feature is available for Websites and Mobile Services in reserved mode, Cloud services in production environment, and for Virtual Machines.

You can try the web endpoint monitoring support in Windows Azure and enable your http/https endpoints to be tested from different locations. For example, to monitor your Web Site, scale the Web Site to reserved mode and then navigate to the configure page for the Web Site. Within the configure page, navigate to the monitoring section:

The monitoring section allows you to add multiple URLs that you wish to monitor.  Add a friendly name for each URL and select the locations around the world that you wish to monitor it from. With this week’s preview you can monitor the Web URL from up to 3 test locations. After you have saved the configuration, the Web Site’s URL will be tested once every 5 minutes from each of the configured locations.

The results of the tests can be viewed on the Web Site’s dashboard as well as from the monitoring tab:

Availability is monitored using HTTP response codes, and response time. The Web Site is considered down when the response time is greater than 30 seconds or the HTTP status code is greater than 400. 

The same features are available for Virtual Machines, Mobile Services and Cloud Services (in Production slot).

Service Bus Enhancements

With this release, we have added some nice new capabilities to the Service Bus experience. First, the new CONFIGURATION tabs for Queues and Topics now enables you to edit runtime properties for these entities. We also allow you enable/disable Queues and Topics at the granularity of Send and Receive states:

We have also added more dashboard metrics for Queues, Topics and Subscriptions. These include additions to operation counts and error counts.

We have also significantly enhanced the content on the QUICK START page as well as provided the ability to download sample solutions that shows off how to build apps that use Service Bus Queues, Topics and Relays.

Storage Enhancements

You can now download blob storage files (even private blobs in your account) directly from within the Windows Azure Management Portal.  From your storage account management page, go to the CONTAINERS tab to list your containers.  Then click on the container name to go to the blob listing.  You can select any blob and click the DOWNLOAD BLOB command on the command bar to download it directly from the browser:

Clicking this button will generate a temporary URL using a shared access signature and will trigger a browser download in a new tab. 

Another new enhancement is the ability to edit blob metadata and properties within the portal using the EDIT BLOB command:

From this dialog, you can see all of the relevant blob properties and user defined metadata.  You can also edit some properties such as the Content Type as well as all of the metadata key value pairs.

Media Services Enhancements

This week’s release includes several update to Windows Azure Media Services.

Monitoring Metrics for on-demand streaming

Windows Azure Media Services enables you to easily stream video on-demand (and soon live) from Windows Azure – without having to setup your own streaming server.  With this week’s update the dashboard view of your media service now displays monitoring metrics for on-demand streaming:

Improved Content and Samples

With this week’s release we have also updated the Media Services quick start page and added some helpful links as well as some sample code snippets that you can easily copy and paste into your code to start integrating Windows Azure Media Service tasks (typically encoding and streaming video) into your existing solutions:

 

For example, the “Upload a video programmatically” code snippet will show you how to programmatically upload a video file into your Windows Azure Media Services account (it even includes your account name + key in the snippet so that you can literally copy/paste to try it out):

Cloud Service Enhancements

In previous versions of the Windows Azure Management Portal, you could only upload a certificate PFX file. We listened to you feedback – with this week’s release, the portal now also supports upload of just the public key of the certificate 9e.g. a *.cer certificate file).

Localization in 5 Additional Languages

With this week’s release, we have added additional localization support for 5 NEW LANGUAGES: Russian, Korean, Portuguese, Chinese Simplified, Chinese Traditional.  You can select the language you want to use from the globe icon on the top of the portal:

Windows Azure Store Support in 22 New Countries

With this week’s release we have also expanded support for the Windows Azure Store to 33 countries (up from the previous 11 countries supported).  The Windows Azure Store is an awesome feature of Windows Azure and enables you to consume services from a variety of Microsoft and non-Microsoft services.

Summary

The above features are now available to start using immediately (note: some of the services are still in preview).  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using them today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu