gRPC con Go

Hoy veremos un ejemplo de uso de gRPC con Go.

Requisitos:

• Tener Go instalado. 
• Tener Protoc instalado.

Listamos la versión de Go instalada:

$ go version

En caso de no tener instalado Protoc, podemos hacer lo siguiente. Abrimos una terminal y tecleamos:

$ winget install protobuf

Listamos la versión instalada:

$ protoc --version

Con esto hemos validado las herramientas necesarias.

Antes de hacer nada, vamos a recordando un poco sobre los cuatro modos en que gRPC puede enviar y recibir datos:

• Unario: Funciona mediante un ciclo de solicitud y respuesta, donde el cliente envía una solicitud y el servidor devuelve una respuesta. 
• Transmisión del servidor: Cuando solo el servidor envía un flujo de datos al cliente. 
• Transmisión del cliente: Cuando solo el cliente envía un flujo de datos al servidor. 
• Bidireccional: Cuando tanto el servidor como el cliente se envían datos mutuamente de forma simultánea.

Esto es importante saber, pues no todas las formas se usan en un desarrollo. Algunas permiten ciertas cosas y otras no.

En este caso usaremos el modo unario. Donde un servidor recibe peticiones de un cliente y le envía respuestas.

Además, como vimos en la entrega anterior, Protobuff será el mecanismo de serialización que usaremos en nuestro proyecto, ya que es el que usa gRPC. Será el que define los mensajes y servicios de nuestra aplicación.

Creando el proyecto gRPC con Go

Vamos a crear una aplicación gRPC con Go. Será del tipo unario, donde el servidor recibe peticiones de un cliente y le manda una respuesta. El cliente mandará un número entero y el servidor responderá si es o no mayor a 100.

1. Creamos un directorio:

$ mkdir demo-grpc-go
$ cd demo-grpc-go

2. Una vez dentro del directorio, crearemos un directorio llamado protoc y dentro un archivo ``validar.proto``. Quedando de esta manera:

proto\validar.proto

syntax = "proto3";

package validar;

service Validar {
  rpc EsMayorQue100 (NumeroRequest) returns (NumeroResponse);
}

message NumeroRequest {
  int32 valor = 1;
}

message NumeroResponse {
  bool es_mayor = 1;
}

Este archivo contiene:

• Un servicio llamado Validar.
• Un método llamado EsMayorQue100 que recibirá un NumeroRequest y devolverá un NumeroResponse.

3. Ahora nos ubicaremos en el directorio principal e instalaremos los Plugin para Protoc:

$ go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

4.Inicializamos el módulo Go:

$ go mod init demo-grpc-go

Si todo va bien, veremos esta salida:

go: creating new go.mod: module demo-grpc-go
go: to add module requirements and sums:
        go mod tidy

5. Instalamos la librerías necesarias:

$ go get google.golang.org/grpc
$ go get google.golang.org/protobuf

6. Una vez teniendo los plugins y librerías instaladas podemos generar el código con Protoc:

$ protoc --go_out=. --go-grpc_out=. --go_opt=module=demo-grpc-go --go-grpc_opt=module=demo-grpc-go proto/validar.proto

Si todo es correcto, veremos estos archivos creados:

validar.pb.go 
validar.proto
validar_grpc.pb.go

Pero, ¿Qué significa cada uno?

• validar.pb.go: Es el contrato entre cliente y servidor: ambos deben respetar esta definición para poder comunicarse. 
• validar.proto: Contiene las estructuras Go que representan los mensajes definidos en el .proto. 
• validar_grpc.pb.go: Contiene el código relacionado con el servicio gRPC.

7. Creamos el programa servidor:

servidor\servidor.go

package main

import (
	"context"
	"log"
	"net"

	pb "demo-grpc-go/proto"
	"google.golang.org/grpc"
)

type server struct {
	pb.UnimplementedValidarServer
}

func (s *server) EsMayorQue100(ctx context.Context, req *pb.NumeroRequest) (*pb.NumeroResponse, error) {
	resultado := req.Valor > 100
	return &pb.NumeroResponse{EsMayor: resultado}, nil
}

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("Error al escuchar: %v", err)
	}

	grpcServer := grpc.NewServer()
	pb.RegisterValidarServer(grpcServer, &server{})

	log.Println("Servidor gRPC escuchando en :50051")
	if err := grpcServer.Serve(lis); err != nil {
		log.Fatalf("Error al servir: %v", err)
	}
}

8. Creamos el programa cliente:

cliente\cliente.go

package main

import (
	"context"
	"log"
	"time"

	pb "demo-grpc-go/proto"
	"google.golang.org/grpc"
)

func main() {
	conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
	if err != nil {
		log.Fatalf("No se pudo conectar: %v", err)
	}
	defer conn.Close()

	c := pb.NewValidarClient(conn)

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	r, err := c.EsMayorQue100(ctx, &pb.NumeroRequest{Valor: 150})
	if err != nil {
		log.Fatalf("Error al llamar RPC: %v", err)
	}

	log.Printf("¿Es mayor a 100? %v", r.EsMayor)
}

9. Ejecutamos el servidor:

$ go run servidor.go

10. En otra terminal ejecutamos el cliente:

$ go run cliente.go

Si todo va bien veremos lo siguiente en el lado del servidor:

2026/03/23 11:53:36 Servidor gRPC escuchando en :50051

Del lado del cliente:

2026/03/23 11:54:32 ¿Es mayor a 100? true

Lo cual es correcto, pues el número envíado es 150:

r, err := c.EsMayorQue100(ctx, &pb.NumeroRequest{Valor: 150})

Modificaremos el programa ``cliente\cliente.go`` para que se pueda enviar cualquier número entero y que el servidor válide si es o no mayor a 100.

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"strconv"
	"time"

	pb "demo-grpc-go/proto"
	"google.golang.org/grpc"
)

func main() {
	if len(os.Args) < 2 {
		log.Fatalf("Uso: go run cliente.go <numero>")
	}

	numero, err := strconv.Atoi(os.Args[1])
	if err != nil {
		log.Fatalf("El argumento debe ser un número entero: %v", err)
	}

	conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
	if err != nil {
		log.Fatalf("No se pudo conectar: %v", err)
	}
	defer conn.Close()

	c := pb.NewValidarClient(conn)

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	r, err := c.EsMayorQue100(ctx, &pb.NumeroRequest{Valor: int32(numero)})
	if err != nil {
		log.Fatalf("Error al llamar RPC: %v", err)
	}

	fmt.Printf("Número enviado: %d\n", numero)
	fmt.Printf("¿Es mayor a 100? %v\n", r.EsMayor)
}

Volvemos a ejecutar el cliente:

$ go run cliente.go 54

Salida:

Número enviado: 54
¿Es mayor a 100? false

¡Hemos creado nuestra primera aplicación cliente-servidor con gRPC y Go!

Continuaremos con esta serie de entregas sobre gRPC.

Enlaces:

https://go.dev
https://grpc.io/
https://protobuf.dev
https://alquimistadecodigo.blogspot.com/2026/03/grpc-con-python.html
https://codemonkeyjunior.blogspot.com/2026/01/grpc-y-graphql-en-una-comparativa.html
https://codemonkeyjunior.blogspot.com/2026/02/grpc-una-alternativa-para-servicios-de.html
https://medium.com/@rashid14713524/introduction-to-grpc-using-golang-for-beginners-e37d7dbafef2