kentoh - Fotolia
For the average worker, particularly the mobile worker, both the complexity of tools and the need for consultation with experts make it difficult to realize productivity improvement through analytics. However, microservices may hold the key to solving this problem. Since applications are being driven to microservice form by increased needs for context-sensitive work support, event management and IoT, it makes sense to frame analytics as a microservice toolkit and then compose those tools directly into applications.
By submitting your personal information, you agree that TechTarget and its partners may contact you regarding relevant content, products and special offers.
The problem with monolithic analytics
Monolithic analytics applications usually run in a stand-alone way, meaning they are generating queries against one or more databases. This approach doesn't work well in supporting workers in general, but it also means mobile workers have no practical way of generating queries. Thus, they are forced to rely on pre-generated reports that are typically not timely and don't necessarily provide the specific analytics needed.
The solution to this problem is the ability to more easily integrate analytics with applications. That can be done by using analytics toolkits or front-end elements that visualize analytical data or by providing a means of directly linking analytics features into other applications. The best approach will depend on how your workers expect to use analytical data and how tightly coupled you'd like the analytics to be.
Two approaches to analytics integration
Mobile or web applications are already designed to work with APIs, so they can accept analytics integration based on APIs that the packages expose. However, these are often not particularly simple to use, so additional tools are helpful. There are two paths that can be taken: You can use a composable front-end element to your analytics applications, like IBM Graph or Domo, that presents a simple visual-oriented GUI, or you could use microservices to enhance composability. The front-end approach focuses on a visual representation of analytics. The microservice composition approach offers more control over the process, but is also more complex to adopt since it's essentially a programming task.
Front-end tools like Compose for JanusGraph and Domo are designed for direct use by workers. Compose for JanusGraph is managed by IBM, but other analytics front-ends and visualization tools like Domo are hosted and managed by the user. The advantage of these tools is that they reduce analytical query results to a simple form or a variety of visualizations, rather than presenting undigested query results. This is ideal for results that can be represented visually. The disadvantage is that the options for presentation may not match what the worker needs. In many cases, the visual-result solutions are independent applications, meaning you still have to access them explicitly.
The principle of microservices-based analytics is that if the analytics application is composed from microservices, it could be integrated with other applications easily. If an analytics application consisted entirely of microservices, you could fit pieces of it into existing applications -- including those used by mobile workers -- and pass information to analytics for additional projections.
The same effect can be achieved if the analytics application is virtually decomposed by having its APIs matched with a front-end service set that resembles microservices and has the same level of flexibility in composition. Zoomdata has been a pioneer in this space, providing a new middleware layer that presents analytics tools as microservices without actually changing the tools. That's a big help to companies who have an analytics product in house and don't want to change vendors.
Composable microservices analytics, whatever the implementation specifics, can be made to look much like the front-end elements you find in mobile applications. There's a set of interfaces, usually including both composable APIs and some GUIs, and a queue that stages requests for processing by the analytics application. This queue structure also serves to load-balance the requests across multiple instances of the analytics application or steer work to the proper application. If you want integration with the back-end application elements, microservices make that as easy as calling an API.
The agility of a microservices analytics approach means that you can apply it to more than simply visualizing query results. Machine learning, natural language processing and even complex event processing can be supported by microservices analytics, since you can insert a query into almost any application. Many believe that this capability alone justifies the microservice approach, but about two years have passed since the notion first surfaced, and it's still far from the mainstream.
The in-house vs. third-party debate
A lack of tooling may be part of the problem, but microservices analytics is available to anyone who can develop microservices. It's helpful to use a vendor offering to create the link between microservice-based composability and analytics tools, but it's also possible to build the bridge yourself. Most companies have front-end-based applications for web access and mobile access, and a front-end system can be used to create composable APIs that appear as microservices. The new composable elements would then dispatch requests into a queue or service bus for handling by the analytics system, which would return a result as any other business application would.
The difficulty in rolling your own microservices is often API management, but there are widely used tools to make that easier. All of the major cloud providers provide web services for API management and so do companies like Mashape, whose product is used in many industries and online applications. Remember that with microservices there are a variety of functions that can fall into the management category, including the brokerage of microservices to provide access and the distribution of information on the APIs available. Make sure your application fits your needs.
Composable microservices' utility may depend on just how they're defined. There are two pieces to analytics: query structure and visualization. It's important to be able to control both with any microservice, whether you build it yourself or use one offered by a third party. There's great potential in microservices analytics, but controlling those two pieces may be the factor that decides whether it will be realized.