Skip to content

Instantly share code, notes, and snippets.

@posener
Last active Sep 13, 2022
Embed
What would you like to do?
Why I Recommend to Avoid Using the go-kit Library

Why I Recommend to Avoid Using the go-kit Library

There is a trending 'microservice' library called go-kit. I've been using the go-kit library for a while now. The library provide a lot of convenience integrations that you might need in your service: with service discovery with Consul, distributed tracing with Zipkin, for example, and nice logic utilities such as round robin client side load balancing, and circuit breaking. It is also providing a way to implement communication layer, with support of RPC and REST.

The toolchain that the library provide is very nice, and it does try to solve a fundamental problem we have in the Go community: missing ecosystem to write microservices. I do like the approach of the package: 'take what you want', you can write your service and use certain tools given in this libary, and not use all of it. But, I recommend not to use the library server implementation for your REST microservices. (I think this recommendation will also apply for the RPC part of the library, but I don't have any experience with that).

You could read why, and I would love to hear your opinion about it, if you agree, disagree, and why.

1. Too verbose

Usually microservices expose APIs: external, which are exposed, and internal for inter-service communication.

When using the go-kit, it was very noticeable that the overhead of adding API you your service is very high. You need to add a lot of code, which is mostly copy-paste of other APIs and there are too many places to make mistakes.

To add a single simple API, you should add:

a. Function in the interface (make sense) b. Implementation (make sense) c. Endpoint factory function d. Transport function e. Request encoder, request decoder, response encoder and response decoder. f. Add the endpoint to the server g. Add the endpoint to the client.

For a quick impression of what I mean by "a lot of code" take a look at the simple example in the go-kit website

2. Hard to understand (at least, for me)

I think the main reason for this verbosity is the layer separation for the business logic, endpoint and transport, which is nice, and benefits in nice abstractions for the client-side load balancing, circuit breaking, tracing, etc.

But, it is hard to understand.

If you are using the go-kit as REST service library, I recommend to know the following ServerHTTP function by heart: Only then you truly understand how your service is expected to behave.

3. The interface{} API

When using the go-kit, your endpoints get an interface{} object and return an interface{}, error tuple. You need to explicitly write the conversion to your implementation function. Actually, your endpoint factory will almost be a copy-paste of the following function:

func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint {
  return func(ctx context.Context, request interface{}) (interface{}, error) {
    req := request.(myRequest)
    v, err := svc.Function(req.A, req.B)
    if err != nil {
      return myResponse{v, err.Error()}, nil
    }
    return myResponse{v, ""}, nil
  }
}

To summarize

This library is really nice, and with really good intensions. It looks very popular, but can't really understand how much production ready it is, and how many actual use cases there are out there. I personally don't like the basic concepts of it, specially because of the interface{} and the verbosity issues discussed above, and I find them not easy to use, and not intuitive.

You couldn't use the nice features of the library of load-balancing, circuit breaking, and tracing, if you are not using the endpoint APIs, but if you look at the code, it is not that big. You could use the actual code or find other libraries that provide them as middleware for the standard http client/server.

Thanks for reading,

If you find this interesting, please, ✎ comment below or ★ star above

For more stuff: gist.github.com/posener.

Cheers, Eyal

@tranphuoctien
Copy link

tranphuoctien commented Nov 28, 2019

Hi friend,
I do agree with these opinions of yours. But to understand it's you must have base knowledge things:

  • Protobuf how is working?
  • Interface in Golang? what it's?
  • You should understand how RPC send request and response!

@tomilchik
Copy link

tomilchik commented Jun 18, 2020

Disclosure: I have no experience with other Golang frameworks/kits/libraries mentioned here, except go-kit.
In my work, it definitely paid for itself.
The main benefits, for my projects:

  • clean, layered separation of concerns;
  • ability to keep transport-level code (anything that has to do with http, MoM like AWS sqs/sns, tracing, db transaction management) firmly out of the way of business logic domain;
  • no-brain-involved, templated way of doing things that shouldnt really need any thinking. Think “I have an operation that I want to expose as http endpoint; of course, fully traceable, with anti-fragility built in, with audit trail logging, and db transaction management”.

Re: productivity: I timed myself, out of pure interest. Adding another http/sqs endpoint to my service’s API took between 5-10 min when I use existing data models, and up to 30-45 min when I have to create new ones. And I’m a quite slow typer :)

Where go-kit is lacking is anything to do with messaging. The amqp support is questionable - uses completely wrong (IMHO) paradigm of synchronous request/response exchange, which kinda defeats the purpose of messaging.

All in all: I’ll do a quick-n-dirty impl without go-kit, but will definitely use it for anything industrial (as in: prod-grade).

@gadieichhorn
Copy link

gadieichhorn commented Jul 20, 2020

the idea is to have a standardized api and clean architecture design. I like go-kit as it enforces order and agreement on how things should be done in a team. Once you get your head around the concepts there is no place for hacks and breaking dependencies. When you run a large project, ordering things and creating best practice is what makes a difference.

I like the clean separation between transport and implementation. smaller code chunks do one thing and not mixing different concerns.

The middleware is a benefit when you come to construct your services, like LEGO you can add layers of instrumentation and trace without changing core services code.

making code testable is a massive benefit. injecting dependencies and abstracting interfaces is what makes it possible.

yes, if you run a very small project, it is an overkill, otherwise, I recommend it.

@RussellLuo
Copy link

RussellLuo commented Sep 10, 2020

I have just developed a toolkit for Go kit named kok, in order to reduce the burden of handwriting boilerplate code.

I hope you guys find it helpful :-)

@alienatorZ
Copy link

alienatorZ commented Sep 23, 2020

I actually switched from go-micro to go-kit for the fact that you can have complete control from transport down to the service. I got frustrated not knowing why my Java GRPC service could not call my go-micro service due to the fact that nice easy API hid all kinds of magic that was not working for me and I could not control it. Go-Kit while a LOT more verbose allows for easy debugging any issues which results in a development time savings when doing complicated orchestrations.

@eldad87
Copy link

eldad87 commented Apr 6, 2021

I wrote my own opinionated microservice example:
https://github.com/eldad87/go-boilerplate

My approach is simple, define the service HTTP & gRPC transport layers using protobuf and work your way top to bottom.
The foundations of the service are rock-solid & decoupled, which makes every component replaceable.
In addition, the HTTP layer is been document seemly using Swagger.

@ricardodovalle
Copy link

ricardodovalle commented Aug 16, 2021

What would you recommend for microservices? @posener

@NishanthSpShetty
Copy link

NishanthSpShetty commented Jan 18, 2022

anyone tried using https://github.com/go-coldbrew ?

@nyelnizy
Copy link

nyelnizy commented Mar 18, 2022

Why not use kubernettes with vanilla go??

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment