Heim > Backend-Entwicklung > Golang > Anwendungsbeispiel: Mit go-micro ein Microservice-Empfehlungssystem aufbauen

Anwendungsbeispiel: Mit go-micro ein Microservice-Empfehlungssystem aufbauen

王林
Freigeben: 2023-06-18 12:43:41
Original
1800 Leute haben es durchsucht

Mit der Popularität von Internetanwendungen ist die Microservice-Architektur zu einer beliebten Architekturmethode geworden. Unter anderem besteht der Schlüssel zur Microservice-Architektur darin, die Anwendung in verschiedene Dienste aufzuteilen und über RPC zu kommunizieren, um eine lose gekoppelte Service-Architektur zu erreichen. In diesem Artikel stellen wir vor, wie man mit go-micro ein Microservice-Empfehlungssystem basierend auf tatsächlichen Fällen erstellt.

1. Was ist ein Microservice-Empfehlungssystem?

Ein Microservice-Empfehlungssystem ist ein Empfehlungssystem, das auf einer Microservice-Architektur basiert. Es unterteilt verschiedene Module im Empfehlungssystem (z. B. Feature Engineering, Klassifikatoren, Sortierer usw.). Der Dienst kommuniziert über RPC, um ein effizientes, skalierbares und einfach zu wartendes Empfehlungssystem zu realisieren. Das Microservice-Empfehlungssystem kann auf Empfehlungsszenarien in verschiedenen vertikalen Bereichen wie E-Commerce, Musik, Video usw. angewendet werden.

2. So implementieren Sie ein Microservice-Empfehlungssystem

go-micro ist ein Microservice-Framework, das auf der Go-Sprache basiert. Es bietet allgemeine Funktionen wie Dienstregistrierung und -erkennung, Lastausgleich, RPC-Kommunikation usw. und eignet sich sehr gut zum Aufbau einer Microservices-Architektur. Als nächstes stellen wir vor, wie man mit go-micro ein Microservice-Empfehlungssystem implementiert. „go-micro installieren“ Architektur, wir müssen das Empfehlungssystem umwandeln. Verschiedene Module darin sind in verschiedene Dienste aufgeteilt. Hier nehmen wir das Feature-Engineering als Beispiel für die Implementierung eines Feature-Engineering-Dienstes.

    Erstellen Sie zunächst lokal ein Go-Modul mit dem Namen feature_engineering:
  1. go get github.com/micro/go-micro/v2
    Nach dem Login kopieren
  2. Dann erstellen wir einen Dienst zum Implementieren von Feature-Engineering-bezogenen Funktionen. Hier nehmen wir „Feature-Extraktion aus historischem Benutzerverhalten“ als Beispiel und implementieren den folgenden Code:
mkdir -p feature_engineering
cd feature_engineering
go mod init feature_engineering
Nach dem Login kopieren

In diesem Dienst implementieren wir eine RPC-Methode namens ExtractFeatures, um Anforderungen vom Client zu empfangen und die angegebenen historischen Verhaltensmerkmale des Benutzers zu extrahieren an den Kunden zurückgegeben.

  1. Registrierungsdienst

Um Dienste verschiedener Module auf verschiedenen Maschinen bereitzustellen, müssen Dienstregistrierung und -erkennung implementiert werden. In go-micro können Sie Registrierungszentren wie etcd oder consul verwenden, um die Registrierung und Erkennung von Diensten zu implementieren. Hier verwenden wir etcd als Registry.

Sie können den folgenden Befehl verwenden, um etcd zu starten:

package main

import (
    "context"
    "github.com/micro/go-micro/v2"
    pb "github.com/username/recommender/protos"
    "log"
)

type FeatureEngineeringService struct{}

func (s *FeatureEngineeringService) ExtractFeatures(ctx context.Context, req *pb.ExtractFeaturesRequest, rsp *pb.ExtractFeaturesResponse) error {
    log.Printf("Extracting features for user %d", req.UserId)
    rsp.Features = []float32{0.1, 0.2, 0.3}
    return nil
}

func main() {
    // Create service
    service := micro.NewService(
        micro.Name("go.micro.service.feature_engineering"),
    )

    // Initialise service
    service.Init()

    // Register handler
    pb.RegisterFeatureEngineeringHandler(service.Server(), new(FeatureEngineeringService))

    // Run the server
    if err := service.Run(); err != nil {
        log.Fatal(err)
    }
}
Nach dem Login kopieren

Nach dem Start können Sie http://localhost:2379/v2/keys/ besuchen, um zu überprüfen, ob etcd normal läuft.

Dann müssen wir uns im Dienst registrieren. Sie können nach service.Init() den folgenden Code hinzufügen:

docker run -p 2379:2379 -p 2380:2380 
    --name etcd 
    -v /tmp/etcd:/etcd-data 
    etcd:latest 
    /usr/local/bin/etcd 
    --name my-etcd-1 
    --data-dir /etcd-data 
    --advertise-client-urls http://0.0.0.0:2379 
    --listen-client-urls http://0.0.0.0:2379 
    --initial-advertise-peer-urls http://0.0.0.0:2380 
    --listen-peer-urls http://0.0.0.0:2380 
    --initial-cluster my-etcd-1=http://0.0.0.0:2380
Nach dem Login kopieren
    Dieser Code verwendet etcd als Registrierungszentrum und registriert den Dienst in etcd.
Anrufdienst

In anderen Diensten können wir den von go-micro bereitgestellten Client verwenden, um RPC-Anrufe zu tätigen. Das Folgende ist ein Codebeispiel für den Aufruf des Feature-Engineering-Dienstes:

import (
    "github.com/micro/go-micro/v2/registry"
    "github.com/micro/go-plugins/registry/etcdv3/v2"
)

// Create new registry
etcdRegistry := etcdv3.NewRegistry(
    registry.Addrs("127.0.0.1:2379"),
)

// Register service
if err := etcdRegistry.Register(service.Options().Service); err != nil {
    log.Fatal(err)
}
Nach dem Login kopieren

Dieser Code verwendet etcd als Registrierungszentrum und erstellt über den von go-micro bereitgestellten Client einen Client für den Feature-Engineering-Service. Rufen Sie dann die ExtractFeatures-Methode auf und drucken Sie das Rückgabeergebnis aus. Es ist zu beachten, dass der übergebene Parameter go.micro.service.feature_engineering der Name des Feature-Engineering-Dienstes ist, der durch Ausführen des Befehls etcdctl get /micro/config angezeigt werden kann.

Paketierung und Bereitstellung

    Schließlich müssen wir verschiedene Dienste paketieren und auf verschiedenen Maschinen bereitstellen. Sie können Docker zum Packen und Bereitstellen über Kubernetes verwenden oder den Dienst manuell auf jeder Maschine starten.
  1. 3. Zusammenfassung

Durch diesen Artikel können wir die Vorteile der Microservice-Architektur verstehen und erfahren, wie man mit go-micro ein effizientes, skalierbares und einfach zu wartendes Microservice-Empfehlungssystem aufbaut. Natürlich ist Go-Micro nur eines von vielen Microservice-Frameworks, und der Leser kann das geeignete Framework für die Entwicklung entsprechend seinen eigenen Anforderungen auswählen. Kurz gesagt, die Microservice-Architektur ist zur Mainstream-Methode für die Entwicklung von Internetanwendungen geworden und wird in Zukunft zweifellos immer beliebter.

Das obige ist der detaillierte Inhalt vonAnwendungsbeispiel: Mit go-micro ein Microservice-Empfehlungssystem aufbauen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage