Go Zero

A cloud-native Go microservices framework with cli tool for productivity.
Alternatives To Go Zero
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
a day ago64cc-by-sa-4.0Dockerfile
:white_check_mark: The Node.js best practices list (July 2023)
Dubbo39,4105,4611643 hours ago59December 29, 20211,005apache-2.0Java
The java implementation of Apache Dubbo. An RPC and microservice framework.
Go Zero25,5782622 days ago154July 14, 2023396mitGo
A cloud-native Go microservices framework with cli tool for productivity.
a day ago105apache-2.0Go
The API traffic analyzer for Kubernetes providing real-time K8s protocol-level visibility, capturing and monitoring all traffic and payloads going in, out and across containers, pods, nodes and clusters. Inspired by Wireshark, purposely built for Kubernetes
Falcon9,2411,52118723 days ago75November 18, 2022157apache-2.0Python
The no-magic web data plane API and microservices framework for Python developers, with a focus on reliability, correctness, and performance at scale.
5 days ago193apache-2.0C++
🌱Light and powerful C++ web framework for highly scalable and resource-efficient web application. It's zero-dependency and easy-portable.
Goa5,299688 hours ago127July 24, 202310mitGo
Design-based APIs and microservices in Go
Spring Boot Projects4,551
7 months ago2apache-2.0Java
:fire: 该仓库中主要是 Spring Boot 的入门学习教程以及一些常用的 Spring Boot 实战项目教程,包括 Spring Boot 使用的各种示例代码,同时也包括一些实战项目的项目源码和效果展示,实战项目包括基本的 web 开发以及目前大家普遍使用的线上博客项目/企业大型商城系统/前后端分离实践项目等,摆脱各种 hello world 入门案例的束缚,真正的掌握 Spring Boot 开发。
Nodejs Integration Tests Best Practices2,983
2 months ago42JavaScript
✅ Beyond the basics of Node.js testing. Including a super-comprehensive best practices list and an example app (July 2022)
Go Chassis2,698633a month ago80November 10, 202238apache-2.0Go
a cloud native application framework for Go with rich eco-system
Alternatives To Go Zero
Select To Compare

Alternative Project Comparisons


go-zero is a web and rpc framework with lots of builtin engineering practices. Its 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 codecov Go Report Card Release Go Reference Awesome Go License: MIT Discord

What is go-zero?

English |

go-zero - A web & rpc framework written in Go. | Product Hunt

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. Its 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:

  • improve 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:

  • Golang based
    • great performance
    • simple syntax
    • proven engineering efficiency
    • extreme deployment experience
    • less server resource consumption
  • Self-designed microservice architecture
    • I have rich experience in designing microservice architectures
    • easy to locate the problems
    • easy to extend the features

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



Run the following command under your project:

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

Quick Start

  1. full examples can be checked out from below:

    Rapid development of microservice systems

    Rapid development of microservice systems - multiple RPCs

  2. 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 goctl --help
    # docker for arm64 (M1) architecture
    docker pull kevinwan/goctl:latest-arm64
    # run goctl like
    docker run --rm -it -v `pwd`:/app kevinwan/goctl:latest-arm64 goctl --help

    make sure goctl is executable.

  3. 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
  4. generate the go server-side code

    goctl api go -api greet.api -dir greet

    the generated files look like:

       greet-api.yaml        // configuration file
      greet.go                  // main file
           config.go         // configuration definition
           greethandler.go   // get/put/post/delete routes are defined here
           routes.go         // routes list
           greetlogic.go     // request logic can be written here
           servicecontext.go // service context, mysql/redis can be passed in here
              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, its 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
  5. Write the business logic code

    • the dependencies can be passed into the logic within servicecontext.go, like mysql, reds, etc.
    • add the logic code in a logic package according to .api file
  6. 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



Checkout the test code


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!

Buy me a coffee

Buy Me A Coffee

Popular Microservices Projects
Popular Rest Projects
Popular Application Programming Interfaces Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Rest Api
Restful Api
Web Framework
Code Generation
Cloud Native
Rpc Framework
Grpc Gateway
Microservice Framework