Microservices, Service Registries, and Architectural Debt

Microservices is not just a style of application development, it’s a set of design principles guiding how applications are composed (or decomposed, as the case may be) with a resulting architectural shift as supporting components are added to the mix. Much in the same way SOA brought us UDDI registries and gateways, microservices is bringing service registries.

Service registries, for the uninitiated, are kind of like the internal DNS of a microservices environment. They’re needed to manage the rapid association and disassociation with IP addresses of the containers in which the microservices are typically (but not always) hosted. The average lifespan of a container is measured in minutes or hours, perhaps a day or two, but rarely weeks, months, and probably never years. That means a state of nearly constant change with respect to the infrastructure supporting those services, like the network and app services.

The service registry is responsible for managing that change; it’s where IP addresses and service instances are matched up and handed out to clients (in a client-side architectural pattern) or load balancers (in a server-side architectural pattern). It’s maintained through automation; manual methods of managing the change would simply be too slow and expensive in an environment where new mappings might occur by the minute, hour, or even on a daily basis.

It is here that we return to the imperative that is managing architectural debt. While you can’t eliminate it any more than you can eliminate the technical debt incurred by choices at the code layer, you can manage and try to minimize it. Careful attention to how these new, supporting components are selected and implemented is critical to that endeavor. Each option (client-side, server-side) brings with it a certain amount of architectural debt that will need to be paid in the future.

Introduction of an external service registry necessarily introduces a dependency that cannot be ignored. With a client-side registry, the client is tightly coupled to the registry. Code in the app is required to maintain that dependency and thus impacts the overall development lifecycle. With both patterns, the application will not be able to function without the service registry. This is because without it there’s no way to properly direct the client to an instance of the microservice for processing. Like DNS, the service registry is the glue that loosely binds clients and the “app”.

Thus additional precautions may be required to ensure availability of the service registry, such as the deployment of a high availability (HA) architecture. Because an HA architecture relies on redundancy, this means there must be at least two service registry instances running. This can further complicate the server-side architecture because both instances must be updated whenever an instance is launched or terminated.

This is architectural debt, in which choices made require specific architectures that must be maintained over time and incur operational overhead, and is often difficult to change in the future.  This is increasingly true as app-centric (affine) services like load balancing migrate into the application architecture rather than simply co-existing “nearby” in the network. As these critical services (scale is inarguably critical today) are integrated into operational systems that are code-driven, automated, and orchestrated they become as vulnerable to incurring debt as any other code-bound counterpart. Simply shifting from an external server-side service registry to the use of the load balancer’s innate ability to act as a service registry requires payment of the architectural debt incurred from the original decision and further, in an automated, software-driven environment, also requires payment of the technical debt you incurred to integrate with the external service registry. . 

It’s important to remember that microservices impacts not just development, but deployment, too, and the architectures required to support delivering their services to the users (people, things, and apps). This is not as simple a change as migrating from Apache to IIS (or vice versa). It’s a disruptive change to the architecture, and that will necessitate a certain amount of architectural debt stemming from the choices you make early on in the adoption cycle.

Architectural debt can be minimized, but not mitigated entirely. Therefore it’s important to start evaluating options now, before hasty decisions are made that will later be regretted or cause unforeseen costs or complications.

Published Apr 14, 2016
Version 1.0

Was this article helpful?

No CommentsBe the first to comment