Go Orb is a framework for distributed systems development, it can be seen as the successor of go-micro.dev/v4.

The core of go-orb has been completely refactored, to support the removal of reflect and introduction of wire.

While its possible to try out go-orb currently, it is in active development and not ready for production use. Please have a look at our roadmap for more details.

Go Orb provides the core requirements for distributed systems development including RPC and Event driven communication. The Go Orb philosophy is sane defaults with a pluggable architecture. We provide defaults to get you started quickly but everything can be easily swapped out.

Go Orb abstracts away the details of distributed systems. Here are the main features.

• Config - Load dynamic config from anywhere. The config interface provides a way to load application level config from any source such as env vars, file and http. You can merge the sources and even define fallbacks.

• Service Discovery - Automatic service registration and name resolution. Service discovery is at the core of Go Orb service development. When service A needs to speak to service B it needs the location of that service. The default discovery mechanism is multicast DNS (mdns), a zeroconf system.

• Message Encoding - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client and server handle this by default. This includes protobuf and json by default.

• RPC Client/Server - RPC based request/response with support for bidirectional streaming. We provide an abstraction for synchronous communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.

• RPC over event topics - RPC over event topics, makes RPC even easier.

• Pluggable Interfaces - Go Orb makes use of Go interfaces for each distributed system abstraction. Because of this these interfaces are pluggable and allows Go Orb to be runtime agnostic. You can plugin any underlying technology.

• Strongly tested and linted - We use golangci-lint to ensure code quality and we have a comprehensive test suite, all lints and tests are run on CI.

Please see the examples repo.

With wire we gain:

• compile-time safety
• no more globals

It was the main reason for starting orb, wire allows us to decouple the components and plugins.

we have been working hard on removing all usage of reflect.

Orb allows you to listen on multiple port's with different protocols: gRPC, HTTP, HTTPS, DRPC, HTTP2, H2C, HTTP3. See the config system entry on howto configure it.

With orb you can configure your plugins with a config file or environment options.

service1:
  server:
    handlers:
      - UserInfo
    middlewares:
      - middleware-1
    entrypoints:
      - name: grpc
        plugin: grpc
        insecure: true
        reflection: false
  registry:
    enabled: true
    plugin: mdns
    timeout: 350
    domain: svc.orb

service1:
  server:
    handlers:
      - UserInfo
    middlewares:
      - middleware-1
      - middleware-2
    entrypoints:
      - name: hertzhttp
        plugin: hertz
        http2: false
        insecure: true

      - name: grpc
        plugin: grpc
        insecure: true
        reflection: false
        handlers:
          - ImOnlyOnGRPC
        middlewares:
          - ImAGRPCSpecificMiddlware

      - name: http
        plugin: http
        insecure: true

      - name: drpc
        plugin: drpc
  registry:
    plugin: consul
    address: consul:8500

These 2 config's with different options will both work, we first parse the config, get the "plugin" from it and pass a map[any]any with all config data to the plugin.

Both work with a single binary. :)

Return types as a result instead of HTTP req format.

New:

req := HelloRequest{Name: "test"}

// Look at resp, it's now returned as a result.
resp , err := client.Call[HelloResponse](context.Background(), clientDi, "org.orb.svc.hello", "Say.Hello", &req)

Old:

req := c.c.NewRequest(c.serviceName, "Greeter.Hello", in)
out := new(HelloResponse)
err := c.c.Call(ctx, req, out, opts...)
if err != nil {
  return nil, err
}
return out, nil

go-orb has support for sending nearly anything you throw in as application/json to the Server.

resp , err := client.Call[map[string]any](context.Background(), clientDi, "org.orb.svc.hello", "Say.Hello", `{"name": "Alex"}`, client.WithContentType(codecs.MimeJSON))

req := make(map[string]any)
req["name"] = "Alex"

resp , err := client.Call[map[string]any](context.Background(), clientDi, "org.orb.svc.hello", "Say.Hello", req, client.WithContentType(codecs.MimeJSON))

We like structured logging, this is why we replaced all logging with one based on slog.

We made sure that go-orb/go-orb (the core) is just a bunch of interfaces as well as some glue code, the most real code lives in go-orb/plugins.

Everything is linted and staticaly analyzed by golangci-lint, enforced with CI pipelines on github.

Chat with us on Discord.

• David Brouwer
• René Jochum

A lot of this is copy&pasted from go-micro, top contributors have been:

• Asim Aslam the founder/creator of go-micro.
• Milos Gajdos
• ben-toogood
• Vasiliy Tolstov
• Johnson C

go-orb is Apache 2.0 licensed and is based on go-micro.