The key to creating and maintaining exceptional applications is not, simply, great development. A truly brilliant application accelerates the delivery of features, benefits and outcomes. Agile and DevOps are two paths to this goal. However, cloud-based microservices models are also widely used to inject real-time agility, flexibility and scalability into applications
Getting the ground work in place
How do organizations begin to steer themselves towards application agility? The first step is to examine the entire application portfolio and segment it across various parameters. Applications cannot be segmented based on technical value alone. Key parameters such as business criticality, effectiveness, differentiators, growth, maturity and business outcomes should also be considered.
Further, applications must be examined to see if they are monolithic, microservices-based or candidates for software-as-a-service (SaaS). This exercise provides an opportunity to determine the value streams each application creates. In turn, it becomes easier to determine which application must be migrated to a cloud-based microservices model. An example of this is a hotel application that leverages Virtual Reality (VR), making it easier for customers to decide which room to book. Now consider that the same hotel also has access to rich customer data that allows it to sell rooms directly and reduces its dependence on Global Distribution Systems (GDS) and Online Travel Agents (OTA). If the hotel benefits more from the second application, that should be prioritized for containerization, microservices and for the Continuous Integration-Continuous Development (CI-CD) pipeline.
Organizations have numerous other options before them. One of these options is to break a monolithic application into smaller microservices and expose them via APIs to inject agility into key service functionalities. For example, a heavy load SQL server used for data processing and storage can be broken into components for data processing (Apache Spark), storage (S3) and frequently used queries (Redis Cache).
The dominant trend today is to use a microservices pattern to build tomorrow’s cloud applications. This architecture leverages multiple services created in response to specific business needs. To succeed, it’s necessary to ensure these loosely coupled services collaborate and interact with each other based on policies and dependencies. In microservices architecture, centralized management is kept to a bare minimum. Therefore, effective rules-based communication between services is critical. The bedrock for achieving this is to automate everything, from day one setup to day two run operations. There are three other factors to bear in mind when making your applications agile: move on from traditional ESB to cloud native middleware, focus on multi cloud management and keep an eye on immutable infrastructure.
Modernizing middleware for cloud native
For enterprises that use middleware to bind applications with data and users now is a good time to update from Enterprise Service Bus (ESB) to cloud native middleware. Although ESB technology has several advantages it has failed to keep pace with the needs of modern application development.
As organizations shift to a cloud native strategy, moving middleware to the cloud can be tricky. Instead, cloud native middleware works with CI-CD, observability and cloud orchestration tools. It therefore makes a brilliant fit for today’s application development needs.
Cloud services also provide most of the middleware capabilities that organizations desire, while some would want to opt for Middleware as a Service (MWaaS) offerings. These offerings are designed to meet the needs of containers and microservices.
In reality, organizations, for a variety of reasons, do modernize their existing middleware as well to enable a microservices approach. The considerations for doing this include a cost-benefit analysis and an assessment to see if the ESB business logic and code is stable or it needs change to drive speed and agility. The approaches to modernize can be phased:
- Span containerizing front end and connecting to the current ESB backend and maintaining the existing integrations
- Move ESB into PaaS and let PaaS manage it
- Refactor components of ESB to cloud native
However, business needs sometimes force enterprises to ignore a phased method and adopt a Big Bang greenfield approach to cloud native microservices leveraging event-based architecture such as Azure functions. This allows organizations to transition from a central heavy-weight ESB to a light-weight cloud native middleware for use by interested self-contained microservices.
Cloud native based microservices led development and monoliths running in containers with CI-CD are gaining momentum across enterprises. This requires enterprises to gain expertise of IaaS, PaaS and CaaS on multi-clouds. In addition, while it is easy to provision a server or two on cloud, a shortage of top-level cloud skills makes it difficult and time consuming to supply and maintain a number of complex services across a multi-cloud environment. This is one of the key reasons why code should be written to describe the desired state of a cloud system. Using Infra-as-a-Code (IaaC), which is automation by another name, is therefore recommended and is gaining traction.
Cloud native provisioning, securing and managing infrastructure are not going away soon. The challenge is that when managing cloud native infrastructure for CI-CD DevOps, the tools remain fragmented. In addition, there are a variety of deployment models on multi-cloud presenting options between first-party and third-party tools. This places a significant burden on enterprise IT and/or service providers to decode the underlying offerings of the infrastructure and allow businesses to consume services via a single catalog (making it similar to a PaaS offering).
Containers on immutable infrastructure
The importance of immutable infrastructure in the context of containers and CI-CD cannot be emphasized enough. Immutable infrastructure and the level of self-healing at the application level is foundational to microservices architecture where repeatable processes need to scale. Immutable infrastructure makes it possible to control how containers interact. The interaction between containers is core to how microservices are strung together. Kubernetes takes this to the next logical level by providing a platform that schedules, manages and scales containers to match the desired state of the application.
Traditionally, tools are used to maintain and/or update application servers. Eventually, over several iterations, the server state drifts, making it almost impossible to manage it efficiently. Immutable infrastructure is the solution—the concept dictates that servers should be rebuilt when required instead of being updated or adjusted.
There is no denying that great application design is a necessity. But in a cloud native environment, it takes an understanding of several additional factors to guarantee application agility.