How to Build Modern Applications with MicroservicesMarch 21, 2019
Microservices are starting to take over nearly every aspect & angle of modern enterprises
In one survey of more than 350 senior development stakeholders, 91% said they are currently using or have plans to use microservices and 92% said they increased their number of microservices in the last year.
This rise has come in conjunction with an imperative for businesses to be far more agile in their development of applications and software—an imperative driven by increasing amounts and types of data.
The microservices imperative
Historically, when organizations developed software, they would take a monolithic approach, packing all business logic into a single process that was unified by an underlying relational database. Such an approach may still be perfectly fine for smaller applications that don’t have scalability requirements.
But when data grows and an application needs to scale, monolithic applications usually need to be rebuilt and redeployed—a process that can take several weeks. Instead of having to simply update a small component of an application, developers have to almost reinvent the wheel entirely every time they needed to ship an update.
This isn’t the most effective approach, particularly for large enterprises that require highly available, scalable software solutions.
What are microservices?
Per Forbes: “Microservices are business-driven, service-specific applications that can be scaled quickly and cheaply with high performance and availability across public and private clouds.”
Microservices, at their core, enable developers to independently deploy and upgrade individual software components. Each service in a microservice architecture (MSA) is “designed to fail”—meaning that when one of them goes down, the rest of the application will still function as designed.
Add it all up and it’s much easier to ship updates, since engineers don’t have to work with the entire code base every time they want to adjust something.
The Challenges With Microservices
Despite these benefits, microservices also introduce a few challenges:
- Applications based on MSA are distributed. Different services all communicate with each other across the network. MSA solutions, then, require a new communications model that ensures low latency across geographies even as transactions scale.
- Failure is not an option for organizations that demand high availability. Developers must therefore ensure that each microservice within an application can resolve failures quickly. Otherwise, productivity drops and the user experience crumbles.
- Microservices also present a challenge due to the fact that each service operates independently, which means that MSA requires decentralized data management. Whereas monolithic applications share a single data layer (usually a traditional RDBMS), each microservice needs to have its own data persistence mechanism. Microservices that require data from another microservice can only access that data through the API layer.
Imagine an MSA solution where a user needs to query data that is owned by several different microservices using multi-model queries. Not only does such an operation have to be facilitated quickly, data needs to remain consistent across each service.
These aren’t easy problems to solve. With an agile enterprise data layer in place, however, developers can rely on an eventual data consistency model that ensures current, contextual data is always accessible, regardless of where a user is.
Building Modern Applications with Microservices
While microservices can certainly help you build stronger applications, you can’t just expect to patch together several microservices and have a great final product.
Instead, you need to understand the data management implications this modern approach to software development has.
Your goal, after all, should be to build high-performance applications that are highly available and highly scalable. If you build applications with microservices but don’t take data management into account from the outset, there’s no way you’ll achieve that goal. It’s like building an enormous mansion on top of wetlands or a swamp without studying the terrain initially. Sooner or later, there will be serious problems. The house will no longer serve its original purpose, and the owners will have to rebuild.
Here are some things to think through before you get started:
- What database will serve as the foundation of your application and is that database powerful enough to meet your needs as your app scales?
- As adoption increases, how much data will need to be stored and how quickly will users need to be able to retrieve it?
- What kinds of security requirements (e.g., authentication, access control, and encryption) need to be in place to ensure data is kept private and your app complies with internal policies and external regulations (e.g., GDPR)?
- How will your app ensure that everyone is looking at the same data (assuming that’s a requirement)—even when users are in different time zones?
- How quickly, per your SLA, should users be able to access data during high-traffic periods, regardless of where they are in the world?
There’s a reason why so many of today’s leading organizations are building with microservices: they enable you to ultimately build stronger, more nimble applications.
By thinking ahead and figuring out how your microservices will work together when your app is ultimately shipped—and configuring your architecture in a way that ensures data will move through your application seamlessly, even during periods of high traffic—you can build transformative tools that help your employees become more productive and deliver stronger experiences to your users.
eBook: The Power of an Active Everywhere Database
SHARE THIS PAGE