Serverless and Microservices Architecture
Microservices and serverless architectures are one of the hot topics in the cloud-native computing world. While most people think those architectures are similar, they are actually distinct technologies fulfilling different roles in software development.
This article presents an overview of what microservices and serverless architectures are, how they relate to each other, their benefits, and how they can work together.
What is serverless architecture?
“Focus on your application, not on the infrastructure.”
Serverless architecture is an event and request-driven technology with the goal to minimize the coding flow when developers are creating working environments in the cloud that are very resource-intensive [1].
Contrary to what most people think, serverless architecture does not mean the lack of any server. Instead, serverless means that developers no longer need to focus on the server management to include implementation, maintenance, debugging, and monitoring of the infrastructure [1]. To address this problem, the cloud service provider actually fully manages the responsibility of server allocation and provisioning. Serverless architecture is an execution model for cloud computing [1].
Event-driven architectures such as serverless, have the following advantages:
- The solution allows great flexibility allowing to scale up or down computational resources.
- Developers do not have to think about infrastructure maintenance or timely data syncing, because in serverless architecture this is mostly done by automated processes.
- The cloud service provider is responsible for managing all the infrastructure, orchestration allocation of code data, downtime issues handling, etc.
- The cost is minimized since the pay-per-use approach helps to avoid unnecessary app development and deployment expenses
Companies like Google, Microsoft, IBM, and Amazon already offer the customers the possibility to migrate all local business operations to be hosted on their serverless platforms such as AWS Lambda and Azure Functions.
What are microservices?
Microservice is an architectural pattern in which the application is based on many small interconnected services [2]. They are based on the single responsibility principle, which means “gathering things that change for the same reason, and separate those things that change for different reasons”. The microservices architecture is also extended to the loosely coupled services that can be developed, deployed, and maintained independently [2].
TARS is an example of a microservices framework. TARS supports multiple programming languages, including C++, Golang, Java, Node.js, PHP, and Python; and it can quickly build systems, allowing the developer to focus on the business logic to effectively improve operational efficiency.
How can serverless and microservices work together?
Now that you know that serverless is a cloud host where an application or component loads and runs on-demand, anywhere, and can scale to any quantity needed, it’s time to know how serverless and microservices relate to one another.
Because of the characteristics of serverless, a serverless application runs in stateless components. That is, serverless does not need to store anything between its uses. With serverless, everything is stateless! You can’t save a file to disk on one execution of a function and expect it to be there later. In practice, that signifies that serverless normally uses stateless components that are often referred to as a function, a lambda, or a microservice [4].
In this article, we are focusing on microservices. Serverless uses stateless microservices, which prioritizes elasticity in deploying applications and components sharing in which microservices are hosted on containers [4]. Typically, containers offer a lower overhead than virtual machines, and container orchestration tools (such as Kubernetes) make the microservice deployment easier [5].
When using stateless microservices with serverless, the difference is that traditional applications usually call microservices, and with serverless, microservices need to be triggered.
The way that application and business process orchestration drives serverless and microservices together
The state-of-the-art of both serverless and microservices is an event-driven application and business process orchestration.
The target of serverless when first introduced by Amazon and Microsoft in their clouds was event-triggered applications, such as Internet of Things (IoT) applications. In IoT, applications run occasionally, so there is no need to use clouds, virtual machines, or servers to persist data. Nowadays, however, things have changed. IoT is not the only focus of serverless anymore. In fact, nowadays, cloud providers allow an application to trigger events to track their progress, and then use these events to trigger other steps or other applications [5]. As a result, serverless or stateless microservice functions are not used only for IoT events anymore. Instead, they orchestrate application workflows. This has changed the serverless computing model.
To process orchestration through serverless and microservices technologies, applications and businesses need to have three basic elements.
- Applications must be able to manage triggered events.
- Applications should have a mechanism to activate processes according to those triggers.
- Applications should have a method to define the workflow or sequence of tasks after each triggered event. This method should impose the workflow/sequence on the stateless events and processes.
Orchestration and integration tools such as Amazon Step Functions allow defining the workflow/sequence of microservices and serverless based on the events that are generated by steps in other applications. Some tools even allow triggering user-developed functions and microservices that run on-demand as a serverless component.
TLDR-summary:
The idea that microservices and serverless could join to bind business processes and integrate business applications is transformational. Event-driven serverless microservices could provide the perfect way to fulfill a multitude of business needs, including reducing costs and increasing business performance.
About the author:
Isabella Ferreira is an Ambassador at TARS Foundation, a cloud-native open-source microservice foundation under the Linux Foundation.
References:
[2] https://tarscloud.org/feeds/5252833302625855
[3] https://www.sumologic.com/blog/microservices-vs-serverless-architecture/
