Saltar al contenido

Lección 4 de 20 · Lectura y práctica

Práctica: Crear una API simple para gestión de usuarios

Concepto claveEn el desarrollo de APIs REST con Go y gorilla/mux, el enrutador es el corazón que dirige las peticiones HTTP hacia los manejadores adecuados. Imagina un edificio de oficinas donde el recepcionista (el enrutador).

Del concepto a la práctica

Taller de esta lección

Una API de usuarios necesita separar la identidad pública de los datos que no deben salir. En este ejercicio el modelo almacenado incluye email y nombre, pero la respuesta solo expone id, name y email; no hay contraseña en el JSON de salida.

Ejemplo resuelto

go
type User struct { ID int; Name, Email string }
type UserView struct { ID int `json:"id"`; Name string `json:"name"`; Email string `json:"email"` }

Para GET /users/11 en el fixture de abajo, el handler busca el ID y transforma el resultado a UserView. Si no existe, responde 404 y no construye una vista vacía.

Pruébalo

  1. Carga tres usuarios con IDs 10, 11 y 12.

  2. Implementa GET /users/{id} usando mux.Vars.

  3. Devuelve solo la vista pública del usuario encontrado.

  4. Prueba los IDs 11 y 99.

Error frecuente: usar el índice del slice como si fuera el ID. Corrígelo comparando el campo ID; los datos pueden estar ordenados de otra manera.

Comprueba tu resultado

El ID 11 debe devolver exactamente el usuario correspondiente y código 200. El ID 99 debe devolver 404, un mensaje JSON de error y ningún usuario inventado.

Usuarios concretos y ausencia segura

Declara usuarios completos: ID10/Luz/luz@example.test, ID11/Ana/ana@example.test, ID12/Ivo/ivo@example.test. El ejemplo GET/users/2 es un caso de ausencia para este fixture; el ejercicio que existe es GET/users/11→{"id":11,"name":"Ana","email":"ana@example.test"} con200. GET/users/99→404 con error user_not_found. GET/users/abc→400 si el contrato admite enteros positivos y strconv.Atoi falla; una restricción de ruta que nunca coincide puede dar404, así que documenta el diseño elegido.

No ignores Atoi ni Decode como en algunos fragmentos históricos. DTO UserView tiene tags y campos permitidos explícitos; omite contraseñas/hash aunque existan en almacenamiento. El tipo de respuesta pública no implica que email sea apropiado para cualquier usuario: autorización decide quién puede leerlo. Inicializa la colección vacía con make([]UserView,0) para codificar[] si ese es el contrato; un slice nil normalmente codifica null. Lee/escribe almacenamiento compartido con sincronización, sin confundir índice y ID.

Navegador, API y base de datos conectados por solicitudes, consultas y respuestas en sentidos opuestos.
CursaloMapa de práctica
Del navegador a los datos

El 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

En el desarrollo de APIs REST con Go y gorilla/mux, el enrutador es el corazón que dirige las peticiones HTTP hacia los manejadores adecuados. Imagina un edificio de oficinas donde el recepcionista (el enrutador) decide a qué departamento (manejador) enviar a cada visitante (petición) basándose en su identificación (ruta y método HTTP). gorilla/mux extiende el enrutador estándar de Go, permitiendo definir rutas con parámetros dinámicos, validaciones y middleware de forma más expresiva.

Para una API de gestión de usuarios, necesitamos rutas que manejen operaciones CRUD (Crear, Leer, Actualizar, Eliminar) sobre recursos de usuario. Cada ruta debe seguir las convenciones REST: usar métodos HTTP apropiados (GET para leer, POST para crear, PUT/PATCH para actualizar, DELETE para eliminar) y devolver códigos de estado significativos (como 200 para éxito, 404 para no encontrado). La estructura del proyecto típica incluye un archivo principal (main.go) que configura el enrutador y los manejadores, separando la lógica de negocio en funciones o estructuras.

Cómo funciona en la práctica

Comienza creando un proyecto Go con go mod init y añadiendo la dependencia de gorilla/mux. Luego, en main.go, importa los paquetes necesarios y define una estructura User para representar los datos del usuario. Configura el enrutador usando mux.NewRouter() y registra rutas con métodos como router.HandleFunc(). Por ejemplo, para manejar una petición GET a /users/{id}, define una función que extraiga el ID de la URL, busque el usuario en memoria (o una base de datos) y devuelva una respuesta JSON.

Paso a paso: 1) Inicializa el enrutador, 2) Define las rutas y sus manejadores, 3) Implementa la lógica en los manejadores para procesar peticiones y respuestas, 4) Inicia el servidor HTTP. Usa herramientas como Postman o curl para probar cada endpoint, verificando que las respuestas sean correctas y los códigos de estado apropiados. Esto te permite iterar rápidamente y asegurar que la API funcione como se espera antes de añadir complejidad.

Código en acción

Aquí tienes un ejemplo funcional de una API simple para gestión de usuarios con gorilla/mux. Este código maneja usuarios almacenados en un slice en memoria, con operaciones básicas de CRUD. Copia y pega esto en un archivo main.go para ejecutarlo localmente.

package main

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

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users []User
var currentID = 1

func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

func getUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    for _, user := range users {
        if user.ID == id {
            json.NewEncoder(w).Encode(user)
            return
        }
    }
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{"error": "Usuario no encontrado"})
}

func createUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var user User
    _ = json.NewDecoder(r.Body).Decode(&user)
    user.ID = currentID
    currentID++
    users = append(users, user)
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func updateUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    var updatedUser User
    _ = json.NewDecoder(r.Body).Decode(&updatedUser)
    for index, user := range users {
        if user.ID == id {
            users[index].Name = updatedUser.Name
            users[index].Email = updatedUser.Email
            json.NewEncoder(w).Encode(users[index])
            return
        }
    }
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{"error": "Usuario no encontrado"})
}

func deleteUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    for index, user := range users {
        if user.ID == id {
            users = append(users[:index], users[index+1:]...)
            w.WriteHeader(http.StatusNoContent)
            return
        }
    }
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{"error": "Usuario no encontrado"})
}

func main() {
    router := mux.NewRouter()
    router.HandleFunc("/users", getUsers).Methods("GET")
    router.HandleFunc("/users/{id}", getUser).Methods("GET")
    router.HandleFunc("/users", createUser).Methods("POST")
    router.HandleFunc("/users/{id}", updateUser).Methods("PUT")
    router.HandleFunc("/users/{id}", deleteUser).Methods("DELETE")
    log.Fatal(http.ListenAndServe(":8080", router))
}

Antes de ejecutar, instala gorilla/mux con go get github.com/gorilla/mux. Luego, ejecuta go run main.go y prueba con curl: curl -X GET http://localhost:8080/users para ver la lista vacía inicial. Después, crea un usuario: curl -X POST -H "Content-Type: application/json" -d '{"name":"Juan","email":"juan@example.com"}' http://localhost:8080/users. Esto te dará una respuesta JSON con el usuario creado, incluyendo un ID asignado.

Errores comunes

  • No validar entradas: En el ejemplo anterior, no validamos que el cuerpo de la petición POST tenga los campos requeridos. Esto puede llevar a datos corruptos. Solución: Añade validaciones básicas, como verificar que Name y Email no estén vacíos antes de procesar.
  • Olvidar configurar headers de contenido: Si no estableces Content-Type: application/json en las respuestas, los clientes pueden no interpretar correctamente los datos. Siempre incluye w.Header().Set("Content-Type", "application/json") al inicio de cada manejador que devuelva JSON.
  • Manejo inadecuado de errores: En el código, usamos _ = json.NewDecoder(r.Body).Decode(&user) ignorando errores. Esto puede causar pánicos si el JSON es inválido. Solución: Maneja el error y devuelve un código 400 Bad Request con un mensaje claro.
  • Uso de slices en memoria para producción: Almacenar usuarios en un slice volátil es solo para demostración; en producción, usa una base de datos. Refactoriza para integrar algo como PostgreSQL o MongoDB, manteniendo la misma interfaz de API.
  • No limpiar recursos: En una API real, asegúrate de cerrar conexiones o liberar recursos. Aunque este ejemplo es simple, es un hábito clave para evitar fugas de memoria en sistemas de alto rendimiento.

Checklist de dominio

  1. ¿Puedes crear un enrutador con gorilla/mux y definir al menos 5 rutas RESTful para un recurso?
  2. ¿Sabes extraer parámetros de URL (como {id}) y convertirlos a tipos Go adecuados?
  3. ¿Eres capaz de manejar peticiones POST, decodificar JSON del cuerpo y validar datos básicos?
  4. ¿Puedes devolver respuestas JSON con códigos de estado HTTP apropiados (200, 201, 404, etc.)?
  5. ¿Entiendes cómo probar la API con herramientas como curl o Postman, verificando cada endpoint?
  6. ¿Sabes identificar y corregir errores comunes, como falta de validación o headers incorrectos?
  7. ¿Puedes explicar por qué el almacenamiento en memoria no es adecuado para producción y qué alternativas usarías?

Extender la API de usuarios con validación y logging

En este ejercicio, mejorarás la API de gestión de usuarios añadiendo validación de datos y logging básico. Sigue estos pasos:

  1. Clona el código base: Usa el ejemplo proporcionado en la lección como punto de partida. Asegúrate de que funcione localmente en localhost:8080.
  2. Añade validación en el manejador POST: Modifica la función createUser para validar que los campos Name y Email no estén vacíos y que el email tenga un formato básico (contenga '@'). Si la validación falla, devuelve un código de estado 400 con un mensaje de error en JSON.
  3. Implementa logging: Añade logging para registrar cada petición entrante. Usa el paquete log de Go para imprimir en consola el método HTTP, la ruta y el código de estado de respuesta. Haz esto en un middleware o directamente en cada manejador.
  4. Refactoriza el almacenamiento: Cambia el slice en memoria por un map de Go (por ejemplo, map[int]User) para mejorar la eficiencia en búsquedas por ID. Actualiza las funciones CRUD para usar este map.
  5. Prueba las mejoras: Usa curl o Postman para enviar peticiones válidas e inválidas, verificando que las validaciones y el logging funcionen correctamente. Por ejemplo, prueba crear un usuario sin nombre y observa la respuesta de error.

Al final, deberías tener una API más robusta y lista para integrar en un entorno de desarrollo real.

Pistas
  • Para validar el formato de email, puedes usar una expresión regular simple o verificar que la cadena contenga '@' y un punto después.
  • Considera crear una función auxiliar para logging que puedas llamar desde cada manejador, evitando duplicar código.
  • Al usar un map, recuerda manejar el acceso concurrente si planeas usar gorutinas en el futuro; por ahora, un map simple es suficiente para este ejercicio.

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.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.