PHP Microservice Practice: A Guide to Service Discovery and Load Balancing Implémentation

Découverte de services et équilibrage de charge dans les microservices PHP

La découverte de services et l'équilibrage de la charge sont des fonctions de base lors de la construction de systèmes distribués. La découverte de services est utilisée pour identifier automatiquement les services et leurs emplacements de réseau dans le système, tandis que l'équilibrage des charges est responsable de la distribution raisonnable des demandes à plusieurs instances de service pour améliorer la haute disponibilité et les performances du système.

Cet article partagera des méthodes spécifiques et des exemples de codes pour implémenter ces deux fonctions dans les microservices PHP.

Découverte de service

Le but de la découverte de services est de trouver toutes les instances de service disponibles et de fournir leur emplacement de réseau à d'autres services. Dans PHP Microservices, les instances de service peuvent être gérées via le registre. Un registre est un service centralisé qui enregistre tous les services disponibles dans le système et leurs informations réseau.

Voici un exemple PHP qui montre comment implémenter la découverte de services à l'aide du registre:

 Classe Registry {
    SERVICES STATIQUES PRIVÉS = [];
    
    Registerservice de fonction statique publique ($ ServiceName, $ hôte, $ port) {
        self :: $ Services [$ ServiceName] [] = [
            'host' => $ hôte,
            'port' => $ port,
        ]]
    }
    
    Fonction statique publique getService ($ ServiceName) {
        $ Services = self :: $ Services [$ ServiceName] ?? [];
        $ index = mt_rand (0, count ($ services) - 1);
        retourner $ services [$ index] ?? nul;
    }
}

Registry :: Registerservice («utilisateur-service», «localhost», 8001);
Registry :: Registerservice («utilisateur-service», «localhost», 8002);
Registry :: Registerservice («Order-Service», «LocalHost», 9001);

$ userService = Registry :: getService ('utilisateur-service');
$ orderService = Registry :: getService ('Order-Service');

Echo "Service utilisateur:". $ userService ['hôte']. ":". $ userService ['port']. "\ n";
Echo "Service de commande:". $ orderService ['hôte']. ":". $ ORDERSERVICE ['PORT']. "\ n";

La classe de registre est définie dans l'exemple de l'enregistrement et de l'obtention de services. La méthode Registerservice est utilisée pour enregistrer une instance de service et la méthode GetService est utilisée pour obtenir une instance aléatoire d'un certain service. Les développeurs peuvent étendre les fonctionnalités en fonction de la demande, comme l'ajout de dates d'expiration des services ou de contrôles de santé.

Équilibrage de charge

L'équilibrage de charge permet une haute disponibilité et une optimisation des performances du système en distribuant des demandes à plusieurs instances de service. Dans les microservices PHP, les algorithmes couramment utilisés comprennent le sondage, la sélection aléatoire et le hasard pondéré.

Voici un exemple de PHP qui met en œuvre l'algorithme d'équilibrage de la charge de sondage:

 classe chargée de chargement {
    SERVICES STATIQUES PRIVÉS = [];
    index statique privé = 0;
    
    Fonction statique publique AddService ($ ServiceName, $ hôte, $ port) {
        self :: $ Services [$ ServiceName] [] = [
            'host' => $ hôte,
            'port' => $ port,
        ]]
    }
    
    Fonction statique publique getService ($ ServiceName) {
        $ Services = self :: $ Services [$ ServiceName] ?? [];
        $ index = self :: $ index% Count ($ services);
        self :: $ index ++;
        retourner $ services [$ index] ?? nul;
    }
}

LoadBalancer :: AddService («User-Service», «LocalHost», 8001);
LoadBalancer :: AddService («User-Service», «LocalHost», 8002);
LoadBalancer :: AddService («Order-Service», «LocalHost», 9001);

pour ($ i = 0; $ i <10; $ i ++) {
    $ userService = LoadBalancer :: getService (&#39;utilisateur-service&#39;);
    Echo "Service utilisateur:". $ userService [&#39;hôte&#39;]. ":". $ userService [&#39;port&#39;]. "\ n";
}

Dans l'exemple, la classe LoadBalancer est utilisée pour ajouter des instances de service et un sondage pour obtenir des services. En maintenant l'index, l'instance de service suivante est retournée à son tour chaque fois que vous appelez GetService, en réalisant l'équilibrage de charge de sondage simple.

Résumer

La découverte de services et l'équilibrage de charge sont le fondement de l'architecture de microservice PHP. Utilisez le registre pour gérer uniformément les instances de service, tandis que les algorithmes d'équilibrage de charge peuvent améliorer les performances et la stabilité du système. Les exemples fournis dans cet article sont basés sur des implémentations, et les développeurs peuvent se développer et optimiser en fonction des besoins réels de l'entreprise.