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.

1. Installer go-micro

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

2. Créer un service

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.

3. Service d'enregistrement

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.

4. Service d'appel

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.

5. Emballage et déploiement

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!