We have just updated the WebSockets prototype on our HTML5 Labs site, bringing the implementation in line with the recently released IETF WebSockets 09 Protocol Specification.
This latest release updates both the server and client prototype implementations based on the IETF 09 specification, and brings no significant feature changes.
We will release additional HTML5 labs prototypes if there are further changes to the specification.
Principal Program Manager, Interoperability Strategy Team
We've been participating in creating a roadmap for adoption of cloud computing throughout the federal government, with the National Institute for Standards and Technology (NIST) , an agency of the U.S. Department of Commerce, and the United States first federal physical science research laboratory. NIST is also known for publishing the often-quoted Definition of Cloud Computing, used by many organizations and vendors in the cloud space.
Microsoft is participating in the NIST initiative to jumpstart the adoption of cloud computing standards called Standards Acceleration to Jumpstart the Adoption of Cloud Computing, (SAJACC).The goal is to formulate a roadmap for adoption of high-quality cloud computing standards. One way they do this is by providing working examples to show how key cloud computing use cases can be supported by interfaces implemented by various cloud services available today. Microsoft worked with NIST and our partner, Soyatec, to demonstrate how Windows Azure can support some of the key use cases defined by SAJACC using our publicly documented and openly available cloud APIs.
NIST works with industry, government agencies and academia. They use an open and ongoing process of collecting and generating cloud system specifications. The hope is to have these resources serve to both accelerate the development of standards and reduce technical uncertainty during the interim adoption period before many cloud computing standards are formalized.
By using the Windows Azure Service Management REST APIs we are able to manage services and run simple operations including simple CRUD operations, solve simple authentication and authorizations using certificates. Our Service management components are built with RESTful principles and support multiple languages and runtimes including Java, PHP and .NET as well as IDEs including Eclipse and Visual Studio.
It also provides rich interfaces and functionality that provide scalable access to public, private and hosted clouds. All of the SDKs are available as open source too. With the Windows Azure Storage Service REST APIs we can use 3 sets of APIs that provide storage management support for Tables, Blobs and Queues with the same RESTful principles using the same set of languages. These APIs as well are available as open source.
We also have an example that we have created called SAJACC use case drivers to demonstrate this code in action. In this demonstration written in Java we show the basic functionality demonstrated for the NIST Sample. We created the following scenarios and corresponding code …
1. Copying Data Objects into a Cloud, the user is able to copy items on their local machine (client) and copy to the Windows Azure Storage without any change in the file; the assumptions are to have credential with a pair of account name and key. The scenario involves generating a container with a random name in each test execution to avoid possible name conflicts. The container uses the Windows Azure API. With the credential previously created the user prepares the Windows Azure Storage execution context. Then a blob container is created, with optional custom network connection timeout and retry policy, you are able to easily recover from network failure. Then we will create a block blob and transfer a local file to it. We will then compute a MD5 hash for the local file, get one for the blob and compare it to show there are equivalent and no data was lost
2. Copying Data Objects Out of a Cloud, repeats what we do from the first use case, Copying Data Objects into a Cloud. Additionally we will include another scenario, where set public access to the blob container and get its public URL; we will then as an un-identified (public) user retrieve the blob using an http GET request and save it to the local file system. We will then generate a MD5 hash for this file and compare it to the originals we used previously
3. Erasing Data Objects in a Cloud erases a data object on behalf of a user. With the credentials and data you created in the previous examples we will use the public URL of the blob and delete it by using its blob name. We will verify by using an http GET request to confirm that it has been erased.
4. VM Control: Allocating VM Instance, the user is able to create a VM image to compute on that is secure and performs well. The scenario involves creating a Java Keystore and Truststore from a user certificate to support SSL transport (described below). We will also create Windows Azure management execution context to issue commands from and create a hosted service using it. We will then prepare a Windows Azure service package and copy it to the blob we created in the first use case. We will then deploy in the hosted service using its name and service configuration information including the URL of the blob and the number of instances. We can then change the instance count to as many roles we want to execute using what we deploy and verify the change by getting status information from it.
5. VM Control: Managing Virtual Machine Instance State, the user is able to stop, terminate, reboot, and start the state of a virtual instance. We will first prepare an app to run as the Web Role in Windows Azure. The program will add a Windows Azure Drive to keep some files persistent when the VM is killed or rebooted. We will have two web pages, one where a random file is created inside the mounted drive, and another to list all the files on the drive. Then we will build and package the program and deploy the Web Role create as a hosted service on Window Azure using the portal. We will then create another program to manage the VM instance state similar to what we had done before in the previous use case, VM Control: Allocating VM Instance. We will use http GET requests to visit the first web page to create a random file on the Windows Azure Drive and the second web page to lists the files to show that they are not empty. We will then use the management execution context to stop the VM and disassociate the IP address and confirm this by visiting the second web page which will not be available. We will then use the same management execution context to restart the VM and confirm that the files in the drive are persistent between the restarts of the VM.
6. Copying Data Objects between Cloud-Providers, the user is able to copy data objects from one Windows Azure Storage account to another. This example involves creating a program to run as a worker role where a storage execution context is created. We will use the container as per the first use case, Copying Data Objects into a Cloud. We will download the blob to a local file system. We will then then create a second storage execution context and transfer the downloaded file to this new storage execution context. Then as per the first use case we will create a new program and deploy it to retrieve the two blobs and compare and verify the contents MD5 hashes are the same.
Java code to test the Service Management API
Managing API Certificates
For the Java examples (use cases 4-6), we need to have key credentials. In our download we demonstrate the Service Management API being called with an IIS certificate. We will take you through generating an X509 certificate for the Windows Azure Management API. We show the management console for IIS7 and certificate manager in Windows. Creating the self-signed server certificates and exporting them to the Windows Azure portal and generate a JKS format key store for the Java Azure SDK. We will then upload it to the Azure account and converting the keys for use in the Java Keystore and for calling the Service Management API from Java We then demonstrate the Service Management API using the Java Key tool Certificates. We will use the Java Keystore and export an X.509 certificate to the Windows Azure Management API. Then we upload certificate to an Azure account. We will then construct a new Service Management Rest object with the specific parameters and end by testing the Services Management API from Java
To get more information, the Windows Azure Storage Services REST API Reference and the Windows Azure SDK for PHP Developers are useful resources to have. You may also want to explore more with the following tutorials:
With the above tools and Azure cloud services, you can implement most of the Use Cases listed by NIST for use in SAJACC. We hope you find these demonstrations and resources useful, and please send feedback!
Jas Sandhu, Technical Evangelist, @jassand
I am pleased to announce that Microsoft has joined Joyent and Ryan Dahl in their effort to make Windows a supported platform in Node.
Our first goal is to add a high-performance IOCP API to Node to give developers the same high-performance/scalability on Windows that Node is known for, given that the IOCP API performs multiple simultaneous asynchronous input/output operations.
At the end of this initial phase of the project, we will have official binary node.exe releases on nodejs.org, meaning that Node.js will run on Windows Azure, Windows 2008 R2, Windows 2008 and Windows 2003.
You can read more about all this on nodejs.org as well as on Joyeur.com.
While this is just the beginning of the journey to make Node.js on Windows a great platform for Node developers, I’m really excited about making this happen.
So, stay tuned, as there’s a lot more to come!
As we announced in April, we have been working hard on developing a prototype to cover the Media Capture API, a draft specification that defines HTML form enhancements to provide access to the audio, image and video capture capabilities of a device.
As such, I am delighted to be able to announce that today we have the first release of the prototype, which includes Audio capabilities only, but we do plan to add image and video support over the next month or so.
This first version of the Media Capture prototype implements the Audio portion of this W3C specification. We have also included a sample that demonstrates how to properly utilize the APIs that the IE9 plugin exposes.
Once a user has connected their microphone and the drivers are properly installed, they can click on the microphone iconand the web page will capture the sound until it either hears silence or it is stopped (the captured sequence is preserved), or cancelled (captured sequence is discarded). When the Play button is pressed, the sounds just captured will play back.
A screenshot of the Audio Capture Demo that lets you record and play back captured sounds
Our next prototype will support Speech recognition and will implement the Microsoft proposal available on the W3C website here and here. It will also include two implementations of the sample apps that are described in sections 5.1 and 5.2 of the draft.
Then, after that, we will deliver another update to the Media Capture prototype that will add video capabilities. We are very excited about the ability of these extensions to the existing IE9 capabilities to showcase how everybody will be able to interact in an ever more natural way with the Web going forward.
Again, my thanks to you for helping Microsoft and the Internet Explorer team build a better and more interoperable Web, and I encourage you to continue participating in the appropriate standards bodies to help finalize the specifications.
So stay tuned for all this goodness!
As I wrote in this post “Being a polyglot developer: tools & guidance to help iPhone developers learn Windows Phone 7” about a few weeks ago, I think it is essential to be a “polyglot” developer. And although you might have a preferred language, opening your mind to others will bring considerable value to your abilities and your resume. It’s true that jumping from one platform or language to another can break your habits, but change can be stimulating and will ultimately expand your opportunities.
Today we have released a comprehensive package for Android developers to easily learn Windows Phone and port their app to Microsoft’s phone platform. There’s no magic wand that will do the work for you, but we have put together a great package to help you get started. The package consists of:
All the details are explained on the Windows Phone Developer blog.
I just want to point a few things. Mapping is tedious on-going work. Don’t expect a mapping for all of the APIs, simply because the platforms are built upon different architectures and user interfaces. We’re working on expanding the coverage of the API Mapping tool for both iOS and Android, but there will be some situations where you might be stuck, not knowing what way to port your feature over from iOS or Android to Windows Phone.
We’re willing to help! We have hired the “App Guy” who crawls developer forums aggregating discussions from different locations to answer questions related to porting iOS and Android applications to Windows Phone, but hey, that’s just one guy for now, anybody can help out. Tell us if we’ve missed something and tag your questions/answers so that we can find them (see guidance) and show them off.
Open for feedback
When we opened the API mapping tool, we invited developers to offer up their ideas (http://wp7mapping.uservoice.com) about what mapping we should cover. With this new version including Android, we’ve also introduced the possibility to add comments directly on the existing mapping. So if you want to provide additional details or if you spot something inaccurate, just add a comment, we’re listening!
Jean-Christophe Cimetiere, Sr. Technical Evangelist – Interoperability @jccim - blogs.msdn.com/interoperability
I’m pleased to announce that the June 2011 CTP (Community Technology Preview) of the Windows Azure Plugin for Eclipse with Java is now available for download. As the project manager and designer behind our Java tooling efforts for Windows Azure, I invite you to take a look at our latest release and share your feedback to help us make further progress in helping Java developers take advantage of the Windows Azure cloud. At the time this blog goes live, I'll be sleeping, but my colleague Gianugo Rabellino would have announced the new CTP during his keynote "Behind the scenes: Microsoft and Open Source" at the Jazoon conference in Zurich.
This plugin is intended to help Eclipse users create and configure deployment packages of their Java applications for the Windows Azure cloud. Its key features include:
To install, just point Eclipse’s “Install New Software…” feature at http://webdownload.persistent.co.in/windowsazureplugin4ej/. Also make sure to install al the prerequisites, as explained in detail here or here. For those who have already been playing around with our Ant-based command-line tools called Windows Azure Starter Kit for Java, note that your Starter Kit projects are compatible with this plugin, in fact the plugin builds on top of the Starter Kit.
We’re continuously working on new tutorials and feature additions in our Windows Azure tooling for Java developers, so keep checking back with our main portal at http://java.interopbridges.com/cloud for further updates.
Martin Sawicki, Senior Program Manager, Interoperability Strategy team
W3C has announced they are beta testing a W3C Community Process that allows groups to develop specifications and other useful documents under the W3C umbrella, but using a more lightweight process than the one used to create formal Recommendations. This means that jumpstarting potential new Web standards is becoming easier and faster at the W3C and that anyone, including non W3C members, will be able to participate. As Microsoft’s representative to the W3C Advisory Committee and an elected member of the Advisory Board, I’ve been involved in planning this for more than a year now. We think that W3C is the right organization to host this new venue for collaboration on Web challenges, because they have experience in helping communities build real consensus and have a strong reputation as the most credible source of guidance on Web specifications.At Microsoft we, like many others, have been struggling with a challenge that has motivated us to participate in these planning discussions. Take the scenario where a group of web developers wish to get together to propose a new API that solves a particular problem they’re facing, but isn’t handled by Web standards today. They work for different companies, large, and small, and whose employers participate in different standards organizations (or none at all). They know there are a bunch of legal details that might come back to haunt them, but don’t have the time or legal resources to identify them or craft a legal framework for the collaboration. What can they do?
None of the options available right now are probably all that great for the group:
The W3C Community Process adds a new option for W3C members and non-members to work together to brainstorm specifications that could eventually become open web standards. An earlier W3C blog post explains how:
A Community Group is an open forum for developing specifications, holding discussions, developing test suites, and otherwise building communities around innovation. There are no fees, no charters, no end dates, and a lightweight set of participation agreements to make them fast to launch and open to all. Some Community Groups may produce results that are subsequently carried forward on the standards track, but others may not. That will be for the communities themselves to decide ...So, here’s how the process will work: to start a Community Group, you will pick a topic, write a short scope statement (for communications purposes), and get four other parties to support the creation of the group. Once you have enough support, the system we plan to have in place at launch will create the tooling (wiki, spam-controlled mailing lists, microblog, and other infrastructure) to support the group's activities.
Community Groups will operate under a simple legal agreement intended to balance the concerns of implementers and potential IPR holders, and designed to provide a smooth transition to the W3C Patent Policy if a group ultimately decides to go in that direction.
So, in summary, we are excited about this innovation and the opportunities it brings – both for us and for you. Jumpstarting potential new Web standards is becoming easier and faster at the W3C and all interested parties, including non W3C members, will now be able to participate. We are also excited about the opportunity this brings to start working with you to propose new ideas in W3C Communities.
Michael Champion, Senior Program Manager, Interoperability Strategy Team