Créez une passerelle API de microservices efficace basée sur le go-zero

Ces dernières années, l'application de l'architecture de microservices est devenue de plus en plus répandue. Elle est centrée sur les services et divise les applications en modules fonctionnels indépendants en découplant les services, améliorant ainsi la fiabilité et l'évolutivité des applications. Cependant, dans une architecture de microservices, en raison du grand nombre de services, la communication entre les services augmente inévitablement la complexité. À ce stade, la passerelle API devient un composant essentiel. Dans cet article, nous présenterons la méthode go-zero pour créer une passerelle API de microservice efficace.

Qu'est-ce qu'une passerelle API

Une passerelle API est un serveur qui gère le trafic entrant, transmet les requêtes et les réponses. C'est la couche intermédiaire entre le client et le serveur. Dans l'architecture des microservices, la passerelle API joue principalement les deux rôles suivants :

• Fournir une interface unifiée avec le monde extérieur
• Fournir le routage des requêtes et le proxy d'interface en interne

En tant que modèle architectural, la passerelle API présente également les caractéristiques suivantes :

• Responsable de l'acheminement des demandes externes entrantes vers les services internes
• Routage, filtrage et transformation des demandes selon différentes conditions
• Fournir des services tels que l'authentification, la sécurité et la limitation de courant

Cadre go-zero

go-zero est un framework web et rpc pour l'architecture de microservices, dédié à fournir des capacités de traitement hautement simultanées et des interfaces de programmation simples et faciles à utiliser. Il est construit sur la bibliothèque standard Golang et peut réaliser un traitement efficace des requêtes réseau basé sur les capacités de concurrence et les avantages de gestion de la mémoire du langage Go.

Le framework go-zero fournit un framework Web, un framework RPC, un framework de microservices et une série d'outils périphériques. Le composant le plus important est le framework de microservices go-zero. Ce framework est très flexible et peut être personnalisé en fonction des besoins spécifiques de l'entreprise. Il présente également les avantages suivants :

• Hautes performances : basé sur les fonctionnalités de haute concurrence et de faible consommation de mémoire de Golang, go-zero implémente un traitement et des ressources réseau hautes performances. utiliser.
• Évolutivité : go-zero prend en charge le développement en couches et peut isoler les services à forte charge en couches indépendantes pour garantir la stabilité et l'évolutivité.
• Haute fiabilité : go-zero utilise des méthodes de test complètes pour garantir l'exactitude des fonctions du système et intègre des conceptions à haute disponibilité telles que les nouvelles tentatives, les fusibles et la limitation de courant pour améliorer la fiabilité du système.
• Chaîne d'outils riche : go-zero fournit de nombreux outils pour nous aider à développer et déployer rapidement des services.

go-zero construit une passerelle API

Ensuite, nous présenterons les étapes permettant à go-zero de créer une passerelle API :

Étape 1 : Définir l'interface

Nous devons d'abord définir certaines interfaces API, en supposant que nous avons défini trois interfaces :

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

Étape 2 : Écrire des microservices

Ensuite, nous devons écrire des microservices qui gèrent ces interfaces. En go-zero, les microservices peuvent être implémentés en définissant des Handlers. Ces Handlers peuvent être automatiquement générés par le framework et intégrés au service pour être appelés par la passerelle API. Handlers来实现，这些Handlers可以被框架自动生成，并集成到服务中提供给API网关调用。

示例代码如下：

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),
    }
}

在上述代码中，我们定义了一个Service接口，其中包含三个方法，分别对应前面定义的三个接口。同时，我们需要实现HttpHandlers接口，该接口可以通过实现rest.Handler接口，直接将请求路由到对应的处理函数中。

第三步：配置API网关

接下来，我们需要在API网关中配置相关信息，如路由、限流策略、服务发现等。go-zero提供了一个名为goctl的工具，可以帮助我们快速创建和管理微服务和API网关。

1. 安装goctl工具：

   goctl工具的安装非常简单，只需要通过以下命名进行安装即可：

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

2. 创建API网关：

   可以使用以下命令创建API网关：

   $ goctl api new gateway

   执行该命令后，goctl会自动生成一个API网关的代码框架。

3. 配置路由：

   我们需要在定义api接口后，添加相关的路由配置。在go-zero中，可以使用Group和Proxy进行路由配置，同时也可以使用WithJwtAuth、WithCircuitBreaker等方法，进行路由过滤和控制。

   示例代码如下：

   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
   }

我们可以看到，在上述代码中，将api的请求路由到了userService定义的处理函数中，并使用Proxy

L'exemple de code est le suivant :

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

Dans le code ci-dessus, nous définissons une interface Service, qui contient trois méthodes, correspondant aux trois interfaces définies précédemment. Dans le même temps, nous devons implémenter l'interface HttpHandlers, qui peut directement acheminer les requêtes vers la fonction de traitement correspondante en implémentant l'interface rest.Handler.

Étape 3 : Configurer API Gateway

Ensuite, nous devons configurer les informations pertinentes dans API Gateway, telles que le routage, la politique de limitation actuelle, la découverte de services, etc. go-zero fournit un outil appelé goctl qui peut nous aider à créer et gérer rapidement des microservices et des passerelles API.

Installer l'outil goctl :
• L'installation de l'outil goctl est très simple, il suffit de l'installer en le nommant :
• rrreee
• Créer une passerelle API :
• Vous pouvez utiliser la commande suivante pour créer une Passerelle API :

rrreee

Après avoir exécuté cette commande, goctl générera automatiquement un framework de code de passerelle API.

🎜Configurer le routage : 🎜🎜Nous devons ajouter une configuration de routage pertinente après avoir défini l'interface api. En go-zero, vous pouvez utiliser Group et Proxy pour la configuration du routage, et vous pouvez également utiliser WithJwtAuth et WithCircuitBreaker et d'autres méthodes pour effectuer le filtrage et le contrôle des itinéraires. 🎜🎜L'exemple de code est le suivant : 🎜rrreee🎜🎜Nous pouvons voir que dans le code ci-dessus, la requête de api est acheminée vers la fonction de traitement définie par userService et utilisez <code>Proxy pour transmettre d'autres requêtes non définies au service spécifié. 🎜🎜Après avoir défini l'API, vous pouvez démarrer le service API gateway : 🎜rrreee🎜Après un démarrage réussi, vous pouvez accéder à l'interface fournie par la passerelle API. 🎜🎜Résumé🎜🎜Les étapes pour créer une passerelle API de microservices efficace basée sur le go-zero sont les suivantes : 🎜🎜🎜Définir l'interface API 🎜🎜Écrire des microservices 🎜🎜Configurer la passerelle API 🎜🎜Démarrer le service de passerelle API 🎜🎜🎜go-zero est un framework de microservices très flexible, hautes performances et évolutif. Il fournit non seulement un framework Web, un framework RPC et un framework de microservices, mais fournit également une série d'outils périphériques qui peuvent nous aider à créer rapidement des applications de microservices efficaces. 🎜🎜Grâce aux étapes ci-dessus, nous pouvons facilement créer une passerelle API de microservices efficace et puissante, fournissant ainsi une base architecturale hautement évolutive et hautes performances pour nos applications. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!