Lección 16 de 20 · Lectura y práctica
Diseño de microservicios con Go y gorilla/mux
Concepto claveEl diseño de microservicios con Go y gorilla/mux se basa en crear servicios independientes que se comunican a través de APIs REST. Imagina una cadena de montaje en una fábrica: cada estación (microservicio) realiza.
Del concepto a la práctica
Taller de esta lección
La frontera de un microservicio debe seguir una responsabilidad de negocio, no una división arbitraria por archivo. Para una librería digital, catalog administra libros y loans administra préstamos; un servicio no modifica directamente las estructuras internas del otro.
Ejemplo resuelto
catalog expone GET /books/{id} y loans expone POST /loans. El préstamo guarda book_id, pero comprueba la disponibilidad mediante el contrato del catálogo, no mediante su base de datos. Si el libro no existe, el préstamo responde 404 para ausencia, o409 para libro existente no disponible, según el contrato de abajo.
Pruébalo
Dibuja los dos servicios y sus datos propios.
Define una respuesta mínima para consultar un libro.
Define la solicitud de creación de préstamo.
Simula el caso de libro disponible y ausente.
Error frecuente: compartir un paquete de modelos que obliga a desplegar ambos servicios juntos. Corrígelo compartiendo contratos pequeños o tipos locales compatibles.
Comprueba tu resultado
El diagrama debe mostrar dos almacenes separados y una llamada explícita de loans a catalog. Un libro ausente no puede generar un préstamo persistido.
Contratos y consistencia de una reserva
Fixture catálogo: {id:'B-7',title:'Atlas local',available:true}. Préstamo recibe {book_id:'B-7',user_id:'u17'} y obtiene la identidad autorizada de sesión cuando corresponda, sin permitir suplantar user_id. B-9 ausente→404/book_not_found en esta ampliación; B-7 no disponible→409/book_unavailable. No deja un préstamo en ambos fallos. Documenta esa política única en lugar de alternar404/409 para el mismo caso.
Una consulta disponible=true seguida de escritura local no reserva atómicamente el libro: otro cliente puede ganarlo entre pasos. Define un comando de reserva idempotente del catálogo y estados pendiente/confirmado/fallido del préstamo; compensa una reserva si la escritura posterior falla. Separar servicios no proporciona una transacción global automáticamente. Pueden compartir infraestructura física con ownership lógico de datos, sin obligar a cada servicio a una máquina/servidor DB distinto.
Un cliente HTTP tiene plazo y request.NewRequestWithContext; tras Do exitoso cierra response.Body, revisa status y acota el contenido. CORS controla ciertos accesos del navegador, no autentica servicios. Un contrato pequeño versionado permite independencia; un paquete compartido no obliga siempre al despliegue simultáneo, pero cambios incompatibles sí requieren coordinación.

Mapa de prácticaEl navegador envía una solicitud a la API. El servidor valida la operación y consulta los datos; después devuelve una respuesta que el navegador puede mostrar. La base de datos se comunica con el servidor y no directamente con el navegador.
Ver la infografía en tamaño completo ↗Concepto clave
El diseño de microservicios con Go y gorilla/mux se basa en crear servicios independientes que se comunican a través de APIs REST. Imagina una cadena de montaje en una fábrica: cada estación (microservicio) realiza una tarea específica, como pintar, ensamblar o empaquetar, y pasa el producto a la siguiente estación mediante cintas transportadoras (APIs). En Go, esto significa que cada servicio es un programa separado que corre en su propio proceso, usando gorilla/mux para manejar rutas HTTP de manera eficiente.
La clave está en la autonomía: cada microservicio debe tener su propia base de datos y lógica de negocio, evitando dependencias directas. Por ejemplo, en un sistema de e-commerce, un servicio maneja usuarios, otro productos y otro pagos. Esto mejora la escalabilidad, ya que puedes desplegar más instancias de un servicio bajo carga sin afectar a los demás. Go, con su concurrencia nativa mediante goroutines, es ideal para esto, ya que maneja muchas peticiones simultáneas con bajo consumo de recursos.
Cómo funciona en la práctica
Para implementar un microservicio con Go y gorilla/mux, sigue estos pasos: primero, define la estructura del proyecto, separando capas como handlers, servicios y modelos. Luego, configura gorilla/mux para enrutar peticiones HTTP a funciones específicas. Por ejemplo, una ruta /api/users podría mapearse a un handler que gestiona operaciones CRUD de usuarios. Usa middlewares para tareas comunes como autenticación o logging.
En un escenario real, supón que estás construyendo un servicio de pedidos. El flujo sería: el cliente envía una petición POST a /api/orders con datos JSON, gorilla/mux la dirige al handler correspondiente, que valida los datos, llama a un servicio para procesar el pedido y devuelve una respuesta. Asegúrate de usar puertos diferentes para cada servicio, como 8080 para usuarios y 8081 para pedidos, y comunícalos mediante HTTP o mensajería.
Codigo en accion
Aquí tienes un ejemplo básico de un microservicio para gestionar usuarios con gorilla/mux. Primero, el código inicial sin estructura:
package main
import (
"encoding/json"
"net/http"
"github.com/gorilla/mux"
)
func main() {
r := mux.NewRouter()
r.HandleFunc("/users", getUsers).Methods("GET")
http.ListenAndServe(":8080", r)
}
func getUsers(w http.ResponseWriter, r *http.Request) {
users := []string{"Alice", "Bob"}
json.NewEncoder(w).Encode(users)
}Ahora, refactorizado con mejor estructura y manejo de errores:
package main
import (
"encoding/json"
"log"
"net/http"
"github.com/gorilla/mux"
)
type User struct {
ID int `json:"id"`
Name string `json:"name"`
}
func main() {
r := mux.NewRouter()
r.HandleFunc("/api/users", getUsersHandler).Methods("GET")
log.Println("Servicio de usuarios iniciado en puerto 8080")
if err := http.ListenAndServe(":8080", r); err != nil {
log.Fatal(err)
}
}
func getUsersHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
users := []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}}
if err := json.NewEncoder(w).Encode(users); err != nil {
http.Error(w, "Error al codificar respuesta", http.StatusInternalServerError)
}
}Errores comunes
- Acoplamiento fuerte entre servicios: Evita que un microservicio llame directamente a la base de datos de otro. En su lugar, usa APIs REST o colas de mensajes para la comunicación.
- Manejo inadecuado de errores: No ignores errores en Go; siempre verifica los retornos de funciones como
json.Encodeohttp.ListenAndServepara prevenir caídas silenciosas. - Falta de timeouts en peticiones HTTP: Al comunicar servicios, configura timeouts usando
http.Clientpara evitar bloqueos por servicios lentos. - Rutas mal definidas en gorilla/mux: Asegúrate de que las rutas como
/api/users/{id}usenmux.Vars(r)correctamente para extraer parámetros. - Olvidar middlewares para seguridad: Incluye middlewares para CORS, autenticación y logging para proteger y monitorear tu API.
Checklist de dominio
- ¿Puedes crear un microservicio con Go que responda a rutas GET y POST usando gorilla/mux?
- ¿Sabes estructurar un proyecto en capas (handlers, services, models) para mantener el código limpio?
- ¿Manejas errores HTTP adecuadamente, devolviendo códigos de estado como 400 o 500?
- ¿Configuras middlewares en gorilla/mux para tareas como logging o autenticación?
- ¿Comunicas microservicios mediante peticiones HTTP con timeouts y manejo de respuestas?
- ¿Despliegas servicios en puertos diferentes y los pruebas con herramientas como curl o Postman?
- ¿Documentas tus APIs con comentarios o herramientas como Swagger?
Construye un microservicio de productos con CRUD completo
Sigue estos pasos para crear un microservicio que gestione productos usando Go y gorilla/mux:
- Crea un nuevo proyecto Go con una estructura de carpetas:
handlers/,models/,main.go. - En
models/product.go, define una estructuraProductcon campos ID, Nombre, Precio y Stock. - En
handlers/product_handler.go, implementa funciones para manejar rutas: GET/api/products(listar todos), GET/api/products/{id}(obtener uno), POST/api/products(crear), PUT/api/products/{id}(actualizar), DELETE/api/products/{id}(eliminar). Usa un slice en memoria para almacenar productos temporalmente. - En
main.go, configura gorilla/mux para enrutar estas rutas a los handlers, añade un middleware para logging que registre cada petición. - Ejecuta el servicio en el puerto 8081 y prueba cada endpoint con curl o Postman, verificando que devuelva los códigos HTTP correctos (200, 201, 404, etc.).
Pistas
- Usa mux.Vars(r) para extraer el ID de la URL en las rutas con parámetros.
- En el handler POST, decodifica el cuerpo JSON con json.NewDecoder(r.Body).Decode(&product).
- Para simular una base de datos, usa un slice global de Product y un mutex para seguridad en concurrencia.
Evalua tu comprension
Completa el quiz interactivo de arriba para ganar XP.
Sigue con Go con Gorilla/Mux: CRUD, Validación y Microservicios
Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.
Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.