Streaming del servidor y del cliente
Streaming bidireccional y control de presión
Streaming del servidor y del cliente es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.
Tipos de streaming de gRPC
gRPC admite tres modos de streaming además del unario: streaming del servidor (el servidor envía muchos mensajes), streaming del cliente (el cliente envía muchos mensajes) y streaming bidireccional (ambos transmiten).
Streaming del servidor en .proto
Utilice la palabra clave stream delante del tipo de respuesta:
service EventService {
rpc ListEvents (ListEventsRequest) returns (stream Event);
}Implementación del streaming del servidor
El servidor envía varios mensajes llamando a stream.Send() y devuelve nil cuando termina:
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
}Recepción del streaming del servidor por el cliente
El cliente llama a Recv() en un bucle hasta llegar a 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)
}Streaming del cliente en .proto
Utilice stream delante del tipo de solicitud:
service UploadService {
rpc Upload (stream Chunk) returns (UploadResponse);
}Implementación del streaming del cliente
El cliente envía varios mensajes y después cierra el stream con CloseAndRecv:
stream, _ := client.Upload(ctx)
for _, chunk := range chunks {
stream.Send(chunk)
}
resp, err := stream.CloseAndRecv()Recepción del streaming del cliente por el servidor
Llame a stream.Recv() en un bucle hasta llegar a io.EOF y, después, devuelva la respuesta final:
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)
}
}Streaming bidireccional
Tanto el cliente como el servidor pueden enviar y recibir de forma independiente. Declárelo con stream en ambos lados del archivo .proto.
service ChatService {
rpc Chat (stream Message) returns (stream Message);
}Implementación del servidor bidireccional
El servidor recibe mensajes en una goroutine y envía mensajes de forma independiente:
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})
}
}Control de flujo
gRPC utiliza el control de flujo de HTTP/2 para evitar que los emisores rápidos saturen a los receptores lentos. Las llamadas a Recv() aplican contrapresión de forma natural: el envío se bloquea cuando el receptor no está leyendo.
Cancelación del contexto
Pase un contexto con un tiempo límite o cancelación a todas las llamadas de streaming. El stream se cancela cuando el contexto finaliza, lo que hace que Recv/Send devuelvan un error.
Comprobación rápida
¿Cómo indica el servidor de un RPC con streaming del servidor que ha terminado de enviar mensajes?
Recapitulación: streaming de gRPC
Puntos clave:
- Streaming del servidor: palabra clave stream en la respuesta; el servidor llama a Send()
- Streaming del cliente: palabra clave stream en la solicitud; el cliente llama a Send() y después a CloseAndRecv()
- Bidireccional: stream en ambos lados; goroutines independientes para Send y Recv
- La cancelación del contexto se aplica a todas las llamadas de streaming
Preguntas frecuentes
¿La lección «Streaming del servidor y del cliente» es gratis?
Sí — el texto completo de «Streaming del servidor y del cliente» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Streaming del servidor y del cliente»?
Streaming bidireccional y control de presión Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Go Academy?
No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Streaming del servidor y del cliente»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Go Academy?
Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Protocol Buffers y archivos .proto
- Implementación de un servicio gRPC unario
- Streaming del servidor y del cliente
- Interceptores y metadatos de gRPC