Microservices Governance is a methodology or approach to establish policies, standards, best practices and guidelines on the adoption of Microservices to enable enterprise agile IT environment.

Microservices promote the polyglot model regarding technology stack for supported languages, tools, and data stores. Reusability of assets and tools is the main concept of Microservices, rather than centralized. A decentralized model is best suited for Microservices governance. Decentralized governance gives Microservices teams the freedom to develop software components using different stacks.

Microservices governance framework emphasizes on:

Business

• Derive IT vision, goals and objectives to align IT efforts in line with the Business vision
• Reusability of services and quick time-to-production

Technology

• Baseline architecture guideline for service design and integration with enterprise usage systems
• Identifying, specifying, creating and deploying Microservices Services through DevOps methodology
• Management and monitoring of access policies, Quality of Service metrics and KPIs to gauge performance and throughput

Organizational

• Establishing a dedicated Microservices enterprise to govern effective management

Elements of Microservices Governance

A strong Microservices Governance foundation contains three elements: people, process, and technology. For a successful functioning governance, these three elements must align.

The following diagram demonstrates these elements,

Guiding Principles

Some of the key guiding principles for establishing successful Microservices governance are:

• Independent Services: A Microservice is independent of all other services. Independence of services enables rapid service development & deployment. Requires both design & runtime independence of services.
• Single Responsibility: Requires business function, decomposition into granular
• Self-Containment: Microservices is an independent deployable unit and in order to be independent, it needs to include all necessary building blocks for its operation, contained within
• Policies & Best practices: Compliance to Microservices Domain Reference Architectures, Governance Processes and Roadmap

People

The focus of a Microservices architecture team is to manage and monitor enterprise activities in designing the enterprise application based on Microservices technology. It provides the right function to end users and the appropriate operational support for new architecture.

MS Organizational Model

In enterprise level Microservices adoption, team structure and skills play a major role rather than technology. Flat organization structure and flexible, effective and skilled teams across cross-functional abilities are the key for the success of the Microservices adoption.

Skills & Competency

A Microservices team consists of various members with different skill sets such as system analysts, UX/UI designers, backend and frontend developers, etc. The teams are responsible for their project (Microservice) from end to end.

The size of the team depends on the size of the enterprise along with the project being developed. Experience shows the ideal size is 8-10 people per team.

MS Strategy & Roadmap

Agile and DevOps Environment: Services are small and developed by small teams. Agile makes it possible to release frequently in small chunks and hence show business progress. Instead of deploying one application, the team would be deploying many services.

Data Strategy: An MDM strategy is required to support the distribution of data. Consumption of Core data of an enterprise, done by multiple Microservices to be stored in their local databases.

Technology

Reference Architecture

Microservices architecture offers enterprises many advantages like independent scalability of diverse application components to faster, easier software development and maintenance.

Registry

Usage of dynamic registries helps to track the services that are deployed and monitored. These registries provide lookup addresses to the consumers of the services.

Tools

To achieve a highly scalable architecture using Microservices requires tools to manage additional services and application components, including:

• Service discovery tools, such as Kubernetes.
• Packaging standards for containerizing applications, such as Docker
• CI environment creation tools such as Jenkins
• Failover and resiliency tools, including libraries such as Hystrix and Ribbon
• Service monitoring, alert, and event tools, such as ELK stack

Cloud & API

API is used to establish the interaction between the Microservices, which helps the application to work properly.

Infrastructure Management

Infrastructure management monitors storage, CPU consumption, memory consumption, and hardware network characteristics for deployed services. If a service is deployed on an IAAS or PAAS platform, then the respective cloud or platform management tools are used.

Service Monitoring

This involves monitoring the application service deployments for uptime, and health. Services can report their health by Pull mechanism via JMX, or exposing an HTTP URL.

Process

Federated Teams and DevOps

In a Microservices environment, developers keep adding and removing functionalities frequently. Developers change the code all the time implying that Microservices are constantly evolving. The way an application is broken down into numerous interdependent services, large and siloed teams are broken down into small, multifunctional teams. The development, testing teams transform into smaller DevOps teams. The team that builds the Microservice owns its implementation and maintenance.

Design Time Independence

Defining and controlling the service creations, design, and implementation of service policies.

Runtime Independence

API Gateway helps to realize Run time governance at a dedicated component level.

Data Management

Each Microservice has a separate physical data store and polyglot persistence that lets a variety of database engines run under each Microservice.

Summary

In summary, Microservices adopt decentralized governance, which means that standards enable the team to better build and deploy the code that they have created according to their individual governance plans. The goal of decentralized governance is to free development teams to solve development problems more efficiently and with greater speed. It is important to develop a Devops mindset within the enterprise so that developers are more in control of how their individually governed components are built and operated.