Microservicios en Go: arquitectura y práctica de la A a la Z

Introducción: ¿Por qué Go es el lenguaje ideal para microservicios?

La arquitectura de microservicios se ha convertido en el estándar de facto para construir aplicaciones modernas y escalables. El lenguaje Go (Golang), creado en las entrañas de Google, es ideal para esta tarea gracias a su simplicidad, rendimiento y soporte integrado para la concurrencia. En este artículo, analizaremos el ciclo completo de creación de un microservicio en Go: desde el diseño de la arquitectura hasta el despliegue en producción.

Go ofrece compilación rápida, consumo mínimo de memoria y trabajo nativo con gorutinas — hilos ligeros. Esto lo convierte en una excelente opción para sistemas distribuidos de alta carga. Revisaremos conceptos clave, escribiremos ejemplos de código y discutiremos las mejores prácticas.

1. Diseño de la arquitectura de microservicios en Go

1.1. Principios de la arquitectura de microservicios

Antes de escribir código, es necesario definir los límites de los microservicios. Principios fundamentales:

\n
• Responsabilidad Única (Single Responsibility) — cada servicio se encarga de una función de negocio.
\n
• Independencia de despliegue — cada microservicio puede actualizarse sin detener todo el sistema.
\n
• Acoplamiento débil (Loose Coupling) — los servicios se comunican a través de APIs claramente definidas.
\n
• Descentralización de la gestión de datos — cada servicio tiene su propia base de datos.
\n

1.2. Estructura del proyecto Go para un microservicio

Estructura de carpetas recomendada para un microservicio en Go:

my-service/\n├── cmd/\n│   └── server/\n│       └── main.go          # Punto de entrada\n├── internal/\n│   ├── handler/             # Manejadores HTTP/gRPC\n│   ├── service/             # Lógica de negocio\n│   ├── repository/          # Trabajo con BD\n│   └── model/               # Estructuras de datos\n├── pkg/\n│   └── api/                 # Archivos proto comunes (gRPC)\n├── config/\n│   └── config.go            # Configuración\n├── migrations/              # Migraciones de BD\n├── Dockerfile\n└── go.mod

1.3. Ejemplo de un microservicio simple

Crearemos un microservicio HTTP básico para la gestión de usuarios. Comencemos definiendo el modelo y el repositorio:

// internal/model/user.go\npackage model\n\ntype User struct {\n    ID    int64  `json:"id"`\n    Name  string `json:"name"`\n    Email string `json:"email"`\n}\n\n// internal/repository/user_repo.go\npackage repository\n\nimport (\n    "context"\n    "my-service/internal/model"\n)\n\ntype UserRepository interface {\n    GetByID(ctx context.Context, id int64) (*model.User, error)\n    Create(ctx context.Context, user *model.User) (int64, error)\n}\n\ntype inMemoryRepo struct {\n    users map[int64]*model.User\n    nextID int64\n}\n\nfunc NewInMemoryRepo() UserRepository {\n    return &inMemoryRepo{\n        users:  make(map[int64]*model.User),\n        nextID: 1,\n    }\n}\n\nfunc (r *inMemoryRepo) GetByID(ctx context.Context, id int64) (*model.User, error) {\n    user, ok := r.users[id]\n    if !ok {\n        return nil, fmt.Errorf("user not found")\n    }\n    return user, nil\n}\n\nfunc (r *inMemoryRepo) Create(ctx context.Context, user *model.User) (int64, error) {\n    user.ID = r.nextID\n    r.users[user.ID] = user\n    r.nextID++\n    return user.ID, nil\n}

2. Comunicación entre microservicios: REST, gRPC y colas

2.1. API REST en Go

Para la interacción síncrona, se suele usar REST o gRPC. Veamos un controlador REST utilizando la biblioteca estándar net/http y el enrutador chi:

// internal/handler/user_handler.go\npackage handler\n\nimport (\n    "encoding/json"\n    "net/http"\n    "strconv"\n    "my-service/internal/service"\n    "github.com/go-chi/chi/v5"\n)\n\ntype UserHandler struct {\n    svc *service.UserService\n}\n\nfunc NewUserHandler(svc *service.UserService) *UserHandler {\n