Implémentation d'un moteur de recherche distribué en utilisant go-zero

Avec l'avènement de l'ère Internet, le rôle des moteurs de recherche devient de plus en plus important. En tant que l'un des outils les plus couramment utilisés par les utilisateurs d'Internet, les moteurs de recherche nous fournissent non seulement des méthodes de récupération pratiques, mais prennent également en charge le filtrage et la classification des informations sur le réseau. Cependant, pour traiter des volumes de données et des visites d’utilisateurs à grande échelle, l’architecture traditionnelle des moteurs de recherche ne peut plus répondre aux besoins.

L'architecture du moteur de recherche distribué peut résoudre efficacement le problème des goulots d'étranglement de l'architecture traditionnelle. En attribuant différentes tâches à différents nœuds pour l'exécution, elle peut utiliser pleinement les ressources informatiques du cluster et améliorer la vitesse de réponse et la stabilité du système. Dans la technologie d’architecture distribuée actuelle, le framework go-zero est un très excellent choix.

go-zero est un framework de microservices open source léger développé sur la base de Golang. Il fournit un ensemble complet de chaînes d'outils, comprenant la génération de code, la vérification des paramètres, le routage, la journalisation, la gestion des erreurs, la mise en cache, la limitation de courant et d'autres fonctions, ce qui simplifie grandement le développement et la maintenance des microservices. Dans la construction de moteurs de recherche distribués, le framework go-zero peut nous aider à mettre en œuvre rapidement des systèmes hautes performances et haute disponibilité.

Ci-dessous, nous présenterons comment utiliser go-zero pour créer un moteur de recherche distribué avec des exemples.

Étape 1 : Créer l'environnement

Tout d'abord, nous devons installer les frameworks Golang et go-zero. Après l'installation, utilisez la ligne de commande de l'outil fournie par go-zero pour générer un modèle de projet. Entrez :

goctl api new search

dans la ligne de commande pour générer un nouveau projet. Sur cette base, nous pouvons commencer à nous développer.

Étape 2 : Configurer la configuration

Lors du développement d'un moteur de recherche distribué, l'étape la plus importante consiste à définir la configuration distribuée du système. Nous devons créer un fichier de configuration nommé search-api.yaml dans le répertoire racine du projet et y définir les informations de configuration suivantes :

Name: search # 服务名
Description: "搜索服务" # 服务描述
Version: 1.0.0 # 服务版本

Host: 127.0.0.1 # 服务绑定IP地址
Port: 8888 # 服务绑定端口号

Redis:
  Host: 127.0.0.1 # Redis服务地址
  Port: 6379 # Redis服务端口号
  Password: "" # Redis密码

Etcd:
  Hosts:
    - 127.0.0.1:2379 # Etcd集群地址

Dans le fichier de configuration, nous définissons le nom du service, la description, la version et l'adresse de liaison du service et numéro de port, et inclut également les informations de configuration de Redis et Etcd. Parmi eux, Redis est utilisé pour mettre en cache les résultats de recherche et Etcd est utilisé pour implémenter l'enregistrement et la découverte de services.

Étape 3 : Définir l'interface API

Ensuite, nous devons définir l'interface API du moteur de recherche. Dans search/api/search.api, définissez les éléments suivants :

syntax = "proto3";

package search.api;

option go_package = "search/api/search";

message Request {
    string keyword = 1;
    int32 page = 2;
    int32 size = 3;
}

message Response {
    repeated Result result = 1;
}

message Result {
    string title = 1;
    string url = 2;
    string abstract = 3;
}

service Search {
    rpc Query(Request) returns (Response);
}

Dans l'API de recherche, nous définissons les paramètres Request request et Response, ainsi que la structure des résultats de la recherche Result. L'API de recherche comprend une interface de requête, qui accepte les mots-clés de recherche des utilisateurs, les informations de pagination et d'autres paramètres, et renvoie les résultats de la recherche.

Étape 4 : Implémenter la logique métier

Après avoir défini l'interface API, nous pouvons commencer à écrire du code de logique métier. Dans search/internal/search/search.go, le traitement des demandes de recherche et la mise en cache des résultats de recherche sont implémentés. Voir les commentaires pour les détails spécifiques de l'implémentation du code :

package search

import (
    "context"
    "encoding/json"

    "github.com/Yesterday17/go-search-engine/global"
    "github.com/Yesterday17/go-search-engine/internal/search/model"
    "github.com/Yesterday17/go-search-engine/internal/search/service"
    "github.com/Yesterday17/go-zero/core/stores/redis"
    "github.com/Yesterday17/go-zero/rest/httpx"
)

type Search struct {
    redis      *redis.Redis
    searchFunc func(string, int32, int32) ([]model.Result, error)
}

func NewSearch(redis *redis.Redis) *Search {
    return &Search{
        redis: redis,
        searchFunc: service.Search.implement,
    }
}

func (s *Search) Query(ctx context.Context, req *model.Request) (*model.Response, error) {
    resp := &model.Response{}
    key := generateKey(req.Keyword, req.Page, req.Size)

    // 搜索结果缓存
    result, err := s.redis.Get(key).Result()
    if err == nil {
        if err := json.Unmarshal([]byte(result), resp); err != nil {
            return nil, err
        }
        return resp, nil
    }

    result, err = s.searchFunc(req.Keyword, req.Page, req.Size)
    if err != nil {
        return nil, err
    }

    // 将搜索结果序列化为json，存储至redis
    data, err := json.Marshal(result)
    if err != nil {
        return nil, err
    }

    if err := s.redis.Set(key, string(data), global.SearchResultExpire).Err(); err != nil {
        return nil, err
    }

    resp.Result = result
    return resp, nil
}

func generateKey(keyword string, page, size int32) string {
    return "search_" + keyword + "_" + httpx.ConvertIntToString(int(page)) + "_" +
        httpx.ConvertIntToString(int(size))
}

Dans le code, nous implémentons la méthode Query pour recevoir les demandes des utilisateurs et récupérer les résultats de recherche de Redis. Si le résultat de la recherche existe dans Redis, le résultat mis en cache est renvoyé directement ; s'il n'existe pas, la méthode service.Search.implement est appelée pour effectuer la recherche et le résultat de la recherche est sérialisé dans json et mis en cache dans Redis.

Étape 5 : Démarrez le service

La dernière étape consiste à démarrer le service de recherche. Nous exécutons la commande suivante sur la ligne de commande dans le répertoire de recherche :

go run search.go -f api/search.api -s svc.yaml -c search-api.yaml

Une fois le service démarré avec succès, nous pouvons tester l'implémentation de la fonction de recherche en accédant à l'interface localhost:8888/search/query.

Résumé

Cet article explique comment utiliser le framework go-zero pour créer rapidement un moteur de recherche distribué. Dans le développement de systèmes distribués, la flexibilité et l'efficacité du cadre go-zero ont été largement reconnues et ont été largement utilisées dans les microservices et les scénarios commerciaux à forte concurrence. J'espère que cet article sera utile aux lecteurs qui souhaitent maîtriser la technologie de développement de systèmes distribués.

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!