Originally posted on: http://geekswithblogs.net/EltonStoneman/archive/2014/05/22/how-about-a-new-platform-for-your-next-apihellip-a.aspxSay what? I’m seeing
a type of API emerge which serves static or long-lived resources, which are mostly read-only and have
a controlled process to update the data that
gets served. Think of something like an app configuration API, where you want
a central location for changeable settings. You could use this server side to store database connection strings and keep all your instances in sync, or it could be used client side to push changes out to all users (and potentially driving A/B or MVT testing). That’s
a good candidate for
a RESTful API which makes proper use of HTTP expiration and validation caching to minimise traffic, but really you want
a front end UI where you can edit the current config that the API returns and publish your changes. Sound like
a Content Mangement System would be
a good fit? I’ve been looking at that and it’s
a great fit for this scenario. You get
a lot of what you need out of the box, the amount of custom code you need to write is minimal, and you get
a whole lot of extra stuff from using CMS which is very useful, but probably not something you’d build if you had to put together
a quick UI over your API content (like
a publish workflow, fine-grained security and an audit trail). You typically use
a CMS for HTML resources, but it’s simple to expose JSON instead – or to do content negotiation to support both, so you can open
a resource in
a browser and see
a nice visual representation, or request it with: Accept=application/json
and get the same content rendered as JSON for the app to use.
Enter Umbraco
Umbraco is an open source .NET CMS that’s been around for
a while. It has very good adoption,
a lively community and
a good release cycle. It’s easy to use, has all the functionality you need for
a CMS-driven API, and it’s scalable (although you won’t necessarily put much scale on the CMS layer).
In the rest of this post, I’ll build out
a simple app config API using Umbraco. We’ll define the structure of the configuration resource by creating
a new Document Type and setting custom properties; then we’ll build
a very simple Razor template to return configuration documents as JSON; then create
a resource and see how it looks. And we’ll look at how you could build this into
a wider solution.
If you want to try this for yourself, it’s ultra easy – there’s an Umbraco image in the Azure Website gallery, so all you need to to is create
a new Website, select Umbraco from the image and complete the installation. It will create
a SQL Azure website to store all the content, as well as
a Website instance for editing and accessing content. They’re standard Azure resources, so you can scale them as you need. The default install creates
a starter site for some HTML content, which you can use to learn your way around (or just delete).
1. Create Configuration Document Type
In Umbraco you manage content by creating and modifying documents, and
every document has
a known type, defining what properties it holds.
We’ll create
a new Document Type to describe some basic config settings. In the Settings section from the left navigation (spanner icon), expand Document Types and Master, hit the ellipsis and select to create
a new Document Type:
This will base your new type off the Master type, which gives you some existing properties that we’ll use – like the Page Title which will be the resource URL.
In the Generic Properties tab for the new Document Type, you set the properties you’ll be able to edit and return for the resource:
Here I’ve added
a text string where I’ll set
a default cache lifespan, an image which I can use for
a banner display, and
a date which could show the user when the next release is due.
This is the sort of thing that sits nicely in an app config API. It’s likely to change during the life of the product, but not very often, so it’s good to have
a centralised place where you can make and publish changes easily and safely. It also enables A/B and MVT testing, as you can change the response each client
gets based on your set logic, and their apps will behave differently without needing
a release.
2. Define the response template
Now we’ve defined the structure of the resource (as
a document), in Umbraco we can define
a C# Razor template to say how that resource
gets rendered to the client.
If you only want to provide JSON, it’s easy to render the content of the document by building each property in the response (Umbraco uses dynamic objects so you can specify document properties as object properties), or you can support content negotiation with very little effort.
Here’s
a template to render the document as HTML or JSON depending on the Accept header, using JSON.NET for the API rendering:
@inherits Umbraco.Web.Mvc.UmbracoTemplatePage
@using Newtonsoft.Json
@{
Layout = null;
}
@if(UmbracoContext.HttpContext.Request.Headers["accept"] != null && UmbracoContext.HttpContext.Request.Headers["accept"] == "application/json")
{
Response.ContentType = "application/json";
@Html.Raw(JsonConvert.SerializeObject(new {
cacheLifespan = CurrentPage.cacheLifespan,
bannerImageUrl = CurrentPage.bannerImage,
nextReleaseDate = CurrentPage.nextReleaseDate
}))
}
else
{
<h1>App configuration</h1>
<p>Cache lifespan: <b>@CurrentPage.cacheLifespan</b></p>
<p>Banner Image: </p>
<img src="@CurrentPage.bannerImage">
<p>Next Release Date: <b>@CurrentPage.nextReleaseDate</b></p>
}
That’s
a rough-and ready example of what you can do. You could make it completely generic and just render all the document’s properties as JSON, but having
a specific template for each resource gives you control over what
gets sent out.
And the templates are evaluated at run-time, so if you need to change the output – or extend it, say to add caching response headers – you just edit the template and save, and the next client request
gets rendered from the new template. No code to build and ship.
3. Create the content
With your document type created, in the Content pane you can create
a new instance of that document, where Umbraco gives you
a nice UI to input values for the properties we set up on the Document Type:
Here I’ve set the cache lifespan to an xs:duration value, uploaded an image for the banner and specified
a release date. Each property
gets the appropriate input control – text box, file upload and date picker.
At the top of the page is the name of the resource – myapp in this example. That specifies the URL for the resource, so if I had
a DNS entry pointing to my Umbraco instance, I could access the config with
a URL like http://static.x.y.z.com/config/myapp.
The setup is all done now, so when we publish this resource it’ll be available to access.
4. Access the resource
Now if you open that URL in the browser, you’ll see the HTML version rendered:
- complete with the image and formatted date. Umbraco lets you save changes and preview them before publishing, so the HTML view could be
a good way of showing editors their changes in
a usable view, before they confirm them.
If you browse the same URL from
a REST client, specifying the Accept=application/json request header, you get this response:
That’s the exact same resource, with
a managed UI to publish it, being accessed as HTML or JSON with
a tiny amount of effort.
5. The wider landscape
If you have fairy stable content to expose as an API, I think this approach is really worth considering. Umbraco scales very nicely, but in
a typical solution you probably wouldn’t need it to.
When you have additional requirements, like logging API access requests - but doing it out-of-band so clients aren’t impacted, you can put
a very thin API layer on top of Umbraco, and cache the CMS responses in your API layer:
Here the API does
a passthrough to CMS, so the CMS still controls the content, but it caches the response. If the response is cached for 1 minute, then Umbraco only needs to handle 1 request per minute (multiplied by the number of API instances), so if you need to support 1000s of request per second, you’re scaling
a thin, simple API layer rather than having to scale the more complex CMS infrastructure (including the database).
This diagram also shows an approach to logging, by asynchronously publishing
a message to
a queue (Redis in this case), which can be picked up later and persisted by
a different process.
Does it work?
Beautifully. Using Azure, I spiked the solution above (including the Redis logging framework which I’ll blog about later) in half
a day. That included setting up different roles in Umbraco to demonstrate
a managed workflow for publishing changes, and
a couple of document types representing different resources.
Is it maintainable?
We have three moving parts, which are all managed resources in Azure – an Azure Website for Umbraco which may need
a couple of instances for HA (or may not, depending on how long the content can be cached),
a message queue (Redis is in preview in Azure, but you can easily use Service Bus Queues if performance is less of
a concern), and the Web Role for the API. Two of the components are off-the-shelf, from open source projects, and the only custom code is the API which is very simple.
Does it scale?
Pretty nicely. With
a single Umbraco instance running as an Azure Website, and with 4x instances for my API layer (Standard sized Web Roles), I got just under 4,000 requests per second served reliably, with
a Worker Role in the background saving the access logs. So we had
a nice UI to publish app config changes, with
a friendly Web preview and
a publishing workflow, capable of supporting 14 million requests in an hour, with less than
a day’s effort.
Worth considering if you’re publishing long-lived resources through your API.
