Implementierung einer verteilten Suchmaschine mit Go-Zero

Mit dem Aufkommen des Internetzeitalters wird die Rolle von Suchmaschinen immer wichtiger. Als eines der am häufigsten verwendeten Tools für Internetnutzer bieten Suchmaschinen uns nicht nur komfortable Suchmethoden, sondern unterstützen auch beim Filtern und Klassifizieren von Netzwerkinformationen. Für die Verarbeitung großer Datenmengen und Benutzerbesuche kann die traditionelle Suchmaschinenarchitektur jedoch nicht mehr den Anforderungen gerecht werden.

Die verteilte Suchmaschinenarchitektur kann das Engpassproblem in der herkömmlichen Architektur effektiv lösen, indem sie verschiedenen Knoten verschiedene Aufgaben zur Ausführung zuweist, wodurch die Rechenressourcen des Clusters vollständig genutzt und die Reaktionsgeschwindigkeit und Stabilität des Systems verbessert werden. In der aktuellen verteilten Architekturtechnologie ist das Go-Zero-Framework eine ausgezeichnete Wahl.

go-zero ist ein leichtes Open-Source-Microservice-Framework, das auf Basis von Golang entwickelt wurde. Es bietet einen vollständigen Satz an Toolketten, einschließlich Codegenerierung, Parameterüberprüfung, Routing, Protokollierung, Fehlerbehandlung, Caching, Strombegrenzung und anderen Funktionen, was die Entwicklung und Wartung von Microservices erheblich vereinfacht. Beim Aufbau verteilter Suchmaschinen kann uns das Go-Zero-Framework dabei helfen, schnell leistungsstarke und hochverfügbare Systeme zu implementieren.

Im Folgenden stellen wir anhand von Beispielen vor, wie Sie mit Go-Zero eine verteilte Suchmaschine erstellen.

Schritt 1: Erstellen Sie die Umgebung

Zuerst müssen wir die Golang- und Go-Zero-Frameworks installieren. Verwenden Sie nach der Installation die von go-zero bereitgestellte Tool-Befehlszeile, um eine Projektvorlage zu generieren. Geben Sie:

goctl api new search

in die Befehlszeile ein, um ein neues Projekt zu generieren. Auf dieser Grundlage können wir mit der Entwicklung beginnen.

Schritt 2: Konfiguration einrichten

Bei der Entwicklung einer verteilten Suchmaschine besteht der wichtigste Schritt darin, die verteilte Konfiguration des Systems zu definieren. Wir müssen eine Konfigurationsdatei mit dem Namen search-api.yaml im Stammverzeichnis des Projekts erstellen und darin die folgenden Konfigurationsinformationen definieren:

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集群地址

In der Konfigurationsdatei definieren wir den Dienstnamen, die Beschreibung, die Version und die Dienstbindungsadresse und Portnummer und enthält auch die Konfigurationsinformationen von Redis und Etcd. Unter anderem wird Redis zum Zwischenspeichern von Suchergebnissen und Etcd zum Implementieren der Dienstregistrierung und -erkennung verwendet.

Schritt 3: Definieren Sie die API-Schnittstelle

Als nächstes müssen wir die API-Schnittstelle der Suchmaschine definieren. Definieren Sie in search/api/search.api Folgendes:

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

In der Such-API definieren wir die Parameter „Request request“ und „Response“ sowie die Suchergebnisstruktur „Result“. Die Such-API umfasst eine Abfrageschnittstelle, die Benutzersuchschlüsselwörter, Paging-Informationen und andere Parameter akzeptiert und Suchergebnisse zurückgibt.

Schritt 4: Geschäftslogik implementieren

Nachdem wir die API-Schnittstellendefinition haben, können wir mit dem Schreiben von Geschäftslogikcode beginnen. In search/internal/search/search.go ist die Verarbeitung von Suchanfragen und das Zwischenspeichern von Suchergebnissen implementiert. Spezifische Details zur Code-Implementierung finden Sie in den Kommentaren:

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

Im Code implementieren wir die Query-Methode, um Benutzeranfragen zu empfangen und Suchergebnisse von Redis abzurufen. Wenn das Suchergebnis in Redis vorhanden ist, wird das zwischengespeicherte Ergebnis direkt zurückgegeben. Wenn es nicht vorhanden ist, wird die Methode service.Search.implement aufgerufen, um die Suche durchzuführen, und das Suchergebnis wird in JSON serialisiert und in Redis zwischengespeichert.

Schritt 5: Dienst starten

Der letzte Schritt besteht darin, den Suchdienst zu starten. Wir führen den folgenden Befehl auf der Befehlszeile im Suchverzeichnis aus:

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

Nachdem der Dienst erfolgreich gestartet wurde, können wir die Implementierung der Suchfunktion testen, indem wir auf die Schnittstelle localhost:8888/search/query zugreifen.

Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit dem Go-Zero-Framework schnell eine verteilte Suchmaschine erstellen. In der verteilten Systementwicklung sind die Flexibilität und Effizienz des Go-Zero-Frameworks weithin anerkannt und werden häufig in Microservices und Geschäftsszenarien mit hoher Parallelität eingesetzt. Ich hoffe, dass dieser Artikel für Leser hilfreich ist, die die Technologie der verteilten Systementwicklung beherrschen möchten.

Das obige ist der detaillierte Inhalt vonImplementierung einer verteilten Suchmaschine mit Go-Zero. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!