Jupiter is an Apache-2.0 governance-oriented microservice framework written in Go that is used in production at Douyu, aimed at Go teams that want configuration, service discovery, metrics, tracing and RPC handled by the framework instead of by glue code in every service.
What it is
Jupiter lives in the Go microservice ecosystem. It requires Go 1.19 or newer, integrates with gRPC for RPC and etcd for service discovery, and ships as a library together with a command-line toolkit. Three companion projects live in the same organization: Juno, described in the README as the microservice governance system for Jupiter; jupiter-layout, a project template; and jupiter-examples, a collection of worked examples. A hosted Juno console is offered as an online demo at jupiterconsole.douyu.com, with the credentials admin / admin.
The concrete problem it solves is the repeated assembly work that precedes every new Go service. Without a framework, a team has to wire configuration loading, etcd-backed service registration, metrics collection, trace instrumentation and RPC setup by hand, then repeat that work for each new service. Jupiter replaces that per-service scaffolding with one framework and a matching project layout, so the governance concerns — the published topics are governance, metrics and trace — arrive switched on rather than bolted on afterwards.
Key capabilities
- The
jupiter CLI toolkit, installed from github.com/douyu/jupiter/cmd/jupiter, handles both project creation and service execution.
- Configuration is loaded from a
.jupiter.toml file and passed at start with jupiter run -c cmd/exampleserver/.jupiter.toml.
- Project scaffolding comes from
jupiter new example-go, which draws on the jupiter-layout template.
- gRPC is supported for service-to-service RPC.
- etcd provides service discovery and the registry backing governance.
- Metrics and trace instrumentation are first-class framework concerns rather than add-ons.
- A web framework component sits alongside the RPC layer, with the companion Juno console covering governance.
Who uses it and how
- Douyu runs Jupiter in production, and the README states it has been in use there for years.
- Teams starting a new Go service run
jupiter new and then code against the generated layout instead of building structure from scratch.
- Local development brings up dependencies with
docker compose -f test/docker-compose.yml up -d before jupiter run starts the service.
- Operators use Juno as the governance system for services built on the framework, and the hosted console is available for evaluation.
- etcd acts as the shared registry that discovery and governance rely on across services.
Getting started
Install the toolkit with go install github.com/douyu/jupiter/cmd/jupiter@latest, create a project with jupiter new example-go, bring up dependencies with docker compose -f test/docker-compose.yml up -d, and start the service with jupiter run -c cmd/exampleserver/.jupiter.toml. Go 1.19 or newer and Docker are both required.
How it compares
No competing framework is named anywhere in the facts supplied for this entry, so Jupiter stands alone here rather than sitting on a comparative axis. Its nearest relatives in the facts are its own companion projects — Juno for governance, jupiter-layout for scaffolding, and jupiter-examples for reference code — not alternatives to it.
When to use it — and when not
A self-hoster runs etcd and Docker alongside the service, and the repository ships no hosted control plane beyond the demo console, so the operational surface is real. Documentation is primarily Chinese at jupiter.douyu.com, which leaves the English README thin as a sole reference. Teams outside Go, or those not using gRPC and etcd, gain little from it, and the README itself is sparse — a quick start and outward links rather than in-depth framework documentation.
