PHP Academy · Lektion

Tjänstekommunikation: REST och gRPC

Anslut tjänster synkront och effektivt.

Lektion 2 av 413 steg

Tjänstekommunikation: REST och gRPC är en gratis lektion i PHP Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för PHP Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i PHP Academy innehåller totalt 4 lektioner.

REST och gRPC

Tjänster behöver kommunicera synkront: en förfrågan skickas ut och ett svar kommer tillbaka. De två dominerande alternativen är REST över HTTP/JSON och gRPC över HTTP/2 + Protobuf. De är optimerade för olika saker — REST för räckvidd och användarvänlighet, gRPC för hastighet och strikta kontrakt.

Den här lektionen visar båda ur ett PHP-perspektiv och när ni bör välja respektive alternativ.

REST: det gemensamma språket

REST modellerar resurser bakom URL:er och använder HTTP-metoder och statuskoder för semantik. Dess styrkor är universella verktyg, cachningsmöjlighet, felsökning med curl och att inga särskilda klienter behövs. Dess svagheter är utförlig JSON, avsaknad av ett tvingande schema samt att det endast stöder förfrågan och svar.

För offentliga API:er och webbläsarnära slutpunkter är REST nästan alltid rätt.

Anropa en REST-tjänst

Använd en PSR-18 HTTP-klient (Guzzle här). Ange alltid en timeout för anslutning och anrop — ett obegränsat anrop till en långsam motpart kan tömma era PHP-FPM-workers och orsaka ett kaskadfel.

<?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";
}

Statuskoderna är kontraktet

I REST-kommunikation mellan tjänster är HTTP-statuskoderna själva felprotokollet. Hantera dem medvetet:

2xx betyder lyckat; 4xx är anroparens fel (gör inte blint omförsök); 5xx och timeouts kan försöka igen.
Använd 409 för konflikter, 422 för validering och 429 för anropsfrekvensbegränsningar (respektera Retry-After).

Att försöka igen efter en 400 slösar bara anrop; att försöka igen efter en 503 med backoff är korrekt.

<?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: kontraktsstyrt och snabbt

gRPC använder Protocol Buffers: ni definierar tjänster och meddelanden i en .proto-fil och genererar sedan starkt typade stubbar för klient och server. Via HTTP/2 med binär Protobuf är det betydligt kompaktare och ger lägre latens än JSON, och det stöder streaming.

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;
}

Generera PHP-stubbar

Installera gRPC PHP-tillägget och protoc-pluginen och generera sedan klientklasser från .proto-filen. PHP kan fungera som en fullt utrustad gRPC-klient via ext-grpc; att köra en inbyggd PHP gRPC-server kräver vanligtvis Roadrunner eller 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

Ett gRPC-klientanrop

Genererade stubbar ger er typade förfrågningar och svar. Ett gRPC-anrop returnerar meddelandet och ett status-objekt — kontrollera alltid statuskoden innan ni litar på svaret.

<?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");
}

Schemautveckling

Protobuf är byggt för framåt-/bakåtkompatibilitet — om ni följer reglerna:

Återanvänd eller ändra aldrig ett fältnummer. Lägg till nya fält med nya nummer.
Märk borttagna fält som reserved så att numret inte kan återanvändas.
Äldre klienter ignorerar okända fält; saknade fält får typens standardvärden.

JSON/REST ger inget av detta gratis — ni måste upprätthålla kompatibiliteten genom konvention (och helst med ett delat OpenAPI-schema med kontraktstester).

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
}

Streaming

gRPC stöder fyra anropstyper; REST stöder inbyggt endast den första:

Unary — en förfrågan, ett svar.
Server streaming — en förfrågan, en ström av svar (t.ex. liveuppdateringar).
Client streaming — en ström av förfrågningar, ett svar (t.ex. massuppladdning).
Bidirectional — båda strömmar samtidigt.

Om ert användningsfall gäller push eller ett långvarigt dataflöde är gRPC-streaming bättre än att polla en REST-slutpunkt.

Förmedla kontext och deadlines

Synkrona anrop bildar kedjor, så två saker måste följa med varje förfrågan: ett korrelations-/spårnings-ID för spårning från ände till ände och en deadline så att en långsam lövnod inte får hela kedjan att hänga sig. gRPC har förstklassigt stöd för deadlines; i REST efterliknar ni dem med en krympande timeoutbudget som skickas vidare nedströms.

<?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));

Välja mellan dem

En praktisk vägledning för valet:

REST för offentliga API:er och partner-API:er, webbläsarklienter, enkel CRUD, enkel felsökning och brett cachestöd.
gRPC för interna tjänsteanrop med hög volym och låg latens, strikt typade kontrakt och streaming.

Många system använder båda: gRPC bakom gatewayen mellan tjänster och REST i ytterkanten mot omvärlden. Tvinga inte ett verktyg att göra det som det andra är till för.

Snabb kontroll

Matcha protokoll efter användningsfall.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Synkron kommunikation mellan tjänster:

REST/JSON — universellt, felsökningsbart och cachebart; statuskoderna är kontraktet; ange alltid timeouts.
gRPC/Protobuf — kontraktsstyrt, kompakt, snabbt och med streaming; generera typade PHP-stubbar.
Avgör möjligheten till omförsök utifrån status- och gRPC-koder; gör aldrig omförsök för klientfel.
Utveckla scheman additivt — återanvänd aldrig Protobuf-fältnummer.
REST i ytterkanten och gRPC mellan interna tjänster är en vanlig och välfungerande uppdelning.

Nästa steg: att routa och hitta alla dessa tjänster med gateways och service discovery.

Gratis att börja

Lär dig PHP med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 49
Lektioner: 195

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Tjänstekommunikation: REST och gRPC” gratis?

Ja – hela texten till ”Tjänstekommunikation: REST och gRPC” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i PHP Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i PHP Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Tjänstekommunikation: REST och gRPC”?

Anslut tjänster synkront och effektivt. Ni övar på PHP Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig PHP Academy?

Du behöver inga förkunskaper. Utbildningen i PHP Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Tjänstekommunikation: REST och gRPC”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här PHP Academy-lektionen?

Ja. Varje PHP Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till PHP Academy