Go Academy · Leçon

Flux côté serveur et côté client

Flux bidirectionnel et contrôle de la pression

Flux côté serveur et côté client est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Types de flux gRPC

gRPC prend en charge trois modes de flux en plus du mode unaire : le flux serveur (le serveur envoie plusieurs messages), le flux client (le client en envoie plusieurs) et le flux bidirectionnel (les deux en envoient).

Flux serveur dans .proto

Utilisez le mot-clé stream avant le type de réponse :

service EventService {
    rpc ListEvents (ListEventsRequest) returns (stream Event);
}

Implémentation d’un flux serveur

Le serveur envoie plusieurs messages en appelant stream.Send(), puis renvoie nil lorsqu’il a terminé :

func (s *server) ListEvents(req *pb.ListEventsRequest, stream pb.EventService_ListEventsServer) error {
    for _, event := range s.events {
        if err := stream.Send(event); err != nil { return err }
    }
    return nil
}

Réception d’un flux serveur par le client

Le client appelle Recv() dans une boucle jusqu’à io.EOF :

stream, err := client.ListEvents(ctx, &pb.ListEventsRequest{})
for {
    event, err := stream.Recv()
    if err == io.EOF { break }
    if err != nil { log.Fatal(err) }
    fmt.Println(event)
}

Flux client dans .proto

Utilisez stream avant le type de requête :

service UploadService {
    rpc Upload (stream Chunk) returns (UploadResponse);
}

Implémentation d’un flux client

Le client envoie plusieurs messages, puis ferme le flux avec CloseAndRecv :

stream, _ := client.Upload(ctx)
for _, chunk := range chunks {
    stream.Send(chunk)
}
resp, err := stream.CloseAndRecv()

Réception d’un flux client par le serveur

Appelez stream.Recv() dans une boucle jusqu’à io.EOF, puis renvoyez la réponse finale :

func (s *server) Upload(stream pb.UploadService_UploadServer) error {
    for {
        chunk, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&pb.UploadResponse{Received: total})
        }
        if err != nil { return err }
        total += len(chunk.Data)
    }
}

Flux bidirectionnel

Le client et le serveur peuvent chacun envoyer et recevoir indépendamment. Déclarez stream des deux côtés dans le fichier .proto.

service ChatService {
    rpc Chat (stream Message) returns (stream Message);
}

Implémentation d’un serveur bidirectionnel

Le serveur reçoit les messages dans une goroutine et les envoie indépendamment :

func (s *server) Chat(stream pb.ChatService_ChatServer) error {
    for {
        msg, err := stream.Recv()
        if err == io.EOF { return nil }
        if err != nil { return err }
        stream.Send(&pb.Message{Text: "echo: " + msg.Text})
    }
}

Contrôle du flux

gRPC utilise le contrôle de flux HTTP/2 pour empêcher les émetteurs rapides de saturer les récepteurs lents. Les appels à Recv() appliquent naturellement une contre-pression : l’envoi est bloqué lorsque le récepteur ne lit pas les données.

Annulation du contexte

Transmettez un contexte avec délai d’expiration ou annulation à tous les appels de flux. Le flux est annulé lorsque le contexte est terminé, ce qui fait que Recv/Send renvoie une erreur.

Vérification rapide

Comment un serveur RPC avec flux serveur indique-t-il qu’il a terminé ses envois ?

Récapitulatif : flux gRPC

Points clés :

Flux serveur : mot-clé stream sur la réponse ; le serveur appelle Send()
Flux client : mot-clé stream sur la requête ; le client appelle Send(), puis CloseAndRecv()
Bidirectionnel : stream des deux côtés ; goroutines Send et Recv indépendantes
L’annulation du contexte s’applique à tous les appels de flux

Questions Fréquemment Posées

La leçon « Flux côté serveur et côté client » est-elle gratuite ?

Oui — le texte complet de « Flux côté serveur et côté client » 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 Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Flux côté serveur et côté client » ?

Flux bidirectionnel et contrôle de la pression Tu pratiques Go 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 Go Academy ?

Aucune expérience préalable n'est requise. Go 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 3 sur 4.

Combien de temps prend la leçon « Flux côté serveur et côté client » ?

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 Go Academy ?

Oui. Chaque leçon Go 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

← Retour à Go Academy