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.
