The ongoing need for IT Architecture

The benefits of combining microservices IT architecture and DevOps

The journey to a microservices architecture

As discussed in the blog, there are three key indicators that a move to an architecture based on a microservices architecture pattern should be considered. These are:

  • A significant decline in delivery speed. Most organisation have an aging and increasingly large application code base that has typically been designed as a monolithic whole. This makes the code increasingly difficult to understand and is further complicated by the fact that many organisations continue to lose their institutional knowledge relating to their existing application code. These issues make their application code increasingly difficult to analyse and enhance over time which results in the steady lengthening of the time needed to enhance and add to existing applications, hence an increasingly inefficient software development life cycle. 
  • A steady increase in the number of defects from each testing cycle.  As the monolithic code becomes increasingly complex and difficult to understand developers and testers will start to miss test scenarios and / or start to make an increasing number of mistakes. This usually makes it increasingly difficult for organisations to maintain a consistent and regular production release schedule. An inconsistent and irregular release pattern typically results in increasingly inefficient and ineffective production releases over time. 
  • It gradually becomes increasingly difficult to scale horizontally. As the demands of the business grow and the business footprint becomes ever wider (increasing number of users, increasing number of systems end-points, increasing number of input devices such as Internet of Things devices, etc.) it becomes increasingly difficult for organisations existing technology stacks to accommodate this growth. This tends to happen for several reasons including the fact that the current technology is technically incapable of scaling out any further, or that the cost of such horizontal growth becomes financially prohibitive. As this becomes increasingly acute organisations tend to start considering the duplication of their entire technology stack which although an obvious solution to the problem is rather an expensive option which also introduces greater complexity.  

It is at this point that an architecture based on the microservice architecture pattern using a distributed systems design starts to look increasingly attractive. But decomposing a monolithic application suite into a series of mini services comes with its own challenges. A distributed system has to be the right size and must remain self-contained in terms of functional coverage.  This takes careful design, with services that are the right size for each organisations individual needs and must be reinforced by an effective way of orchestrating logic across these various services. Carefully designed integration solutions are therefore key to success and must be supported by a well-managed library of application programming interfaces (APIs) and a well-managed distributed data design. As well as the above the resulting solutions must also support the effective and efficient centralisation of common concerns across the solution. 

DevOps and its relevance to the Microservices architecture journey.

Development and operations (DevOps) describe the processes which can be used to integrate development, quality assurance, and IT operations and provide the tooling needed to deliver software solutions far more rapidly and consistently while ensuring the compatibility of all software solution components. This is achieved by breaking up the software solutions architecture into self-contained software components (or services) that enable software solutions providers to deliver a self-contained set of software services while ensuring that each component is interoperable with all the other services.

DevOps enables a software development environment that supports these activities and operations:

  • Continuous integration (CI) – the process of automatically building and testing code every time a software developer commits code changes to version control. The purpose of this is to:
    • To quickly discover and correct code issues
    • Streamline deployment.

    • Ensure code quality. 

  • Continuous delivery (CD) – the process of automating build, test, configuration, and deployment from a build to a production environment. A release pipeline can create multiple testing or staging areas. The objective is to ensure that:
    • Code is always ready to deploy. 
    • Create a full CI/CD pipeline by adding continuous delivery in order to improve the process of detecting code defects as soon as possible. 

    • Enable properly tested updates to be released as quickly as possible. 

  • Continuous deployment – an additional process that automatically takes any updates that have passed through the CI/CD pipeline and deploys them into production. This requires robust automatic testing and advanced process planning. 
  • Continuous monitoring – provides the process and technology required to incorporate monitoring across each phase of the DevOps and IT operations lifecycles. It helps top to ensure the health, performance, and reliability of applications as they move from development to production. 

Using Micro-services architectures to build and mature a DevOps capability is therefore effective because advanced automation, monitoring, and DevOps are all key components of microservices operations. 

In most development environments releases happen once a month, with each release requiring careful planning and frequent release meetings. But in an increasingly agile competitive landscape which demands swiftness when reacting to software bugs, customer demand, feedback, and market requirements, development teams cannot afford to settle for monthly releases. Automation is the answer. Automation is a core principle of microservices DevOps practices. But by automating the DevOps pipeline, software developers need to ensure that the service they design and deploy meets consistent quality standards. This in turn demands a comprehensive testing approach across every stage of the release pipeline, which is best supported by microservices architectures.

Microservices architectures allow developers to test while in production, while DevOps provides the necessary functionality to monitor and detect deviation and issues rapidly and apply bug fixes or rollback to previous versions where required. 

The similarities between Microservices and DevOps

Organisations that have embraced microservices are reaping the rewards of increased productivity, rapid deployment, and flexible, more scalable applications. DevOps makes this easier to do by breaking down the boundaries between Development and Operations in a way that creates a rapid automated process which enables the fastest possible development and deployment of software. This is possible because DevOps teams are made up of both development and operations engineers who work hand in hand throughout the software lifecycle, from the design and the development stages, to support.

Both DevOps and microservices design approaches support the principles of creating an agile and efficient environment for the organisations they are deployed in but combining them as part of the same software development life cycle typical provides greater benefits in all aspects of operations. For example, Amazon engineers use a combination of microservices and DevOps to deploy lines of code roughly every 11 seconds while ensuring that the incidence and duration of downtimes are kept low. Similarly, Netflix engineers deploy code thousands of times a day.

The benefits of combining Microservices and DevOps.

By combining Microservices and DevOps principles software development teams are better positioned to release high-quality software components frequently and predictably thereby allowing them to satisfy and even exceed the expectations and needs of their customers. For DevOps teams, microservices offer many significant advantages, some of the key benefits include: 

  • DevOps and Microservices empowering Small, Autonomous Teams.  
  • The ability to uses different programming languages or different versions of the same programming language. 
  • Decentralizing applications and teams helps to narrow the gap between the user interface, backend, and middle-tier developers, who tend to work in isolation.
  • Decentralizing applications and teams also helps to narrow the gap between the development, security, business, production management, and operations teams, who also usually work in their own silos.
  • Modular Services Can be Released as Autonomously Deployed Artifacts, thereby allowing: 
    • Conduct feature and configuration experiments in a safe, contained, and secure manner.

    • Recover from problems and failures quickly without disrupting the application experience for customers.

  • The provision of fully automated solutions that support independently deployable versions of artifacts across development, testing, and production.
  • The provision of fully automated solutions that support independently deployable versions of artifacts across development, testing, and production.
  • Projects based on microservices architectures feature a suite of services with clearly defined boundaries. Not only that, but these projects are also support continuous flow from start to finish, minimizing handoffs, dependency conflicts, etc. 

In WiRD’s experience DevOps is becoming increasingly important to effective and efficient solutions design and deployments as much of the world continues its journey to a microservices based solutions landscape. What has your experience been with regards to deploying IT architectures in recent years? Please share your experiences with WiRD and each other by commenting or interacting on LinkedIn

This website uses cookies and asks your personal data to enhance your browsing experience.