Best Practices for Microservice

Chamal Weerasinghe
6 min readJun 8, 2021
Photo by Patrick Fore on Unsplash

“To every problem, there is a most simple solution.” — Agatha Christie

Microservice architecture is a lifesaver for the big companies with complex architectures with complex systems which helps to move a more modular approach by making the codebase into smaller parts and also scalable on-demand saving cost and easily replaceable by new features. But even though it is resilient architecture, to get the full benefits of what microservice has to offer the proper practices should be followed in the software development life cycle and always trying to rely on proven solutions without inventing the wheel and using the solutions and technologies that have proven the ability to give the output what the organization expects from the Microservice after a proper R&D process and not doing the R&D in the production. 😆 And let’s find out what are those best practices are.

Best Practices in Design and Development

Design based on the Domain-Driven Design

The isolation of the Microservice comes with the proper design and with its boundary. a design with the boundary makes it does not want to talk to any other services to get the works done within its available functionality. and always can expose service to other services without other services do not have to worry about the implementation.

Have a separate database for each Service

When having access to the same database by all the services can cause multiple issues. the first one is the performance, trying to do all the CRUD operations in one database can lead to database availability issues and data anomalies.

The next issue is the consistency of the database. When more than one service trying to directly access the database, even though the services are independent other services had to depend on the same database. in the case of schema change, this causes all the services to return an error and all the services had to apply the fix as a solution for this it is better to use a separate database for each service and expose data via an API through the service.

Avoid using hardcoded values for configuration values

For ease of development and to get it working fewer times developers try to hardcode the configuration values including database URL, service URL, port, keys, and other configuration settings. This brings a few risks and failure points, one is the services running are not always a constant in Microservice some may remove from the running state, and new will get assigned when needed, in this case, the hostnames, ports won’t stay the same.

And also there might other issues like exposing secret keys in the code itself, and when changes are ongoing there might be multiple places to change. As a solution for this without hardcoding the services hostnames, IPs developers can use the Service Discovery tool to automatically discover the available services. and for configuration information rather than directly using them, the program developers can define them securely environments and also in properties files and retrieve them using variables without exposing.

Use Design Patterns

Design patterns are used in existing problems and solve those problems in a proven, testable and universal way which is tested and used by all developers using design patterns is also helps to maintain a proper consistent codebase of an application. When it comes to microservice few widely used design patterns help services to achieve fault tolerance using patterns like Circuit Breaker Design Pattern. Handling data throughout services without having to communicate with the direct database using Aggregation Patterns, and also Proxy Design Pattern for achieving resilience for changes without having considerable downtimes.

Use Proper Level of Logs

Although the logging is used in the monitoring the application logging is planned and implemented at the development. When implementing a proper log there are few things developers consider. one is the user log levels, there are a few set of defined log types widely used in applications are DEBUG, ERROR, INFO, and WARN. when the developer is logging whatever the content they should be aware of what is the actual log level, if it is an error it should log as “ERROR” and some abnormal behavior or unexpected content that might log as “WARN” that will ease the traceability.

The next point is where to log the data, usually, there is an application flow where the system components are interconnected, rather than logging the error at the same place it happens it should move to the next level and then to the topmost level then it can log the error, The advantage over this is the same error won’t log at different places and all the exceptions can be caught by the log and represent to the user.

Furthermore, it is a good practice to generate a specific unique number at the logging and also include where the error or any other log happens with the specific timestamps which will increase the traceability.

Maintaining Proper Versioning

Each service of the microservice architecture should have its own development cycle which independent from any other services. The main reason for that is with the time individual services have to grow and might add a function or fix the bugs more frequently when compared to other services, at that time proper versioning maintain is necessary, because these services may interact with each other services and by having a proper versioning system will ensure that other services are compatible with whatever the modification happens recently.

By using a version convention like semantic versioning will the developers can have a better understanding of major, minor, and patch version modification of other services and they can decide whether the compatibility will be the same after the integration of the new version service into their services as discussed above.

Maintaining Proper Documentation

Each service is developed by a separate team of developers, and they do not need to know about the other service’s implementation. But when it comes to the integration or adding a new service to their services then developers had to have a better understanding of the response that those services are expecting, parameters, data interchange formats, and more. If every team has to go through the implementation to do this work will take lots of time and also it will put back to a similar monolith approach of work style.

As solution developers who are working in the original service itself can do the documentation of the service, documentation of service meant providing technical information used in development (to some extend), information about the design. and useful when consuming the services without having to understand the codebase. and this documentation can be done using code snippets inside the source code itself.

Best Practices in Deployment

Deploy Services Separately

Just like the separate development schedule for the services their release cycle won’t stay the same. And when do the releasing each service must not depend on or consume any other service’s components or resource. And also deploying an application will cause some downtimes but when microservice deploy separately it can route traffic to some portation of working services and gradually direct back to new service without having to deploy all the systems at once and re-route all the traffics at once, this helps to achieve zero downtime.

Service Containerization

What happens in application containerization is it bundle all the necessary resources including code, libraries, and runtimes into a single unit call container which can run on a container platform in an isolated environment. When it comes to the microservice rather than having it as a best practice it is a must to have a thing because when and after the deployment container provides the isolated environment to run the application without affecting the instance of other services or the same instance of the same services.

And when it comes to scalability containers can increase as much as need or can remove the containers when it is not necessary. due to the isolated environment provided by the containers removing running containers does not cause the application to stop completely and consume fewer resources compared to the VMs or dedicated hardware.

Best Practices in Maintainance

Continuous Monitoring and Logging

Every application can behave differently rather than expected and tested, that’s the nature of the software. this can happens for various reasons and most of the issues may arise when the product is launch to customers or maybe a larger userbase.

At that time avoiding the errors is impossible, but to increase the resiliency of the application continuous monitoring of the application can provide valuable data of the application behavior and provide data about the patterns which may use from a business aspect and also for solving issues. Also after deployment, there is no way of debugging the application on production but having good monitoring and logging will provide the necessary data to regenerate the errors on testing environments and fix them and find application behavior in real-time.