Build an efficient microservice API gateway based on go-zero

In recent years, the application of microservice architecture has become more and more widespread. It is service-centric and divides applications into independent functional modules by decoupling services, thereby improving the reliability and scalability of applications. However, in a microservice architecture, due to the large number of services, communication between services inevitably increases complexity. At this point, the API gateway becomes an essential component. In this article, we will introduce go-zero's method of building an efficient microservice API gateway.

What is API Gateway

API gateway is a server that handles ingress traffic, forwards requests and responses. It is the middle layer between the client and the server. In the microservice architecture, the API gateway mainly plays the following two roles:

• Provides a unified interface to the outside world
• Performs request routing and interface proxy internally

As an architectural model, API gateway also has the following characteristics:

• Responsible for forwarding external incoming requests to internal services
• Conduct requests according to different conditions Routing, filtering and transformation
• Provides services such as authentication, security and current limiting

go-zero framework

go-zero is a microservice The web and rpc framework of the architecture is committed to providing high concurrency processing capabilities and simple and easy-to-use programming interfaces. It is built on the Golang standard library and can achieve efficient network request processing based on the concurrency capabilities and memory management advantages of the Go language.

The go-zero framework provides a Web framework, an RPC framework, a microservice framework and a series of peripheral tools. The most important component is the go-zero microservice framework. This framework is very flexible and can be customized according to specific business needs. It also has the following advantages:

• High performance: Based on Golang’s high concurrency and low memory consumption features, go-zero implements High performance network processing and resource utilization.
• Scalability: go-zero supports layered development and can isolate high-load services into independent layers to ensure stability and scalability.
• High reliability: go-zero uses comprehensive testing methods to ensure the correctness of system functions, and integrates high-availability designs such as retry, fuse, and current limiting to improve the reliability of the system.
• Rich tool chain: go-zero provides many tools to help us quickly develop and deploy services.

go-zero builds API gateway

Next, we will introduce the steps for go-zero to build API gateway:

Step one: define the interface

First we need to define some API interfaces. Suppose we define three interfaces:

GET /api/user/{id}
POST /api/user
DELETE /api/user/{id}

Step 2: Write microservices

Next, we need to write microservices that handle these interfaces. Serve. In go-zero, microservices can be implemented by defining Handlers. These Handlers can be automatically generated by the framework and integrated into the service to be called by the API gateway.

The sample code is as follows:

package service

import "github.com/tal-tech/go-zero/rest"

type Request struct {
    Id int `json:"id"`
}
type Response struct {
    Data string `json:"data"`
}

type Service interface {
    GetUser(*Request) (*Response, error)
    AddUser(*Request) (*Response, error)
    DeleteUser(*Request) (*Response, error)
}

type UserService struct {
}

func NewUserService() *UserService {
    return &UserService{}
}

func (s *UserService) GetUser(req *Request) (*Response, error) {
    return &Response{
        Data: "get user success",
    }, nil
}

func (s *UserService) AddUser(req *Request) (*Response, error) {
    return &Response{
        Data: "add user success",
    }, nil
}

func (s *UserService) DeleteUser(req *Request) (*Response, error) {
    return &Response{
        Data: "delete user success",
    }, nil
}

func (s *UserService) HttpHandlers() []rest.Handler {
    return []rest.Handler{
        rest.Get("/api/user/:id", s.GetUser),
        rest.Post("/api/user", s.AddUser),
        rest.Delete("/api/user/:id", s.DeleteUser),
    }
}

In the above code, we define a Service interface, which contains three methods, corresponding to the three interfaces defined previously. At the same time, we need to implement the HttpHandlers interface, which can directly route requests to the corresponding processing function by implementing the rest.Handler interface.

Step 3: Configure API Gateway

Next, we need to configure relevant information in the API gateway, such as routing, current limiting policy, service discovery, etc. go-zero provides a tool called goctl that can help us quickly create and manage microservices and API gateways.

1. Install the goctl tool:

   The installation of the goctl tool is very simple. You only need to install it through the following naming:

   $ curl -sSL https://git.io/godev | bash

2. Create API gateway:

   You can use the following command to create an API gateway:

   $ goctl api new gateway

   After executing this command, goctl will automatically generate a code framework for the API gateway.

3. Configure routing:

   We need to add relevant routing configuration after defining the api interface. In go-zero, you can use Group and Proxy for routing configuration, and you can also use methods such as WithJwtAuth, WithCircuitBreaker, etc. Route filtering and control.

   The sample code is as follows:

   package api
   
   import (
      "github.com/tal-tech/go-zero/rest"
      "github.com/tal-tech/go-zero/zrpc"
      "gateway/internal/service"
   )
   
   type Api struct {
      rest.RestHandler
   }
   
   func NewApi() (*Api, error) {
      userService := service.NewUserService()
      cli := zrpc.MustNewClient(zrpc.RpcClientConf{
         ServiceConf: zrpc.ServiceConf{
            Name: "gateway",
            Etcd: zrpc.EtcdConf{
               Endpoints: []string{"localhost:2379"},
               Key:       "rpc",
               Timeout:   5000,
            },
            Middleware: []zrpc.Middleware{
               zrpc.NewClientMiddleware(),
            },
         },
      })
      handler := rest.NewGroupRouter("/api").
         GET("/user/:id", rest.WithNoti(func(ctx *rest.RestContext) error {
               response, err := userService.GetUser(&service.Request{Id: ctx.Request.Params["id"]})
               if err != nil {
                  return nil
               }
               ctx.SendJson(response)
               return nil
            })).
         POST("/user", rest.WithNoti(func(ctx *rest.RestContext) error {
               response, err := userService.AddUser(&service.Request{})
               if err != nil {
                  return nil
               }
               ctx.SendJson(response)
               return nil
            })).
         DELETE("/user/:id", rest.WithNoti(func(ctx *rest.RestContext) error {
               response, err := userService.DeleteUser(&service.Request{Id: ctx.Request.Params["id"]})
               if err != nil {
                  return nil
               }
               ctx.SendJson(response)
               return nil
            })).
         Proxy(func(ctx *rest.RestContext) error {
               err := zrpc.Invoke(ctx, cli, "gateway", ctx.Request.Method, ctx.Request.URL.Path, ctx.Request.Params, &ctx.Output.Body)
               if err != nil {
                  return err
               }
               return nil
            })
      return &Api{
         RestHandler: handler,
      }, nil
   }

We can see that in the above code, the request of api is routed to userServiceDefined processing function, and use Proxy to forward other undefined requests to the specified service.

After defining the API, you can start the API gateway service:

$ go run main.go -f etc/gateway-api.yaml 

After successful startup, you can access the interface provided by the API gateway.

Summary

The steps to build an efficient microservice API gateway based on go-zero are as follows:

• Define API interface
• Write microservice
• Configure API Gateway
• Start API Gateway Service

go-zero is a very flexible, high-performance, and scalable microservice framework. It not only It provides Web framework, RPC framework and microservice framework, and also provides a series of peripheral tools to help us quickly build efficient microservice applications.

Through the above steps, we can easily build an efficient and powerful microservice API gateway, thereby providing a highly scalable and high-performance architectural foundation for our applications.

The above is the detailed content of Build an efficient microservice API gateway based on go-zero. For more information, please follow other related articles on the PHP Chinese website!