adam121 - Fotolia


Microservices-based architecture powers apps in AWS

Developers can upgrade applications more efficiently and adapt to uneven workflows by ditching a monolithic architecture and switching to microservices.

Microservices are a new approach to software application design. Rather than designing an application as a single entity that does everything -- a monolithic application -- microservices allow developers to break an application into constituent parts, processes or functions that communicate with each other using a common API.

To understand how a microservices-based architecture works, consider the server side of a traditional client-server application. Generally, it includes an interface, a way to handle HTTP requests, various logical processing functions -- such as loading, saving, organizing and displaying file data and producing graphs -- and countless other tasks. When developers build a traditional application, all of these operations are tied together and compiled into one entity like an executable (.exe) file.

This approach works, but there are notable drawbacks. For example, when a change is made to one feature or function, it typically affects other parts of the application. Any change, update or upgrade requires extensive regression testing to identify flaws. And even the slightest tweak requires building and deploying a completely new version of the entire application.

In addition, the workload within that monolithic application is usually uneven. For example, an application that handles HTTP requests might receive very heavy traffic, while the graphing function might see relatively light use. But this is all part of the same application, which means it's necessary to provide far more computing resources to accommodate whole new instances of the entire application when more work needs to be done. Monolithic applications simply don't scale well.

Microservices turns this paradigm on its head. Rather than developing an application as a single monolithic workload, a microservices-based architecture designs the application as a series of individual components that are logically combined to provide the features and functionality of the greater application. For our example application, the functions like HTTP handling, interface, data processing and graphing can all be broken into individual tasks. Each task can be deployed to VMs or containers, and each component communicates using a common API, such as a REST API.

With a microservices-based architecture, a change to one component doesn't affect other components, as long as the API doesn't change. Parts of an application can be updated or upgraded faster with less testing than monolithic architectures. A feature or function that requires more computing power can also be scaled up with additional instances without the need to scale up other components.

AWS offers several services that allow developers to create and deploy applications in terms of microservices. Amazon EC2 Container Service uses microservices to deploy application components into scalable, quickly deployable virtual instances. In addition, AWS Lambda enables event-driven computing; Lambda functions only call code in response to specific conditions or events. User-defined APIs such as Amazon API Gateway allow developers to customize APIs that tie front-end applications to services such as AWS Lambda, AWS Elastic Compute Cloud instances and Amazon Simple Storage Service.

Next Steps

Boost availability in AWS with microservices

AWS Lambda, microservices draw hype at re:Invent

How are cloud computing and microservices related?

Dig Deeper on Deploying Microservices