Configuración inicial de un proyecto Go con gorilla/mux

Concepto clave

Configurar un proyecto Go correctamente es como preparar los cimientos de un edificio: si la base es sólida, todo lo que construyas encima será estable y escalable. En el contexto de APIs REST con gorilla/mux, esto implica no solo instalar dependencias, sino estructurar tu código de manera que sea mantenible y eficiente desde el primer día.

Imagina que estás organizando una cocina profesional: necesitas tener tus herramientas (paquetes Go) en lugares específicos, ingredientes (dependencias) frescos y un flujo de trabajo claro. De manera similar, un proyecto Go bien configurado usa go modules para gestionar dependencias, separa responsabilidades en carpetas lógicas, y establece puntos de entrada claros para tu API. Esto evita el "spaghetti code" y facilita colaboraciones en equipos.

Cómo funciona en la práctica

Vamos a desglosar el proceso en pasos concretos que puedes seguir en tu terminal y editor de código. Primero, asegúrate de tener Go instalado (versión 1.16 o superior recomendada). Luego, crea un directorio para tu proyecto y navega a él. Inicializa un módulo Go con go mod init, que generará un archivo go.mod para rastrear dependencias.

Después, instala gorilla/mux usando go get. Este paquete es un enrutador HTTP potente que te permite definir rutas RESTful de manera intuitiva. Organiza tu código en carpetas como cmd/ para el ejecutable principal, internal/ para lógica privada, y pkg/ para código reusable. Configura un archivo main.go básico que importe gorilla/mux y defina un servidor HTTP.

Código en acción

Aquí tienes un ejemplo funcional de configuración inicial. Crea un archivo main.go en la raíz de tu proyecto:

package main

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

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", homeHandler).Methods("GET")
    r.HandleFunc("/api/health", healthHandler).Methods("GET")

    fmt.Println("Servidor iniciado en http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", r))
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("¡API con gorilla/mux configurada!"))
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"status": "ok"}`))
}

Antes de ejecutar, asegúrate de que tu go.mod incluya gorilla/mux. Si no, corre go mod tidy para sincronizar dependencias. Luego, ejecuta con go run main.go y visita http://localhost:8080 en tu navegador para ver el mensaje.

Errores comunes

• Olvidar inicializar go modules: Sin go mod init, no puedes gestionar dependencias eficientemente. Siempre ejecútalo al crear un nuevo proyecto.
• Importar gorilla/mux incorrectamente: Asegúrate de usar la ruta correcta github.com/gorilla/mux en tus imports; errores de tipografía causan fallos de compilación.
• No usar go mod tidy: Este comando limpia y actualiza go.mod y go.sum. Ejecútalo después de agregar o remover dependencias para evitar inconsistencias.
• Estructura de carpetas desorganizada: Evita poner todo en la raíz. Usa carpetas como cmd/ y internal/ para mejorar la mantenibilidad.
• Ignorar el manejo de errores en el servidor: Siempre verifica errores al iniciar el servidor, como se hace con log.Fatal en el ejemplo, para debuggear rápido.

Checklist de dominio

1. ¿Inicialicé el proyecto con go mod init y tengo un archivo go.mod válido?
2. ¿Instalé gorilla/mux usando go get y aparece en go.mod?
3. ¿Mi archivo main.go importa correctamente gorilla/mux y define rutas básicas?
4. ¿Ejecuté go mod tidy para sincronizar dependencias y verifiqué que no hay warnings?
5. ¿Puedo correr el servidor con go run main.go y acceder a las rutas definidas?
6. ¿Organicé mi código en carpetas lógicas (ej., cmd/, internal/) para escalabilidad?
7. ¿Incluí manejo básico de errores y logs en la configuración inicial?

Configura un proyecto Go desde cero con gorilla/mux y despliégalo localmente

Sigue estos pasos para crear y probar un proyecto Go básico con gorilla/mux:

1. Crea un nuevo directorio llamado mi-api-go y navega a él en tu terminal.
2. Inicializa un módulo Go ejecutando go mod init github.com/tu-usuario/mi-api-go (reemplaza con tu usuario real o un nombre único).
3. Instala gorilla/mux con go get github.com/gorilla/mux.
4. Crea un archivo main.go en la raíz y copia el código del ejemplo de "Código en acción", pero agrega una nueva ruta /api/users que responda con JSON {"users": []}.
5. Ejecuta go mod tidy para asegurar que las dependencias estén actualizadas.
6. Corre el servidor con go run main.go y prueba las rutas /, /api/health, y /api/users usando curl o un navegador.
7. Verifica que todas las respuestas sean correctas y que no haya errores en la terminal.

• Usa curl http://localhost:8080/api/users en otra terminal para probar tu nueva ruta sin navegador.
• Si ves errores de importación, revisa que go.mod incluya gorilla/mux y ejecuta go mod tidy de nuevo.
• Para la nueva ruta, define un handler similar a healthHandler pero con diferente contenido JSON.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.