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.

apache/dubbo-spring-boot-project

5,389View on GitHub

This project is an integration framework that bootstraps Apache Dubbo remote procedure call services within Spring Boot applications. It serves as a microservice communication framework that enables the implementation of RPC services, service discovery, and distributed governance through automated configuration. The project distinguishes itself by providing a cross-language RPC bridge, allowing services written in different languages to communicate via standards such as gRPC and Protobuf. It further enables the exposure of backend microservices as REST endpoints using the Triple protocol for

apache/dubbo

41,519View on GitHub

Dubbo is a Java RPC framework and microservices governance platform designed for high-performance remote procedure calls in distributed architectures. It provides the foundational components necessary to connect distributed services across a network, including a binary data serialization library and a distributed service registry. The platform distinguishes itself through a comprehensive governance suite that manages service discovery, load balancing, and traffic routing. It enables precise control over network traffic via conditional routing and a pluggable extension mechanism based on a ser

alibaba/dubbo

41,522View on GitHub

Dubbo is a high-performance Java remote procedure call framework and microservice governance platform. It enables communication between distributed services using a remote service orchestrator and a distributed service registry to locate available providers in real time. The system provides a microservice monitoring suite for health tracking and distributed tracing, alongside integrated security plugins for access control. It manages network traffic through routing strategies, rate limiting, and thread pool isolation to maintain system stability. The framework covers broader capabilities in

apache/brpc

17,545View on GitHub

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

apachedubbo-go

Features

Open-source alternatives to Dubbo Go

apache/dubbo-spring-boot-project

apache/dubbo

alibaba/dubbo

apache/brpc

Star history

Open-source alternatives to Dubbo Go

apache/dubbo-spring-boot-project

apache/dubbo

alibaba/dubbo

apache/brpc