GoKit CLI

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.

Prerequisites

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

To utilise generation of gRPC service code through kit generate service <SERVICE_NAME> -t grpc you will need to install the grpc prequisites.

go get -u google.golang.org/grpc
go get -u github.com/golang/protobuf/protoc-gen-go

Table of Content

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

Installation

Before you install please read prerequisites

go get github.com/kujtimiihoxha/kit

Usage

kit help

Also read this medium story

Create a new service

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)
}

Generate the service

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

Generate the client library

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)
}

Generate new middleware

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.

Enable docker integration

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

After you run docker-compose up your services will start up and any change you make to your code will automatically rebuild and restart your service (only the service that is changed)