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
Crea una tabla local con esos tres registros.
Ejecuta la consulta parametrizada para
pending.Itera con
rows.Nexty escanea ambos campos.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.
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.

Mapa de prácticaUna 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:
- Instala el driver de PostgreSQL para Go usando
go get github.com/lib/pq. - Configura una estructura de conexión con parámetros como host, puerto, usuario, contraseña y nombre de la base de datos.
- Inicializa un pool de conexiones usando
sql.Openy configuración adicional para optimizar el rendimiento (ej., máximo de conexiones, tiempo de vida). - En tus handlers de gorilla/mux, usa el pool para ejecutar consultas SQL (SELECT, INSERT, UPDATE, DELETE) y manejar transacciones cuando sea necesario.
- 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
SetMaxOpenConnsySetMaxIdleConnssegún la carga esperada. - Ignorar el manejo de errores en consultas: No verificar
sql.ErrNoRowso errores de conexión puede causar respuestas incorrectas o pánicos. Solución: Usa sentenciasif err != nily maneja casos específicos. - Olvidar cerrar recursos: No cerrar
RowsoTransactionsdespues de usarlos genera fugas de memoria. Solución: Usadefer rows.Close()odefer tx.Rollback(). - No usar contextos para timeouts: Consultas sin límite de tiempo pueden bloquear el servidor indefinidamente. Solución: Implementa
QueryRowContextcon 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:
- Configura una base de datos PostgreSQL local o en un contenedor Docker con una tabla
productsque tenga columnas:id(SERIAL PRIMARY KEY),name(VARCHAR),price(DECIMAL). - Crea un proyecto Go e instala las dependencias:
gorilla/muxylib/pq. - Implementa una función
initDBque inicialice un pool de conexiones con configuración para máximo 20 conexiones abiertas y 5 inactivas. - 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.
- Asegúrate de usar contextos con timeout de 2 segundos en todas las consultas.
- 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 condefer. - 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.