Skip to content

Instantly share code, notes, and snippets.

@posener posener/go-kit.md
Last active Nov 28, 2019

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

@rcholic

This comment has been minimized.

Copy link

rcholic commented Nov 21, 2017

I agree with you on the verbosity part: when I tried to understand the examples, the boilerplate code such as endpoint, request/response encoders and decoders, and the transportation layer threw me off. It is supposed to be a microservice API, why do I need to repeat these boilerplates everywhere? This kind of verbosity makes it easy to make mistakes and may be hard to maintain down the road. This being said, I think the library has some very cool concepts that help me learn go 👍

@fteem

This comment has been minimized.

Copy link

fteem commented Jan 18, 2018

Nice writeup! I've been looking at various microservices frameworks for Go. My idea is to basically build like a small set of micromicroservices so I can connect them and play. What alternative would you suggest for go-kit? Or, which one have you found less annoying to use?

@mdiesen

This comment has been minimized.

Copy link

mdiesen commented Jan 20, 2018

Nice summary. I do agree that go kit requires some boilerplate code but I like the separation of the different layers once you get your head around their purpose. When investigating different libraries I first set my eyes on goadesign which auto generates a lot of boilerplate code for you given a specification. The downside is that the DSL for the spec is fairly verbose in itself and compared to go kit I find their separation of concern less clear.
I think the best solution would be to combine the strengths of these two libraries and I will do my own attempt at that by creating templates to generate the boilerplate code required in go git (ie routing, endpints, transport, incl "hiding" the ugly interface{} and casts). If someone is interrested I'm happy to share that code once its ready.

@joejarlett

This comment has been minimized.

Copy link

joejarlett commented Apr 7, 2018

Hey @mdiesen, did you progress with your template. I am setting out with goa v2 plus go-kit combined with the jsonapi.org spec. So keen to continue any work you have done.

@sagikazarmark

This comment has been minimized.

Copy link

sagikazarmark commented Apr 28, 2018

It's hard to argue with your assessment, because every information you wrote about go-kit is true. It certainly has some solutions that come at a price, but I believe it is subjective whether you are willing or are able to pay that or not. It does not make the solutions themselves bad.

(And I don't think it was your intention to say, I just want to express that although you are absolutely right about your opinion, go-kit is not nearly as "bad" from a professional point of view as other, obviously bad solutions 😄 )

@weitzj

This comment has been minimized.

Copy link

weitzj commented May 8, 2018

The idea, which I kind of like is to define the services in a protobuf file (as you would do for gRPC).

This project does this really nicely. https://github.com/moul/protoc-gen-gotemplate
And the examples show some go-kit integration:

@zak905

This comment has been minimized.

Copy link

zak905 commented May 29, 2018

Hi @posener, thanks for the information. How complex is testing go-kit based services ? Not that simple I suppose

@hgkmail

This comment has been minimized.

Copy link

hgkmail commented Aug 17, 2018

go-kit need a code generator, like go-micro.

@cjyar

This comment has been minimized.

Copy link

cjyar commented Sep 6, 2018

@hgkmail is right. Either a code generator or use reflection to eliminate all that boilerplate code. (I'd prefer reflection.)

@jeroenvand

This comment has been minimized.

Copy link

jeroenvand commented Sep 6, 2018

I've actually started on a code generator for go-kit that generates endpoints and handles most of the boilerplate for you, starting from a Go interface definition. It's still in the WorksForMe(tm) phase, but if you're interested see: https://github.com/jeroenvand/kitboiler.

@jeroenvand

This comment has been minimized.

Copy link

jeroenvand commented Sep 6, 2018

Or perhaps have a look at this: https://github.com/kujtimiihoxha/kit - seems actually quite a bit further along and more complete

@mashingan

This comment has been minimized.

Copy link

mashingan commented Oct 4, 2018

Same here, couldn't comprehend the service that should be "micro" but go-kit made it so bloating in development 😞

In the end I'm doing what @jeroenvand did by writing a template for code generation. But I'm writing it in Nim 😅

@WebspressoCo

This comment has been minimized.

Copy link

WebspressoCo commented Dec 5, 2018

I recently compared go microservice toolkits, and the verbosity of go-kit caught my eye. Fortunately the community has been working on this for a while and now go-kit has great boilerplate generation through the cli (track this pull request for details: go-kit/kit#589)

@Henry75m39

This comment has been minimized.

Copy link

Henry75m39 commented Jul 8, 2019

so, how about go-micro ?

@reyvababtista

This comment has been minimized.

Copy link

reyvababtista commented Nov 7, 2019

I do agree on these opinions of yours, @posener. Go-kit really has a lot of boilerplate codes. However, I did learn a lot about concepts and ideas of microservices and Golang by developing using the base of Go-kit. There is also another way of writing microservices in Golang using Go-micro toolkit. Go-micro declares itself as an opinionated microservices toolkit/framework. That being said, if we want to get a better grip of what microservices are, how does it works (layer by layer), how to develop one and have freedom doing it, I would still recommend to write microservices with the help of Go-kit beforehand rather than another toolkit/framework available as for now.

@ravlio

This comment has been minimized.

Copy link

ravlio commented Nov 13, 2019

Great article. Must read to avoid using of go-kit. This framework is nothing more than code hell. For 1 line of code, you must write 10-20 lines of boilerplate. Just check any of the examples, for instance, https://github.com/go-kit/kit/tree/master/examples/profilesvc Why you need all these Endpoints and Middlewares? Why just not to use a proxy pattern? Why just not to write straight code without func(ctx context.Context, request interface{}) (response interface{}, err error)? Use interface{} only in middlewares, in other cases you can fully control your types.

I'm 99% sure that you want to use gRPC with microservices — in that case, you absolutely do not need complex abstractions that go-kit provides. Just use gRPC directly. With its interceptors, logging, tracing, service discovery ecosystem. Straightforward, simple to debug and understand.

Another unresolvable problem with Go-kit is error passing: you can’t just take your custom error and throw it through metadata from server to client to handle it correctly. Go-kit popularizes anti-patterns like error throwing via struct properties. But it can be done easily with custom gRPC interceptors and few lines of code.

Using event-driven approach? Try to use native libraries with tiny helpers for metadata, encoding/decoding, logging, etc.. You do not need to bind your hands with go-kit thinking how to make this or that task — just do it with as little code as possible.

I'm glad that I refused to work with go-kit a long time ago. In retrospect, it was like — one day for actual business logic programming and another 2-3 days for annoying wrapping all together into endpoints and middlewares.

BTW Go-Micro looks much better designed. If you still want to stay with some framework, give go-micro a try.

Sorry if rude, but I'm upset with that fact that go-kit spread among many companies and I periodically have to work with it. Anti-go-way for sure.

@tranphuoctien

This comment has been minimized.

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!
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.