Concepto clave

Configurar un entorno de desarrollo para APIs REST en Go con Gorilla/Mux es como preparar una cocina profesional antes de cocinar un banquete. Necesitas las herramientas correctas, ingredientes frescos y un espacio organizado. En este contexto, el entorno de desarrollo incluye Go instalado, un gestor de dependencias como Go Modules, y el router Gorilla/Mux que actúa como el "chef" que dirige las peticiones HTTP a las funciones adecuadas.

Gorilla/Mux es un router HTTP potente y flexible que extiende las capacidades del paquete net/http estándar de Go. Piensa en él como un sistema de enrutamiento inteligente que puede manejar rutas complejas, parámetros dinámicos y middleware de forma eficiente. Para APIs de alto rendimiento, esta configuración inicial es crucial porque establece las bases para un servidor escalable y mantenible.

Cómo funciona en la práctica

Vamos a configurar el entorno paso a paso. Primero, asegúrate de tener Go 1.16 o superior instalado. Luego, crea un nuevo directorio para tu proyecto y ejecuta go mod init nombre-del-proyecto para inicializar Go Modules. Esto genera un archivo go.mod que gestiona las dependencias.

Instala Gorilla/Mux ejecutando go get github.com/gorilla/mux. Ahora, crea un archivo main.go con una estructura básica. El router de Gorilla/Mux te permite definir rutas usando métodos HTTP como GET, POST, PUT, DELETE, y asociarlas a funciones manejadoras. Por ejemplo, puedes crear una ruta /api/users que responda a solicitudes GET.

Configura el servidor HTTP para escuchar en un puerto específico, como 8080. Usa http.ListenAndServe con el router como handler. Este enfoque separa claramente la lógica de enrutamiento de la lógica de negocio, facilitando el mantenimiento y las pruebas.

Código en acción

Aquí tienes un ejemplo funcional de un servidor HTTP básico con Gorilla/Mux:

package main

import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/mux"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "¡Bienvenido a mi API REST con Gorilla/Mux!")
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", homeHandler).Methods("GET")
    
    fmt.Println("Servidor iniciado en http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", r))
}

Ahora, mejoremos este código añadiendo una ruta con parámetros dinámicos y middleware para logging:

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
    "github.com/gorilla/mux"
)

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %s", r.Method, r.RequestURI, time.Since(start))
    })
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID := vars["id"]
    fmt.Fprintf(w, "Usuario ID: %s", userID)
}

func main() {
    r := mux.NewRouter()
    r.Use(loggingMiddleware)
    r.HandleFunc("/", homeHandler).Methods("GET")
    r.HandleFunc("/users/{id}", getUserHandler).Methods("GET")
    
    fmt.Println("Servidor iniciado en http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", r))
}

Errores comunes

No usar Go Modules: Esto puede llevar a problemas de dependencias. Siempre inicializa con go mod init para gestionar versiones de paquetes.
Olvidar importar Gorilla/Mux: Asegúrate de incluir "github.com/gorilla/mux" en tus imports, o el código no compilará.
Configurar rutas sin métodos HTTP: Gorilla/Mux requiere especificar métodos como .Methods("GET") para evitar comportamientos inesperados.
No manejar errores en http.ListenAndServe: Usa log.Fatal para registrar errores y detener el servidor si falla.
Ignorar el puerto en uso: Si el puerto 8080 está ocupado, cambia a otro como 8081 para evitar conflictos.

Checklist de dominio

Go instalado y configurado en la versión 1.16 o superior.
Proyecto inicializado con Go Modules usando go mod init.
Gorilla/Mux instalado como dependencia con go get.
Servidor HTTP básico funcionando en localhost con al menos una ruta GET.
Uso de rutas con parámetros dinámicos (ej: /users/{id}).
Middleware implementado para logging o similares.
Capacidad de probar el servidor con herramientas como curl o Postman.

Configura un servidor HTTP con rutas CRUD básicas

Sigue estos pasos para crear un servidor que maneje operaciones CRUD para un recurso 'productos':

Crea un nuevo directorio para el proyecto y ejecuta go mod init productos-api.
Instala Gorilla/Mux con go get github.com/gorilla/mux.
Crea un archivo main.go y define un struct Producto con campos ID, Nombre y Precio.
Implementa un slice en memoria para almacenar productos simulados.
Configura rutas con Gorilla/Mux para:
- GET /productos - Listar todos los productos
- GET /productos/{id} - Obtener un producto por ID
- POST /productos - Crear un nuevo producto (usa JSON)
- PUT /productos/{id} - Actualizar un producto existente
- DELETE /productos/{id} - Eliminar un producto
Añade middleware para loggear cada petición.
Ejecuta el servidor en puerto 8080 y prueba con curl o Postman.

Pistas

Usa encoding/json para manejar JSON en las peticiones POST y PUT.
Para rutas con ID, extrae el parámetro con mux.Vars(r).
Implementa manejo de errores HTTP, como 404 para productos no encontrados.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Configuración del entorno y primer servidor HTTP