Apache Dubbo for Golang

English | 中文

Apache Dubbo-go is a high-performance RPC and microservice framework compatible with other Dubbo language implementations. It leverages Golang's concurrency features to provide efficient service governance, including service discovery, load balancing, and traffic management. Dubbo-go supports multiple protocols, such as Dubbo, JSONRPC, Triple(gRPC-compatible), gRPC, HTTP, HTTP2, and HTTP/3 (experimental), ensuring seamless integration in heterogeneous environments.

You can visit the official website for more information.

Recent Updates

For detailed changes, refer to CHANGELOG.md.

3.3.2:

Upgrade note: Go 1.25 or later is required. The legacy config package has been removed; applications that imported it directly must migrate to the instance/options APIs and configuration types under global. See the 3.3.2 changelog and dubbo-go-samples for migration details and current usage.

Apache Dubbo-go 3.3.2 is a production-readiness release focused on API consolidation, Triple protocol capabilities, application-level metadata, service governance, concurrency safety, and release tooling. It completes the removal of the legacy config package, expands generic invocation and HTTP-facing Triple features, refreshes generated-project workflows, and fixes multiple races, stale-snapshot issues, and resource leaks.

3.3.1: Optimized configuration hot-reloading with content-based caching to prevent redundant notifications. Added experimental HTTP/3 support, Apollo integration, and Triple protocol OpenAPI generation. Fixed critical race conditions in service discovery under high-concurrency.

3.3.0: Introduced script routing, multi-destination conditional routing, Triple protocol keepalive and connection pooling, Nacos multi-category subscriptions, and enhancements for observability and interoperability.

Getting started

Prerequisites

Go 1.25 or later.

Installation

To install Dubbo-go, use the following command:

go get dubbo.apache.org/dubbo-go/v3@latest

Quick Example

You can learn how to develop a dubbo-go RPC application step by step in 5 minutes by following our Quick Start demo.

It's as simple as the code shown below, you define a service with Protobuf, provide your own service implementation, register it to a server, and start the server.

func (srv GreetTripleServer) Greet(ctx context.Context, req greet.GreetRequest) (*greet.GreetResponse, error) {
	resp := &greet.GreetResponse{Greeting: req.Name}
	return resp, nil
}
func main() {
	srv, _ := server.NewServer(
		server.WithServerProtocol(
			protocol.WithPort(20000),
			protocol.WithTriple(),
		),
	)
_ := greet.RegisterGreetServiceHandler(srv, &GreetTripleServer{})
if err := srv.Serve(); err != nil {
		logger.Error(err)
	}
}

After the server is up and running, call your service via cURL:

curl \
    --header "Content-Type: application/json" \
    --data '{"name": "Dubbo"}' \
    http://localhost:20000/greet.GreetService/Greet

Or, you can start a standard dubbo-go client to call the service:

func main() {
	cli, _ := client.NewClient(
		client.WithClientURL("127.0.0.1:20000"),
	)
svc, _ := greet.NewGreetService(cli)
resp, _ := svc.Greet(context.Background(), &greet.GreetRequest{Name: "hello world"})
	
	logger.Infof("Greet response: %s", resp.Greeting)
}

See the samples for detailed information on usage. Next, learn how to deploy, monitor and manage the traffic of your dubbo-go application by visiting the official website.

Features

!dubbo-go-architecture

Dubbo-go provides robust service governance capabilities:

RPC Protocols: Triple, gRPC compatible and HTTP-friendly
Service Discovery: Nacos, Zookeeper, Etcd, Polaris-mesh.
Load Balance: Adaptive, Random, RoundRobin, LeastActive, ConsistentHash
Traffic Management: traffic split, timeout, rate limiting, canary release
Configuration: yaml file, dynamic configuration(Nacos, Apollo, Zookeeper, etc.).
Observability: Metrics (Prometheus), tracing (OpenTelemetry v1.21.0+ with insecure options and standardized span names), logging (with service registration lifecycle events).
HA Strategy: Failover, Failfast, Failsafe/Failback, Available, Broadcast, Forking.
Interoperability: Full compatibility with Apache Dubbo (Java) via Triple protocol generic calls, group/version wildcard matching, and TLS API redesign.

Tools

Common development tools live in tools/.

| Tool | Purpose | | --- | --- | | dubbogo-cli | Scaffold demos/apps, install companion tools, inspect metadata, and debug services. | | protoc-gen-go-triple | Generate dubbo-go Triple bindings from protobuf service definitions. | | protoc-gen-triple-openapi | Generate OpenAPI v3 documents from Triple protobuf services. | | imports-formatter | Format Go import blocks using dubbo-go grouping rules. | | dubbo-go-schema | Provide JSON Schema completion and validation for dubbo-go YAML config. | | benchmark | Performance benchmark suite for comparing Dubbo-Go, Dubbo-Java, and gRPC frameworks. |

Ecosystem

dubbo-go-samples
dubbo-go-pixiu which acting as a proxy to solve Dubbo multi-language interoperability
Interoperability with Dubbo Java
Console, under development
dubbo-go-extensions, under development

Documentation

Official Website: https://dubbo.apache.org/
Dubbo-go Documentation: https://cn.dubbo.apache.org/zh-cn/overview/mannual/golang-sdk/
CHANGELOG: https://github.com/apache/dubbo-go/blob/main/CHANGELOG.md

Community

GitHub Issues: https://github.com/apache/dubbo-go/issues
Mailing Lists: https://dubbo.apache.org/en/community/

Contributions, issues, and discussions are welcome. Please visit CONTRIBUTING for details on submitting patches and the contribution workflow.

Contact

Join our discussion group through Ding talk or WeChat.

!invite.png

User List

If you are using apache/dubbo-go and think that it helps you or want to contribute code for Dubbo-go, please add your company to the user list to let us know your needs.