RPC en flux : serveur, client et bidirectionnel
Allez au-delà des appels unaires et découvrez les trois modes de flux de gRPC pour envoyer des séquences de messages au cours d’un seul appel.
RPC en flux : serveur, client et bidirectionnel est une leçon gRPC & High Performance APIs gratuite sur CoddyKit. Ceci est la leçon 4 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 gRPC & High Performance APIs, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours gRPC & High Performance APIs comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Beyond Unary
A unary RPC is one request, one response. But many problems need a sequence of messages — feeds, uploads, chat.
gRPC offers three streaming modes built on HTTP/2 streams.
The Four Method Shapes
In a .proto service you can declare:
- Unary: one in, one out.
- Server streaming: one in, many out.
- Client streaming: many in, one out.
- Bidirectional: many in, many out.
Declaring Streams in Proto
The stream keyword marks a parameter as a stream.
service Feed {
rpc Watch (WatchRequest) returns (stream Event);
rpc Upload (stream Chunk) returns (UploadResult);
rpc Chat (stream Message) returns (stream Message);
}Server Streaming
The client sends one request; the server replies with many messages until it closes the stream.
Great for: live feeds, large result sets, progress updates.
// Server side (Go-style pseudocode)
func (s *server) Watch(req *WatchRequest, stream Feed_WatchServer) error {
for _, e := range events {
stream.Send(e)
}
return nil
}Client Streaming
The client sends many messages, then the server returns a single response.
Great for: file uploads, batched ingestion, aggregations.
// Server reads the whole client stream, then replies once
func (s *server) Upload(stream Feed_UploadServer) error {
for {
chunk, err := stream.Recv()
if err == io.EOF {
return stream.SendAndClose(&UploadResult{})
}
}
}Bidirectional Streaming
Both sides send streams independently over the same call. Messages can interleave freely.
Great for: chat, real-time collaboration, interactive protocols.
Why It's Efficient
All four shapes ride a single HTTP/2 stream — no new connection per message.
Multiplexing means many streaming calls share one connection without head-of-line blocking.
Flow Control
HTTP/2 provides built-in flow control, so a slow reader naturally backpressures a fast writer.
This prevents a streaming server from overwhelming a client that can't keep up.
Ending a Stream
Streams close explicitly:
- Server streaming ends when the server returns.
- Client streaming ends when the client signals end-of-stream and the server replies.
- Bidirectional ends when both halves complete or an error/cancel occurs.
Errors & Cancellation
Either side can cancel or fail mid-stream. The peer receives a status code and should clean up.
Always handle EOF and error returns from Recv() / Send() to avoid leaks.
Choosing a Mode
Pick by data shape:
- One-shot request/response: unary.
- Push many results: server streaming.
- Send many, get a summary: client streaming.
- Continuous two-way: bidirectional.
Quick Check
Test your understanding of streaming RPCs.
Recap
You learned gRPC's streaming modes.
- Unary, server streaming, client streaming, and bidirectional.
- Mark streams with the
streamkeyword in proto. - All ride a single multiplexed HTTP/2 stream with built-in flow control.
- Choose the mode that matches your data's shape.
Questions Fréquemment Posées
La leçon « RPC en flux : serveur, client et bidirectionnel » est-elle gratuite ?
Oui — le texte complet de « RPC en flux : serveur, client et bidirectionnel » 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 gRPC & High Performance APIs, passe à CoddyKit PRO. Le cours gRPC & High Performance APIs comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « RPC en flux : serveur, client et bidirectionnel » ?
Allez au-delà des appels unaires et découvrez les trois modes de flux de gRPC pour envoyer des séquences de messages au cours d’un seul appel. Tu pratiques gRPC & High Performance APIs 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 gRPC & High Performance APIs ?
Aucune expérience préalable n'est requise. gRPC & High Performance APIs 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 4 sur 4.
Combien de temps prend la leçon « RPC en flux : serveur, client et bidirectionnel » ?
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 gRPC & High Performance APIs ?
Oui. Chaque leçon gRPC & High Performance APIs 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
- Définir un schéma Protobuf
- Générer du code gRPC
- Service gRPC unaire simple
- RPC en flux : serveur, client et bidirectionnel