How the WaveRunner GUI API Enables Tomorrow’s SDDC Innovation, Today
Guest blog post by Chris Busse, CTO at APIvista
In my consulting work, I encourage enterprises of many sizes to use standardized APIs across their business areas. This means I’m often called upon to explain what an application programming interface is to non-technical stakeholders.
Many technologists say, "APIs are like LEGO bricks," but I prefer a more complete description: "They’re a way developers can make their software available to future developers to integrate with, but without having to know today what those future developers want to do with the software." Put yet another way: APIs are the technical enabler of digital innovation.
Over the past six months I’ve had the privilege of working with the TidalScale team to help define the TidalScxale WaveRUnner REST AP, the point-and-click control panel for TidalScale’s HyperKernel software. (HyperKernel — and by extension, the WaveRunner GUI — is the enabling technology behind the creation of Software-Defined Servers, which allows you to right-size servers on the fly to fit any workload or data problem.) When TidalScale and I first talked about its API project, there was one particular aspect in their approach that really excited me: They wanted to embrace "contract first" API design. This is an approach where the API specification is documented and agreed upon by all involved — the front and back-end developers, product managers, and project sponsors — before actual API development work begins. This collaborative approach takes everyone’s input into consideration, but more importantly, it lets the front and back-end developers do their work in parallel without worrying about one building something that will fail to interface with the other.
To get everyone aligned around a single API specification embracing REST principles, we used the Swagger Editor tool, following the Open API Specification as a common documentation and definition language. Close attention was paid to developing a taxonomy that represented the WaveRunner console's unique product attributes, such as a visual, intuitive interface, real-time sparklines and status indicators, various options for configuring and deploying Software-Defined Servers, and a command line interface for more granular control. This enabled the developers working on the UI and command line to have a shared understanding of how commands and interfaces needed to be built. And it fostered the creation of a suite of tools for administering the WaveRunner platform that feels cohesive to use. Building these tools allowed the folks at TidalScale to "eat their own dog food" and use their APIs before exposing them to partners.
But what about those future unknown use cases?
Enabling DevOps and Build Automation
Cloud hosting providers like Amazon Web Services and Microsoft Azure, along with on-premises solutions such as VMware and Nutanix, have revolutionized how automated infrastructure management is handled by exposing their own APIs to enable a software-defined data center tailored for an array of point-in-time resource needs. TidalScale has embraced this approach with its APIs and command-line tools, which themselves are essentially a set of client applications using TidalScale’s APIs.
In today’s world, end customers judge a software product’s value not only by the results it produces with its inputs and outputs, but by how well it functions. Is it up and running? Is it performing to the level that is expected or better? The WaveRunner GYU addresses this need by providing a visual dashboard for monitoring the performance and status of Software-Defined Servers in the data center. For instance, the WaveRunner interface displays which nodes have been implemented and booted within a specific Software-Defined Server, along with the various resources (CPUs, memory, storage and network) associated with that Software-Defined Server. Users can view the status of all these resources at any given time and diagnose issues as they arise. In fact, they can use the WaveRunner console to dynamically control server, storage and network infrastructure from a single interface.
Savvy developers address this by making use of modern DevOps methodologies. "DevOps" is one of those words that has many definitions depending on whom you ask and the context you ask it in, but it basically comes down to defining infrastructure as code, and being able to automate the deployment of that infrastructure in an on-demand and as-needed manner. At the same time, being able to shut down the resources when they’re no longer in use is a key attribute of DevOps because it makes resources available to others that might need them, and because it saves costs.
This approach delivers huge advantages not only in developer productivity, but also in the areas of compliance, security and data integrity. Infrastructure defined as code can be kept in version control just like the software that is deployed to it, can be monitored for changes (both good and bad), and can be modified when needed in an observable, repeatable, and reversible way. Done right, it also eliminates the "It runs on my machine just fine, I don’t understand why it doesn’t run on the server!" trope of failed deployments.
There is a huge ecosystem of software tools to manage these processes, but at the end of the day they all rely on the fact that the component pieces they’re working with, such as the WaveRunner GUI, offer modern APIs and command line tools.
Enabling Partner Ecosystems
As I mentioned earlier, APIs are the technical enabler of digital innovation. They are especially powerful for enabling partner integrations. Buzzwords like "catalyst" and "synergy" abound, but partner relationships underpinned by APIs mean that two or more parties are now providing more benefit to a common customer than either one party could on their own. Again, the original developers of the platform didn’t have to know — and might not have been able to imagine — what kind of new value the partner wants to bring to the table. But with their APIs, they’re ready for it!
One example where TidalScale is already seeing results with this is its use of Jenkins, a continuous build tool recognized and used by many in the test automation industry. TidalScale's DevOps team used the WaveRunner API to integrate all of the company's Software-Defined Servers with Jenkins and Docker to automate tests and streamline development and testing operations. The result was an order of magnitude increase in testing throughput without the purchase of any additional hardware. Check out TidalScale’s white paper on Docker, Jenkins & Software-Defined Servers for more details.
As volume and usage increases, a virtuous cycle emerges: the initial creators of an API get feedback on their utility and are able to use that input to plan future product enhancements. This drives conversations that never would have been possible if it wasn’t for those APIs being available in the first place. It’s easy to see from these examples how a little investment in up-front API design and planning can pay real dividends throughout the entire lifecycle of a digital platform.
Watch a WaveRunner demonstration to learn more: