This project is a more advanced version of gk. The goal of the gokit cli is to be a tool that you can use while you develop your microservices with gokit.

While gk did help you create your basic folder structure it was not really able to be used further on in your project. This is what GoKit Cli is aiming to change.

GoKit Cli needs to ne installed using go get and go install so Go is a requirement to be able to test your services gokit is needed.

• Installation
• Usage
• Create a new service
• Generate the service
• Generate the client library
• Generate new middlewares
• Enable docker integration

Before you install please read prerequisites

go get github.com/kujtimiihoxha/kit

kit help

kit new service hello
kit n s hello # using aliases

This will generate the initial folder structure and the service interface

service-name/pkg/service/service.go

package service

// HelloService describes the service.
type HelloService interface {
	// Add your methods here
	// e.x: Foo(ctx context.Context,s string)(rs string, err error)
}

kit g s hello
kit g s hello --dmw # to create the default middleware
kit g s hello -t grpc # specify the transport (default is http)

This command will do these things:

• Create the service boilerplate: hello/pkg/service/service.go
• Create the service middleware: hello/pkg/service/middleware.go
• Create the endpoint: hello/pkg/endpoint/endpoint.go and hello/pkg/endpoint/endpoint_gen.go
• If using --dmw create the endpoint middleware: hello/pkg/endpoint/middleware.go
• Create the transport files e.x http: service-name/pkg/http/handler.go
• Create the service main file 💥
  hello/cmd/service/service.go
hello/cmd/service/service_gen.go
hello/cmd/main.go

⚠️ Notice all the files that end with _gen will be regenerated when you add endpoints to your service and you rerun kit g s hello ⚠️

You can run the service by running:

go run hello/cmd/main.go

kit g c hello

This will generate the client library ✨ http/client/http/http.go that you can than use to call the service methods, you can use it like this:

package main

import (
	"context"
	"fmt"

	client "hello/client/http"
	"github.com/go-kit/kit/transport/http"
)

func main() {
	svc, err := client.New("http://localhost:8081", map[string][]http.ClientOption{})
	if err != nil {
		panic(err)
	}

	r, err := svc.Foo(context.Background(), "hello")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Result:", r)
}

kit g m hi -s hello
kit g m hi -s hello -e # if you want to add endpoint middleware

The only thing left to do is add your middleware logic and wire the middleware with your service/endpoint.

kit g d

This will add the individual service docker files and one docker-compose.yml file that will allow you to start your services. To start your services just run

docker-compose up

If you change something in your code just restart the docker containers using docker-compose restart.