Posted by Richard Wadsworth on 25/08/16 07:54

Microservices and Serverless Computing — The Road to Take in 2016

Traditional enterprise applications and services are overly complex in design, difficult to maintain, risky to deploy and require expensive high-grade infrastructure to run on.  In 2016, many organizations are transitioning to a microservices architecture and serverless infrastructure to build their applications.

Mono_Vs_Micro.png

Source: mypurecloud.com

Then and Now — Why Applications need a New Architecture

Traditionally, applications were launched to serve clearly defined organizational needs. On-premises servers and in-house development tools were employed to produce apps for a well-defined user base. However, over time, as devices and platforms became more complex, developers and Ops teams found themselves grappling with huge, complex apps with issues at every level. These complex systems, though initially constructed to be simple, reliable and scalable, became difficult to develop, deploy, and scale. Ultimately, the use of complex and hardware-centric infrastructure became a heavy mantle for developers and Ops teams to bear.

In recent years, there have been radical changes with application architecture. Cloud infrastructure, and more recently, Docker containers have transformed the lifecycle of enterprise applications. At the same time, the modern DevOps approach has brought unprecedented speed and collaboration across the entire software development pipeline. Riding this wave of technological advances, serverless computing and microservices are paving the way for more reliable and efficient production abilities for organizations, globally. Not restricted to a select few, these movements have made app development faster and more cost-effective for organizations of all sizes and types.

Traditional Monolithic Apps vs. Modern Microservices Apps         

Monolithic applications were all you needed when developing apps within the boundaries of closed platforms, and few devices. These single-tiered software applications dealt with data access and user interfaces that worked from a single platform as a single program. They were designed without modularity, were self-contained, did not rely on external APIs, and were not built for rapid elasticity. Though simple at first blush, monolithic applications frequently suffer from the danger of single-point of failure, which can lead to major disruptions. Further, they aren’t scalable, and are unable to take the load of modern cloud applications.

On the other hand, a microservices-based architecture aligns with DevOps. Microservices is the approach of breaking down a large application into a collection of smaller, modular services. The benefit of this approach is that it becomes possible to build, test, and deploy individual services without impacting the entire product or other services adversely. As microservices enable smaller, faster releases, they allow new features to be released to only a subset of users initially, and then to the entire user base once the feature meets quality expectations. Even though a microservices architecture is more complex, especially at the start, it brings much-needed speed, agility, reliability, and scalability, which are critical to today’s DevOps teams.
                                  

Serverless Architecture: Servers Without Maintenance                           

Serverless computing, along with microservices, is another promising trend that’s gaining rapid adoption within DevOps teams. Serverless computing is the concept of abstracting away the infrastructure server layer, so that developers can focus on building an app without worrying about scalability, availability, and security of hardware servers. From a usage point of view, the application utilizes as much networking and storage as it needs. This means that when there’s little usage, hardware resources aren’t lying idle; at the same time, when there are spikes in usage, the infrastructure can scale to any extent without having to manually provision new servers on the fly.

Serverless computing is a key enabler for microservices-based applications. It makes infrastructure event-driven, completely controlled by the needs of each service that make up an application. If you are in the process of building IoT apps, you need the advantages that serverless computing provides. The variety of devices and high data volumes require a modern dynamic infrastructure.

Some notable examples of serverless computing solutions include AWS Lambda, Google Cloud Functions, and Microsoft Azure Functions. One of the concerns around serverless computing is that it brings vendor lock-in as each vendor requires you use their complementary technologies across the entire stack. As your app scales, it may not be easy to switch vendors, or mix and match as you like. However, these are still early days, and the tooling for serverless computing is fast maturing.

As you make the important transition to DevOps, it pays to adopt modern approaches to application architecture like microservices and serverless computing. These trends are here to stay, and the organizations that capitalize on them are set to take the lead in tomorrow’s digital economy.

 

Richard Wadsworth

Richard Wadsworth - Richard Wadsworth is a Director and Principal DevOps Consultant at Contino. Richard is a pragmatic, straight talking, hands on technical consultant and cloud architect with 18 years enterprise experience across finance, insurance, retail and media on the Windows and LAMP stack. He has proven experience in executing and delivering disruptive business propositions with a deep understanding of the technical and operational requirements needed to deliver change.

Topics: Microservices, Serverless

Meet Contino At An Online or Offline Event

Comments