Cloud Smart, digital modernization and a push toward digital services, in general, have prompted most agencies to adopt some form of Agile software development.
Often, it is microservices-based, which breaks applications down to very small components for development. This approach has gone a long way toward making government more efficient, but in some cases, application development still takes too long, and it’s too expensive.
When tasks must execute quickly and change often, the microservices model may not be efficient enough. For example, a task that requires fast data aggregation or analysis and will execute for only a few seconds may be hampered by the thousands of functions making up that application that surrounds it. The same is true of scalability.
Applications that need to handle large increases in the number of requests, such as apps with seasonal spikes, face similar issues. For example, an image processing app could include a microservice that would allow it to scale to handle the load, but it could be bogged down by other functions, because in the microservices model, all functions stand by, ready to execute at all times.
That challenge — being bogged down by other processes running at all times — translates into dollars. Because microservices are on standby waiting to be activated, resources and infrastructure are constantly in use, costing money both in terms of the host servers they reside on and the care and feeding of those resources.
The Solution: An Event-Driven Approach to Service Delivery
Depending on the use case, serverless application development can improve efficiency and agility while reducing cost.
While there are still servers in the serverless model, developers don’t have to manage them; cloud providers do. And unlike the microservices approach, which breaks everything into individual components, the serverless approach breaks things down even further. In fact, one microservice can have several serverless functions. The serverless approach also allows those functions to occur only when needed, reducing infrastructure needs and cost.
“Serverless development has the unique capability of being able to turn your software off by using a mechanism to make the code only wake up and run when it’s needed,” explained Jason Dudash, a Principal Solutions Architect at Red Hat. “If there are no events coming to trigger that code, then the code just lies dormant.
That means you can use your infrastructure more effectively because you aren’t running something that’s idle.” That event-driven approach is what can make serverless application development extremely agile. Instead of standing ready to work, it springs into action only when events trigger those actions.
For example, if a healthcare-related agency wanted to develop a mobile app that can analyze skin blemishes to determine whether they are cancerous, it might use this approach. A patient could use that app to upload a picture of a mole for analysis. Uploading the photo is an event, and it would trigger the function of sending the photo to some type of cloud-native storage, along with a function that would strip the data of all personally identifiable information (PII). In turn, that would trigger a notification that the data exists, which would trigger functions that would run the algorithm, form a theory and return results to the user.
These types of efficiencies do more than increase agility. By reducing the time needed for expensive resources to perform tasks, they can reduce costs, and by using a single application programming interface (API) to perform multiple tasks — such as telling an application how to scale and how it should be exposed to the outside world — they can accelerate the entire development process.
This article is an excerpt from the GovLoop report, “Why the Future of Open Hybrid Cloud Should Include a Serverless Approach.” Download the full report here and learn about best practices in serverless computing.