go-kit VS fx

https://github.com/go-kit/kit

. Web backend (with various frameworks available) . Web Assembly (one of them is vugu framework) . Microservices (some frameworks: Go Micro, Go Kit, Gizmo, Kite) . Fragments services (Term mentioned by @jeffotoni in a microservices discussion group) . Lambdas (FaaS example) . Client Server . Terminal applications (using the tview lib) . IoT (some frameworks) . Bots (some here) . Client Applications using Web technology . Desktop using Qt+QML, Native Win Lib (example Qt, Qt widgets, Qml) . Network Applications . Protocol applications . REST Applications . SOAP Applications . GraphQL Applications . RPC Applications . TCP Applications . gRPC Applications . WebSocket Applications . GopherJS (compiles Go to JavaScript)

To implement service discovery in our GoLang microservice we will use GoKit, a toolkit for microservices that provides support to auth, log, service discovery, tracing and more. For this starter code the mod already installed, you can skip this step

My company uses go-kit

For reference my company Go projects are built with (go-kit)[https://gokit.io/] design patterns.

5. kit. The kit framework is a programming toolkit for building robust, reliable, and maintainable microservices in Golang. It is a collection of packages and best practices that offer businesses of all sizes a thorough, reliable, and trustworthy way to create microservices. Go is a fantastic general-purpose language, but microservices need some specialized assistance. As a result, the kit framework offers infrastructure integration, system observability, and Remote Procedure Call (RPC) safety. Golang is a first-class language for creating microservices in any organization thanks to its composition of numerous closely related packages that together form an opinionated framework for building substantial Service-Oriented Architectures (SOAs).It was created with interoperability in mind, and developers are free to select the platforms, databases, components, and architectural styles that best suit their needs. The disadvantage of using go-kit is that it has a high overhead for adding API to the service because of how heavily it relies on interfaces. Documentation Link: https://github.com/go-kit/kit

At first I was confused but this GitHub user/org is completely different from the massively popular go-kit/kit https://github.com/go-kit/kit

https://github.com/go-kit/kit#related-projects

go-micro seems like it does a bit too much, like service discovery and balancing within the framework when that's likely better handled by an Envoy/Istio.

I think the more interesting aspect of this is the framework being used: https://github.com/micro/micro

I haven't dug into it at all yet, but at a glance it looks like it's aiming to do something similar to what Go kit (https://gokit.io/) or Finagle (https://twitter.github.io/finagle/) does, where it gives you a nice abstraction for defining your "service" and then handles all the supplementary aspects (service discovery, serialization, retry/circuit breaker logic, rate limiting, hooks for logging, tracing, and metrics, etc) so you don't have to build those from scratch every time.

I don't know if any of those other frameworks could really be considered very "successful" outside the original organizations they were built for (it seems like the industry has bet more on service meshes and API gateway products), but I'd probably be more inclined to start with one of them than making a new framework.

I found fx(https://github.com/uber-go/fx) to be a super simple yet versatile tool to design my application around.

All the advice in the article is still helpful, but it takes the "how do I make sure X is initialized when Y needs it" part completely out of the equation and reduces it from an N*M problem to an N problem, ie I only have to worry about how to initialize individual pieces, not about how to synchronize initialization between them.

I've used quite a few dependency injection libraries in various languages over the years (and implemented a couple myself) and the simplicity and versatility of fx makes it my favorite so far.

Some of the features: - ✅ Using Vertical Slice Architecture as a high level architecture - ✅ Using Event Driven Architecture on top of RabbitMQ Message Broker with a custom [Event Bus](pkg/messaging/bus/) - ✅ Using Event Sourcing in Audit Based services like [Orders Service](services/orders/) - ✅ Using CQRS Pattern and Mediator Patternon top of Go-MediatR library - ✅ Using Dependency Injection and Inversion of Controlon top of uber-go/fx library - ✅ Using RESTFul api with Echo framework and using swagger with swaggo/swag library - ✅ Using Postgres and EventStoreDB to write databases with fully supports transactions(ACID) - ✅ Using MongoDB and Elastic Search for read databases (NOSQL) - ✅ Using OpenTelemetry for collection Distributed Tracing with using Jaeger and Zipkin - ✅ Using OpenTelemetry for collection Metrics with using Prometheus and Grafana - ✅ Using Unit Test for testing small units with mocking dependent classes and using Mockery for mocking dependencies - ✅ Using End2End Test and Integration Test for testing features with all of their real dependeinces using docker containers (cleanup tests) and testcontainers-go library

any take on https://github.com/uber-go/fx?

I’m not sure of much that can do all of that - maybe it’s a use case for https://github.com/uber-go/fx

If I still find myself stuck/waiting, I switch over to studying more about our team's main language Go. Currently looking around at Fx ( https://github.com/uber-go/fx ). Which is interesting, though I doubt we'll actually migrate anything for it, but might make a neat lunch and learn topic.

Hello gophers, I am using https://github.com/uber-go/fx and https://github.com/rs/zerolog for logging.

Also, I like to use Uber FX for my DI stuff. You can check it out here:https://github.com/uber-go/fx

I only have private and work repos... But I use Uber fx. https://github.com/uber-go/fx

Spring Boot is notable for its dependency injection / inversion of control. The closest Go has to this is Uber's Fx which also includes some lifecycle management.

If you have such a complex and deep dependency graph, and you don't want to manually maintain it, you could use some DI library to handle that for you. Something like https://github.com/google/wire for small-medium size stuff, or https://github.com/uber-go/fx for larger scale, more enterprise projects.