Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/kujtimiihoxha/kit
GoKit CLI
https://github.com/kujtimiihoxha/kit
go-kit gokit golang kit
Last synced: 30 days ago
JSON representation
GoKit CLI
- Host: GitHub
- URL: https://github.com/kujtimiihoxha/kit
- Owner: kujtimiihoxha
- License: mit
- Created: 2017-09-19T12:04:52.000Z (about 7 years ago)
- Default Branch: master
- Last Pushed: 2022-05-16T17:50:09.000Z (over 2 years ago)
- Last Synced: 2024-08-03T17:19:34.521Z (4 months ago)
- Topics: go-kit, gokit, golang, kit
- Language: Go
- Size: 8.98 MB
- Stars: 720
- Watchers: 25
- Forks: 165
- Open Issues: 25
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- go-awesome - GoKit CLI - Go Kit framework (Open source library / Microservices)
- awesome - kit - GoKit CLI (Go)
README
# GoKit CLI [](https://travis-ci.org/kujtimiihoxha/kit)[](https://goreportcard.com/report/github.com/kujtimiihoxha/kit)[](https://coveralls.io/github/kujtimiihoxha/kit?branch=master)
This project is a more advanced version of [gk](https://github.com/kujtimiihoxha/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](https://github.com/go-kit/kit) is needed.
To utilise generation of gRPC service code through `kit generate service -t grpc` you will need to install the [grpc prequisites](https://grpc.io/docs/quickstart/go/).
```
go get -u google.golang.org/grpc
go get -u github.com/golang/protobuf/protoc-gen-go
```
# Table of Content
- [Installation](#installation)
- [Usage](#usage)
- [Create a new service](#create-a-new-service)
- [Generate the service](#generate-the-service)
- [Generate the client library](#generate-the-client-library)
- [Generate new middlewares](#generate-new-middleware)
- [Enable docker integration](#enable-docker-integration)
# Installation
Before you install please read [prerequisites](#prerequisites)
```bash
go get github.com/kujtimiihoxha/kit
```
# Usage
```bash
kit help
```
Also read this [medium story](https://medium.com/@kujtimii.h/creating-a-todo-app-using-gokit-cli-20f066a58e1)
# Create a new service
```bash
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`
```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
```bash
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 :boom:
`hello/cmd/service/service.go`
`hello/cmd/service/service_gen.go`
`hello/cmd/main.go`
:warning: **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` :warning:
You can run the service by running:
```bash
go run hello/cmd/main.go
```
# Generate the client library
```bash
kit g c hello
```
This will generate the client library :sparkles: `http/client/http/http.go` that you can than use to call the service methods, you can use it like this:
```go
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
```bash
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
```bash
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
```bash
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)