Crear un paquete Go a partir de un archivo Protobuf te permite definir estructuras de datos una sola vez y compilarlas automáticamente para usarlas en cliente, servidor o cualquier servicio. Esta práctica con gRPC y Protocol Buffers es clave si trabajas con microservicios y quieres evitar duplicar modelos en cada lenguaje.

¿Cómo se crea el módulo y la estructura inicial del proyecto?

Antes de tocar Protobuf, necesitas un módulo de Go que sirva como contenedor de todo el código generado.

El primer paso es inicializar el módulo con el nombre platzi.com/go/grpcy. Después creas una carpeta llamada proto que alojará el archivo Student.proto. Esa separación entre módulo y carpeta de definiciones mantiene el proyecto ordenado y facilita la compilación posterior.

• Crea el módulo platzi.com/go/grpcy.
• Genera la carpeta proto en la raíz del proyecto.
• Dentro de proto, crea el archivo Student.proto.

¿Cómo defines un mensaje en un archivo .proto?

Un archivo .proto describe los datos con una sintaxis declarativa que luego se traduce a structs de Go.

En el archivo Student.proto declaras la versión de sintaxis con proto3, defines el paquete student y creas tu primer mensaje. Cada campo del mensaje lleva un número de posición que Protobuf usa para serializar la información de forma binaria y eficiente.

proto syntax = "proto3"; package student;

option go_package = "platzi.com/go/grpcy/studentpb";

message Student { string id = 1; string name = 2; int32 age = 3; }

La opción go_package apunta a platzi.com/go/grpcy/studentpb y le indica al compilador dónde colocar el paquete generado. Recuerda cerrar cada línea con punto y coma cuando aplique.

¿Qué es un archivo .proto? Es un archivo de texto donde defines mensajes y servicios usando la sintaxis de Protocol Buffers. Funciona como contrato entre cliente y servidor en gRPC.

¿Qué dependencias necesitas para compilar Protobuf en Go?

La compilación requiere dos generadores que traducen el .proto a código Go funcional.

El primero es el plugin de Protobuf para Go, que convierte los mensajes en structs. El segundo es el plugin de gRPC, que genera el código de comunicación entre servicios. Ambos se instalan antes de ejecutar el compilador protoc.

• Plugin de Go para Protobuf: traduce mensajes a structs.
• Plugin de Go para gRPC: genera la capa de comunicación remota.
• Compilador protoc: orquesta el proceso completo.

¿Cómo compilas el archivo .proto a un paquete Go?

Una vez instaladas las dependencias, ejecutas protoc con las banderas correctas para generar el paquete.

El comando indica que quieres salida en Go, define rutas relativas al directorio actual y apunta tanto al output normal como al de gRPC. La bandera paths=source_relative asegura que los archivos generados respeten la estructura de carpetas que ya creaste.

bash protoc --go_out=. --go_opt=paths=source_relative
--go-grpc_out=. --go-grpc_opt=paths=source_relative
proto/student.proto

Al presionar Enter, el compilador genera automáticamente el archivo Go dentro de la carpeta proto. Ese archivo contiene la struct Student equivalente al mensaje del .proto, junto con métodos asociados a cada propiedad.

¿Por qué no se debe editar el archivo generado? Porque cualquier recompilación lo sobrescribe. Modificarlo manualmente rompe la sincronización entre el contrato .proto y el código Go.

¿Qué ventajas tiene Protobuf frente a definir modelos manualmente?

La diferencia con proyectos anteriores es enorme: ya no escribes la struct en Go a mano.

Antes tenías que definir el modelo en la base de datos y replicarlo en Go. Con Protobuf defines la estructura una sola vez en el .proto y el compilador genera la versión en Go automáticamente. Esto reduce errores de sincronización y acelera el desarrollo.

• Una sola fuente de verdad para los modelos de datos.
• Generación automática de structs y métodos.
• Distribución del mismo contrato entre múltiples servicios.

¿Qué genera el comando protoc para Go? Crea un archivo Go con structs equivalentes a los mensajes del .proto, métodos de serialización y, si usas la bandera de gRPC, las interfaces de cliente y servidor.

En la siguiente clase verás por qué gRPC encaja tan bien en arquitecturas de microservicios y qué hace a Protobuf más eficiente que el típico JSON de las APIs REST. Cuéntame en los comentarios si ya habías trabajado con generación de código a partir de contratos.