Saltar al contenido

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

Integración con bases de datos (ej., PostgreSQL)

Concepto claveLa integración con bases de datos es el puente entre tu microservicio escrito en Go y el almacenamiento persistente de datos. Imagina que tu API es un restaurante: los clientes (usuarios) piden platos (solicitudes.

Del concepto a la práctica

Taller de esta lección

Una consulta parametrizada separa la instrucción de los valores recibidos. Para buscar pedidos por estado, usa WHERE status = $1 y entrega el estado como argumento; nunca construyas la sentencia concatenando texto del cliente.

Ejemplo resuelto

La función de repositorio completa de abajo consulta y cierra las filas.

Con registros (3,pending), (4,paid) y (8,pending), la consulta devuelve IDs 3 y 8, en ese orden.

Pruébalo

  1. Crea una tabla local con esos tres registros.

  2. Ejecuta la consulta parametrizada para pending.

  3. Itera con rows.Next y escanea ambos campos.

  4. Comprueba rows.Err() después del bucle.

Error frecuente: olvidar rows.Close o no revisar el error final de iteración. Corrígelo usando defer tras una consulta exitosa y comprobando ambos puntos.

Comprueba tu resultado

La salida debe contener exactamente (3,pending) y (8,pending). Una cadena de estado distinta, como pending' OR '1'='1, no debe ampliar el resultado.

Iteración completa y contexto del llamador

El fragmento se convierte en una función de repositorio con imports context,database/sql. El *sql.DB se abre una vez por servicio y representa un pool; no se cierra después de cada consulta.

go
type Order struct { ID int; Status string }
func pendientes(ctx context.Context,db *sql.DB)([]Order,error){
  rows,err:=db.QueryContext(ctx,"SELECT id,status FROM orders WHERE status=$1 ORDER BY id","pending")
  if err!=nil{return nil,err};defer rows.Close()
  out:=make([]Order,0)
  for rows.Next(){
    var o Order
    if err:=rows.Scan(&o.ID,&o.Status);err!=nil{return nil,err}
    out=append(out,o)
  }
  if err:=rows.Err();err!=nil{return nil,err}
  return out,nil
}

Tabla de prueba:3pending,4paid,8pending. Resultado ordenado3/8; una consulta genérica con estado como parámetro pending' OR '1'='1 busca ese valor literal, no todos los registros. Esta función fija pending; para ese segundo ensayo declara otra que recibe status string y lo pasa como argumento.

sql.Open no garantiza conexión viva: verifica PingContext con plazo e instala/importa un driver PostgreSQL compatible. Configura DSN fuera del código, TLS según entorno, y no copia secret/sslmode=disable del ejemplo histórico a producción. QueryRowContext requiere Scan y sql.ErrNoRows se distingue de fallos. Operaciones multiwrite usan BeginTx, defer Rollback y Commit comprobado. Un plazo de consulta no es automáticamente408(request del cliente incompleto); define503 para indisponibilidad o504 si realmente actúas como gateway. Consulta, Cancelación.

Tablas de clientes y pedidos: INNER JOIN conserva coincidencias y LEFT JOIN conserva también a Luis sin pedidos.
CursaloMapa de práctica
Relacionar tablas sin perder filas

Una clave conecta cada pedido con su cliente. INNER JOIN devuelve las coincidencias y puede producir varias filas por cliente. LEFT JOIN conserva también los clientes sin pedido y representa los campos ausentes con NULL.

Ver la infografía en tamaño completo ↗

Concepto clave

La integración con bases de datos es el puente entre tu microservicio escrito en Go y el almacenamiento persistente de datos. Imagina que tu API es un restaurante: los clientes (usuarios) piden platos (solicitudes HTTP), la cocina (tu lógica en Go) los prepara, pero necesita ingredientes almacenados en una despensa (la base de datos). Sin una conexión eficiente a esa despensa, el restaurante no puede funcionar de manera consistente.

En el contexto de microservicios con gorilla/mux, esta integración implica configurar un pool de conexiones a PostgreSQL que maneje múltiples solicitudes concurrentes sin crear una nueva conexión por cada una. Esto es crucial para APIs de alto rendimiento, donde cientos o miles de usuarios pueden acceder simultáneamente. Un pool actúa como un conjunto de conexiones reutilizables, similar a un equipo de repartidores que recogen y entregan paquetes sin necesidad de contratar uno nuevo para cada envío.

Cómo funciona en la práctica

Para integrar PostgreSQL en tu microservicio Go, sigue estos pasos:

  1. Instala el driver de PostgreSQL para Go usando go get github.com/lib/pq.
  2. Configura una estructura de conexión con parámetros como host, puerto, usuario, contraseña y nombre de la base de datos.
  3. Inicializa un pool de conexiones usando sql.Open y configuración adicional para optimizar el rendimiento (ej., máximo de conexiones, tiempo de vida).
  4. En tus handlers de gorilla/mux, usa el pool para ejecutar consultas SQL (SELECT, INSERT, UPDATE, DELETE) y manejar transacciones cuando sea necesario.
  5. Cierra el pool al finalizar la aplicación para liberar recursos.

Este enfoque asegura que tu microservicio pueda manejar carga alta sin saturar la base de datos, manteniendo respuestas rápidas y confiables.

Codigo en accion

Aquí tienes un ejemplo básico de configuración del pool de conexiones y un handler que consulta datos:

package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/gorilla/mux"
    _ "github.com/lib/pq"
)

var db *sql.DB

func initDB() {
    connStr := "host=localhost port=5432 user=postgres password=secret dbname=mydb sslmode=disable"
    var err error
    db, err = sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal(err)
    }
    // Configurar el pool
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(10)
    db.SetConnMaxLifetime(5 * time.Minute)
    // Verificar conexión
    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }
    fmt.Println("Conectado a PostgreSQL")
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id := vars["id"]
    var name string
    err := db.QueryRow("SELECT name FROM users WHERE id = $1", id).Scan(&name)
    if err != nil {
        if err == sql.ErrNoRows {
            http.Error(w, "Usuario no encontrado", http.StatusNotFound)
        } else {
            http.Error(w, "Error interno", http.StatusInternalServerError)
        }
        return
    }
    fmt.Fprintf(w, "Usuario: %s", name)
}

func main() {
    initDB()
    defer db.Close()
    r := mux.NewRouter()
    r.HandleFunc("/users/{id}", getUserHandler).Methods("GET")
    log.Fatal(http.ListenAndServe(":8080", r))
}

Ahora, mejora este código refactorizando para usar un contexto y manejar timeouts, evitando que consultas lentas bloqueen el servidor:

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
    defer cancel()
    vars := mux.Vars(r)
    id := vars["id"]
    var name string
    err := db.QueryRowContext(ctx, "SELECT name FROM users WHERE id = $1", id).Scan(&name)
    if err != nil {
        if err == sql.ErrNoRows {
            http.Error(w, "Usuario no encontrado", http.StatusNotFound)
        } else if ctx.Err() == context.DeadlineExceeded {
            http.Error(w, "Timeout en la consulta", http.StatusRequestTimeout)
        } else {
            http.Error(w, "Error interno", http.StatusInternalServerError)
        }
        return
    }
    fmt.Fprintf(w, "Usuario: %s", name)
}

Errores comunes

  • No usar un pool de conexiones: Crear una nueva conexión por cada solicitud agota los recursos y ralentiza la API. Solución: Configura SetMaxOpenConns y SetMaxIdleConns según la carga esperada.
  • Ignorar el manejo de errores en consultas: No verificar sql.ErrNoRows o errores de conexión puede causar respuestas incorrectas o pánicos. Solución: Usa sentencias if err != nil y maneja casos específicos.
  • Olvidar cerrar recursos: No cerrar Rows o Transactions despues de usarlos genera fugas de memoria. Solución: Usa defer rows.Close() o defer tx.Rollback().
  • No usar contextos para timeouts: Consultas sin límite de tiempo pueden bloquear el servidor indefinidamente. Solución: Implementa QueryRowContext con un contexto con timeout.
  • Exponer detalles de la base de datos en errores: Enviar mensajes de error SQL al cliente compromete la seguridad. Solución: Logea los errores internamente y responde con mensajes genéricos al cliente.

Checklist de dominio

  • Configurar un pool de conexiones a PostgreSQL con parámetros optimizados para tu carga.
  • Implementar handlers en gorilla/mux que ejecuten consultas SELECT, INSERT, UPDATE y DELETE.
  • Manejar transacciones para operaciones que requieren atomicidad (ej., transferencias).
  • Usar contextos para controlar timeouts y cancelaciones en consultas largas.
  • Validar y sanitizar entradas de usuario para prevenir inyecciones SQL.
  • Probar la integración con una base de datos real o un contenedor Docker.
  • Monitorizar métricas como tiempo de respuesta y número de conexiones activas.

Crear un microservicio CRUD con PostgreSQL y gorilla/mux

En este ejercicio, construirás un microservicio básico que gestione una lista de productos, integrando PostgreSQL para persistencia. Sigue estos pasos:

  1. Configura una base de datos PostgreSQL local o en un contenedor Docker con una tabla products que tenga columnas: id (SERIAL PRIMARY KEY), name (VARCHAR), price (DECIMAL).
  2. Crea un proyecto Go e instala las dependencias: gorilla/mux y lib/pq.
  3. Implementa una función initDB que inicialice un pool de conexiones con configuración para máximo 20 conexiones abiertas y 5 inactivas.
  4. Define handlers para:
    • GET /products: Listar todos los productos.
    • GET /products/{id}: Obtener un producto por ID.
    • POST /products: Crear un nuevo producto (usa JSON en el body).
    • PUT /products/{id}: Actualizar un producto existente.
    • DELETE /products/{id}: Eliminar un producto.
  5. Asegúrate de usar contextos con timeout de 2 segundos en todas las consultas.
  6. Prueba el microservicio con herramientas como curl o Postman, verificando que las operaciones CRUD funcionen correctamente.
Pistas
  • Usa json.NewDecoder(r.Body).Decode(&product) para parsear JSON en el handler POST.
  • Para el handler GET de todos los productos, recuerda iterar sobre rows.Next() y cerrar las filas con defer.
  • En el handler PUT, considera usar una transacción si necesitas actualizar múltiples campos atómicamente.

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.