Curso de PL/SH

Entender qué es un lenguaje procedural dentro de PostgreSQL y cómo se integra mediante handlers.

Revisar diferencias entre funciones SQL, PL/pgSQL, lenguajes trusted, lenguajes untrusted y extensiones externas.

Analizar cómo PostgreSQL delega la ejecución de código en un lenguaje procedural instalado.

Identificar implicaciones de seguridad cuando una función puede interactuar con el sistema operativo.

Revisar conceptos de `CREATE FUNCTION`, `LANGUAGE`, argumentos, retorno, volatilidad, coste y permisos.

Diferenciar funciones, procedimientos, triggers, funciones trigger y funciones auxiliares.

Entender cómo el contexto de ejecución afecta a permisos, búsqueda de objetos y acceso a recursos.

Evitar mezclar lógica de negocio crítica con automatizaciones operativas sin criterios claros.

Relacionar PL/sh con el ecosistema de extensiones PostgreSQL.

Taller: comparar la misma tarea en SQL, PL/pgSQL y PL/sh para ver diferencias reales.

Entender PL/sh como handler que ejecuta el cuerpo de la función mediante un intérprete de shell.

Revisar el papel del shebang para indicar qué intérprete ejecutará el script.

Analizar cómo se pasan argumentos desde PostgreSQL al script.

Comprender cómo se captura la salida estándar para devolver valores a PostgreSQL.

Identificar qué ocurre con errores, código de salida, stderr y comportamiento inesperado.

Revisar dependencias del entorno: usuario del proceso PostgreSQL, rutas, permisos, variables y binarios disponibles.

Separar responsabilidad de PostgreSQL, PL/sh, shell y comandos invocados.

Entender por qué el entorno de ejecución no es igual al shell interactivo del administrador.

Diseñar funciones pensando en reproducibilidad entre entornos.

Taller: inspeccionar entorno efectivo de ejecución de una función PL/sh.

Revisar requisitos de sistema, versión de PostgreSQL, compilación, paquetes y compatibilidad.

Preparar entorno aislado para instalar y probar PL/sh sin afectar producción.

Instalar dependencias de compilación y validar ubicación de extensiones PostgreSQL.

Ejecutar instalación siguiendo procedimientos controlados y trazables.

Usar `CREATE EXTENSION plsh` en una base de datos de laboratorio.

Verificar que la extensión está disponible, versión instalada y esquema de instalación.

Controlar quién puede crear extensiones y funciones usando PL/sh.

Evitar instalar PL/sh en producción sin análisis de riesgo, aprobación y plan de rollback.

Documentar cambios realizados, paquetes instalados, rutas y configuración.

Taller: instalar PL/sh en un entorno Docker o VM y validar una función mínima.

Crear una base de datos específica para prácticas de PL/sh.

Separar usuarios administradores, usuarios de desarrollo y usuarios de ejecución.

Preparar directorios temporales seguros para pruebas con permisos limitados.

Evitar rutas del sistema, directorios compartidos sensibles o ficheros reales durante el aprendizaje.

Configurar datasets ficticios para probar entradas, salidas y errores.

Crear scripts auxiliares de laboratorio sin acceso a secretos ni servicios externos.

Usar contenedores o máquinas virtuales para reproducir y destruir entornos fácilmente.

Registrar comandos ejecutados y resultados obtenidos.

Preparar snapshots o backups antes de prácticas arriesgadas.

Taller: construir entorno de laboratorio reproducible para PL/sh con PostgreSQL y Bash.

Crear funciones PL/sh con `CREATE FUNCTION`, tipo de retorno y cuerpo de script.

Usar shebang correcto para `/bin/sh`, Bash u otro intérprete permitido.

Leer argumentos posicionales recibidos desde PostgreSQL.

Devolver valores por salida estándar de forma controlada.

Probar funciones simples desde `SELECT`.

Manejar cadenas, números, fechas y valores nulos de forma prudente.

Controlar saltos de línea, espacios y formato de salida.

Evitar scripts largos dentro de funciones sin estructura ni documentación.

Usar nombres claros, esquemas separados y convenciones internas.

Taller: crear funciones PL/sh básicas para transformar, validar y devolver datos.

Pasar parámetros `text`, `integer`, `numeric`, `date`, `boolean` y arrays cuando sea viable.

Entender cómo PostgreSQL convierte valores para entregarlos al script.

Controlar valores nulos y entradas vacías antes de ejecutar lógica shell.

Devolver tipos escalares de forma consistente.

Diseñar funciones que devuelvan texto estructurado, códigos o valores normalizados.

Evitar retornar salidas ambiguas o dependientes del idioma del sistema.

Validar longitud, formato y caracteres permitidos en argumentos.

Documentar contrato de entrada y salida de cada función.

Preparar pruebas unitarias SQL para diferentes combinaciones de argumentos.

Taller: crear función PL/sh con validación de parámetros y retorno tipado.

Entender cómo PL/sh interpreta stdout como resultado de función.

Gestionar stderr para diagnóstico sin contaminar salidas esperadas.

Usar códigos de salida para distinguir éxito, error controlado y fallo inesperado.

Traducir errores shell en mensajes útiles para PostgreSQL.

Evitar que comandos fallen silenciosamente y devuelvan datos incorrectos.

Aplicar `set -e`, `set -u` y controles equivalentes con criterio.

Capturar errores de comandos externos y devolver mensajes normalizados.

Diseñar salidas compatibles con consumo SQL posterior.

Registrar errores en tablas de auditoría cuando proceda.

Taller: crear función robusta que gestione errores y devuelva estados controlados.

Aplicar prácticas seguras de Bash en scripts ejecutados desde PostgreSQL.

Usar comillas correctamente para evitar expansión inesperada de argumentos.

Validar entradas antes de construir comandos.

Evitar `eval`, sustituciones peligrosas y concatenación directa de comandos.

Controlar globbing, word splitting y caracteres especiales.

Usar arrays de Bash cuando el intérprete lo permita y esté justificado.

Restringir rutas y comandos permitidos mediante listas blancas.

Separar lógica compleja en scripts versionados cuando sea más mantenible.

Revisar scripts con herramientas como ShellCheck en CI/CD.

Taller: corregir una función PL/sh vulnerable a errores de Bash y argumentos maliciosos.

Identificar cómo una entrada SQL puede convertirse en comando shell peligroso.

Analizar patrones de command injection, path injection, option injection y expansión no deseada.

Validar entradas por tipo, longitud, formato, caracteres permitidos y lista blanca.

Rechazar rutas absolutas, comandos compuestos, metacaracteres y argumentos no previstos.

Evitar pasar datos de usuario directamente al shell.

Diseñar wrappers con parámetros controlados y comandos predefinidos.

Registrar intentos rechazados para auditoría.

Crear pruebas negativas con entradas maliciosas.

Establecer revisión obligatoria de seguridad para funciones PL/sh.

Taller: explotar y corregir una función vulnerable en entorno controlado.

Revisar quién puede crear funciones PL/sh y quién puede ejecutarlas.

Entender diferencias entre permisos de PostgreSQL y permisos del usuario del proceso del servidor.

Controlar `EXECUTE` sobre funciones sensibles.

Separar esquemas administrativos y esquemas de aplicación.

Evitar conceder permisos amplios a roles no técnicos.

Revisar riesgos de `SECURITY DEFINER` en funciones que ejecutan shell.

Diseñar funciones con mínimos privilegios y sin acceso innecesario.

Auditar funciones instaladas, propietarios y grants.

Documentar matriz de roles y responsabilidades.

Taller: configurar roles seguros para creación y ejecución de funciones PL/sh.

Entender qué usuario del sistema ejecuta los comandos lanzados desde PostgreSQL.

Revisar permisos sobre ficheros, directorios, binarios, sockets y scripts externos.

Aplicar principio de mínimo privilegio en rutas utilizadas por PL/sh.

Evitar acceso a directorios sensibles, claves, certificados, dumps o configuración del servidor.

Usar directorios controlados para entrada, salida, logs y ficheros temporales.

Definir propietario, grupo, permisos y umask adecuados.

Controlar binarios permitidos y rutas absolutas.

Evaluar aislamiento con contenedores, AppArmor, SELinux o perfiles equivalentes.

Documentar hardening del host donde corre PostgreSQL.

Taller: preparar estructura de directorios segura para funciones PL/sh.

Crear, leer, mover, validar o listar ficheros de forma controlada cuando el caso lo justifica.

Restringir operaciones a directorios autorizados.

Validar nombres de fichero y evitar traversal con `../`.

Gestionar permisos de lectura y escritura con mínimo privilegio.

Evitar manipular ficheros críticos del sistema o de PostgreSQL.

Crear salidas reproducibles para procesos batch o integraciones.

Registrar operaciones sobre ficheros con usuario, fecha, función y resultado.

Limpiar ficheros temporales de forma segura.

Diseñar alternativas cuando la aplicación o ETL debe manejar ficheros fuera de la base de datos.

Taller: generar fichero controlado desde una consulta y registrarlo en tabla de auditoría.

Decidir cuándo conviene incluir script dentro de la función y cuándo invocar script externo versionado.

Gestionar ubicación, permisos, propietario y despliegue de scripts externos.

Evitar dependencias ocultas no documentadas en el servidor.

Versionar scripts en Git con revisión de código y pruebas.

Usar rutas absolutas y argumentos validados.

Separar lógica shell reutilizable de funciones SQL de envoltura.

Documentar contrato entre función PL/sh y script externo.

Añadir pruebas de integración en CI/CD.

Preparar rollback de scripts y funciones.

Taller: crear wrapper PL/sh que invoque script externo seguro y versionado.

Entender cuándo una función trigger en PL/sh puede tener sentido y cuándo no.

Revisar diferencias entre triggers `BEFORE`, `AFTER`, por fila y por sentencia.

Analizar riesgos de ejecutar shell durante operaciones transaccionales.

Evitar triggers lentos, frágiles o dependientes de sistemas externos.

Diseñar triggers que registren eventos sin bloquear operaciones críticas.

Pasar información mínima y validada al script.

Manejar fallos para no romper transacciones sin necesidad.

Registrar acciones ejecutadas por el trigger.

Comparar alternativas: NOTIFY/LISTEN, colas, jobs asíncronos, aplicación o CDC.

Taller: crear trigger de notificación controlada y evaluar sus riesgos.

Identificar automatizaciones que pueden ejecutarse cerca de PostgreSQL sin comprometer arquitectura.

Diseñar funciones para tareas auxiliares de mantenimiento, generación de reportes o integración local.

Evitar usar PL/sh como sustituto de un scheduler, servicio backend o pipeline ETL completo.

Controlar duración, concurrencia, recursos y fallos de tareas batch.

Registrar inicio, fin, estado, salida y errores de cada ejecución.

Preparar ejecución manual controlada y ejecución programada externa cuando proceda.

Integrar con cron, systemd timers, pgAgent o herramientas corporativas de scheduling.

Crear límites de tiempo y tamaño para evitar bloqueos.

Documentar runbooks operativos.

Taller: construir proceso batch controlado con registro de ejecución.

Invocar comandos permitidos como `date`, `wc`, `sha256sum`, `grep` o utilidades internas controladas.

Validar disponibilidad y versión de binarios usados.

Evitar comandos interactivos, destructivos, de red o dependientes de entorno no controlado.

Usar rutas absolutas para reducir riesgo de PATH hijacking.

Capturar salida y errores de forma normalizada.

Diseñar wrappers para herramientas internas.

Controlar consumo de CPU, memoria, disco y procesos.

Documentar dependencias de sistema por función.

Preparar pruebas de compatibilidad entre entornos.

Taller: crear función PL/sh que calcule hash de fichero autorizado y registre resultado.

Identificar variables disponibles durante ejecución desde PostgreSQL.

Evitar depender de `.bashrc`, perfiles interactivos o entorno del administrador.

Definir configuración explícita para rutas, locales, codificación y opciones del script.

Controlar `PATH`, `LANG`, `LC_ALL`, `HOME` y variables críticas.

Evitar almacenar secretos en variables de entorno accesibles sin control.

Pasar configuración mediante tablas seguras cuando sea necesario.

Documentar diferencias entre desarrollo, test, staging y producción.

Crear pruebas que detecten ausencia de dependencias o configuración incorrecta.

Preparar mensajes claros ante configuración incompleta.

Taller: diagnosticar y corregir fallo por entorno distinto al shell interactivo.

Definir qué eventos deben registrarse al ejecutar funciones PL/sh.

Registrar usuario SQL, función, parámetros seguros, timestamp, resultado y código de salida.

Evitar registrar secretos, datos personales o información sensible en logs.

Crear tablas de auditoría para ejecuciones relevantes.

Relacionar logs de PostgreSQL, logs de aplicación, logs de sistema y trazas de script.

Preparar correlación con identificadores de ejecución.

Diseñar niveles de logging: debug, info, warning, error y security.

Revisar logs periódicamente para detectar uso indebido o fallos recurrentes.

Crear reportes de funciones PL/sh activas y ejecuciones sensibles.

Taller: implementar auditoría completa de una función PL/sh crítica.

Entender cómo una función PL/sh se ejecuta dentro del contexto de una consulta o transacción PostgreSQL.

Analizar problemas de efectos externos no reversibles ante rollback.

Evitar escribir ficheros, enviar notificaciones o ejecutar acciones externas en operaciones que pueden revertirse.

Diseñar patrones idempotentes para reducir daños por reintentos.

Controlar concurrencia cuando varias sesiones ejecutan la misma función.

Usar bloqueos, identificadores únicos o colas cuando sea necesario.

Evitar condiciones de carrera sobre ficheros o recursos compartidos.

Medir impacto de funciones lentas sobre sesiones y locks.

Documentar acciones no transaccionales asociadas a cada función.

Taller: simular rollback con efecto externo y rediseñar patrón seguro.

Medir tiempo de ejecución de funciones PL/sh y su impacto en consultas.

Evaluar coste de lanzar procesos del sistema desde PostgreSQL.

Detectar comandos lentos, bloqueantes o dependientes de I/O.

Evitar uso de PL/sh en consultas masivas fila a fila sin control.

Diseñar funciones para lotes pequeños, tareas administrativas o casos justificados.

Comparar rendimiento frente a PL/pgSQL, scripts externos o jobs asíncronos.

Establecer timeouts y límites operativos cuando sea posible.

Monitorizar CPU, memoria, disco, procesos y locks durante ejecución.

Crear benchmarks reproducibles para decisiones arquitectónicas.

Taller: medir una función PL/sh fila a fila y rediseñar solución más eficiente.

Definir errores esperados, errores recuperables y errores críticos.

Devolver mensajes claros para usuarios técnicos y logs internos.

Evitar que un fallo de script deje estados inconsistentes.

Implementar reintentos solo cuando la operación es idempotente.

Gestionar ausencia de ficheros, permisos insuficientes, comandos no encontrados y datos inválidos.

Crear códigos de error internos para diagnóstico.

Separar errores de validación, errores de sistema y errores de negocio.

Preparar alertas ante fallos repetidos o función crítica.

Documentar runbook de resolución.

Taller: introducir fallos controlados y diseñar respuesta robusta.

Crear pruebas SQL para entradas válidas, inválidas, nulas, límite y maliciosas.

Probar scripts shell con herramientas externas antes de integrarlos.

Validar salidas, códigos de error, logs y efectos sobre ficheros.

Usar entornos efímeros para pruebas destructivas controladas.

Incluir pruebas de permisos, rutas y variables de entorno.

Ejecutar ShellCheck o linters equivalentes sobre scripts.

Preparar fixtures de ficheros y tablas para reproducibilidad.

Integrar pruebas en CI/CD cuando la organización lo permita.

Evitar desplegar funciones PL/sh sin tests negativos.

Taller: crear suite de pruebas para función PL/sh con casos límite y seguridad.

Versionar funciones PL/sh, scripts externos, SQL de extensión y documentación.

Crear migraciones controladas para instalar, modificar o retirar funciones.

Separar despliegues de base de datos y despliegues de scripts del sistema cuando proceda.

Validar dependencias antes del despliegue.

Preparar rollback de funciones y scripts.

Revisar cambios mediante pull request y aprobación técnica.

Ejecutar pruebas automáticas en pipeline antes de staging.

Documentar versiones instaladas por entorno.

Evitar cambios manuales directos en producción.

Taller: construir pipeline de despliegue para función PL/sh y script externo.

Definir qué funciones PL/sh pueden existir en producción y bajo qué controles.

Monitorizar tiempos, errores, volumen de ejecución, locks y consumo de recursos.

Crear alertas para fallos, uso inesperado o ejecución excesiva.

Revisar logs de seguridad y auditoría.

Mantener inventario de funciones, propietarios, permisos y dependencias.

Preparar runbooks para errores comunes.

Validar después de upgrades de PostgreSQL, sistema operativo o shell.

Revisar periódicamente si cada función sigue siendo necesaria.

Planificar retirada de funciones obsoletas o peligrosas.

Taller: diseñar dashboard operativo para funciones PL/sh.

Comparar PL/sh con PL/pgSQL para lógica puramente de base de datos.

Comparar PL/sh con PL/Python para procesamiento avanzado y librerías.

Comparar PL/sh con cron, systemd timers, pgAgent y schedulers externos.

Evaluar cuándo conviene crear un servicio backend o worker asíncrono.

Revisar alternativas con NOTIFY/LISTEN, colas, CDC, ETL y pipelines.

Analizar mantenibilidad, seguridad, rendimiento, observabilidad y gobierno.

Evitar usar PL/sh por comodidad cuando existe opción más segura y clara.

Crear matriz de decisión técnica para elegir solución.

Documentar trade-offs y decisión arquitectónica.

Taller: decidir la mejor arquitectura para diez casos de automatización.

Crear checklist de hardening para PL/sh antes de aprobar su uso.

Revisar permisos SQL, roles, owner, schema, grants y `SECURITY DEFINER`.

Auditar comandos permitidos, rutas, scripts externos y dependencias.

Validar entradas, escapado, listas blancas y control de argumentos.

Revisar logs, trazabilidad, secretos y datos sensibles.

Aplicar controles del sistema operativo: permisos, aislamiento, perfiles y límites.

Analizar impacto ante compromiso de usuario SQL con acceso a función PL/sh.

Definir procedimiento de revisión por seguridad antes de producción.

Crear informe de riesgos residuales y mitigaciones.

Taller: auditar una función PL/sh vulnerable y generar plan de remediación.

Definir política interna para permitir, restringir o prohibir PL/sh según entorno y criticidad.

Crear proceso de solicitud, justificación, revisión, aprobación y documentación de funciones.

Establecer criterios mínimos: seguridad, pruebas, owner, logs, permisos, rollback y alternativa evaluada.

Mantener catálogo de funciones PL/sh autorizadas.

Definir responsables: DBA, backend, DevOps, seguridad, arquitectura y owner funcional.

Revisar periódicamente funciones existentes y retirar las que no aportan valor.

Evitar proliferación de scripts ocultos dentro de base de datos.

Crear plantillas de diseño técnico y revisión.

Medir riesgos, incidentes y deuda técnica asociada.

Taller: redactar política corporativa de uso de PL/sh.

Crear función que normaliza texto usando shell sin comandos peligrosos.

Generar fichero de exportación en directorio autorizado y registrar auditoría.

Calcular hash de fichero autorizado y devolver resultado tipado.

Validar una ruta de entrada evitando traversal y caracteres prohibidos.

Invocar script externo versionado desde función wrapper.

Crear trigger de evento controlado y comparar alternativa asíncrona.

Implementar logging estructurado de ejecución.

Diseñar prueba negativa contra command injection.

Preparar análisis de rendimiento de función invocada en lote.

Taller: seleccionar tres casos y diseñarlos con seguridad, pruebas y operación.

Usar PL/sh para resolver lógica de negocio que debería estar en aplicación o PL/pgSQL.

Ejecutar comandos con argumentos no validados.

Conceder `EXECUTE` a usuarios amplios sobre funciones sensibles.

Usar `SECURITY DEFINER` sin hardening ni revisión.

Escribir ficheros fuera de rutas autorizadas.

Ejecutar operaciones externas no reversibles dentro de transacciones.

Depender de variables de entorno no documentadas.

No registrar auditoría ni errores.

Desplegar scripts manualmente sin Git ni CI/CD.

Taller: corregir una implementación PL/sh insegura y convertirla en solución gobernada.

Evaluar madurez actual de PostgreSQL, extensiones, roles, scripts, CI/CD, seguridad y operación.

Identificar casos de uso candidatos y descartar los que requieren otra arquitectura.

Preparar entorno piloto aislado con permisos, logs, pruebas y datos ficticios.

Definir política de seguridad, revisión de código y matriz de decisión.

Crear plantillas de función, logging, validación, auditoría y documentación.

Seleccionar un caso de bajo riesgo para piloto.

Medir estabilidad, rendimiento, seguridad y facilidad de mantenimiento.

Ajustar estándares antes de ampliar uso.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap corporativo de adopción o restricción de PL/sh.

Definir un entorno PostgreSQL corporativo con necesidad de automatización controlada desde base de datos.

Instalar PL/sh en laboratorio y documentar versión, extensión, permisos, esquemas y dependencias.

Diseñar matriz de decisión para justificar por qué un caso se resuelve con PL/sh y no con otra alternativa.

Crear función PL/sh segura con validación de entradas, comandos permitidos, retornos tipados y control de errores.

Integrar script externo versionado con ruta absoluta, permisos mínimos, logging y pruebas.

Implementar auditoría de ejecución con usuario, timestamp, parámetros seguros, resultado y código de salida.

Añadir pruebas positivas, negativas, de permisos, de errores, de rutas y de entradas maliciosas.

Preparar hardening de sistema operativo, permisos SQL, revisión de `SECURITY DEFINER` y control de acceso.

Diseñar pipeline de despliegue, rollback, documentación técnica, runbook y checklist de operación.

Presentar informe final con arquitectura, riesgos, mitigaciones, alternativas evaluadas, métricas y plan de gobierno.