Why distributed applications are difficult to build
Microservice architecture is one of the best solutions for realizing distributed application architecture. However, despite doing microservices for the past eight years, it is still complex to build due to the following reasons:
- Service invocation is still different for different platforms.
- State management is still not mature and stateless services do not solve enterprise problems.
- Service-to-service communication using messaging, which is much more ubiquitous, varies based on the message broker’s adoption.
- Observability within the services is still subject to the developer’s discretion for adoption and not a standard. While OpenTelemetry is laying out standards, it still needs to be adopted.
- Integrating with different vendors using different SDKs/programming languages requires effort and is difficult to change once implemented
While service mesh platforms like Istio and Linkerd alleviate some of these concerns, they do it at the network level, and deal with networking concerns, and do not do much at the higher levels of abstraction. State management, integration, etc. are not a concern of service meshes.
What if we could:
- Solve this problem through a platform that abstracted everything through a pluggable components architecture that simplified the plumbing with external platforms…
- Supporting popular development platforms through language specific SDKs…
- That also worked across different cloud providers at the cloud and the edge…
- Adhering to standard security communication protocols like HTTP/gRPC communications.
Introducing Dapr, the Distributed Application Runtime
Dapr, the Distributed Application Runtime, is an open source project maintained by Microsoft that provides a portable and event-driven runtime that addresses some of the keys concerns for building distributed microservices, such as:
- Service invocation
- State management
- Pub/sub messaging
- External resource bindings
- Observability handling
- Secret handling
- Actor modelling
These are treated as foundational, pluggable components that can work with external vendor platforms through configurations and dynamic binding.