apache/dubbo-go
Dubbo Go
Apache Dubbo Go is a Go language implementation of the Apache Dubbo framework designed for building high-performance microservices. It serves as a cross-language RPC framework and microservices communication layer that enables remote procedure calls between services written in different programming languages.
The framework functions as a service governance toolset and a distributed service mesh proxy, allowing data planes to connect with external control planes in proxy or proxyless modes. It specifically provides a compatibility layer to facilitate communication between Go and Java-based services through language-agnostic definitions and standardized data encoding.
The system covers a broad range of distributed capabilities, including dynamic service discovery, strategy-based load balancing, and traffic management via circuit breakers and rate limiting. It incorporates observability through distributed request tracing and performance metrics, while ensuring security with transport layer encryption and identity-based access control.
Developer productivity is supported via a command-line interface for application bootstrapping and automated RPC stub generation from interface definitions.
Features
- Cross-Language RPC Frameworks - Facilitates high-performance remote procedure calls between Go and Java services using standardized data encoding.
- Remote Procedure Call Frameworks - Implements a high-performance RPC framework for efficient data exchange between distributed microservices.
- Load Balancing - Distributes outgoing requests across multiple service providers using algorithms like round-robin and consistent hashing.
- Load Balancing Strategies - Distributes outgoing requests across multiple service instances using interchangeable algorithms like round-robin or consistent hashing.
- Microservice Traffic Management - Controls request flow through load balancing, circuit breakers, and dynamic routing to ensure system resilience.
- Service Governance Control Planes - Coordinates service registration, health checks, and metadata management across a cluster of distributed application instances.
- Microservices Communications - Handles service registration, health checking, and request tracing across distributed microservice clusters.
- Registry-Based Service Discovery - Locates available service providers by querying a centralized registry instead of using hardcoded network addresses.
- RPC Frameworks - Provides a high-performance framework for executing remote procedures across network nodes.
- Dubbo Integration - Implements the Apache Dubbo framework in Go for building high-performance microservices.
- Service Governance - Provides a toolset for managing service discovery, load balancing, and traffic routing in distributed architectures.
- Proxyless Integrations - Enables data planes to connect with external control planes in both proxy and proxyless modes.
- Compatibility Layers - Handles Java-specific data types and exceptions to enable seamless communication between Go and Java-based services.
- Language Bridges - Maps language-specific data types and exceptions to enable seamless communication between services written in different languages.
- Language Interoperability - Enables interaction between services written in different programming languages using language-agnostic definitions and standardized encoding.
- Dynamic Service Discovery - Locates available service providers in real-time using registry adapters, local file systems, or custom extensions.
- Polyglot Microservices - Enables communication between services written in different languages through standardized data exchange and shared interfaces.
- Distributed Observability Systems - Provides unified observability for distributed systems through integrated metrics, tracing, and performance monitoring.
- Invocation & Routing Extensions - Provides a plugin system to customize how remote procedure calls are invoked and routed.
- RPC Stub Generation - Produces client and server code from interface definitions to automate service contract implementation.
- Interface Definition Code Generation - Produces client and server stubs from shared interface definitions to automate the implementation of service contracts.
- Dynamic Configuration Updates - Updates system settings at runtime using external configuration centers without requiring an application restart.
- High Availability Services - Ensures service availability by implementing failover, failfast, and broadcast routing strategies during interruptions.
- Data Plane Implementations - Acts as a data plane implementation connecting services to an external control plane for centralized governance.
- Service Lifecycle Management - Coordinates graceful shutdowns and offline transitions to ensure requests finish processing before service exit.
- Correlation Tracing - Injects correlation identifiers into service calls to track the flow of a single request across multiple microservices.
- Multi-Protocol Transport Layers - Routes communication over a single port and switches between different wire formats based on configuration.
- Service Mesh Networking - Protects inter-service communication using transport layer encryption and identity-based access control.
- Service Metadata Management - Manages service definitions and metadata to support advanced governance and precise request routing.
- Single-Port Multi-Protocol Support - Publishes multiple communication standards on a single port to support various network protocols for service interaction.
- Circuit Breakers - Prevents cascading failures by monitoring error rates and temporarily blocking requests to unhealthy service providers.
- Dynamic Routing - Steers traffic based on rules, scripts, or tags to enable canary releases and grayscale deployments.
- Transport Protocol Switching - Allows toggling between different communication protocols on a single port using simple configuration settings.
- Service Communication Security - Establishes a zero-trust network using transport encryption and identity-based permission verification.
- Environment Abstraction Layers - Decouples application logic from the underlying execution environment, supporting VMs, containers, and service meshes.
- Pluggable Interceptor Chains - Executes a sequence of customizable interceptors for request and response processing to extend framework behavior.
- Generic Invocations - Allows calling remote methods without requiring the specific interface definition to be present on the client side.
- Traffic Flow Control - Protects services from overload through TPS capping, execution limits, and rate limiting mechanisms.
- Configuration Hot-Reloading - Updates application settings at runtime using external configuration centers without requiring a process restart.
- Metric Collection - Collects request totals, success rates, and response time quantiles via sliding windows to track efficiency.
- Distributed Tracing - Tracks single requests across multiple services to identify performance bottlenecks and failures.
- Service Health Monitoring - Visualizes service running status and performance using metrics, distributed tracing, and access logs.
- Messaging and RPC - A Go implementation of the Dubbo framework for service interoperability.
- RPC Frameworks - Go implementation of the Dubbo RPC framework.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
