This week we released some great updates to Windows Azure that make it significantly easier to develop
mobile applications that use the cloud. These new capabilities include:
Mobile Services: Custom API support
Mobile Services: Git Source Control support
Mobile Services: Node.js NPM Module support
Mobile Services: A .NET API via NuGet
Mobile Services
and Web Sites: Free 20MB SQL Database Option for
Mobile Services
and Web Sites
Mobile Notification Hubs: Android Broadcast Push Notification Support All of these improvements are now available to use immediately (note: some are still in preview). Below are more details about them.
Mobile Services: Custom APIs, Git Source Control,
and NuGet Windows Azure
Mobile Services provides the ability to easily stand up a
mobile backend that can be used to support your Windows 8, Windows Phone, iOS, Android
and HTML5 client applications. Starting with the first preview we supported the ability to easily extend your data backend logic with server side scripting that executes as part of client-side CRUD operations against your cloud back data tables. With today’s update we are extending this support even further
and introducing the ability for you to also create
and expose Custom APIs from your
Mobile Service backend,
and easily publish them to your
Mobile clients without having to associate them with a data table. This capability enables a whole set of new scenarios – including the ability to work with data sources other than SQL Databases (for example: Table Services or MongoDB), broker calls to 3rd party APIs, integrate with Windows Azure Queues or Service Bus, work with custom non-JSON payloads (e.g. Windows Periodic Notifications), route client requests to services back on-premises (e.g. with the new Windows Azure BizTalk Services), or simply implement functionality that doesn’t correspond to a database operation. The custom APIs can be written in server-side JavaScript (using Node.js)
and can use Node’s NPM packages. We will also be adding support for custom APIs written using .NET in the future as well. Creating a Custom API Adding a custom API to an existing
Mobile Service is super easy. Using the Windows Azure Management Portal you can now simply click the new “API” tab with your
Mobile Service,
and then click the “Create a Custom API” button to create a new Custom API within it: Give the API whatever name you want to expose,
and then choose the security permissions you’d like to apply to the HTTP methods you expose within it. You can easily lock down the HTTP verbs to your Custom API to be available to anyone, only those who have a valid application key, only authenticated users, or administrators.
Mobile Services will then enforce these permissions without you having to write any code: When you click the ok button you’ll see the new API show up in the API list. Selecting it will enable you to edit the default script that contains some placeholder functionality: Today’s release enables Custom APIs to be written using Node.js (we will support writing Custom APIs in .NET as well in a future release),
and the Custom API programming model follows the Node.js convention for modules, which is to export functions to handle HTTP requests. The default script above exposes functionality for an HTTP POST request. To support a GET, simply change the export statement accordingly. Below is an example of some code for reading
and returning data from Windows Azure Table Storage using the Azure Node API: After saving the changes, you can now call this API from any
Mobile Service client application (including Windows 8, Windows Phone, iOS, Android or HTML5 with CORS). Below is the code for how you could invoke the API asynchronously from a Windows Store application using .NET
and the new InvokeApiAsync method,
and data-bind the results to control within your XAML: private async void RefreshTodoItems() { var results = await App.MobileService.InvokeApiAsync<List<TodoItem>>("todos", HttpMethod.Get, parameters: null); ListItems.ItemsSource = new ObservableCollection<TodoItem>(results); } Integrating authentication
and authorization with Custom APIs is really easy with
Mobile Services. Just like with data requests, custom API requests enjoy the same built-in authentication
and authorization support of
Mobile Services (including integration with Microsoft ID, Google, Facebook
and Twitter authentication providers),
and it also enables you to easily integrate your Custom API code with other
Mobile Service capabilities like push notifications, logging, SQL, etc. Check out our new tutorials to learn more about to use new Custom API support,
and starting adding them to your app today.
Mobile Services: Git Source Control Support Today’s
Mobile Services update also enables source control integration with Git. The new source control support provides a Git repository as part your
Mobile Service,
and it includes all of your existing
Mobile Service scripts
and permissions. You can clone that git repository on your local machine, make changes to any of your scripts,
and then easily deploy the
mobile service to production using Git. This enables a really great developer workflow that works on any developer machine (Windows, Mac
and Linux). To use the new support, navigate to the dashboard for your
mobile service
and select the Set up source control link: If this is your first time enabling Git within Windows Azure, you will be prompted to enter the credentials you want to use to access the repository: Once you configure this, you can switch to the configure tab of your
Mobile Service
and you will see a Git URL you can use to use your repository: You can use this URL to clone the repository locally from your favorite command line: > git clone https://scottgutodo.scm.azure-mobile.net/ScottGuToDo.git Below is the directory structure of the repository: As you can see, the repository contains a service folder with several subfolders. Custom API scripts
and associated permissions appear under the api folder as .js
and .json files respectively (the .json files persist a JSON representation of the security settings for your endpoints). Similarly, table scripts
and table permissions appear as .js
and .json files, but since table scripts are separate per CRUD operation, they follow the naming convention of <tablename>.<operationname>.js. Finally, scheduled job scripts appear in the scheduler folder,
and the shared folder is provided as a convenient location for you to store code shared by multiple scripts
and a few miscellaneous things such as the APNS feedback script. Lets modify the table script todos.js file so that we have slightly better error handling when an exception occurs when we query our Table service: todos.js tableService.queryEntities(query, function(error, todoItems){ if (error) { console.error("Error querying table: " + error); response.send(500); } else { response.send(200, todoItems); } }); Save these changes,
and now back in the command line prompt commit the changes
and push them to the
Mobile Services: > git add . > git commit –m "better error handling in todos.js" > git push Once deployment of the changes is complete, they will take effect immediately,
and you will also see the changes be reflected in the portal: With the new Source Control feature, we’re making it really easy for you to edit your
mobile service locally
and push changes in an atomic fashion without sacrificing ease of use in the Windows Azure Portal.
Mobile Services: NPM Module Support The new
Mobile Services source control support also allows you to add any Node.js module you need in the scripts beyond the fixed set provided by
Mobile Services. For example, you can easily switch to use Mongo instead of Windows Azure table in our example above. Set up Mongo DB by either purchasing a MongoLab subscription (which provides MongoDB as a Service) via the Windows Azure Store or set it up yourself on a Virtual Machine (either Windows or Linux). Then go the service folder of your local git repository
and run the following command: > npm install mongoose This will add the Mongoose module to your
Mobile Service scripts. After that you can use
and reference the Mongoose module in your custom API scripts to access your Mongo database: var mongoose = require('mongoose'); var schema = mongoose.Schema({ text: String, completed: Boolean }); exports.get = function (request, response) { mongoose.connect('<your Mongo connection string> '); TodoItemModel = mongoose.model('todoitem', schema); TodoItemModel.find(function (err, items) { if (err) { console.log('error:' + err); return response.send(500); } response.send(200, items); }); }; Don’t forget to push your changes to your
mobile service once you are done > git add . > git commit –m "Switched to use Mongo Labs" > git push Now our
Mobile Service app is using Mongo DB! Note, with today’s update usage of custom Node.js modules is limited to Custom API scripts only. We will enable it in all scripts (including data
and custom CRON tasks) shortly. New
Mobile Services NuGet package, including .NET 4.5 support A few months ago we announced a new pre-release version of the
Mobile Services client SDK based on portable class libraries (PCL). Today, we are excited to announce that this new library is now a stable .NET client SDK for
mobile services
and is no longer a pre-release package. Today’s update includes full support for Windows Store, Windows Phone 7.x,
and .NET 4.5, which allows developers to use
Mobile Services from ASP.NET or WPF applications. You can install
and use this package today via NuGet.
Mobile Services
and Web Sites: Free 20MB Database for
Mobile Services
and Web Sites Starting today, every customer of Windows Azure gets one Free 20MB database to use for 12 months free (for both dev/test
and production) with Web Sites
and Mobile Services. When creating a
Mobile Service or a Web Site, simply chose the new “Create a new Free 20MB database” option to take advantage of it: You can use this free SQL Database together with the 10 free Web Sites
and 10 free
Mobile Services you get with your Windows Azure subscription, or from any other Windows Azure VM or Cloud Service. Notification Hubs: Android Broadcast Push Notification Support Earlier this year, we introduced a new capability in Windows Azure for sending broadcast push notifications at high scale: Notification Hubs. In the initial preview of Notification Hubs you could use this support with both iOS
and Windows devices. Today we’re excited to announce new Notification Hubs support for sending push notifications to Android devices as well. Push notifications are a vital component of
mobile applications. They are critical not only in consumer apps, where they are used to increase app engagement
and usage, but also in enterprise apps where up-to-date information increases employee responsiveness to business events. You can use Notification Hubs to send push notifications to devices from any type of app (a
Mobile Service, Web Site, Cloud Service or Virtual Machine). Notification Hubs provide you with the following capabilities: Cross-platform Push Notifications Support. Notification Hubs provide a common API to send push notifications to iOS, Android, or Windows Store at once. Your app can send notifications in platform specific formats or in a platform-independent way. Efficient Multicast. Notification Hubs are optimized to enable push notification broadcast to thousands or millions of devices with low latency. Your server back-end can fire one message into a Notification Hub,
and millions of push notifications can automatically be delivered to your users. Devices
and apps can specify a number of per-user tags when registering with a Notification Hub. These tags do not need to be pre-provisioned or disposed,
and provide a very easy way to send filtered notifications to an infinite number of users/devices with a single API call. Extreme Scale. Notification Hubs enable you to reach millions of devices without you having to re-architect or shard your application. The pub/sub routing mechanism allows you to broadcast notifications in a super-efficient way. This makes it incredibly easy to route
and deliver notification messages to millions of users without having to build your own routing infrastructure. Usable from any Backend App. Notification Hubs can be easily integrated into any back-end server app, whether it is a
Mobile Service, a Web Site, a Cloud Service or an IAAS VM. It is easy to configure Notification Hubs to send push notifications to Android. Create a new Notification Hub within the Windows Azure Management Portal (New->App Services->Service Bus->Notification Hub): Then register for Google Cloud Messaging using https://code.google.com/apis/console
and obtain your API key, then simply paste that key on the Configure tab of your Notification Hub management page under the Google Cloud Messaging Settings: Then just add code to the OnCreate method of your Android app’s MainActivity class to register the device with Notification Hubs: gcm = GoogleCloudMessaging.getInstance(this); String connectionString = "<your listen access connection string>"; hub = new NotificationHub("<your notification hub name>", connectionString, this); String regid = gcm.register(SENDER_ID); hub.register(regid, "myTag"); Now you can broadcast notification from your .NET backend (or Node, Java, or PHP) to any Windows Store, Android, or iOS device registered for “myTag” tag via a single API call (you can literally broadcast messages to millions of clients you have registered with just one API call): var hubClient = NotificationHubClient.CreateClientFromConnectionString( “<your connection string with full access>”, "<your notification hub name>"); hubClient.SendGcmNativeNotification("{ 'data' : {'msg' : 'Hello from Windows Azure!' } }", "myTag”); Notification Hubs provide an extremely scalable, cross-platform, push notification infrastructure that enables you to efficiently route push notification messages to millions of
mobile users
and devices. It will make enabling your push notification logic significantly simpler
and more scalable,
and allow you to build even better apps with it. Learn more about Notification Hubs here on MSDN . Summary The above features are now live
and available to start using immediately (note: some of the services are still in preview). If you don’t already have a Windows Azure account, you can sign-up for a free trial
and start using them today. Visit the Windows Azure Developer Center to learn more about how to build apps with it. Hope this helps, Scott P.S. In addition to blogging, I am also now using Twitter for quick updates
and to share links. Follow me at: twitter.com/scottgu
