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 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.

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.

See more user cases

License

Apache Dubbo-go software is licensed under the Apache License Version 2.0. See the LICENSE file for details.