【PHP Microservice Architecture Practice】 Une stratégie complète pour réaliser les files d'attente de messages distribuées et la communication entre les services

introduction

Avec l'expansion continue des activités Internet, la complexité du système augmente également. Afin d'atteindre une plus grande disponibilité, maintenabilité et évolutivité, de plus en plus d'entreprises commencent à adopter des architectures de microservice. Dans cette architecture, les files d'attente de messages deviennent un mécanisme important pour la communication asynchrone entre les services. Cet article explorera en profondeur comment utiliser l'architecture de microservice PHP pour implémenter les files d'attente de messages distribuées et les méthodes de communication, et fournir des explications détaillées en combinaison avec RabbitMQ, HTTP et RPC.

Présentation de l'architecture de microservice

Les microservices sont un modèle architectural qui divise les applications monolithiques dans un groupe de petits services. Chaque service est construit autour de fonctions commerciales spécifiques et possède une base de données indépendante, un processus de déploiement et de maintenance. Des mécanismes de communication légers sont utilisés entre les services, tels que HTTP, RPC ou les files d'attente de messages, pour interagir. Cette architecture permet d'améliorer la flexibilité du système, les capacités d'isolement des défauts et la vitesse de réponse globale.

Implémentation de files d'attente de messages distribués dans PHP

Dans un environnement distribué, les files d'attente de messages sont utilisées pour traiter les demandes de manière asynchrone, améliorant le débit et la stabilité du système. RabbitMQ est actuellement largement utilisé au middleware de messagerie distribuée, prend en charge plusieurs protocoles et langues et convient aux scénarios de concurrence élevés.

Installation et utilisation de RabbitMQ

Tout d'abord, vous devez installer RabbitMQ et vous pouvez obtenir des instructions d'installation sur son site Web officiel en fonction du système d'exploitation. Une fois l'installation terminée, le modèle de base du producteur et des consommateurs peut être implémenté via le code PHP suivant.

Exemples de producteur et de consommation de lapin

require_once __dir __. '/ vendeur / autoload.php';

Utilisez phpamqplib \ connection \ amqpStreamConnection;
Utilisez phpamqplib \ message \ amqpMessage;

// producteur $ connection = new AmqPStreamConnection («localhost», 5672, «invité», «invité»);
$ canal = $ connection-> canal ();
$ channel-> queue_declare ('bonjour', false, false, false, false);

$ msg = new AmqpMessage («Hello World!»);
$ channel-> Basic_publish ($ msg, '', 'bonjour');

echo "[x] a envoyé 'Hello World!' \ n";

$ canal-> close ();
$ connection-> close ();

// consommateur $ connection = new AmqPStreamConnection («localhost», 5672, «invité», «invité»);
$ canal = $ connection-> canal ();
$ channel-> queue_declare ('bonjour', false, false, false, false);

echo "[*] en attente de messages. Pour quitter, appuyez sur Ctrl + C \ n";

$ callback = fonction ($ msg) {
  echo '[x] reçu', $ msg-> corps, "\ n";
};

$ channel-> basic_consume ('bonjour', '', false, true, false, false, $ callback);

while ($ canal-> is_consuming ()) {
  $ canal-> wait ();
}

Diriger les producteurs et les consommateurs

Exécutez les commandes suivantes dans le terminal:

PHP producteur.php
php consommateur.php

Après l'exécution, le producteur envoie le message à la file d'attente et le consommateur écoute et traite le message. Ce mécanisme prend en charge le traitement simultané multi-consommateur et améliore les performances du système.

Méthode de communication PHP Microservice

La communication entre les microservices est un lien clé dans le fonctionnement du système. Voici trois méthodes de communication traditionnelles.

1. Utilisez HTTP pour la communication de service

HTTP est le protocole de communication de service le plus courant, adapté aux demandes apatrides. Le client HTTP couramment utilisé dans PHP est Guzzle.

exiger «fournisseur / autoload.php»;

Utilisez Guzzlehttp \ Client;

$ client = nouveau client ();
$ réponse = $ client-> request ('get', 'https://example.com');
echo $ réponse-> getBody ();

2. Utilisez le protocole RPC pour passer des appels efficaces

RPC (appel de procédure à distance) permet d'appeler les services distants entre les microservices comme les fonctions locales. Les bibliothèques qui prennent en charge RPC dans PHP incluent GRPC et Thrift.

require_once 'vendeur / autoload.php';

Utilisez Helloworld \ Hellorequest;
Utilisez Helloworld \ GreeterClient;

$ client = new GreeterClient ('LocalHost: 50051', [
  'Identials' => Grpc \ ChannelCredentials :: CreateInSecure (),
]));

$ request = new Hellorequest ();
$ request-> setName ('world');

$ réponse = $ client-> Sayhello ($ request);
echo $ réponse-> getMessage ();

3. Communication asynchrone avec file d'attente de messages

L'article précédent montre l'utilisation de RabbitMQ pour implémenter la communication asynchrone entre les services. Cette méthode présente les avantages d'un fort découplage, d'une tolérance élevée à la faille et d'une bonne évolutivité. Il convient à des scénarios tels que la file d'attente de tâches, la journalisation et le traitement des commandes.

Résumer

La construction d'une architecture de microservice via PHP et l'intégration des files d'attente de messages distribuées et des mécanismes de communication est un moyen important de construire des systèmes modernes de haute performance. RabbitMQ implémente la communication couplée de manière lâche entre les services, HTTP convient aux appels de service réguliers et RPC convient aux interactions à faible latence et à haute fréquence. La combinaison de ces technologies peut considérablement améliorer la robustesse et la réactivité du système.