Windows Workflow

Blog Post: Side by Side Versioning with a Web-Hosted Xamlx Workflow Service video and download on Code Gallery

Syndicated Workflow Author — Fri, 24 May 2013 21:45:00 GMT

I have created a video walkthrough of implementing side-by-side versioning with a web-hosted xamlx workflow service here:

Side by Side Versioning with a Web-Hosted Xamlx Workflow Service

This project provides a demo of implementing side-by-side versioning with a web-hosted xamlx workflow service, as described in the accompanying MSDN topic Side by Side Versioning in WorkflowServiceHost.

The WorkflowServiceHost side-by-side versioning introduced in .NET Framework 4.5 provides the capability to host multiple versions of a workflow service on a single endpoint. The side-by-side functionality provided allows a workflow service to be configured so that new instances of the workflow service are created using the new workflow definition, while running instances complete using the existing definition. It is very easy to configure and implement, and this code gallery project provides a running sample and a video walkthrough that demonstrates how to do it.

Blog Post by: Steve Danielson

Blog Post: Announcing the release of AMQP support with Windows Azure Service Bus

Syndicated Workflow Author — Thu, 23 May 2013 14:42:00 GMT

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

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

Interoperable Messaging

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

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

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

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

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

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

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

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

Step 1: Create a Service Bus Topic and 3 Subscriptions

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

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

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

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

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

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

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

Step 2: Writing the .NET Sender App

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

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

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

using System;  using System.Configuration;  using Microsoft.ServiceBus.Messaging;    namespace SendToScott  {      class Program      {          static void Main(string[] args)          {              string connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];                TopicClient topicClient = TopicClient.CreateFromConnectionString(connectionString, "scottmessages");                Console.WriteLine("Type messages you wish to post to the Topic:");                while (true)              {                  Console.Write("> ");                  string messageText = Console.ReadLine();                    topicClient.Send(new BrokeredMessage(messageText));              }          }      }  }

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" ?>

</startup>

<add key="Microsoft.ServiceBus.ConnectionString"

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

</appSettings>

</configuration>

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

Running the Console App

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

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

Step 3: Writing a Java App Listener

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

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

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

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

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

// ReceiveScottsMessages.java

import javax.jms.*;

import javax.naming.Context;

import javax.naming.InitialContext;

import java.util.Hashtable;

public class ReceiveScottsMessages implements MessageListener {

public static void main(String[] args) {

try {

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

env.put(Context.INITIAL_CONTEXT_FACTORY,

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

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

Context context = new InitialContext(env);

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

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

Connection connection = cf.createConnection();

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

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

subscriber.setMessageListener(new ReceiveScottsMessages());

connection.start();

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

System.in.read();

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

connection.stop();

subscriber.close();

session.close();

connection.close();

} catch (Exception e) {

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

System.exit(1);

}

@Override

public void onMessage(Message message) {

try {

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

} catch (JMSException e) {

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

}

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

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

topic.EntityName = scottmessages

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

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

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

Running the Java App

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

Receiving messages. Press enter to stop.

Message From Scott > Red Shirts are cool

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

Message From Scott > Windows Azure Rocks!

Shutting down.

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

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

Step 4: Creating a Python App Listener

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

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

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

Installing the Proton Library on our Linux VM

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

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

2) Install the various pre-requisite packages:

>> yum install gcc cmake libuuid-devel

>> yum install openssl-devel

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

>> yum install epydoc

3) Download the Proton library

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

4) Extract the Proton code from the distribution archive

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

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

From the directory where you found this README file:

mkdir build

cd build

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

# system.

cmake -DCMAKE_INSTALL_PREFIX=/usr ..

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

# documentation.

make all docs

# Note that this step will require root privileges.

sudo make install

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

import sys

from proton import Messenger, Message

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

entityName = "scottmessages/Subscriptions/python"

messenger = Messenger()

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

messenger.start()

msg = Message()

while True:

messenger.recv(10)

while messenger.incoming:

try:

messenger.get(msg)

except Exception, e:

print e

else:

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

messenger.stop()

print "Done"

A couple of things to note above:

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

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

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

Step 5: Creating a PHP App Listener

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

<?php

include("proton.php");

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

$entityName = "scottmessages/Subscriptions/php";

$messenger = new Messenger();

$messenger->start();

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

$msg = new Message();

while (true) {

$messenger->recv(10);

while ($messenger->incoming) {

try {

$messenger->get($msg);

} catch (Exception $e) {

print "$e\n";

continue;

}

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

}

$messenger->stop();

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

Summary

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

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

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

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

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: Note to self - how to stop VS 2012 menus being all caps

Syndicated Workflow Author — Tue, 21 May 2013 20:49:00 GMT

reg ADD "HKCU\Software\Microsoft\VisualStudio\11.0\General" /v "SuppressUpperCaseConversion" /t REG_DWORD /d 1

I just thought I'd put this here in case I ever lose the info again. :)

Isn't setting up a new machine fun.

Blog Post by: tilovell09

Blog Post: New Workflow Manager 1.0 Getting Started Tutorial

Syndicated Workflow Author — Thu, 16 May 2013 14:32:00 GMT

A new Getting Started Tutorial for Workflow Manager 1.0 has been posted here:

Workflow Manager 1.0 Getting Started Tutorial

This is a 3 step tutorial which covers creating a custom activity, using it in a workflow, and publishing and invoking the workflow. It covers the use of the HttpSend activity, several of the DynamicValue activities, and also includes troubleshooting steps for common issues related to authoring, publishing, and invoking workflows.

There is also a video walkthrough and a download of the completed tutorial here:

Workflow Manager 1.0 Getting Started Tutorial Download and Video Walkthrough

This download also includes the starter files for the tutorial.

I have also started a thread for discussing the tutorial on the Workflow Manager 1.0 MSDN Community Forum. Please feel free to make comments or suggestions to the thread, but if you have any questions, please start a new thread for the question.

Thanks,

Steve Danielson [Microsoft]

Blog Post by: Steve Danielson

Blog Post: SharePoint 2013 PowerPivot Management Dashboard empty

Syndicated Workflow Author — Tue, 14 May 2013 11:07:00 GMT

When you install the SharePoint BI stack, you need to create a PowerPivot Service application that will manage the PowerPivot workbooks via a very nice dashboard which unfortunately was empty in my Central Admin. no error, nothing in the ULS, just an empty page. To fix that, I activated the PowerPivot Administration feature in Central […]
Blog Post by: sergeluca

Blog Post: Note to self : Moving a SharePoint contentDB from dev to test

Syndicated Workflow Author — Fri, 10 May 2013 12:41:00 GMT

How to move a content db from a SharePoint Dev farm to a SharePoint test farm. step 1. backup the dev farm content db step 2. go to your test farm, copy the backup to the SQL Server backup location If you don’t know the default SQL server backup location, start SQL Server Management Studio […]
Blog Post by: sergeluca

Blog Post: The mystery of the missing URL validation

Syndicated Workflow Author — Wed, 08 May 2013 22:22:00 GMT

Further to my adventures with unobtrusive validation of yesterday, I found myself very stuck while implementing a new form for this new editable metadata feature for the NuGet Gallery. And Yet again the cause of all my pain appears to be this evil combination of UnobtrusiveValidation (2.0.30116.0) and JQuery.Validation (1.8.1). (I know it's not meant to be an evil combination, but believe me, it really starts to feel that way.))

For the sake of discussion, a feature I'm trying to add is the ability to edit your package's project url, and logo icon url on nuget.org. Since I'm trying to follow the established patterns of the codebase, I decided to use a RequestModel object to represent the editing form. So naturally I do this inside my request model:

[StringLength(256)]
[Display(Name = "Icon URL")]
[DataType(DataType.ImageUrl)]
public string IconUrl { get; set; }

[StringLength(256)]
[Display(Name = "Project Homepage URL")]
[DataType(DataType.Url)]
public string ProjectUrl { get; set; }

Unfortunately, when it comes to validation of this model, woe is me. If you enter a string which is not a valid URL and doesn't even start with https, you get no indication you've done something stupid.

Perhaps naturally, perhaps not, I had assumed that adding these DataType attributes is going to do something good for me and do URL validation. Why would it be a natural assumption? Well, I say that because UnobtrusiveValidation appears to understand DataType.Url in the following ways:

[Updated: Gee thanks a lot blogs.msdn.com for corrupting my post. Now don't do it again!]

1) It adds a type="Url" attribute to your form INPUT element
2) It has code inside that tries to add an adapter which understands URL typed input elements and apply the jquery.validate URL validation to them. At least that's what I think it's meant to do. Because it doesn't actually work in practice.

I tried to work around this by adding regex validation to my model, thinking that could replace the non-functioning URL validation. Sadly that doesn't work either!

[RegularExpression(Constants.UrlValidationRegEx, ErrorMessage = "This doesn't appear to be a valid URL")]

Some hours of debugging eventually reveals that the reason neither regexes nor URLs are working is because I chose to do [DataType.Url] prevents the focusout delegate from being registered as a validation hook upon the input element

   function delegate(event) {
    var validator = $.data(this[0].form, "validator"),
     eventType = "on" + event.type.replace(/^validate/, "");
    validator.settings[eventType] && validator.settings[eventType].call(validator, this[0] );
   }
   $(this.currentForm)
    .validateDelegate(":text, :password, :file, select, textarea", "focusin focusout keyup", delegate)
    .validateDelegate(":radio, :checkbox, select, option", "click", delegate);

yes... jquery.validate will only add focusout handlers for stuff it knows about.
And it gives you no way of customizing this. Grrr. Yuck.

Best option for working around this seems to be don't use DataType.Url. Second best option would probably be write some script to add the missing focusout event handlers.

Blog Post by: tilovell09

Blog Post: Regular expressions are different in javascript! And Unintrusive Validation.

Syndicated Workflow Author — Wed, 08 May 2013 02:59:00 GMT

Today while trying to implement some new code, and cutting my teeth on javascript validation, I disbelievingly realized that ALL of our client-side validation had stopped working. Like a month ago. And, nobody had noticed or complained! (As a brief reminder I now work on the NuGet Gallery.)

Perhaps that just goes to show how little real value client-side form validation is providing our nuget.org users, who are a smart bunch. Especially when Server side validation is there (it's always going to be there) and it gets the job done. Anyway, regardless of the true value of client side validation, I'm fully mentally and emotionally committed to doing some client side validation for our new features. So let's move ahead!

The original thing turned out to be a minor and easy thing to debug and fix, and didn't require me to understand the validation framework much at all. The script tag for jquery.validate.unobtrusive had accidentally gone missing when my compatriate made some innocent looking performance enhancements to the site. And without that script tag, you'll never see any validation. So problem solved. The way the tag went missing, honestly, was just one of those accidental things that you would think wouldn't be so easy to do. If you look at our code (yes, it's so frickin' cool that I can link to our code since it's open source)

https://github.com/NuGet/NuGetGallery/blob/master/Website/App_Start/AppActivator.cs

you'll see that we're doing script bundling.

var scriptBundle = new ScriptBundle("~/bundles/js")

.Include("~/Scripts/jquery-{version}.js")

.Include("~/Scripts/jquery.validate.js")

.Include("~/Scripts/jquery.validate.unobtrusive.js");

BundleTable.Bundles.Add(scriptBundle);

And it turned out that we were bundling a script that didn't exist (we only had jquery.validate.unobtrusive.min.js). Of course we never ever see an error even though we are bundling something that doesn't exist... Oh well. If you were thinking of playing with script bundling, you have now been warned. :)

But digressions, digressions. The real point of this post was that even after turning on unobtrusive validation, it became apparent that our email address and username validation on the user registration page were still not working. I could type in 'foo#blarg#blah' as an email address and all was well with the webby world. But why?

Well, let's see. What's supposed to happen is that we set a [RegularExpressionAttribute] on our property, like so:

    [Required]
    [StringLength(64)]
    [RegularExpression(@"(?i)[a-z0-9][a-z0-9_.-]+[a-z0-9]",
       ErrorMessage = "User names must start and end with a letter or number, and may only contain letters, numbers, underscores, periods, and hyphens in between.")]
     [Hint("Choose something unique so others will know which contributions are yours.")]
     public string Username { get; set; }

And this will cause some funky HTML to get generated, like so:

<inputclass="text-box single-line"data-val="true"data-val-length="The field Username must be a string with a maximum length of 64."data-val-length-max="64"data-val-regex="User names must start and end with a letter or number, and may only contain letters, numbers, underscores, periods, and hyphens in between."data-val-regex-insensitive="True"data-val-regex-pattern="[a-z0-9][a-z0-9_.-]+[a-z0-9]"data-val-required="The Username field is required."id="Username"name="Username"type="text"value=""/>

Which works.
And then there's a little adapter snippet in the unobtrusive validation script file which turns the data-val- attributes into a jquery.validation rule:

    $jQval.addMethod("regex", function (value, element,
params) {
        var match;
        if (this.optional(element)) {
            return true;
        }

        match = new RegExp(params).exec(value);
        return (match && (match.index === 0) &&
(match[0].length === value.length));
    });

Luckily, the first thing I tried is running this in the JS debugger, and it turns out that 'new RegExp(params)' is what fails. And it fails because (as promised in the title) regular expressions are different in javascript from .Net.

In .Net, the (?i) syntax is legal as part of the regular expression and tells the regular expression parser that you want to build a case-insensitive regular expression.

In Javascript, there are two ways of doing a case insensitive regular expression. One is to use a regular expression literal and suffix it with 'i' like this: /[a-z0-9][a-z0-9_:-]+[a-z0-9]/i

The other is to pass a second parameter "i" to the new RegExp constructor.

This leads to a GRRRRRR moment, where I privately curse the creator of the unobtrusive validation library for failing to consider this issue. And also me spending about an hour trying to understand how to solve the problem myself.

This turns out to be wasted effort, because as is often the case, some bright person has come up with a clever answer on stackoverflow.

http://stackoverflow.com/questions/4218836/regularexpressionattribute-how-to-make-it-not-case-sensitive-for-client-side-v

That said, I did spend this time coming up with another alternative approach, so might as well record it, and explain how it works. This one works not by introducing a new attribute or new annotation, but by overwriting the existing adapters in the unobtrusive validation pipeline.
The logical pipeline is this:

1. Data Model & Attributes (e.g. RegularExpressionAttribute) ->
2. DataAnnotationsModelValidatorProvider & Attribute Adapters (e.g. RegularExpressionAttributeAdapter) ->
3. HTML form + <script tags> (e.g. data-val-regex) ->
4. UnobtrusiveValidation Adapters (e.g. "regex" adapter snippet posted above) ->
5. jquery.validation rules - tada!

We can insert a hacky fix at step 2. in the pipeline:

            DataAnnotationsModelValidatorProvider.RegisterAdapter(
                typeof(RegularExpressionAttribute),
                typeof(FixedRegularExpressionAttributeAdapter));

}

        class FixedRegularExpressionAttributeAdapter : RegularExpressionAttributeAdapter
        {
            private RegularExpressionAttribute _attribute;

            public FixedRegularExpressionAttributeAdapter(
                ModelMetadata metadata, ControllerContext context, RegularExpressionAttribute attribute)
                : base(metadata, context, attribute)
            {
                _attribute = attribute;
            }

            public override System.Collections.Generic.IEnumerable<ModelClientValidationRule> GetClientValidationRules()
            {
                var rules = base.GetClientValidationRules();
                var rule = rules.First();
                var pattern = (string)rule.ValidationParameters["pattern"];
                if (pattern.StartsWith("(?i)"))
                {
                    pattern = pattern.Substring(4);
                    rule.ValidationParameters["pattern"] = pattern;
                    rule.ValidationParameters["insensitive"] = true;
                }
                return rules;
            }
        }

this will rewrite our HTML to remove the leading (?i) from the data-val-regex-pattern attribute, and create a new attribute data-val-regex-insensitive="True".
And since it's a script file, we could then modify the code of the unobtrusive validation adapter.

Well... it sort of gets the job done... but I don't actually feel like this is a very great solution to apply in practice. For one, pattern.StartsWith("(?i)") is hackiness. But for another, making changes to a script file like unobtrusive validation that we get as a nuget package is a headache because updating the nuget package in the future will lose the changes. Not to mention I'm unclear whether licensing permits editing the script files.

The right thing to do instead seems to be to contribute back to unobtrusive validation, or at least file a bug there, and hope it gets fixed, assuming it's open source.

It appears that it is open source, but it took me an awfully long time to confirm it is in the asp.net codeplex project

http://aspnetwebstack.codeplex.com/SourceControl/changeset/view/ea64fc86b54d#src/System.Web.Mvc/JavaScript/jquery.unobtrusive-ajax.js

where, for now, I've just filed a bug on the issue. As for now it makes more sense to me to workaround it using 'A-Za-z' in the regex than to incorporate a hacky non-future-proof fix, which was an interesting way to learn a bit more about these validation frameworks.

Blog Post by: tilovell09

Blog Post: My SharePoint Saturday (Belgium, BIWUG) Slide deck

Syndicated Workflow Author — Tue, 07 May 2013 19:31:00 GMT

A week after the SharePoint Summit (Quebec) I had the pleasure last week to present a session on SharePoint 2013 and Business Intelligence with my partner in crime and colleague isabelle Van Campenhoudt (SQL Server MVP); the slide deck can be downloaded here.
Blog Post by: sergeluca

Blog Post: SharePoint Summit 2013 Quebec : my slide deck (SharePoint 2013 workflows)

Syndicated Workflow Author — Tue, 07 May 2013 18:53:00 GMT

les slides de ma session worflow SharePoint 2013; il est très rare que je donne des sessions en français…
Blog Post by: sergeluca

Blog Post: Announcing the Release of WebMatrix 3

Syndicated Workflow Author — Wed, 01 May 2013 19:53:00 GMT

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

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

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

Windows Azure Integration

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

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

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

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

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

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

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

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

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

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

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

Source Control with Git and TFS

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

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

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

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

Remote Editing

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

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

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

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

Summary

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

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

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: Announcing the release of Windows Azure SDK 2.0 for .NET

Syndicated Workflow Author — Tue, 30 Apr 2013 17:37:00 GMT

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

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

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

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

Web Sites: Improved Visual Studio Publishing

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

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

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

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

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

Web Sites: Management Support within the Visual Studio Server Explorer

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

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

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

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

Web Sites: Streaming Diagnostic Logs

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

How to Enable Live Streaming of Diagnostic Logs

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

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

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

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

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

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

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

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

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

Cloud Services: Support for High Memory VM Instances

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

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

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

Cloud Services: Faster Deployment Support with Simultaneous Update Option

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

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

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

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

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

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

Cloud Services: Improved Diagnostics Support

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

Easily Configure Diagnostics

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

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

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

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

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

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

View Diagnostics on a Live Service

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

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

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

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

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

Update Diagnostics Settings on a Live Service

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

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

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

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

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

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

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

More Information

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

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

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

Storage: Visual Studio Table Explorer

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

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

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

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

You can also edit/delete existing entities within Tables:

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

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

Service Bus: Updated Client Library

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

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

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

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

PowerShell: Tons of new Automation Commands

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

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

Web Sites

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

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

Cloud Services

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

>>> Set-AzureDeployment –Mode Simultaneous

Virtual Machines

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

>>> New-AzureVM

>>> New-AzureQuickVM

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

Service Bus

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

Windows Azure Store

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

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

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

Storage

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

Scaffolding cmdlets for Web/Worker Role

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

More Information

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

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

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

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

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

Learn More

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

Summary

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: Windows Azure: Improvements to Virtual Networks, Virtual Machines, Cloud Services and a new Ruby SDK

Syndicated Workflow Author — Fri, 26 Apr 2013 18:51:00 GMT

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

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

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

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

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

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

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

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

New Point-To-Site Connectivity

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

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

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

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

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

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

How to Enable the Point-to-Site Functionality

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

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

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

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

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

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

Software VPN Device support for Site-to-Site

With today’s release we are also adding software VPN device support to our existing ‘Site-to-Site VPN’ connectivity solution (which previously required you to use a hardware VPN device from Cisco or Juniper). Starting today we also now support a pure software based Windows Server 2012 ‘Site-to-Site’ VPN option. All you need is a vanilla Windows Server 2012 installation. You can then run a PowerShell script 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.

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

Dynamic DNS Support

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

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

Virtual Machines: Remote PowerShell and Linux SSH provisioning enhancements

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

Support for Optionally Enabling Remote PowerShell on Windows Virtual Machines

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

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

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

Linux SSH Provisioning

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

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

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

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

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

How to Enable Dynamic Remote Desktop on a Cloud Service

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

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

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

Windows Azure SDK for Ruby

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

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

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

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

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

Summary

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: Windows AzureConf this Tuesday

Syndicated Workflow Author — Mon, 22 Apr 2013 04:59:00 GMT

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.

Blog Post by: ScottGu

Blog Post: ASP.NET Web API: CORS support and Attribute Based Routing Improvements

Syndicated Workflow Author — Fri, 19 Apr 2013 18:37:00 GMT

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

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

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

CORS support for ASP.NET Web API

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

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

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

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

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

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

Attribute-Based Routing in ASP.NET Web API

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

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

public class OrdersController : ApiController

{

public IEnumerable<Order> GetOrders() {…}

public Order GetOrder(int id) {…}

public Order Post(Order order) {…}

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

public Order Approve(int id) {…}

}

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

public class PeopleController : ApiController

{

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

public string GetByName(string name) {…}

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

public string GetById(int id) {…}

}

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

[RoutePrefix("movies")]

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

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

public class MoviesController : ApiController

{

public IEnumerable<Movie> GetMovies() {…}

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

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

}

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

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

public class CustomersV1Controller : ApiController {…}

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

public class CustomersV2Controller : ApiController {…}

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

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: Windows Azure: General Availability of Infrastructure as a Service (IaaS)

Syndicated Workflow Author — Tue, 16 Apr 2013 13:01:00 GMT

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

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

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

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

Windows Azure Virtual Machines

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

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

Easy to Get Started

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

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

Integrated Management and Monitoring

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

Durable Data Disks

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

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

Built-in Load Balancer Support

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

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

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

Windows Azure Virtual Networks

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

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

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

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

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

Creating a Virtual Network

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

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

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

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

Hourly Billing Support

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

More Details on SQL Server, BizTalk and SharePoint Server

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

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

New VM Sizes (including Larger Memory Options)

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

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

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

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

New Windows Azure Virtual Machine Compute Pricing

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

Size Name	# of CPU Cores	Memory	Windows VM Pricing	Linux VM Pricing
ExtraSmall	Shared	768 MB	$0.02 per hour	$0.02 per hour
Small	1	1.75 GB	$0.09 per hour	$0.06 per hour
Medium	2	3.5 GB	$0.18 per hour	$0.12 per hour
Large	4	7 GB	$0.36 per hour	$0.24 per hour
ExtraLarge	8	14 GB	$0.72 per hour	$0.48 per hour
A6	4	28 GB	$1.02 per hour	$0.82 per hour
A7	8	56 GB	$2.04 per hour	$1.64 per hour

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

Commitment Pricing Discounts

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

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

Other Improvements

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

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

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

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

Summary

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

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

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: Windows Azure Global Bootcamp on April 27th – sign up now

Syndicated Workflow Author — Sat, 13 Apr 2013 01:55:00 GMT

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

Blog Post by: ScottGu

Blog Post: Calling the SharePoint 2013 Rest API from a SharePoint Designer Workflow

Syndicated Workflow Author — Tue, 09 Apr 2013 10:16:00 GMT

At the moment you will find many examples illustrating how to call external JSon web services from SharePoint Designer 2013 workflows by using the Call activity, but we should keep in mind that the Call action works very well with the SharePoint REST api and this opens the door to plenty of possibilities. However you [...]
Blog Post by: sergeluca

Blog Post: Windows Azure: Active Directory Release, New Backup Service + Web Site Monitoring and Log Improvements

Syndicated Workflow Author — Mon, 08 Apr 2013 16:07:00 GMT

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

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

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

Active Directory: Announcing the General Availability release

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

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

Creating a New Active Directory

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

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

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

Managing Users within the Directory

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

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

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

Enabling Apps

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

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

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

Programmatic Integration

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

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

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

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

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

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

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

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

Managing your Backups in the Cloud

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

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

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

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

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

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

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

Web Sites: Monitoring and Diagnostics Improvements

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

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

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

Other Cool Things

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

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

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

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

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

Summary

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

Hope this helps,

Scott

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

Blog Post by: ScottGu

Blog Post: SharePoint 2013 workflows and content types : forget it

Syndicated Workflow Author — Mon, 08 Apr 2013 12:04:00 GMT

Creating and using content types in SharePoint is often considered as the best practice; however SharePoint workflows created for SharePoint 2013 cannot be associated anymore with content types. This is a very important point to consider if you are moving to the new platform In MSDN you can read “Unlike previous versions, SharePoint 2013 does [...]
Blog Post by: sergeluca