Wednesday, April 29, 2015

Cloud microservices make their play

by Kevin L. Jackson

Cloud computing seems destined to be the way enterprises
will use information technology. The drastic cost reductions and
impressive operational improvements make the transition an unstoppable
trend. The “What is cloud computing?” question now, however, seems to be morphing into “Where is cloud computing going?”

While
software-as-a-service (SaaS) providers see their market rocketing
upward as the easiest and quickest path for cloud adoption,
infrastructure-as-a-service providers are suffering as their
high-capital-cost commodity business transitions to a profit margin race
to the bottom. This unsettling paradox, driven by increased competition
between major infrastructure players, portends a near-term shakeout as
smaller players either fail, exit or get gobbled up.

Cloud
services brokerage, still struggling to be even recognized as a real
market, is being seriously threatened by open-source approaches from
giants like Booz Allen Hamilton’s Jellyfish and the European Commission-funded CompatibleOne open-source broker.
So what about platform-as-a-service? Seen by some as the most
profitable segment, this also seems to be where most of the confusion
resides. Unfortunately PaaS is still struggling to deliver on the
promise of universal software interoperability. So what’s next? With all
due deference to Mr. McGuire in “The Graduate,” two words: microservice architecture.

Microservice
architecture, or simply microservices, is a new software development
method that is, for many developers, rapidly becoming a preferred way of
creating enterprise applications. Because of its scalability, this
architectural method is considered ideal when there is a need to enable
support for a range of platforms and devices — spanning web, mobile, the
“Internet-of-Things,” and wearables.

Although no standard, formal
definition of microservices exists, it is generally characterized as a
method of developing software applications that uses a suite of
independently deployable, small, modular services in which each service
runs a unique process and communicates through a well-defined,
lightweight mechanism. How the services communicate with each other
depends on your application’s requirements, but many use HTTP/REST with
JSON or Protobuf.
Microservices architecture contrasts with the
traditional monolithic development styles in that the latter approach is
always built as a single, autonomous unit. In a client-server model,
the server-side application is a monolith that handles the HTTP
requests, executes logic, and retrieves/updates the data in the
underlying database. The challenge with this approach is that all change
cycles usually end up being tied to one another. Microservices are also
better aligned with more modern agile software development approaches.

Already,
Docker (and others) are working on various new forms of service
discovery, in order to solve the infrastructure dependency injection
problem, and consequently the “awareness” of dependencies between
application components on different servers and infrastructure.

The
recent love affair with infrastructure containers like Docker and
VMware’s surprising investment in Linux containers through the release
of Photon has now opened the door for a rapid adoption of microservices
and the isolation of containers to one process or service.

This
containerization of single services or processes makes it very simple to
manage and update these services. Therefore, it’s not surprising that
the emergence of frameworks for managing more complex scenarios will be
next. Open-source projects like Kubernetes, Maestro-ng and Mesos are now springing up to answer this need. Stay tuned.

(This
post was written as part of the Dell Insight Partners program, which
provides news and analysis about the evolving world of tech. For more on
these topics, visit Dell's thought leadership site PowerMore. Dell sponsored this article, but the opinions are my own and don't necessarily represent Dell's positions or strategies.)