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.
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.
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.
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.
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)); } } } }
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.
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:
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.
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:
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.
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:
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:
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.
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.
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
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
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:
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:
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).
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.
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.
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
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.
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>
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.
Today’s release also includes an updated Service Bus client library with several great new features:
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.
A few other updates/changes with today’s release:
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:
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:
All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:
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:
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.
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:
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 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:
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:
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.
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):
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.
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:
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 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.
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:
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.
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.
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.
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.
Today’s Windows Azure release also includes a number of other small VM enhancements including:
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:
All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:
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.
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:
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,
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.
In addition to the features above, there are several other really nice improvements added with today’s release. These include:
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:
The Fall 2012 class has been busy since Demo Day and is leaving big shoes for the new class to fill.
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:
All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:
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:
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:
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.
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.
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.
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:
All of these improvements are now available to start using immediately (note: some services are still in preview). Below are more details on them:
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:
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.
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.
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:
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.
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).
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.
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.
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):
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).
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:
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.
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
I’m excited to announce the final release of the ASP.NET and Web Tools 2012.2 update. This update is a free download for Visual Studio 2012 and .NET 4.5, and adds some great additional features to both ASP.NET and Visual Studio.
Today’s update makes no changes to the existing ASP.NET runtime, and so it is fully compatible with your existing projects and development environment. Whether you use Web Forms, MVC, Web API, or any other ASP.NET technology, there is something in this update for you.
Click here to download and install it today! This ASP.NET and Web Tools update will also be included with the upcoming Visual Studio 2012 Update 2 (aka VS2012.2).
With today’s release, all of the ASP.NET templates have updated versions of jQuery, jQuery UI, jQuery Validation, Modernizr, Knockout, and other open source NuGet packages. Note: your existing projects will continue to use the older packages unless you update them.
Web site projects now have the same publish experience as web application projects, including new support for publishing to Windows Azure Web Sites. You can selectively publish files, update local to remote files or vice versa, and see the differences between local and remote files.
Visual Studio 2012 Page Inspector enhancements include JavaScript selection mapping and CSS live updates as you type. The JavaScript selection mapping enables Page Inspector to map items that were dynamically added to the page back to the corresponding JavaScript code. For more information, read CSS Auto-Sync and JavaScript Selection Mapping in Page Inspector.
The Visual Studio 2012 editor has several improvements. With today’s update VS now supports syntax highlighting for:
The HTML editor provides Intellisense for Knockout bindings. There is even first-class support for editing LESS files, complete with syntax highlighting, Intellisense, and validation. The editor also supports pasting JSON as a .NET class. Copy any JSON data into the clipboard, use a Paste Special command to paste it into a C# or VB.NET code file, and Visual Studio will automatically generate .NET classes inferred from the JSON.
Mobile Emulator support adds extensibility hooks so that third-party emulators can be installed as a VSIX. The installed emulators will show up in the F5 dropdown, so that developers can preview their websites on a variety of mobile devices. Read more about this feature in Scott Hanselman’s blog entry on the new BrowserStack integration with Visual Studio.
With today’s release, ASP.NET Web API now provides support for OData endpoints that support both ATOM and JSON-light formats. With OData you get support for rich query semantics, paging, $metadata, CRUD operations, and custom actions over any data source. Read more about ASP.NET Web API OData support at http://www.asp.net/web-api/overview/odata-support-in-aspnet-web-api.
New built-in tracing functionality now lets you easily diagnose problems with Web API whether you’re running in Visual Studio or on Windows Azure. Tracing output from Web API is automatically written to the Visual Studio output window, IntelliTrace, and any other trace listener that you would like, including Windows Azure Diagnostics. The output shows the full Web API pipeline for all requests, including any exceptions or errors that occur, what controller and action were selected, model binding, the format that was negotiated, and the response.
Updated Web API projects now contain a link to an automatically generated help page that shows how to call your web API. The help page shows all of your API endpoints, the HTTP verbs they support, parameters, and sample request and response messages. You can customize the help page as you like, including adding documentation and test client functionality. This makes it really easy to create documentation pages for developers calling your services.
ASP.NET SignalR is a new library for ASP.NET developers that simplifies the process of adding real-time web functionality to your applications. Real-time web functionality is the ability to have server-side code push content to connected clients instantly as it becomes available.
You may have heard of the HTML5 WebSocket API that enables efficient bidirectional communication between the browser and server. SignalR uses Websockets when it is supported by the browser and the server, and gracefully falls back to other techniques and technologies when it is not (best of all your application code can stay the same regardless of which is being used).
SignalR provides a simple API for creating server-to-client remote procedure calls (RPC) that call JavaScript functions in client browsers from server-side .NET code. SignalR also includes API for connection management (for instance, connect and disconnect events), grouping connections, and authorization.
Included in today’s release is Visual Studio 2012 template support for creating SignalR projects as well as adding SignalR support to existing Web Forms and MVC applications:
Read more about SignalR at http://www.asp.net/signalr.
ASP.NET Friendly URLs enable you to remove the .aspx extension from your Web Forms pages, making your sites’ URLs look cleaner. You can also pass parameters to pages as segments of the URL. For example, instead of ProductDetails.aspx?id=5 you can have ProductsDetails/5. With Friendly URLs you can also easily support mobile devices by creating mobile versions of pages:
A new Facebook Application template makes writing Facebook Canvas applications using ASP.NET MVC really easy. In a few simple steps, you can create a Facebook application that gets data from a logged in user and integrates with their friends. The template includes a new library to take care of all the plumbing involved in building a Facebook app, including authentication, permissions, accessing Facebook data and more. This lets you focus on building the business logic in your app. The Facebook apps you can build with this new template are hosted on the web and displayed inside the Facebook chrome via an iframe.
Single Page Applications
A new Single Page Application template for ASP.NET MVC is also now included and allows developers to build interactive client-side web apps using HTML 5, CSS 3, and the popular Knockout and jQuery JavaScript libraries – all on on top of ASP.NET Web API.
The default template creates a “todo” list application that demonstrates common practices for building a JavaScript HTML5 application that uses a RESTful server API. You can read more at http://www.asp.net/single-page-application.
If you don’t want to use the new Knockout template there are 4 new community-created templates. These templates were built using the improved Custom MVC Template support:
You’ll see even more templates in the months ahead.
A new pre-release of Windows Azure Authentication is also now available for MVC, Web Pages, and Web Forms. This feature enables your application to authenticate Office 365 users from your organization, corporate accounts synced from your on-premise Active Directory, or users created in your own custom Windows Azure Active Directory domain. For more information, see the Windows Azure Authentication tutorial.
Today’s ASP.NET and Web Tools 2012.2 update has a lot of useful features for all developers using ASP.NET. Read the release notes to learn even more, and install it today!
Important Installation Note: If you have installed an earlier version of Mads Kristensen’s excellent (and free) Web Essentials 2012 extension, you’ll want to update it to the latest version before installing today’s ASP.NET and Web Tools 2012.2 update. The latest version of the Web Essentials 2012 extension works well with today’s release – if you have an older version you will get a runtime error when you launch Visual Studio. Updating to the latest version of the extension prior to installing the ASP.NET and Web Tools 2012.2 update will fix this.
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
Earlier this month, the 10 startups in our Fall 2012 Accelerator class got the chance to pitch to a room full of investors, mentors and technology enthusiasts. Over three hundred people joined us on the Redmond campus to see the final pitches in person.
Aseem Badshah, CEO of Socedo, using social to deliver sales leads.
For venture capitalists and angel investors, Demo Day was the chance to meet, and possibly fund, ten new startups that are looking to change the world. For the companies that were a part of this inaugural Accelerator class, this was their official coming out party—an opportunity to capture the attention of investors, reach customers, celebrate how far they’ve come in three short months - and the great businesses they’ve built on Windows Azure.
You can experience Demo Day yourself by watching a video of the presentations.
We are now taking applications for the next class of startups to join the Microsoft Accelerator for Windows Azure, Powered by TechStars program.
If you’re currently working at a startup and want access to an amazing group of mentors and technical support or have a great idea you’d like the time and resources to really focus on, I strongly encourage you to apply by Feb 3rd to be considered for the next class of the Microsoft Accelerator for Windows Azure.
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
During the BUILD 2012 conference we announced a new capability of Windows Azure: the Windows Azure Store. The Windows Azure Store makes it incredibly easy for you to discover, purchase, and provision premium add-on services, provided by our partners, for your cloud based applications. For example, you can use the Windows Azure Store to easily setup a MongoDB database in seconds, or quickly setup an analytics service like NewRelic that gives you deep insight into your application’s performance.
There is a growing list of app and data services now available through the Windows Azure Store, and the list is constantly expanding. Many services offered through the store include a free tier, which makes it incredibly easy for you to try them out with no obligation required. Services you decide to ultimately buy are automatically added to your standard Windows Azure bill – enabling you to add new capabilities to your applications without having to enter a credit card again nor setup a separate payment mechanism.
The Windows Azure Store is currently available to customers in 11 markets: US, UK, Canada, Denmark, France, Germany, Ireland, Italy, Japan, Spain, and South Korea. Over the next few weeks we’ll be expanding the store to be available in even more countries and territories around the world.
It is incredibly easy to start using a partner add-on from the Windows Azure store:
1) Sign-into the Windows Azure Management Portal
2) Click the New button (in the bottom-left corner) and then select the “Store” item within it:
3) This will bring up UI that allows you to browse all of the partner add-ons available within the Store:
You will see two categories of add-ons available: app services and data. Explore each to get an idea of the types of services available, and don’t forget to check back often, as the list is growing quickly!
4) Let’s try out a free app service from SendGrid, which lets you send e-mail from your application using a REST API or an SMTP server. Choose SendGrid from the list and click the next arrow. This will display more information about SendGrid, as well as a variety of plan options. Note that they offer a Free plan that allows you to send 6,000 emails/month, and then paid plans with more features and scale:
5) Let’s select the free plan and click the next arrow. Doing so will display the final screen – which shows us how much this purchase will cost. In this case it will cost nothing.
6) Click the “Purchase” button to complete the transaction (and if it was a non-free plan add it to your Windows Azure bill automatically). Once you click Purchase, SendGrid will provision an account for you and then you are ready to use it. No additional sign-up/billing steps required.
The Windows Azure Management portal makes it really easy to track and manage the add-on services you sign-up for. Once the above steps are completed, the SendGrid service will show up in the list of “add ons” for your account. Click the “add-ons” tab within the portal to display and manage these:
Clicking on the SendGrid item will display information about the service – including details on how many emails I’ve used from my 200/day quota for the free tier:
A row of buttons at the bottom of the page lets you interact with the add-on:
The Upgrade button is particularly useful when trying out a service’s free-tier option. Clicking it allows you to easily upgrade to a paid plan – without having to delete/recreate the service. For example, selecting the upgrade button on our SendGrid service above would display the following screen – which allows us to choose which paid plan we want to use:
We can then select which plan we want, and click the next arrow to see the exact cost:
Clicking the Purchase button will upgrade our service and add the cost to my existing Windows Azure bill – without me ever having to re-enter a credit card or setup an alternate payment mechanism with the add-on provider.
Recent Add-ons to the Windows Azure Store
Since BUILD 2012, we have added several great add-ons to the Windows Azure Store, and the list continues to grow. Two new partners are members of the recent Microsoft Azure Accelerator program:
| Active Cloud Manager by MetricsHub monitors cloud applications, anticipates resource usage and automatically scales the services up or down based on rules you set. This is a great way to monitor your service and save money at the same time. |
| Embarke builds unique profiles of each of your customers, and deeply personalizes communications to maximize engagement. |
Additionally, we are excited to welcome these other recent partners to the Windows Azure Store:
|
EZDRM provides a robust hosted Digital Rights Management (DRM) platform, empowering businesses of any size to affordably add DRM components to their web applications and Windows Azure Media Service solutions. | |
|
| |
| Scheduler lets you schedule recurring CRON jobs on Windows Azure with a simple, REST API. It provides both simple and advanced scheduling features.
| |
|
Pusher provides a simple set of APIs and libraries that allow you to build rich real-time features in hours rather than days. |
The Windows Azure Store is a great opportunity for developers who want to sell their services to Windows Azure customers. We are currently accepting applications and would love to hear about your add-on!
If you want to offer your own service in the store, take a look at the Windows Azure Store SDK, which includes API documentation, sample code and developer tools.
The Windows Azure Store makes it incredibly easy for Windows Azure customers to find and subscribe to great add-on services from a variety of partners. The store automates purchasing, management and billing of these services and allows you to perform all of the tasks associated with them in the same consistent Windows Azure Management Portal that you use to manage other Windows Azure features.
Try out the Windows Azure Store today. If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using it immediately. We are looking forward to seeing what you build 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