API health checks are part of a proactive approach to monitoring the overall health of your APIs.
What is an API health check?
An API health check is a way to check the operational status of an API. It is a monitoring method that can alert you when something isn’t functioning as it should. You can set up an API health check endpoint for each API, view the results on a dashboard, and receive alerts for unexpected results.
Why undertake API health checks?
API health checks are essential to ensuring the availability and functionality of your API endpoints. They keep you abreast of overall API health and can flag issues at an early stage, keeping you in control and enabling you to deliver a reliable user experience (UX).
What do API health checks monitor?
You can monitor anything that could prevent your API from servicing incoming requests in the way that it should. For example, you could monitor:
- Availability – by sending regular requests to API endpoints to verify they are accessible.
- Functionality – by sending requests using specific inputs to check these return the expected responses.
- Performance – by tracking response times, measuring the latency to identify any slowdowns or performance bottlenecks.
- Error detection and recovery – a healthy API shouldn’t return errors and exceptions. A health check can identify abnormal behaviour like this.
- Load balancing – if you have multiple instances of an API, you can use health checks in combination with a load balancer to distribute incoming requests to healthy instances and avoid those that are exhibiting unhealthy behaviour or are unresponsive.
Should any of the checks return unexpected results, the health check service can alert you, so you can take swift remedial action before the issues escalate and impact your UX.
Benefits of API health checks
Monitoring the health of your APIs helps you minimise downtime and optimise performance, delivering a superior UX and identifying issues proactively. This means you can implement remedial action before issues escalate.
API health check best practices
Implement these best practices to get the best out of your health check services.
Automate API health checks
Automating your API health checks means you can implement continuous monitoring without the need for manual intervention. You can automate regular checks, checks in response to predefined triggers and alerts for when a check fails or returns an unexpected result.
Check API health as frequently as possible
The more frequent your checks are, the more likely you are to catch any issues before they escalate. By identifying issues in real-time, you can minimise downtime. Just bear in mind that health checks will impose a load on your API infrastructure.
Disable cache
API health checks work by monitoring responses. However, cached responses can mask underlying issues and produce false positives. As such, disable caching mechanisms during health checks.
Response time matters
There are various ways to get the best out of response time checks. You’ll need to set response time thresholds to define what good looks like for your APIs. You can also bolster the impact of response time checks by analysing response time data over time. Doing so can help you identify performance bottlenecks and trends, plus bring longer-term performance degradation issues to light.
JSON response
It’s a good idea to use a standardised JSON structure to deliver your health check status information and associated details. JSON’s human readability, flexibility, extensibility, efficient serialization and deserialization and broad compatibility make it ideal. Configuring your health check endpoint to return responses in this format means you can receive clear, concise information about the health of your APIs’ critical components and the status of their dependencies.
Response status code
The response status codes that you use will make it easy to verify the status of the API you are checking. For example, you can use a success status code (2xx) to indicate that an API is functioning as it should and an error status code (4xx or 5xx) to indicate that it isn’t.
Consider protecting your health check endpoint
Be sure to implement authentication and authorisation mechanisms to prevent unauthorised access to your API health check endpoint. Regularly review and test your security arrangements to ensure that everything is functioning as it should.
Use cases for API health monitoring
API health monitoring meets a wide range of needs. When you provide applications that rely on APIs, for example, health checks ensure that the underlying API infrastructure is functioning as it should so that your apps can do the same.
An API gateway health check system can be particularly useful in complex environments. Let’s say you use a microservices API gateway and are growing the number of microservices you use. In essence, the more you use, the more complex things get. With plenty to keep an eye on, automating the health monitoring of your microservice API endpoints means you can take a proactive approach to catching issues early.
You can also use health check data to optimise the UX of your APIs and the applications that sit on top of them. For example, if you identify performance bottlenecks as part of an API health check, you can make changes that will iron out those bottlenecks and contribute to enhanced performance.
How do you health check microservices?
Health-checking microservices is simple. You just need a health check API endpoint for each service. You can then check whatever metrics are most relevant to that service – memory consumption, database connection, response time and so on. You can use a dashboard to display the results and an alert system to immediately flag up any issues.
As well as monitoring the operational health of individual microservices, API health checks can also verify each service’s ability to connect to dependent services. This downstream operation status monitoring aids you in spotting issues early.
What is the difference between API health check and API ping?
You can use pings to check your APIs are running and receiving HTTP requests. If you get a successful ping response, you know your API is receiving requests. An API health check, however, can tell you much more. It not only shows that your API is running but can assure you that all the critical parts of it are functioning as expected – and help you home in on any that aren’t.
Health checks sorted now? Great. Why not dive into these API governance topics next?
