In the cutthroat world of digital business, we know that end users drive both innovation and the pace of development. And as end users demand faster response times with deeper functionality from their applications, developers have had to shift their conceptual model of architecture to begin implementing a more modular approach. This is where microservices comes in – and their popularity is on the rise: In a survey of about 1,800 IT professionals, about one-third currently implement some form of microservices. This number is expected to grow exponentially, however, with over 70% of them affirming that they’ll be using some form of microservices moving forward.
What are Microservices?
If you’ve been around technology a while, you’re probably familiar with traditional approaches to application development. In more conventional architecture solutions, such as the traditional server application approach, developers typically constructed a single, large application with tiers that pass data or communicate with each other within a single domain. Even though functionality is distributed among layers, everything is packaged into a singular monolithic application. This type of architecture is great for creating reusable services and is fairly easy to test. One of the downsides of this method includes a lack of scalability, which would require cloning the entire application across virtual machines or servers. Also, with this approach, if a single application function or component fails – the entire application fails.
Microservices takes this concept of a segmented approach a step further by separating discrete processes out into individual functions that can be developed and scaled independently. With the microservices approach, developers can deploy a single service, without relying on the rest of the applications components to be completed. Whereas the traditionally designed components tend to be larger and encompass many functions within a single layer, the discreteness of microservices make them more nimble and able to be scaled quickly as load demands increase. And because microservices make use of universally accessible APIs, they don’t limit changes in technology stacks – enabling developers to be more flexible in their approach to coding.
Shifting from a more monolithic approach to segmenting out functionality through the use of microservices also improves productivity. Now, developers can produce applications even faster that are more complex and easier to maintain. Microservices also help improve fault isolation; unlike with the traditional approach, the failure of a single microservice may have less of an impact on performance.
Shifting Perspectives on Monitoring
By this point, you understand the importance of monitoring your application from the end user’s perspective. Remember that most people will only wait about 6 to 10 seconds before they abandon a page. And after 20 seconds, half your audience will be gone.
Traditional monitoring approaches focus on evaluating a microservice’s server logs – but this only tells part of the story. Testing services in isolation doesn’t provide a clear picture of how those services are working together. Individual services may work according to normal parameters and metrics in isolation, but combined into the whole may negatively impact performance. End users don’t function in isolation; they function in user flows and transactions. Testing the entire system synthetically – predicting for user behavior and monitoring your microservice interactions as a whole – is the only way to evaluate how the entire system is behaving.
Steps to Implement Microservice Monitoring
Feeling overwhelmed? Don’t worry – implementing monitoring of your microservices is easy and just takes few key steps to get started.
Step 1 – Understand the Context Around an API: When implementing a microservice, make sure you understand the context around it. Make sure you consider the question of how the API will be used and evaluate what business transaction flows the service will integrate into. Understanding these parameters will help you develop your behavioral scripts that will simulate the actions end users take on your site and how your end users will interact with the service. Remember, you want to use a synthetic monitoring solution to simulate end user behavior in your pre-production environment to identify problems before they affect actual users, so you really need to understand how your users will interact with the service.
Step 2 – Create Tests from the End User Perspective: Make sure to create tests for all high-usage and business critical transactions flows that incorporate a service, and run these checks from an end user perspective, evaluating the application as a whole. Testing a single service in isolation gives you a great idea of how that service functions – in isolation. But remember that users don’t consume your application in isolation. Testing a service in isolation may produce normal results, but testing it in conjunction with other services may cause that service to fail.
Step 3 – Test with Real Data: You’ll often get better results with real data. Test data is often simple and doesn’t exercise all possible code paths. For example, your application is likely being used internationally – what happens if the product in your cart has funny characters like NORDMÄRKE? (We’re looking at you, IKEA.)
Choosing the Right Monitoring Solution
Keeping in mind that you need to be proactive in your monitoring (i.e., prevent problems before they reach users), you need a solution that can test for performance issues in your pre-production environments and baseline the performance of your production environment. This means you’ll want to opt for a synthetic monitoring solution over real user monitoring. Remember that with synthetic monitoring, you’ll be developing behavioral scripts to simulate user actions and your solution will monitor them at specified intervals for performance, including availability, functionality, and response times.
Key Features of a Good Monitoring Solution
Implementing proactive monitoring of microservices requires a solution that can replicate complex user flows and execute the following tasks:
- Multi-step API Checks. Run API checks using a combination of the following steps: make requests, extract data, save variables, and make assertions, and be alerted of degradation in performance at any step in the process.
- Clear and Concise Alerts. A microservices infrastructure exponentially increases your potential points of failure. Your monitoring solution needs to be able to quickly identify when and where a transaction failed to facilitate an efficient and meaningful effort to resolve the issue. Your system should allow you to configure alerts to identify which step failed – sending only the information necessary to resolve the issue.
To learn more about how Rigor can help you monitor your microservices,