Implementación de Streaming en gRPC: Servidor y Bidireccional

¿Cómo desarrollar un server streaming en gRPC?

El streaming del lado del servidor en gRPC permite al servidor enviar múltiples respuestas a un cliente tras una sola solicitud. Este enfoque es útil en situaciones como la transmisión de datos en tiempo real o la descarga de grandes cantidades de información en partes.

Implementación del server streaming

Para implementar el server streaming, definimos una nueva función llamándola doServerStreaming, donde se utiliza el cliente de servicio TestServiceClient y se invoca el método getStudentsPerTest.

func doServerStreaming(c testpb.TestServiceClient) {
    // Creación del request enviando el test ID
    req := &testpb.GetStudentsPerTestRequest{
        TestId: "t1",
    }

    // Llamada al método del servidor
    stream, err := c.GetStudentsPerTest(context.Background(), req)
    if err != nil {
        log.Fatalf("Error llamando a GetStudentsPerTest: %v", err)
    }

    // Ciclo para leer indefinidamente las respuestas
    for {
        msg, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("Error leyendo del stream: %v", err)
        }

        log.Printf("Estudiante recibido: %v", msg)
    }
}

Con el método implementado, comprobamos en nuestro programa principal su correcto funcionamiento mediante la ejecución de main.go, obteniendo las respuestas de los diferentes estudiantes.

¿Qué es el bidirectional streaming y cómo implementarlo?

El streaming bidireccional en gRPC permite la comunicación simultánea entre cliente y servidor utilizando un único stream. Ambos pueden enviar y recibir datos continuamente sin bloqueo, lo cual es ideal para aplicaciones interactivas en tiempo real.

Implementación del bidirectional streaming

La función doBidirectionalStreaming se encarga de establecer un canal de comunicación para el streaming bidireccional. Definimos el cliente TestServiceClient e implementamos el método takeTest, que permite enviar y recibir flujos de datos.

func doBidirectionalStreaming(c testpb.TestServiceClient) {
    waitChannel := make(chan struct{})

    // Inicia el flujo de datos
    stream, err := c.TakeTest(context.Background())
    if err != nil {
        log.Fatalf("Error llamando a TakeTest: %v", err)
    }

    // Gorutina para enviar datos al servidor
    go func() {
        defer close(waitChannel)
        for i := 0; i < 4; i++ {
            if err := stream.Send(&testpb.TakeTestRequest{Answer: 42}); err != nil {
                log.Fatalf("Error enviando al stream: %v", err)
            }
            time.Sleep(time.Second)  // Emula un tiempo de procesamiento
        }
        stream.CloseSend()
    }()

    // Gorutina para recibir datos del servidor
    go func() {
        for {
            res, err := stream.Recv()
            if err == io.EOF {
                break
            }
            if err != nil {
                log.Fatalf("Error recibiendo del stream: %v", err)
            }
            log.Printf("Respuesta del servidor: %v", res)
        }
    }()

    <-waitChannel // Espera a que se cierren las gorutinas
}

Tras implementar el método, volvemos al main y lo probamos, asegurándonos de que el servidor procesa y responde adecuadamente a las comunicaciones del cliente.

¿Qué metodologías de gRPC hemos implementado?

Durante este proyecto, se implementaron cuatro tipos de métodos en gRPC:

• Unario: Similar a una llamada HTTP estándar. El cliente envía una solicitud y recibe una única respuesta.
• Client streaming: El cliente envía múltiples datos (como un stream) y recibe una única respuesta una vez que termina de enviar.
• Server streaming: El cliente envía una única solicitud y el servidor responde con múltiples mensajes.
• Bidirectional streaming: Cliente y servidor se comunican continuamente enviando y recibiendo datos a través de un solo canal o flujo.

Estos distintos modos de streaming ofrecen flexibilidad y eficiencia a la hora de manejar datos, permitiendo adaptar las comunicaciones según las necesidades de las aplicaciones. Es fundamental entender cómo y cuándo utilizar cada tipo para aprovechar el potencial de gRPC, siempre buscando optimizar la interacción entre servicios cliente-servidor.