Maison >développement back-end >Golang >Exemple d'application : utilisez go-micro pour créer un système de recommandation de microservices
Avec la popularité des applications Internet, l'architecture des microservices est devenue une méthode d'architecture populaire. Parmi eux, la clé de l'architecture des microservices est de diviser l'application en différents services et de communiquer via RPC pour obtenir une architecture de services faiblement couplée. Dans cet article, nous présenterons comment utiliser go-micro pour créer un système de recommandation de microservices basé sur des cas réels.
1. Qu'est-ce qu'un système de recommandation de microservices ?
Un système de recommandation de microservices est un système de recommandation basé sur une architecture de microservices. Il sépare les différents modules du système de recommandation (tels que l'ingénierie des fonctionnalités, les classificateurs, les trieurs, etc.) Le service communique via RPC pour réaliser un système de recommandation efficace, évolutif et facile à entretenir. Le système de recommandation de microservices peut être appliqué à des scénarios de recommandation dans divers domaines verticaux, tels que le commerce électronique, la musique, la vidéo, etc.
2. Comment utiliser go-micro pour implémenter un système de recommandation de microservices
go-micro est un framework de microservices basé sur le langage Go. Il fournit des fonctions courantes telles que l'enregistrement et la découverte de services, l'équilibrage de charge, la communication RPC, etc. et est très approprié pour une utilisation pour construire une architecture de microservices. Nous présenterons ensuite comment utiliser go-micro pour implémenter un système de recommandation de microservices.
Tout d'abord, nous devons installer localement le framework go-micro, qui peut être installé à l'aide de la commande suivante :
go get github.com/micro/go-micro/v2
Selon l'idée du microservice architecture, nous devons convertir le système de recommandation. Différents modules y sont divisés en différents services. Ici, nous prenons l'ingénierie des fonctionnalités comme exemple pour implémenter un service d'ingénierie des fonctionnalités.
Tout d'abord, créons localement un module go nommé feature_engineering :
mkdir -p feature_engineering cd feature_engineering go mod init feature_engineering
Ensuite, nous créons un service pour implémenter les fonctions liées à l'ingénierie des fonctionnalités. Ici, nous prenons comme exemple "l'extraction de fonctionnalités à partir du comportement historique de l'utilisateur" et implémentons le code suivant :
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) } }
Dans ce service, nous implémentons une méthode RPC nommée ExtractFeatures pour recevoir les requêtes du client et extraire les caractéristiques comportementales historiques spécifiées. restitué au client.
Pour déployer des services de différents modules sur différentes machines, l'enregistrement et la découverte des services doivent être implémentés. Dans go-micro, vous pouvez utiliser des centres d'enregistrement tels que etcd ou consul pour mettre en œuvre l'enregistrement et la découverte des services. Ici, nous utilisons etcd comme registre.
Vous pouvez utiliser la commande suivante pour démarrer etcd :
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
Après le démarrage, vous pouvez visiter http://localhost:2379/v2/keys/ pour vérifier si etcd fonctionne normalement.
Ensuite, nous devons nous inscrire dans le service. Vous pouvez ajouter le code suivant après service.Init() :
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) }
Ce code utilisera etcd comme centre d'enregistrement et enregistrera le service dans etcd.
Dans d'autres services, nous pouvons utiliser le client fourni par go-micro pour passer des appels RPC. Voici un exemple de code pour appeler le service d'ingénierie de fonctionnalités :
package main import ( "context" "fmt" "github.com/micro/go-micro/v2" "github.com/micro/go-micro/v2/registry" "github.com/micro/go-plugins/registry/etcdv3/v2" pb "github.com/username/recommender/protos" ) func main() { // Create new registry etcdRegistry := etcdv3.NewRegistry( registry.Addrs("127.0.0.1:2379"), ) // Create new service service := micro.NewService( micro.Registry(etcdRegistry), ) // Initialise service service.Init() // Call feature engineering service featureEngineeringClient := pb.NewFeatureEngineeringService("go.micro.service.feature_engineering", service.Client()) rsp, err := featureEngineeringClient.ExtractFeatures(context.TODO(), &pb.ExtractFeaturesRequest{UserId: 1}) if err != nil { fmt.Println(err) } fmt.Printf("Features: %v", rsp.Features) }
Ce code utilisera etcd comme centre d'enregistrement et créera un client pour le service d'ingénierie de fonctionnalités via le client fourni par go-micro. Appelez ensuite la méthode ExtractFeatures et imprimez le résultat renvoyé. Il convient de noter que le paramètre go.micro.service.feature_engineering transmis est le nom du service d'ingénierie de fonctionnalités, qui peut être affiché en exécutant la commande etcdctl get /micro/config.
Enfin, nous devons empaqueter différents services et les déployer sur différentes machines. Vous pouvez utiliser Docker pour l'empaquetage et le déploiement via Kubernetes, ou vous pouvez démarrer manuellement le service sur chaque machine.
3. Résumé
Grâce à cet article, nous pouvons comprendre les avantages de l'architecture des microservices et comment utiliser go-micro pour créer un système de recommandation de microservices efficace, évolutif et facile à maintenir. Bien entendu, go-micro n'est qu'un des nombreux frameworks de microservices, et les lecteurs peuvent choisir le framework de développement approprié en fonction de leurs propres besoins. En bref, l'architecture des microservices est devenue la méthode principale de développement d'applications Internet et deviendra sans aucun doute plus populaire à l'avenir.
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!