go-zero

go-zero is a web and rpc framework with lots of builtin engineering practices. It’s born to ensure the stability of the busy services with resilience design and has been serving sites with tens of millions of users for years.

🤷‍ What is go-zero?

English | 简体中文

go-zero (listed in CNCF Landscape: https://landscape.cncf.io/?selected=go-zero) is a web and rpc framework with lots of builtin engineering practices. It’s born to ensure the stability of the busy services with resilience design and has been serving sites with tens of millions of users for years.

go-zero contains simple API description syntax and code generation tool called goctl. You can generate Go, iOS, Android, Kotlin, Dart, TypeScript, JavaScript from .api files with goctl.

Advantages of go-zero:

Improves the stability of the services with tens of millions of daily active users
Builtin chained timeout control, concurrency control, rate limit, adaptive circuit breaker, adaptive load shedding, even no configuration needed
Builtin middlewares also can be integrated into your frameworks
Simple API syntax, one command to generate a couple of different languages
Auto validate the request parameters from clients
Plenty of builtin microservice management and concurrent toolkits

Backgrounds of go-zero

At the beginning of 2018, we decided to re-design our system, from monolithic architecture with Java+MongoDB to microservice architecture. After research and comparison, we chose to: In early 2018, we embarked on a transformative journey to redesign our system, transitioning from a monolithic architecture built with Java and MongoDB to a microservices architecture. After careful research and comparison, we made a deliberate choice to:

Go Beyond with Golang
- Great performance
- Simple syntax
- Proven engineering efficiency
- Extreme deployment experience
- Less server resource consumption
Self-Design Our Microservice Architecture
- Microservice architecture facilitates the creation of scalable, flexible, and maintainable software systems with independent, reusable components.
- Easy to locate the problems within microservices.
- Easy to extend the features by adding or modifying specific microservices without impacting the entire system.

Design considerations on go-zero

By designing the microservice architecture, we expected to ensure stability, as well as productivity. And from just the beginning, we have the following design principles:

Keep it simple
High availability
Stable on high concurrency
Easy to extend
Resilience design, failure-oriented programming
Try best to be friendly to the business logic development, encapsulate the complexity
One thing, one way

After almost half a year, we finished the transfer from a monolithic system to microservice system and deployed on August 2018. The new system guaranteed business growth and system stability.

The implementation and features of go-zero

go-zero is a web and rpc framework that integrates lots of engineering practices. The features are mainly listed below:

Powerful tool included, less code to write
Simple interfaces
Fully compatible with net/http
Middlewares are supported, easy to extend
High performance
Failure-oriented programming, resilience design
Builtin service discovery, load balancing
Builtin concurrency control, adaptive circuit breaker, adaptive load shedding, auto-trigger, auto recover
Auto validation of API request parameters
Chained timeout control
Auto management of data caching
Call tracing, metrics, and monitoring
High concurrency protected

As below, go-zero protects the system with a couple of layers and mechanisms:

The simplified architecture that we use with go-zero

Installation

Run the following command under your project:

go get -u github.com/zeromicro/go-zero

Quick Start

Full examples can be checked out from below:

Rapid development of microservice systems

Rapid development of microservice systems - multiple RPCs

Install goctl

goctlcan be read as go control. goctl means not to be controlled by code, instead, we control it. The inside go is not golang. At the very beginning, I was expecting it to help us improve productivity, and make our lives easier.

# for Go
go install github.com/zeromicro/go-zero/tools/goctl@latest

# For Mac
brew install goctl

# docker for amd64 architecture
docker pull kevinwan/goctl
# run goctl like
docker run --rm -it -v `pwd`:/app kevinwan/goctl --help

# docker for arm64(Mac) architecture
docker pull kevinwan/goctl:latest-arm64
# run goctl like
docker run --rm -it -v `pwd`:/app kevinwan/goctl:latest-arm64 --help

make sure goctl is executable.

Create the API file, like greet.api, you can install the plugin of goctl in vs code, api syntax is supported.

type (
  Request {
    Name string `path:"name,options=[you,me]"` // parameters are auto validated
  }

  Response {
    Message string `json:"message"`
  }
)

service greet-api {
  @handler GreetHandler
  get /greet/from/:name(Request) returns (Response)
}

the .api files also can be generated by goctl, like below:

goctl api -o greet.api

Generate the go server-side code

goctl api go -api greet.api -dir greet

the generated files look like:

├── greet
│   ├── etc
│   │   └── greet-api.yaml        // configuration file
│   ├── greet.go                  // main file
│   └── internal
│       ├── config
│       │   └── config.go         // configuration definition
│       ├── handler
│       │   ├── greethandler.go   // get/put/post/delete routes are defined here
│       │   └── routes.go         // routes list
│       ├── logic
│       │   └── greetlogic.go     // request logic can be written here
│       ├── svc
│       │   └── servicecontext.go // service context, mysql/redis can be passed in here
│       └── types
│           └── types.go          // request/response defined here
└── greet.api                     // api description file

the generated code can be run directly:

cd greet
go mod init
go mod tidy
go run greet.go -f etc/greet-api.yaml

by default, it’s listening on port 8888, while it can be changed in the configuration file.

you can check it by curl:

curl -i http://localhost:8888/greet/from/you

the response looks like below:

HTTP/1.1 200 OK
Date: Sun, 30 Aug 2020 15:32:35 GMT
Content-Length: 0

Write the business logic code
- the dependencies can be passed into the logic within servicecontext.go, like mysql, redis, etc.
- add the logic code in a logic package according to .api file

Generate code like Java, TypeScript, Dart, JavaScript, etc. just from the api file

goctl api java -api greet.api -dir greet
goctl api dart -api greet.api -dir greet
...

Benchmark

Checkout the test code

Documents

Chat group

Join the chat via https://discord.gg/4JQvC5A4Fe

Cloud Native Landscape

go-zero enlisted in the CNCF Cloud Native Landscape.

Give a Star! ⭐

If you like or are using this project to learn or start your solution, please give it a star. Thanks!

cubxxw/go-zero