Microservicios en Go: por dónde empezar y no rendirse

Por qué Go es la mejor opción para microservicios (y cuándo no lo es)

Imagina que estás construyendo un centro comercial. En lugar de levantar un edificio gigante, construyes pabellones individuales: una cafetería, una librería, un supermercado. Cada uno funciona por sí solo, pero juntos forman un complejo unificado. ¿Se averió el ascensor en algún lado? La librería sigue funcionando. ¿Se acabaron los vasos en la cafetería? Cerramos solo esa, no todo el complejo.

Eso es la arquitectura de microservicios. Y Go (Golang) es el material ideal para construir esos «pabellones». ¿Por qué?

• Inicio rápido: compilación en un solo binario. Nada de JDK, máquinas virtuales o node_modules.
• Rendimiento: Go funciona al nivel de C++, pero se escribe como Python.
• Concurrencia incorporada: goroutines y channels son una superpotencia para manejar cientos de solicitudes por segundo.
• Simplicidad: Go es intencionalmente limitado. No hay genéricos (hasta Go 1.18 no los había), no hay herencia. El código se lee como un manual de aspiradora: inmediatamente se entiende qué hace cada línea.

Pero también tiene desventajas. Go no es adecuado si necesitas:

• Herencia pesada de clases (aquí no existe en absoluto).
• Una enorme cantidad de bibliotecas listas para cualquier tarea (el ecosistema es más pobre que el de Java o Python).
• Tipado dinámico (Go es fuertemente tipado, tendrás que escribir más boilerplate).

Si tu proyecto es una API de alta carga, un backend para chat, una pasarela de pagos o un sistema de monitoreo, Go es tu elección. Si estás escribiendo un prototipo en un fin de semana y no te importa la velocidad, elige Python.

Etapa 1. Preparamos el equipaje: herramientas y estructura del proyecto

Qué instalar

Antes de escribir código, configuremos el entorno. Necesitarás:

• Go (versión 1.21+). Descárgalo desde go.dev.
• Docker (para contenerización).
• curl o Postman (para probar la API).
• Cualquier IDE: GoLand, VS Code con el plugin de Go, Vim. Recomiendo VS Code: es gratuito y cómodo.

Estructura correcta de carpetas

Acordemos desde ya: nada de trampas. Esta es la estructura estándar para un microservicio en Go:

/user-service├── cmd/│   └── server/│       └── main.go        # punto de entrada├── internal/│   ├── handler/           # manejadores HTTP│   ├── service/           # lógica de negocio│   ├── repository/        # trabajo con BD│   └── model/             # estructuras de datos├── pkg/│   └── middleware/        # utilidades comunes├── Dockerfile├── go.mod└── go.sum

¿Por qué así? Go es un lenguaje donde la estructura de carpetas dicta la arquitectura. cmd/ es el punto de entrada. internal/ es todo lo que no se puede importar desde fuera (protección contra errores). pkg/ es lo que se puede compartir con otros servicios.

Etapa 2. Escribimos nuestro primer microservicio: ¡Hola, Mundo! 2.0

Escribamos un servidor HTTP simple en Go que devuelva JSON. Este será nuestro «microservicio de saludos».

Paso 1. Inicialización del módulo

mkdir hello-servicecd hello-servicego mod init github.com/tu-usuario/hello-service

Paso 2. Escribimos main.go

package main

import (    "encoding/json"    "log"    "net/http"    "time")

// GreetingResponse — estructura de respuestatype GreetingResponse struct {    Message   string `json:"message"`    Timestamp string `json:"timestamp"`}

func greetHandler(w http.ResponseWriter, r *http.Request) {    // Establecemos los encabezados    w.Header().Set("Content-Type", "application/json")    w.WriteHeader(http.StatusOK)

    // Creamos la respuesta    response := GreetingResponse{        Message:   "¡Hola, microservicios!",