Cómo escribir una API REST en Go en 30 minutos: en la práctica

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción: por qué Go es la elección ideal para REST API

Go (Golang) es un lenguaje de programación compilado, creado en Google para sistemas de alta carga. Combina la velocidad de C, la simplicidad de Python y el soporte integrado para concurrencia. Para crear REST API, Go ofrece la potente biblioteca estándar net/http y frameworks populares como gorilla/mux y gin.

En esta guía, crearemos en 30 minutos una REST API completa para gestionar una lista de tareas (Todo List) en Go puro, sin frameworks externos. Aprenderás a:

Configurar enrutamiento y handlers
Trabajar con JSON (serialización/deserialización)
Implementar operaciones CRUD (Create, Read, Update, Delete)
Añadir middleware para logging y CORS

Todo el código estará escrito en un solo archivo main.go para simplificar. ¡Comencemos!

Paso 1: Estructura básica e inicio del servidor HTTP

Crea un archivo main.go y añade el siguiente código. Declararemos la estructura de datos para una tarea e iniciaremos un servidor simple.

package main

import (    "encoding/json"    "log"    "net/http"    "strconv"    "strings"    "sync"    "time")

// Task — estructura de la tareatype Task struct {    ID        int       `json:"id"`    Title     string    `json:"title"`    Completed bool      `json:"completed"`    CreatedAt time.Time `json:"created_at"`}

// Almacenamiento de tareas (in-memory)var (    tasks   = make(map[int]Task)    nextID  = 1    mu      sync.Mutex)

func main() {    // Rutas    http.HandleFunc("/api/tasks", tasksHandler)    http.HandleFunc("/api/tasks/", taskByIDHandler)

    log.Println("Servidor iniciado en :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Explicación:

Task — estructura con etiquetas JSON para una serialización correcta.
tasks — mapa para almacenar tareas en memoria (sin BD).
mu — mutex para acceso seguro desde goroutines.
Dos rutas: /api/tasks (listar y crear) y /api/tasks/ (trabajar con una tarea por ID).

Paso 2: Handlers para la lista de tareas (GET y POST)

Implementamos la función tasksHandler, que maneja GET (obtener todas las tareas) y POST (crear una nueva tarea).

func tasksHandler(w http.ResponseWriter, r *http.Request) {    w.Header().Set("Content-Type", "application/json")

    switch r.Method {    case http.MethodGet:        mu.Lock()        taskList := make([]Task, 0, len(tasks))        for _, task := range tasks {            taskList = append(taskList, task)        }        mu.Unlock()        json.NewEncoder(w).Encode(taskList)

    case http.MethodPost:        var newTask Task        if err := json.NewDecoder(r.Body).Decode(&newTask); err != nil {            http.Error(w, `{"error":"JSON inválido"}`, http.StatusBadRequest)            return        }        mu.Lock()        newTask.ID = nextID        nextID++        newTask.CreatedAt = time.Now()        tasks[newTask.ID] = newTask        mu.Unlock()

        w.WriteHeader(http.StatusCreated)        json.NewEncoder(w).Encode(newTask)

    default:        http.Error(w, `{"error":"Método no soportado"}`, http.StatusMethodNotAllowed)    }}

Puntos clave:

Usamos json.NewEncoder y json.NewDecoder para trabajar con JSON.
En POST, verificamos la validez del JSON, asignamos un ID y devolvemos 201 Created.
El mutex protege los datos durante el acceso concurrente.