The movement to deconstruct monolithic applications makes no sense if you’re left with a pile of services that have to be hand-stitched back together, according to Dave Duggal, founder and managing director of EnterpriseWeb.
The New York-based startup focuses on automating that stitching back together with a peer-to-peer mesh network that can run over any infrastructure.
Initially aimed at the telecommunications industry, the EnterpriseWeb software takes on the complexity enterprises face in managing multiple middleware stacks.
“In the twenty-first century, middleware should be a very thin tier. It should be this horizontally architected, elastically scaled tier between the application logic I want and the objects I have access to,” Duggal said.
The apps, services, infrastructure are all subject to change, and the network itself is volatile. Each component of middleware stack has different hardware requirements, it scales differently, it has different security. All of this needs to be managed for a scalable real-world operation, he explained
“The largest companies have dozens if not hundreds of these [middleware] stacks, and even if they’re implementing standards,” Duggal said. “They have almost no ability to share anything between stacks. It’s all tightly coupled — versions of open source or versions of commercial software all manually integrated. This bloated stack, we want to get rid of this.”
Companies potentially have services and APIs coming from across the organization, across silos, across layers of IT, from partners, sources anywhere in the world.
“I’ve got latency concerns, failure concerns, version-control concerns, these vendors are not under my control, I have no control when they version something — so this very quickly gets way beyond an API gateway problem, a proxy problem, a scheduler problem, an orchestrator problem,” he explained.
“If I’m going to be composing things out of a lot of small modular elements, I really want a software abstraction, I want a logical model that describes everything. It can look at this application and all the connected pieces — it’s all presented as a graph — I can understand everything and how they’re running, I can cope with change.”
Creating a Metamodel
In a white paper, Caroline Chappell, principal analyst for Analysys Mason‘s software-controlled networking research, calls for a single connected model that supports end-to-end automation of onboarding and lifecycle management processes using machine-readable objects that describe the relationships and links between them. These objects and links are processed at runtime at metamodel level and become the central communication control plane.
Based on network functions virtualization (NFV), the model she describes includes:
- A unified modeling environment designed to make heterogeneous endpoints look homogeneous.
- The ability to capture variance and unique details in a machine-readable manner.
- Support for loose coupling and the composability into higher-order objects.
- Full abstraction between service design and service implementation.
- A dynamic runtime environment that coordinates and processes sets of objects for specific service contexts.
“It is important that the metamodel completely eschews hard-coded connections between its objects and the endpoints that fulfill those objects. Instead, the metamodel’s execution environment should decide, at runtime and based on policies, which endpoints to assign to metamodel objects that participate in a service design,” she wrote.
That’s essentially what EnterpriseWeb does for the whole environment, the company claims.
EnterpriseWeb has been highly involved in demos of by the European Telecommunication Standards Institute Industry Specification Group for NFV (ETSI ISG NFV) and TM Forum Catalyst projects with major telecoms such as AT&T, China Mobile, Orange and Verizon.
Onboarding a single partner application package of a network function takes multiple teams four to six weeks, but one person can do that in less than an hour with EnterpriseWeb, Duggal said.
Asked about whether the technology is applicable outside of NFV for the larger enterprise market, Chappell mentioned its use in healthcare, adding it could work equally well for any other type of enterprise.
“It’s essentially next-generation middleware that supports dynamic connections between objects, where an object is an abstracted description of something in the ‘real’ world — either physical, like an appliance, or virtual, like a piece of software or data,” she said.
“Every industry has the problem of getting things to talk to each other and usually there is very clunky machinery for doing this, like APIs for software. EnterpriseWeb solves this integration problem for any enterprise, but obviously has to be specifically populated with the objects of interest to any particular enterprise to be relevant.”
Loosely Coupled Objects
The New York-based company, founded in 2009, set out to build a lightweight, horizontally architected middle tier of loosely coupled objects. Its Java-based platform enables users to model complex distributed environments and compose policy- and rule-based workflows.
Its web-based environment enables rapid modeling of applications using only links, metadata and rules. To do this, it developed a Graph Object and Action Language (GOAL), a dynamic language for declaratively modeling executable objects as a set of metadata and link references to domain concepts and types — a way to make heterogeneous elements look alike.
It uses intelligent agents, which it calls SmartAlex, to handle all the connection, transformation and integration of loosely coupled objects, APIs and services in real-time.
EnterpriseWeb consists of five microservices, each 15MB:
- Application manager — allows onboarding of application packages, functions, algorithms and application controllers. They are created as objects that are indexed automatically.
- Catalog — provides an inventory with a unified dashboard showing real-time state and history.
- Service manager — Enables a designer to point to things in the catalog and create things with policies and rules. You could say, “These things combine under SLAs,” etc. There’s no coding, no manual integration. The only exception would be if an application package requires a string of code to invoke it, but otherwise, everything is done with metadata.
- Resource manager — It’s used to manage resource orchestrators, cloud hosts, virtualization technologies like OpenStack, VMware, Kubernetes, Docker.
- Task manager — It’s used to model lifecycles processes — what happens when there’s an event. The task manager will automatically reconfigure the environment to adjust to any changes or reconfigure the workloads.
EnterpriseWeb creates its own service mesh over the entire universe where everything will be able to freely share events, objects, models, and states.
“EnterpriseWeb will dynamically do all the integration work — all the finding, the binding; it will connect things,” he said.
“If I define everything as a loosely coupled object in a library, and every object is well-defined unto itself, and it’s all mapped to a single model, that means our agents can read the model because they understand the metadata — it’s a common language for understanding all the different objects. …EnterpriseWeb knows the requirements of each object and can figure it out at runtime.”
It can run over infrastructure such as VMware, OpenStack, over server-based processes, over bare metal, across multiple target hosts or hybrid multi-cloud environments.
“EnterpriseWeb will make all those things look the same to the business. It’s just a pool of resources to be managed,” he said.
“Some things might run better on containers, but we know a lot of the more stateful things are going to continue to run on VMs for a long time, and some things are going to run on servers and some things are going to run on mainframes. Those things are not going away tomorrow. EnterpriseWeb is trying to support the enterprise, the real-world environment, which is trying to modernize, but they can’t burn down their legacy.”
Feature image via Pixabay.
The New Stack is a wholly owned subsidiary of Insight Partners, an investor in the following companies mentioned in this article: Docker.