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: go get github.com/micro/go-micro/v2
Nach dem Login kopieren
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.
- 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:2380Nach 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. - 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!
