Lección 1 de 20 · Lectura y práctica
Configuración inicial de un proyecto Go con gorilla/mux
Concepto claveConfigurar 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.
Del concepto a la práctica
Taller de esta lección
La configuración inicial debe demostrar qué pertenece al módulo y qué pertenece a la aplicación. Un proyecto mínimo para una API de inventario puede tener cmd/api/main.go, internal/httpapi y un go.mod; así el punto de entrada no absorbe toda la lógica.
Ejemplo resuelto
package main
import (
"fmt"
"log"
"time"
"net/http"
"github.com/gorilla/mux"
)
func main() {
r := mux.NewRouter()
r.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
fmt.Fprintln(w, "ok")
}).Methods(http.MethodGet)
srv:=&http.Server{Addr:"127.0.0.1:8080",Handler:r,ReadHeaderTimeout:5*time.Second,WriteTimeout:10*time.Second,IdleTimeout:30*time.Second}
if err:=srv.ListenAndServe();err!=nil&&err!=http.ErrServerClosed{log.Fatal(err)}
}Pruébalo
Inicializa el módulo con el import path de tu proyecto.
Añade gorilla/mux y ejecuta el servidor local.
Solicita
GET /healthy guarda el cuerpo recibido.
Error frecuente: importar paquetes sin actualizar el módulo. Corrígelo ejecutando las herramientas de dependencias desde la raíz y comprobando que go.mod registra el paquete.
Comprueba tu resultado
El ejercicio es correcto si el proceso arranca sin errores, GET /health devuelve el texto ok seguido de salto de línea y una ruta inexistente no responde como saludable.
Módulo, respuesta y servidor acotado
Usa una versión Go actualmente soportada y registra go version, go.mod y go.sum; el mínimo1.16 histórico no es recomendación de soporte actual. En el directorio nuevo ejecuta go mod init example.com/inventario, incorpora gorilla/mux con go get y fija la versión seleccionada; go mod tidy conserva imports usados, no convierte automáticamente todos los paquetes a su última versión. pkg/ es una convención opcional, internal/ sí tiene restricciones de importación.
El main completo del ejemplo debe manejar el error del servidor y limitar tiempos. fmt.Fprintln escribe ok seguido de salto de línea: comprueba ambos, no bytes exactos sin ese salto. GET /health→200; GET /missing→404; POST /health→405 con la restricción del router. La salud mínima indica proceso/ruta, no conexión de base de datos ni capacidad de crear pedidos. Sirve en loopback para la práctica; en contenedor se cambia conscientemente la interfaz. No escribas Servidor iniciado como prueba anterior a ListenAndServe: un puerto ocupado puede impedir arrancar. Módulos.

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
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/muxen tus imports; errores de tipografía causan fallos de compilación. - No usar go mod tidy: Este comando limpia y actualiza
go.modygo.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/yinternal/para mejorar la mantenibilidad. - Ignorar el manejo de errores en el servidor: Siempre verifica errores al iniciar el servidor, como se hace con
log.Fatalen el ejemplo, para debuggear rápido.
Checklist de dominio
- ¿Inicialicé el proyecto con
go mod inity tengo un archivogo.modválido? - ¿Instalé gorilla/mux usando
go gety aparece engo.mod? - ¿Mi archivo
main.goimporta correctamente gorilla/mux y define rutas básicas? - ¿Ejecuté
go mod tidypara sincronizar dependencias y verifiqué que no hay warnings? - ¿Puedo correr el servidor con
go run main.goy acceder a las rutas definidas? - ¿Organicé mi código en carpetas lógicas (ej.,
cmd/,internal/) para escalabilidad? - ¿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:
- Crea un nuevo directorio llamado
mi-api-goy navega a él en tu terminal. - 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). - Instala gorilla/mux con
go get github.com/gorilla/mux. - Crea un archivo
main.goen la raíz y copia el código del ejemplo de "Código en acción", pero agrega una nueva ruta/api/usersque responda con JSON{"users": []}. - Ejecuta
go mod tidypara asegurar que las dependencias estén actualizadas. - Corre el servidor con
go run main.goy prueba las rutas/,/api/health, y/api/usersusando curl o un navegador. - Verifica que todas las respuestas sean correctas y que no haya errores en la terminal.
Pistas
- Usa
curl http://localhost:8080/api/usersen otra terminal para probar tu nueva ruta sin navegador. - Si ves errores de importación, revisa que
go.modincluya gorilla/mux y ejecutago mod tidyde nuevo. - Para la nueva ruta, define un handler similar a
healthHandlerpero con diferente contenido JSON.
Evalua tu comprension
Completa el quiz interactivo de arriba para ganar XP.
Práctica acompañada: Una app que cabe en tu día
Un proyecto pequeño con React Native y Expo. Usa este cuaderno como práctica complementaria de la ruta; el material original de la lección continúa siendo tu referencia.
Práctica: prueba en cuatro condiciones
Completa el flujo con una imagen vertical, una horizontal, cancelando el selector y negando el permiso. Comprueba que la aplicación conserva proporciones y que ningún control queda fuera de alcance. Repite al volver del fondo y al cambiar el tamaño del texto.
Si tu proyecto permite guardar la imagen, verifica por separado el permiso y el resultado de guardado. No muestres «Guardado» antes de que la operación termine. Usa archivos de prueba propios. Para comparar versiones, conserva capturas con el mismo dispositivo, orientación y tamaño de letra.
Comprueba tu entrega
Entrega el repositorio con instrucciones, la lista de versiones y la matriz de dispositivos. Incluye una captura de cada estado y un video propio breve que muestre el recorrido entero, incluida la cancelación. No hace falta publicar una app para demostrar este aprendizaje.
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.