GitHub - zeromicro/go-zero: A cloud-native Go microservices framework with cli tool for productivity. (original) (raw)

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

In early 2018, we transitioned from a Java+MongoDB monolithic architecture to microservices, choosing:

Golang - High performance, simple syntax, excellent deployment experience, and low resource consumption
Self-designed microservice framework - Better problem isolation, easier feature extension, and faster issue resolution

Design considerations on go-zero

go-zero follows these core design principles:

Simplicity - Keep it simple, first principle
High availability - Stable under high concurrency
Resilience - Failure-oriented programming with adaptive protection
Developer friendly - Encapsulate complexity, one way to do one thing
Easy to extend - Flexible architecture for growth

The implementation and features of go-zero

go-zero integrates engineering best practices:

Code generation - Powerful tools to minimize boilerplate
Simple API - Clean interfaces, fully compatible with net/http
High performance - Optimized for speed and efficiency
Resilience - Built-in circuit breaker, rate limiting, load shedding, timeout control
Service mesh - Service discovery, load balancing, call tracing
Developer tools - Auto parameter validation, cache management, metrics and monitoring

Architecture with go-zero

Installation

Run the following command under your project:

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

AI-Native Development

The go-zero team provides AI tooling for Claude, GitHub Copilot, Cursor to generate framework-compliant code.

Three Core Projects

ai-context - Workflow guide for AI assistants

zero-skills - Pattern library with examples

mcp-zero - Code generation tools via Model Context Protocol

Quick Setup

GitHub Copilot

git submodule add https://github.com/zeromicro/ai-context.git .github/ai-context ln -s ai-context/00-instructions.md .github/copilot-instructions.md # macOS/Linux

Windows: mklink .github\copilot-instructions.md .github\ai-context\00-instructions.md

git submodule update --remote .github/ai-context # Update

Cursor

git submodule add https://github.com/zeromicro/ai-context.git .cursorrules git submodule update --remote .cursorrules # Update

Windsurf

git submodule add https://github.com/zeromicro/ai-context.git .windsurfrules git submodule update --remote .windsurfrules # Update

Claude Desktop

git clone https://github.com/zeromicro/mcp-zero.git && cd mcp-zero && go build

Configure: ~/Library/Application Support/Claude/claude_desktop_config.json

Or: claude mcp add --transport stdio mcp-zero --env GOCTL_PATH=/path/to/goctl -- /path/to/mcp-zero

How It Works

AI assistants use these tools together:

ai-context - workflow guidance
zero-skills - implementation patterns
mcp-zero - real-time code generation

Example: Creating a REST API → AI reads ai-context for workflow → calls mcp-zero to generate code → references zero-skills for patterns → produces production-ready code ✅

Quick Start

Full examples:
Rapid development of microservice systems
Rapid development of microservice systems - multiple RPCs
Install goctl

for Go

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

For Mac

brew install goctl

docker for all platforms

docker pull kevinwan/goctl

run goctl

docker run --rm -it -v pwd:/app kevinwan/goctl --help
Ensure goctl is executable and in your $PATH. 3. Create the API file (greet.api):
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)
}
Generate .api template: 4. Generate Go server code
goctl api go -api greet.api -dir greet
Generated structure:

├── 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

Run the service:
cd greet
go mod tidy
go run greet.go -f etc/greet-api.yaml
Default port: 8888 (configurable in etc/greet-api.yaml)
Test with curl:
curl -i http://localhost:8888/greet/from/you
Response:
HTTP/1.1 200 OK
Date: Sun, 30 Aug 2020 15:32:35 GMT
Content-Length: 0 5. Write business logic

Pass dependencies (mysql, redis, etc.) via servicecontext.go
Add logic code in the logic package per .api definition

Generate client code for multiple languages
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 this project or are using it to learn or start your own solution, give it a star to get updates on new releases. Your support matters!