Créez des services API à haute concurrence : utilisez go-zero pour implémenter

Avec l'avènement de l'ère du Big Data, la quantité de données que les entreprises doivent traiter devient de plus en plus importante et la vitesse de traitement est de plus en plus rapide. Par conséquent, il devient très important de créer des services API à haute concurrence. Dans cet article, nous expliquerons comment utiliser le framework go-zero pour créer des services API à haute concurrence.

1. Qu'est-ce que le go-zéro ?

go-zero est un framework de microservices développé sur la base du langage Golang. Son objectif est de résoudre les problèmes de l'architecture des microservices, tels que la configuration complexe, la gestion des middlewares, l'enregistrement des services et d'autres problèmes. go-zero prend en charge la construction rapide d'API, de middleware et de services RPC hautes performances, et fournit un riche ensemble de composants et de chaînes d'outils.

2. Pourquoi utiliser le go-zéro ?

L'utilisation de go-zero peut apporter les avantages suivants :

1. Hautes performances

go-zero utilise un grand nombre de technologies d'optimisation, notamment les E/S asynchrones, le pool de coroutines sous-jacent, etc. Par conséquent, ses performances sont très élevées et il peut gérer un grand nombre de requêtes simultanées.

2. Facile à étendre

go-zero fournit un grand nombre de composants et de chaînes d'outils, et vous pouvez rapidement étendre vos propres services via des fichiers de configuration sans réécrire le code.

3. Haute fiabilité

go-zero utilise de nombreuses technologies stables, telles que des centres d'enregistrement de services tels que etcd et Consul, pour garantir la fiabilité de l'ensemble du système.

4. Haute efficacité de développement

Le développement de l'API de go-zero est basé sur Swagger/OpenAPI, il peut donc générer des documents et des clients, améliorant ainsi l'efficacité du développement.

3. Comment utiliser go-zero pour créer un service API à haute concurrence ?

Étape 1 : Installer go-zero

go-zero utilise un grand nombre de technologies d'optimisation, notamment les E/S asynchrones, le pool de coroutines sous-jacent, etc. Par conséquent, ses performances sont très élevées et il peut gérer un grand nombre de requêtes simultanées.

Étape 2 : Créer une API

Pour créer une API simple, nous devons créer un répertoire api sous le répertoire du projet et créer un fichier à l'intérieur, tel que user.api, puis écrire le contenu suivant dans le fichier :

type (
    UserReq struct {
        Name  string `json:"name"`
        Age   int    `json:"age"`
        Email string `json:"email"`
    }

    UserResp struct {
        Id       int    `json:"id"`
        UserName string `json:"username"`
        Age      int    `json:"age"`
        Email    string `json:"email"`
    }

    UserApi interface {
        AddUser(ctx context.Context, req UserReq) (*UserResp, error)
        UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error)
        GetUser(ctx context.Context, id int) (*UserResp, error)
    }
)

type (
    // 具体实现自己根据需要实现
    DefaultUserApi struct {
    }
)

func (ua *DefaultUserApi) AddUser(ctx context.Context, req UserReq) (*UserResp, error) {
    // 具体实现自己根据需要实现
    return nil, errors.New("not implement")
}

func (ua *DefaultUserApi) UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error) {
    // 具体实现自己根据需要实现
    return nil, errors.New("not implement")
}

func (ua *DefaultUserApi) GetUser(ctx context.Context, id int) (*UserResp, error) {
    // 具体实现自己根据需要实现
    return nil, errors.New("not implement")
}

Étape 3 : Utilisez goctl pour générer du code

# 安装goctl
GO111MODULE=on GOPROXY=https://goproxy.io,direct go get -u github.com/tal-tech/go-zero/tools/goctl
# 生成代码
goctl api go -api user.api -dir .

générera le fichier user.go dans le répertoire, qui contient notre structure et notre interface personnalisées, ainsi que certaines structures et fonctions générées par go-zero lui-même.

Étape 4 : Implémenter une logique spécifique

Dans le fichier user.go, nous devons implémenter notre propre logique spécifique, par exemple :

package api

import (
    "context"
    "errors"

    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/rest/httpx"
)

type (
    UserReq struct {
        Name  string `json:"name"`
        Age   int    `json:"age"`
        Email string `json:"email"`
    }

    UserResp struct {
        Id       int    `json:"id"`
        UserName string `json:"username"`
        Age      int    `json:"age"`
        Email    string `json:"email"`
    }

    UserApi interface {
        AddUser(ctx context.Context, req UserReq) (*UserResp, error)
        UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error)
        GetUser(ctx context.Context, id int) (*UserResp, error)
    }
)

type (
    // 具体实现自己根据需要实现
    DefaultUserApi struct {
    }
)

func (ua *DefaultUserApi) AddUser(ctx context.Context, req UserReq) (*UserResp, error) {
    // 具体实现
    logx.Info("add user:", req)
    return &UserResp{
        Id:       10001,
        UserName: req.Name,
        Age:      req.Age,
        Email:    req.Email,
    }, nil
}

func (ua *DefaultUserApi) UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error) {
    // 具体实现
    logx.Info("update user:", id, req)
    return &UserResp{
        Id:       id,
        UserName: req.Name,
        Age:      req.Age,
        Email:    req.Email,
    }, nil
}

func (ua *DefaultUserApi) GetUser(ctx context.Context, id int) (*UserResp, error) {
    // 具体实现
    logx.Info("get user:", id)
    return &UserResp{
        Id:       id,
        UserName: "张三",
        Age:      25,
        Email:    "zhangsan@mail.com",
    }, nil
}

func (ua *DefaultUserApi) Error(ctx context.Context, err error) {
    httpx.Error(ctx, err)
}

Étape 5 : Écrire le fichier de configuration

Créer un répertoire etc dans le répertoire racine du projet , dans lequel Créez un fichier config.toml et écrivez le contenu suivant :

Name = "user"

[server]
Host = "0.0.0.0"
Port = 8888
Mode = "dev"

[etcd]
Hosts = [
    "127.0.0.1:2379"
]

[redis]
Host = "127.0.0.1:6379"
Type = "standalone"
Password = ""

Parmi eux, Host et Port sous serveur représentent respectivement l'adresse et le port du service en écoute, etcd représente l'adresse du centre d'enregistrement etcd, et redis représente le adresse de redis.

Étape 6 : Démarrez le service

Exécutez la commande suivante dans le répertoire du projet :

go run user.go -f etc/config.toml

signifie démarrer le service API avec config.toml comme fichier de configuration.

Étape 7 : Testez le service

Utilisez curl et d'autres outils pour lancer une requête et tester si l'interface API est disponible. Par exemple :

curl localhost:8888/user -X POST -H "Content-Type: application/json" -d '{"name":"zhangsan", "age": 20, "email": "zhangsan@mail.com"}'

signifie envoyer une requête à la méthode POST de localhost:8888/user, et le corps de la requête contient un objet JSON.

Matériaux de référence :

Documentation officielle de go-zero : https://go-zero.dev/

Adresse github de go-zero : https://github.com/tal-tech/go-zero

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!