PHP Academy · Leçon

Communication entre services : REST et gRPC

Connectez les services de manière synchrone et efficace.

Communication entre services : REST et gRPC est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

REST et gRPC

Les services doivent communiquer de manière synchrone : une requête est envoyée et une réponse revient. Les deux principales options sont REST sur HTTP/JSON et gRPC sur HTTP/2 + Protobuf. Elles privilégient des aspects différents : REST pour l'accessibilité et la facilité d'utilisation, gRPC pour la rapidité et les contrats stricts.

Cette leçon présente les deux options du point de vue de PHP et explique quand choisir chacune.

REST : la langue commune

REST modélise des ressources accessibles via des URL et utilise les verbes HTTP ainsi que les codes d'état pour exprimer leur sémantique. Ses points forts : un outillage universel, la mise en cache, le débogage avec curl et l'absence de client spécial requis. Ses faiblesses : un JSON verbeux, aucun schéma imposé et une communication limitée aux requêtes et aux réponses.

Pour les API publiques et les points d'accès destinés aux navigateurs, REST est presque toujours le bon choix.

Appeler un service REST

Utilisez un client HTTP PSR-18 (Guzzle ici). Définissez toujours un délai d'attente de connexion et de requête : un appel sans limite vers un pair lent peut épuiser vos processus PHP-FPM et provoquer une panne en cascade.

<?php
require 'vendor/autoload.php';
use GuzzleHttp\Client;

$http = new Client([
    'base_uri'        => 'http://customers-svc/',
    'connect_timeout' => 1.0,  // never block forever on connect
    'timeout'         => 3.0,  // total request budget
    'http_errors'     => false,
]);

$res = $http->get('customers/42', ['headers' => ['Accept' => 'application/json']]);
if ($res->getStatusCode() === 200) {
    $customer = json_decode((string) $res->getBody(), true);
    echo $customer['email'] . "\n";
}

Les codes d'état constituent le contrat

Dans REST entre services, les codes d'état HTTP sont votre protocole d'erreur. Traitez-les délibérément :

2xx indique un succès ; 4xx indique une faute de l'appelant (ne relancez pas aveuglément la requête) ; 5xx et les délais d'attente peuvent faire l'objet d'une nouvelle tentative.
Utilisez 409 pour les conflits, 422 pour la validation et 429 pour les limites de débit (respectez Retry-After).

Relancer une requête 400 ne fait que gaspiller des appels ; relancer une requête 503 avec une temporisation progressive est correct.

<?php
function isRetryable(int $status): bool {
    return $status === 0          // timeout/connection error
        || $status === 429
        || ($status >= 500 && $status !== 501);
}
var_dump(isRetryable(503)); // true
var_dump(isRetryable(400)); // false

gRPC : contrat d'abord et rapidité

gRPC utilise Protocol Buffers : vous définissez les services et les messages dans un fichier .proto, puis générez des squelettes client et serveur fortement typés. Sur HTTP/2, avec Protobuf binaire, l'ensemble est beaucoup plus compact et présente une latence bien plus faible que JSON, tout en prenant en charge la diffusion en continu.

syntax = "proto3";
package customers;

service Customers {
  rpc GetCustomer (GetCustomerRequest) returns (Customer);
}

message GetCustomerRequest { string id = 1; }
message Customer {
  string id = 1;
  string email = 2;
  int32  loyalty_points = 3;
}

Génération des squelettes PHP

Installez l'extension gRPC de PHP et le module d'extension de protoc, puis générez les classes clientes à partir du fichier .proto. PHP peut agir comme un client gRPC complet via ext-grpc ; l'exécution d'un serveur gRPC PHP natif nécessite généralement Roadrunner ou Swoole.

pecl install grpc
composer require grpc/grpc google/protobuf

protoc --proto_path=. \
  --php_out=./generated \
  --grpc_out=./generated \
  --plugin=protoc-gen-grpc=$(which grpc_php_plugin) \
  customers.proto

Un appel client gRPC

Les squelettes générés vous fournissent des requêtes et des réponses typées. Un appel gRPC renvoie le message et un objet status — vérifiez toujours le code d'état avant de faire confiance à la réponse.

<?php
require 'vendor/autoload.php';
use Customers\CustomersClient;
use Customers\GetCustomerRequest;
use Grpc\ChannelCredentials;

$client = new CustomersClient('customers-svc:50051', [
    'credentials' => ChannelCredentials::createInsecure(),
]);

$req = (new GetCustomerRequest())->setId('42');
[$reply, $status] = $client->GetCustomer($req)->wait();

if ($status->code === \Grpc\STATUS_OK) {
    echo $reply->getEmail(), "\n";
} else {
    fwrite(STDERR, "gRPC error: {$status->details}\n");
}

Évolution des schémas

Protobuf est conçu pour assurer la compatibilité ascendante et descendante, à condition de respecter ses règles :

Ne réutilisez ni ne modifiez jamais le numéro d'un champ. Ajoutez les nouveaux champs avec de nouveaux numéros.
Marquez les champs supprimés comme reserved afin que leur numéro ne puisse pas être réutilisé.
Les anciens clients ignorent les champs inconnus ; les champs absents prennent les valeurs par défaut de leur type.

JSON/REST ne vous offre rien de tout cela gratuitement : vous devez imposer la compatibilité par convention (et, idéalement, utiliser un schéma OpenAPI partagé avec des tests de contrat).

message Customer {
  string id = 1;
  string email = 2;
  reserved 3;            // old 'loyalty_points', never reuse 3
  reserved "loyalty_points";
  string display_name = 4; // new field, safe additive change
}

Diffusion en continu

gRPC prend en charge quatre types d'appels ; REST ne prend nativement en charge que le premier :

Unaire — une requête, une réponse.
Diffusion côté serveur — une requête, un flux de réponses (par exemple, des mises à jour en direct).
Diffusion côté client — un flux de requêtes, une réponse (par exemple, un téléversement en masse).
Bidirectionnel — les deux flux sont actifs simultanément.

Si votre cas d'utilisation implique un envoi poussé ou un flux de données de longue durée, la diffusion gRPC est préférable à l'interrogation répétée d'un point d'accès REST.

Propagation du contexte et des échéances

Les appels synchrones forment des chaînes ; deux éléments doivent donc accompagner chaque requête : un identifiant de corrélation ou de trace pour le traçage de bout en bout, et une échéance afin qu'un service feuille lent ne puisse pas bloquer toute la chaîne. gRPC prend nativement en charge les échéances ; avec REST, vous les reproduisez au moyen d'un budget de délai d'attente décroissant transmis aux services en aval.

<?php
// REST: shrink the remaining budget as the call chain deepens
function forwardHeaders(array $incoming, float $remainingMs): array {
    return [
        'X-Correlation-Id' => $incoming['X-Correlation-Id'] ?? bin2hex(random_bytes(8)),
        // downstream must finish within what's left of our budget
        'X-Timeout-Ms'     => (string) max(0, (int) $remainingMs),
    ];
}
print_r(forwardHeaders(['X-Correlation-Id' => 'trace-9'], 1500));

Choisir entre ces protocoles

Guide pratique pour décider :

REST pour les API publiques ou destinées aux partenaires, les clients de navigateur, les opérations CRUD simples, le débogage facile et une prise en charge étendue de la mise en cache.
gRPC pour les appels internes entre services, à fort volume et faible latence, les contrats typés stricts et la diffusion en continu.

De nombreux systèmes utilisent les deux : gRPC derrière la passerelle, entre les services, et REST à la périphérie pour le monde extérieur. N'imposez pas à un outil de faire le travail de l'autre.

Vérification rapide

Associer le protocole au cas d'utilisation.

Bilan

Communication synchrone entre services :

REST/JSON — universel, facile à déboguer et compatible avec la mise en cache ; les codes d'état constituent le contrat ; définissez toujours des délais d'attente.
gRPC/Protobuf — contrat d'abord, compact, rapide et compatible avec la diffusion en continu ; générez des squelettes PHP typés.
Déterminez la possibilité d'une nouvelle tentative à partir des codes d'état ou des codes gRPC ; ne relancez jamais les erreurs du client.
Faites évoluer les schémas de manière additive — ne réutilisez jamais les numéros de champs Protobuf.
REST à la périphérie et gRPC entre les services internes constituent un découpage courant et judicieux.

Ensuite : acheminer et localiser tous ces services grâce aux passerelles et à la découverte de services.

Questions Fréquemment Posées

La leçon « Communication entre services : REST et gRPC » est-elle gratuite ?

Oui — le texte complet de « Communication entre services : REST et gRPC » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Communication entre services : REST et gRPC » ?

Connectez les services de manière synchrone et efficace. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Communication entre services : REST et gRPC » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Du monolithe aux microservices
Communication entre services : REST et gRPC
Passerelles d’API et découverte de services
Résilience : disjoncteurs et nouvelles tentatives

← Retour à PHP Academy