Introduction There are several ways to handle data in a microservice architecture, in this article we will cover the approach of having a separate database for each microservice. Prerequisites This article will build upon the concepts covered in the following video by : Houssem Dellai Data in a Microservice Architecture Architecture Overview We will use the following architecture as described in the video above. The following diagram shows the architecture: Quick overview of the architecture: We have an eCommerce website that consists of these two microservices: : This microservice is responsible for managing products. Catalog Service : This microservice is responsible for managing orders. Basket Service Both microservices are behind an API Gateway. Each microservice has its own database. In order for the Backend to communicate with the Catalog service, we use a REST API. This is how the Basket service gets the products data from the Catalog service. The problem with the above architecture is that the Basket service is tightly coupled with the Catalog service. There are a few drawbacks to this architecture: If the Catalog service is down, the Basket service will not be able to get the products data. Meaning, the Basket service will not be able to process orders and would also be down. When scaling up, the Basket service will start generating load on the Catalog service meaning, the Catalog service will also need to be scaled up. Each time the Catalog service is updated, the Basket service will need to be updated as well. To decouple the microservices, we will use a third microservice called . This microservice will be responsible for routing the requests to the other microservices. But with this approach, the API Gateway will handle all the requests and the microservices and this could turn into a bottleneck as it will have a lot of responsibilities. Gateway Let's take a look at another approach to decouple the microservices. Loosely Coupled Microservices As each microservice is independent and owns its own data, to decouple the microservices, we can use a materialized view that will store the aggregated data of the microservices. The following diagram shows the architecture with the materialized view: Quick overview of the architecture above: We are adding a new materialized view to the Basket service which will store the aggregated data of the Basket service and the Catalog service. The Catalog service is now extended to send change events to the Basket service. The change events could be stored in a service like Apache Kafka or RedPanda. The Basket service will now handle the change events and update the materialized view accordingly as the data in the Catalog service changes. The materialized view will be used as a read-only data source for the Basket service. The downsides of this approach are: There will be a duplicate of the data in the aggregator. The change events would add lots of complexity to the microservices. If you do not have the expertise, adding the additional components and changes means that there will be a steep learning curve for the development team. Using Materialize Materialize is a streaming database that takes data coming from different sources like Kafka, PostgreSQL, S3 buckets, and more and allows users to write views that aggregate/materialize that data and let you query those views using pure SQL. Unlike traditional materialized views, Materialize is designed to maintain the data in a continuous state and keeps the views incrementally updated. This means that if you have a view that is constantly updating, you can query the data in real-time. A normal materialized view would do a full table scan every time it needs to be updated which can be very expensive. For a more detailed explanation of Materialize, please see the . Materialize Documentation You can also take a look at this quick that explains what Materialize is. video Decoupled Microservices Architecture with Materialize Thanks to Materialize, we can decouple the microservices architecture and use a live materialized view to store the aggregated data. Materialize will keep the materialized view incrementally updated and will allow us to query the data in real-time with subsecond latency. This will eliminate the need for the event-driven architecture and will also eliminate the need for extending the Catalog service to send change events to the Basket service. The following diagram shows the architecture with Materialize: Quick overview of the architecture using Materialize: We will again use a materialized view to store the aggregated data of the Basket service and the Catalog service. This time, we will use Materialize to store the data. As this will provide us with a real-time view of the data, we no longer need the change events as we can query the aggregated data in real-time. That way if the price of a product changes, the Basket service will be aware of the change immediately. As Materialize is Postgres wire-compatible, we don't need to use any third-party libraries to use Materialize and there is no learning curve. One thing that you need to keep in mind is that as of the time being, Materialize does not have persistence. This means that if you restart the service, the materialized view will need to re-aggregate the data. This feature is on our roadmap and will be available soon. Demo To put this into practice, you can take a look and run the following demo: How to join MySQL and Postgres in a live materialized view First Published here

Apache

YouTube

FastAPI with Materialize for Real-Time Data Processing: An Essential Guide

How to Use Materialize and Redpanda to Analyze Raspberry Pi Temperature Data

Nominated for 2022 - HackerNoon Contributor of the Year - Open Source

Nominated for 2022 - HackerNoon Contributor of the Year - Sql

Nominated for 2022 - HackerNoon Contributor of the Year - Docker

Nominated for 2022 - HackerNoon Contributor of the Year - Kubernetes

Nominated for 2022 - HackerNoon Contributor of the Year - Database

Nominated for 2022 - HackerNoon Contributor of the Year - Books

Too Long; Didn't Read

Make resilience your competitive advantage

How to Build a Decoupled Microservice Using Materialize

How to Build a Decoupled Microservice Using Materialize

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Build your Own Live Chart With Deno, WebSockets, Chart.js and Materialize

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

03/09/2018: Biggest Stories in the Cryptosphere

The Noonification: Immigrant Teens Are Working Dangerous Night Shifts in Factories (11/21/2022)

The Noonification: How to Implement a Merkle Tree in Solidity (11/12/2023)

Build your Own Live Chart With Deno, WebSockets, Chart.js and Materialize

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

03/09/2018: Biggest Stories in the Cryptosphere

The Noonification: Immigrant Teens Are Working Dangerous Night Shifts in Factories (11/21/2022)

The Noonification: How to Implement a Merkle Tree in Solidity (11/12/2023)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps