Microservices Architecture and Design First Approach to API

Home / Tech Blog / Microservices Architecture and Design First Approach to API
Posted on October 25, 2019

What are Microservices?

Microservices (microservice architecture) – is a software development methodology to building applications — a variant of the service-oriented architectural (SOA) style that structures an application as a collection of loosely coupled services that are:

  • Highly maintainable and testable
  • Loosely coupled 
  • Independently developed
  • Independently deployable
  • Organized around business capabilities
  • Owned by small agile teams

 

This technique represents a fundamental shift in how IT approaches software development. The idea is to split your single monolithic application into a set of smaller, interconnected services.  The benefit of using Microservices in comparison to the more traditional approach is that development teams are able to rapidly build new components of apps, without negatively affecting other services. One team’s changes won’t break/damage the entire app or its parts. This helps to embrace the technology side of DevOps and make delivery (CI/CD) more seamless.

Difference Between Monolithic and Microservice Architecture

Big Giants are Already Evolving Microservices

The trend has grown popular in recent years as enterprises look to become more Agile and move towards a DevOps and continuous testing. The arguments seem to be strong enough to convince some big enterprise players such as Amazon, Netflix, eBay, Amazon, Twitter, PayPal, and other tech stars to evolve with Microservices. 

An early adopter to use Microservices in their service-oriented architecture is NetFlix. They were able to overcome issues with the scalability of their data centers, which arose when the company was growing at a fast pace. Today, NetFlix uses 500+ microservices managed by 30+ mid and small size engineering teams. 

Why Microservices?

The Microservices architecture enables the continuous delivery and deployment of large, complex applications. It also allows an organization to evolve its technology stack, scale, and be more resilient with time. These units also enable the continuous delivery and deployment of large, monolithic applications with minimal need for centralization.

Microservices Features:

  • Agility – any new feature can be quickly developed and discarded again.
  • Resiliency – by dispersing functionality across multiple services eliminates susceptibility to a single point of failure. 
  • Profitability – faster iterations and decreased downtime can increase revenue.
  • Flexibility – different languages and technologies can be used to build various services of the same application.
  • Decoupling – all services can be easily built and scaled.
  • Independence – teams can work independently of each other
  • Continuous delivery – allows frequent releases of software and upgrades.
  • Responsibility – Microservices treat each application as a separate, self-sufficient unit.

Software Development Architecture: Monolithic vs. Microservices

Microservices may be a hot trend, and the advantages seem strong enough to have convinced more and more enterprises to adopt the methodology. But on the flip side, it does not come without its drawbacks. Let’s compare monolithic and Microservices architecture.

 

Monolithic Architecture

Microservice Architecture

 Architect an application as a single deployable unit.  Architect an application as a collection of loosely coupled, services.
 Follows single-tier architecture for all business goals.  Each component in the entire application must be small and must deliver end-goals. 
 Focuses on the entire project.  Focuses on product/service, not on the entire project.
 Works well in the early stages of the project.  Easy to implement in the late stages.
 All services are tightly coupled.  All services work independently.
 Implemented using a single development stack. It is hard to adopt new technologies and to make changes   Different technologies and frameworks can be used for different microservices. 
 If there is any issue, the whole system needs to be pulled down.  If one service goes down, it doesn’t affect other components.
 Software development processes usually result in relatively large teams working on a single monolithic deployment artifact.   Services are encouraged to be small, ideally owned by small teams.
 Continuous deployment is difficult.  Independently deployable.
 Scaling monolithic applications can often be a challenge.  Services can be scaled independently of other services.
 It is easy to start new projects with a monolithic architecture.  Developing distributed systems can be complex, and developers may be forced to write extra code to avoid disruption.
 Simple testing process. It is only needed to launch WAR on an application server and ensure its connectivity with the underlying database.  Testing a microservices-based application can be cumbersome. Each dependent service needs to be confirmed before testing can occur.
 It’s difficult to achieve operational agility in the repeated deployment.  By breaking down functionality to the most basic level, DevOps can focus on only updating the relevant pieces of an application.

 

Now, when we know the difference, there is one reasonable outcome – you shouldn’t start with a microservices architecture. Instead begin with the monolithic pattern, which is more traditional and it is still a good choice for many applications. Keep it modular, and split it into microservices once the monolith becomes a problem. 

And, one more! Before starting with new architecture, make sure that your microservices delivery is carefully managed and that the SDLC is automated properly. A lack of DevOps automation will mean that your microservices initiative will bring more pain than benefits. 

How to Start Developing Microservices?

When it comes to Microservices, there are two possibilities from here on to API development: The “Design First” and the “Code First” approach. 

  1.  Design First: The plan is converted to a human and machine-readable contract, such as a Swagger document, from which the code is built.
  2.  Code First: Based on the business plan, API is directly coded, from which a human or machine-readable document, such as a Swagger document can be generated.

Microcervices - API development The “Design First” and the “Code First” approach.

Summary

  • It is better to start with monolithic architecture for small-scale software.
  • Microservices architecture pattern is a better choice for large/complex software.
  • Microservices are beneficial to both technical development and business strategy at all. 
  • Microservices help organize teams into units that focus on developing and owning specific business functions. 
  • When you are just starting to develop microservices, start modestly with just one or two services, learn from them, and with time and experience, add more.
  • Microservice architecture promises to keep teams scaling and function better.

 

One last thing. Before you getting started, we’d like to offer up a final piece of advice: whichever solution you select – monolithic or Microservices, both have advantages and disadvantages. The final choice depends on your project requirements, size, team composition, project difficulty. So keep your eye on the ball before getting down to business and starting with the software architecture for your new project.

 


Looking to refactor your existing software architecture for your next big project?

Drop us a line, and our technical consultants will be back to you.

Contact DevCom - custom software development company

 


Written by: Halyna Vilchynska, Marketing Lead at DevCom

Don't miss out our similar posts: