English | 简体中文

go-template

• boilerplate, go project starter with go-zero/gin/go-micro.
• go microservice (go-zero/gin/go-micro) project directory generation tool/scaffold.
• Implementation based on cookiecutter.

Feature:

• mono repo: support creating mono repo, the git project root directory.
  • go-zero
  • go-kratos
  • gin
  • go-micro
  • rs : rust monorepo
• single app: support creating single app, a single microservice directory.
  • go-zero
  • gin
  • go-micro
• can be used individually or in combination
• usage:
  • Create the mono-repo root directory first
  • Switch to app/, create single app single microservice directory.

Development Roadmap:

• https://github.com/better-go/cookiecutter-go/projects/1

Intro:

• go-zero microservice:
  • Integrate air tool, watch project code, automatic compilation + hot reload, make go development smoother (like Python/Js)
  • rpc: integrated grpc
  • log: integrated uber log
  • db: integrate gorm + mysql
  • cache: integrate redis
  • mq: integrate rabbitmq
  • Service Discovery: Integrate etcd
  • cronjob: integrate cronjob
• go-kratos microservice:
  • Integrate go-kratos scaffolding built-in components
  • integrated air tool
  • integrated grpc/http
• gin microservice:
  • Integrate air tool, watch project code, automatic compilation + hot reload, make go development smoother (like Python/Js)
  • rpc: integrated grpc
  • log: integrated uber log
  • db: integrate gorm + mysql
  • cache: integrate redis
  • mq: integrate rabbitmq
  • Service Discovery: Integrate etcd
  • cronjob: integrate cronjob
• go-micro microservice:
  • Integrate air tool, watch project code, automatic compilation + hot reload, make go development smoother (like Python/Js)
  • rpc: integrated grpc
  • log: integrated uber log
  • db: integrate gorm + mysql

User Case:

• https://github.com/zeromicro/zeromall
  • Microservice B2B2C e-commerce platform based on go-zero

Quick Start:

Install:

• https://cookiecutter.readthedocs.io/en/1.7.2/installation.html

# Mac OS X install cookiecutter:
brew install cookiecutter

# Python + pipx:
brew install pipx
pipx ensurepath
pipx install cookiecutter

# Debian/Ubuntu:
sudo apt-get install cookiecutter

Best Practice:

• choice 1: create mono-repo + single-app
  • support templates:
    • go-zero
    • gin
    • go-micro
• choice 2: create library-repo

1. Mono-Repo + Single-App

• 1.1 create mono repo:

git repo / project root.

Elevate according to command line parameters, gradually create.

cd your-workspace/

# In the current directory, create the root directory of the go-zero mono repo project
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="mono-repo/go-zero"


# In the current directory, create the gin mono repo project root directory
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="mono-repo/gin"


# In the current directory, create the root directory of the go-micro mono repo project
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="mono-repo/go-micro"

• 1.2 create single app folder:

cd your-mono-repo-app-create-root/


# In the current directory, create a microservice directory: use go-zero
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="single-app/go-zero"


# In the current directory, create a microservice directory: use gin
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="single-app/gin"

# In the current directory, create a microservice directory: use go-micro
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="single-app/go-micro"

• tips:
  • Path parameters, do not add suffix : /
  • If go_module_name is different from project_folder_name, be careful not to pass it wrong.

2. create library repo:

• library-repo

cd your-workspace/

# In the current directory, create the mono repo project root directory:
cookiecutter https://github.com/better-go/cookiecutter-go.git --directory="library-repo"

Generate Project Folder Structure:

• Mono Repo:

• Brief description of directory structure: a quick look of the overall directory.

-> % tree . -L 3
.
├── app
│ ├── basic // Basic services: usually business-agnostic
│ │ ├── demo // Example:
│ │ └── user // user management:
│  ├── biz // Business Services: Segmentation according to business
│ │ └── member // Member service:
│ │ └── order // order service:
│ │ └── cart // Shopping cart service:
│ └── std // Unified definition within the business:
│ ├── proto // Unified definition of business status code
├── deploy // deployment script, service orchestration
│   ├── local
│   │   └── Makefile
│   └── staging
│       └── Makefile
├── infra // infrastructure
│   └── tool
└── pkg // Utility code base accumulated by the project, not related to business

• Detailed description of directory structure:

-> % tree . -L 6
.
├── LICENSE
├── Makefile
├── README.MD
├── app
│ ├── basic // Basic service unit 1: general services unrelated to user management/push/SMS/etc.
│ │ ├── demo // Example of a single microservice:
│ │ │ │ ├── cmd // Single-service startup entry: including multiple startup methods:
│   │   │   │   └── main.go                         // api server, grpc server, job server, admin server 启动
│ │ │ │ ├── configs // External middleware configuration items: db, cache, mq, etc.
│   │   │   │   └── configs.toml
│ │ │ │ ├── docs // single-service documentation
│ │ │ │ ├── internal // business logic (not exposed)
│ │ │ │ │ ├── dao // data layer read/write
│ │ │ │ │ │ │ ├── cache // cache r/w
│   │   │   │   │   ├── db                          //      db crud
│ │ │ │ │ │ ├── http // Call http api outside this service
│ │ │ │ │ │ ├── meta.go // dao resource convergence
│   │   │   │   │   ├── mq                          //      mq r/w
│ │ │ │ │ │ └── rpc // call rpc(gRPC) api outside this service
│ │ │ │ │ ├── domain // In-service business split:
│ │ │ │ │ │ └── demo // Business Unit 1 / Business Unit 2
│ │ │ │ │ └── service // API convergence layer (external convergence internal logic, exposed API: grpc/http/job/admin)
│   │   │   │       └── service.go
│ │ │ │ └── proto // Data definition layer: (exposed to the outside world)
│ │ │ │ ├── api // grpc + http api definition
│   │   │       │   └── api.proto
│ │ │ │ ├── config // config toml mapping model
│   │   │       │   └── config.proto
│ │ │ └── model // internal model
Model │ │ └── model.proto
│ │ └── user // Basic service 2:
│ │ ├── identity // within the service
│   │       │   ├── Makefile
│   │       │   ├── cmd
│   │       │   │   └── main.go
│   │       │   ├── configs
│   │       │   │   └── configs.toml
│   │       │   ├── docs
│   │       │   ├── internal
│   │       │   │   ├── dao
│   │       │   │   ├── domain
│   │       │   │   └── service
│   │       │   ├── proto
│   │       │   │   ├── api
│   │       │   │   ├── config
│   │       │   │   └── model
│   │       │   └── readme.md
│   │       └── readme.md
│ ├── biz // Specific business unit:
│ │ │── member // Member service
│   │   │   └── cmd
│   │   │       └── main.go
│ │ └── order // order service
│   │       └── cmd
│   │           └── main.go
│ └── std // Unified definition within the project business (business status code, business error msg number)
│       ├── Makefile
│       ├── proto
│       │   ├── config
│       │   │   └── config.proto
│       │   └── error
│ │ └── code.proto // business status code
│       └── readme.md
├── deploy // Deploy related scripts: dockerfile etc.
│   ├── local
│   │   └── Makefile
│   └── staging
│       └── Makefile
├── go.mod
├── go.sum
├── infra // Plugin dependent services: cli, middleware, etc.
│   └── tool
└── pkg // Utility code base gradually accumulated in the project

46 directories, 24 files

• single app:

-> % tree -L 3 ./single-app/{{cookiecutter.app_name}}
./single-app/{{cookiecutter.app_name}}
├── cmd
│   └── main.go
├── configs
│   └── configs.toml
├── internal
│   └── dao
│       └── db
├── proto
│   └── api
│       └── api.go
└── readme.md

7 directories, 4 files

Call link description:

• Code call link description: Take the app/basic/demo service as an example (top-down call)
  • Cmd startup entry: app/basic/demo/cmd/main.go
  • Service 入口: app/basic/demo/internal/service/service.go
    • External API Gateway: app/basic/demo/internal/service/outer/outer.go
    • Inbound RPC gateway: app/basic/demo/internal/service/inner/inner.go
    • Internal Admin API Gateway: app/basic/demo/internal/service/admin/admin.go
    • Internal Job Gateway: app/basic/demo/internal/service/job/job.go
  • Proto data definition: --API layers: app / basic / demo / proto / api / api.proto
    • Config 层: app/basic/demo/proto/config/config.proto
    • Model 层: app/basic/demo/proto/model/model.proto
  • Router route registration: app/basic/demo/internal/router/router.go
  • Domain business areas:
    • A business unit: app/basic/demo/internal/domain/demo/demo.go
  • Dao data layer operations:
    • Meta aggregation (convergence of Dao layer resources): app/basic/demo/internal/dao/meta.go
    • DB 层: app/basic/demo/internal/dao/db/db.go
    • Cache 层: app / basic / demo / internal / dao / cache / cache.go

User Manual:

• https://github.com/better-go/cookiecutter-go/wiki/manual
• Initialize the microservice directory, how to use it.

Reference:

• https://github.com/better-go/cookiecutter-go/wiki/reference

Contributors:

Henry.Huang

Ferris

Mourad Maatoug