Microservices: The Capstone of SOA and Agile Methodology. December 8, 2017 by Riston Leave a Comment Image courtesy of Geralt. Service Oriented Architecture evolved from many of the defining characteristics of the Object Oriented Programming paradigm, including key concepts such as encapsulation, containerization, and reusability. SOA developed, initially in the 1990’s, as a response to the inefficiencies encountered while attempting to update legacy software systems, where often updating one aspect of the system could cause complete failure of the system. The Agile development methodology also arose to mitigate the rather cumbersome “Waterfall” paradigm of engineering that dominated most software development prior to the mid-2000’s, and places emphasis on people and the interactions between them over rigid processes. This approach to software development encourages the fast delivery of reliable software in an adaptable environment where engineers are able to work according to changing client specifications. The agile development philosophy eventually progressed to the integration of development and operations teams, assuring the prevalence of the practice commonly called DevOps. The focus of the SOA practice of segmenting an application into reusable language-agnostic services eventually evolved into the Micro-services architecture, which is one of the principle tools used by DevOps engineers; which in turn allows for the rapid deployment, integration, and automation of development processes. Brief Overview of SOA Author Thomas Erl defines eight basic principles of Service Orientation: a formal service contract, loose coupling, abstraction, composability, reusability, discoverability, autonomy, and statelessness. Having a formalized contract allows for the interrelationship between services to be defined, while loose coupling means that no component service is dependent on other services. Abstraction in the context of SOA is parallel to the OOP concept of encapsulation, in that it only makes data and logic available consumer entities as necessary, which in turn facilitate easy reuse of the services. Discoverability is a key element to the usefulness of a given service, since if the service is not discoverable, no-one will know to use it. Autonomy and statelessness are also key to allowing services to be used and updated independent of the rest of the application. All of these principles then work together to facilitate composability, wherein services can be combined to execute specific business needs of the application. There were many issues generally encountered by the implementation of Service Orientation into previously monolithic legacy applications, and most modern applications developed by building service components are polyglot and require intelligent endpoints. Thus was born the Micro-services architecture, which in essence fulfills the promises brought forth by SOA. The micro-services architecture has worked effectively in the proliferation of cloud-based applications and development, and give developers of specific services the versatility to use the best languages and tools for the job at hand. Also, the design principle of “Smart endpoints and dumb pipes” further concretizes the SOA principle of statelessness while increasing service interoperability. These features have allowed microservice architecture to blend perfectly with the philosophy of agile development, and consequently is a defining tool for modern DevOps practices. Brief Overview of DevOps and Agile Methodology The defining characteristics of the agile methodology are rapid development and deployment facilitate by an emphasis on client and developer interaction. “People over Process” is one of the common mantras of this philosophy, and the inclusion of consistent client input facilitates a degree of agility in the development process, allowing for necessary changes to be implemented throughout all stages instead of having to wait until a finalized version is released. Another major principle of the Agile Methodology is the emphasis on simplicity, and maximizing the amount of work not done. This simplicity can help to mitigate an excessive “cargo cult” mentality among members of a development team by eliminating the addition of unnecessary moving parts that may cause problems later down the road. DevOps engineering shares many principles that are congruous with Agile philosophy, although the primary focus of DevOps is to integrate both development and operations team for collaboration throughout the development process. Much as in the client interaction facilitated in agile development, the inclusion of operations in the development process allows for insights to be shared throughout the lifecycle of the application, rather than each team having to wait until the deployment stage to start addressing errors. The primary practice areas of DevOps can be defined as: Infrastructure Automation, Continuous Delivery, and Site Reliability Engineering. Infrastructure automation is the practice of automating the scripting of the software environments, such as servers and operating systems. Continuous Delivery, which can be lumped in with continuation integration, is the process of rapidly deploying and updating an application. The continuous integration assures that the code-base is consistently up-to date with the latest versions across development teams. Site Reliability Engineering has as a general concern scalability of the application, so that as the application extends in functionality and volume it continues to operate as intended. The application of these practices are consistent with agile philosophy, and the micro-services architecture is particularly well-suited for the aims of DevOps. Best Practices and Application of Microservices in the DevOps Environment Most modern applications are built through the construction and leveraging of various Associated Programming Interfaces in order to fulfill various various services. Scalability concerns remain at the forefront of challenges faced by modern development teams, and the introduction of a microservice architecture allows teams to use the best tools for the specific service that they are tasked with building and maintaining. The most notable advantages of integrating DevOps and microservices can be defined as: each service is independently deployed, each service scales independently, services can feature different scripting languages, failure of one service will not directly impact another (unless of course the service is a composite), communication between teams are enhanced, and maintaining the application is made easier. All of these features are directly relative to the essential principles of both Service Orientation and Agile methodology. One of the benefits of using a DevOps approach while implementing a microservices architecture is that often times the services are distributed among various servers, requiring the ability to work adaptively across multiple OS environments. Since micro services generally follow the SOA principle of loose coupling, the failure of one system should not necessarily affect the entire system, thus making the debugging process more manageable by helping to isolate both the service and its respective environment. This allows for greater flexibility among development teams that are tasked with individual services, in that they are able to more fully dictate what servers and environments are best suited for their respective service, and to have greater control of configuration of that environment. As cloud computing and other various “X-As-A-Service” practices continue to rise in popularity, so will the adoption of DevOps and its associated microservice architecture. This adoption will greatly aid in facilitating business scalability, allowing businesses to easily adapt to present and future considerations regarding their application. Being able to add a service or update an existing service without concern over breaking the entire application offers a significant advantage over monolithic legacy code-bases, and the integration of automation tools for the configuration of various disparate environments allows for greatly expands the tools available for a specific business requirement. DevOps is also already being expanded into the realm of Security, and in some cases is called DevSecOps. Agile philosophy and Service Orientation have found the fulfillment of their promises in DevOps and Microservices Architecture, and the practices derived from these will essentially propel the future evolution of software development. References 1. Erl, Thomas. The Principles of Service Orientation Part 1 of 6: Introduction to Service Orientation 2. Anuff, Ed APIGEE. May 13, 2014. API-Centric Architecture: SOA Gives Way to Micro Services 3. Morganthal, JP. DevOps.com October 16, 2017. SOA vs. Microservices 4. Mueller, Ernest. The Agile Admin. Aug 2, 2010- July 24, 2017. What is DevOps? 5. Subhakars. WS Tech Blog Feb 11, 2017. Service Oriented Architecture and DevOps Complement each other.