bLivecode

Automatizando la Creación de Virtual Hosts en Nginx con un Script Bash

Si trabajas con servidores Nginx y necesitas configurar múltiples dominios locales para desarrollo, escribir las configuraciones manualmente puede ser tedioso. En este post, te mostraré cómo crear un script Bash que automatiza la creación y despliegue de virtual hosts en Nginx con PHP 8.3-FPM. ## El Script Este script tiene varias funciones para hacer que un solo comando genere lo necesario para poner un dominio local en funcionamiento y cree el host a donde va a apuntar el dominio local. A continuación describo lo que hará el script. - Crea un archivo de configuración en /etc/nginx/sites-available/ - Lo enlaza en /etc/nginx/sites-enabled/. - Agrega el dominio al archivo /etc/hosts. - Verifica la configuración de Nginx y recarga el servicio. Para empezar vamos a necesitar algunas rutas y validación de datos requeridos por el script, empezamos con la validación ```bash #!/bin/bash # Verifica si se pasaron los parámetros correctos # Nombre del Host local # Ruta donde esta el proyecto if [ "$#" -ne 2 ]; then echo "El nombre de domino y la ubicación del proyecto son requeridos:" echo "$0 dominio.local ruta_proyecto_relativa" exit 1 fi # Creamos las variables a ocupar, Los nombres los puedes personalizar. DOMINIO="$1" RUTA_RELATIVA="$2" USUARIO=$(whoami) HOME_DIR="/home/$USUARIO" RUTA_COMPLETA="$HOME_DIR/$RUTA_RELATIVA" NGINX_SITES_AVAILABLE="/etc/nginx/sites-available" NGINX_SITES_ENABLED="/etc/nginx/sites-enabled" VHOST_CONF="$NGINX_SITES_AVAILABLE/$DOMINIO" # Verifica si la carpeta del proyecto existe if [ ! -d "$RUTA_COMPLETA" ]; then echo "Error: La carpeta del proyecto no existe en $RUTA_COMPLETA" exit 1 fi ``` Bien, si las validaciones pasan correctamente vamos a proceder a la creación del archivo de configuración del v-Host y a realizar la configuración en Nginx para que este lo reconozca como un archivo de configuración ```bash # Crea el archivo de configuración del vhost sudo tee "$VHOST_CONF" > /dev/null < /dev/null echo "Dominio $DOMINIO agregado a /etc/hosts" fi # Verifica la configuración y recarga Nginx sudo nginx -t && sudo systemctl reload nginx echo "Vhost para $DOMINIO creado y habilitado con éxito." ``` Listo con esto ya tenemos el script para generar toda la configuración de un nuevo host que usemos de manera local con nginx y php. Ahora solo quedaría configurarlo para poder ejecutarlo en la línea de comandos y pasar los parámetros, esto quedaría de la siguiente manera. ## 🛠️ Instalación del Script como Comando Global Para que este script se pueda ejecutar desde cualquier parte del sistema como un comando, sigue estos pasos: 1. Mueve el script a `/usr/local/bin/` y dale permisos de ejecución: ```bash sudo mv crear_vhost.sh /usr/local/bin/crear_vhost sudo chmod +x /usr/local/bin/crear_vhost ``` 2. Ahora puedes ejecutarlo desde cualquier ubicación con: ```bash crear_vhost midominio.local Proyectos/midominio ``` ## 🔍 Uso del Script Para crear un nuevo virtual host, simplemente usa: ```bash crear_vhost midominio.local Proyectos/midominio ``` Esto hará que el dominio `midominio.local` apunte a `~/Proyectos/midominio/public`, permitiéndote acceder a él desde tu navegador. Espero que esto les funcione para automatizar algo de sus tareas diarias.

📐 Convertir Pixeles a Centímetros en PHP

En mi trabajo diario con imágenes, muchas veces necesito convertir medidas de pixeles a centímetros, especialmente cuando trabajo con generación de PDFs, diseño para impresión o manipulación de imágenes. Para facilitarme la vida, tengo una función en PHP que utilizo constantemente ### 🧠 ¿Qué hace esta función? La función recibe como parámetros un Array asociativo con las claves **width** y **height** de la imagen de la cual necesitas saber los centimetros, tambien recibe los **DPI** (Dots Per Inch) ó (puntos por pulgada), con esta información se realizará el calculo y regresará un Array con los datos. ```php public function convertPixelToCentimeter($dataMeasures=[], $dpi="") { $arrayCentimeter = []; if (empty($dataMeasures)) { return false; } if(!isset($dataMeasures['width']) && !isset($dataMeasures['height'])) { return false; } $dpiImage = ($dpi=="") ? 300 : $dpi; $centimeterPerInch = 2.54; // 1 pulgada = 2.54 cm $arrayCentimeter['width'] = round(($dataMeasures['width'] * $centimeterPerInch) / $dpiImage, 2); $arrayCentimeter['height'] = round(($dataMeasures['height'] * $centimeterPerInch) / $dpiImage, 2); return $arrayCentimeter; } ``` ### 🧮 ¿Cómo funciona? La funcion recibe como parametro el array **$dataMeasures** donde contendra los datos **width** y **height** de la imagen, en dado caso que el array se encuentre vacio o que alguno de los datos no venga definido, la funcion regresara un **false**. El parametro de **$dpi** puede estar vacio y se asignara un valor por defecto de **300** puntos por pulgada. La variable **$centimeterPerInch** es una constante, el valor asignado es por que **1 pulgada** equivale a **2.54 cm**. ### 🧪 Ejemplo de uso El uso de la funcion puede darle al agregarla a un **Helper** o cualquier **clase** en PHP, a continuación dejo un ejemplo de como se puede usar en un ejercicio real. ```php 1200, 'height' => 1800]; $utils = new Utils(); $cm = $utils->convertPixelToCentimeter($pixeles); print_r($cm); // Resultado: ['width' => 10.16, 'height' => 15.24] ```

Obtener ultimo día del mes

En el desarrollo web, a menudo es necesario manipular fechas y tiempos. Una tarea común es determinar el último día de un mes dado. Aquí te presento una función en PHP que realiza esta tarea de manera eficiente. ## Descripción de la Función La función **getLastDayMonth** toma una fecha como entrada y devuelve el último día del mes de esa fecha. Esta función es útil, por ejemplo, para calcular fechas límites, programar eventos o validar rangos de fechas. ## Definición de la Función Aquí está la función que vamos a revisar: ```php /** * Función para Regresar el Último Día del Mes * @date $date - Fecha de la cual se va a obtener el último día */ public static function getLastDayMonth($date) { list($year, $mon, $day) = explode('-', $date); return date("Y-m-d", (mktime(0, 0, 0, $mon + 1, 1, $year) - 1)); } ``` - **Parámetro de Entrada**: La función acepta un único parámetro, $date, que es una cadena de texto en formato YYYY-MM-DD. - **Descomposición de la Fecha**: Utiliza explode para dividir la fecha en año ($year), mes ($mon) y día ($day). ```php list($year, $mon, $day) = explode('-', $date); ``` - **Calcular el Último Día**: La función mktime se usa para generar una marca de tiempo Unix para el primer día del mes siguiente ($mon + 1) a las 00:00 horas. ```php mktime(0, 0, 0, $mon + 1, 1, $year) ``` - **Restar un Segundo**: Al restar un segundo (-1) de esta marca de tiempo, se obtiene el último día del mes anterior, que es el mes de la fecha original. - **Formato de la Fecha**: Finalmente, la función date se usa para formatear esta marca de tiempo como una cadena de texto en formato YYYY-MM-DD. ```php return date("Y-m-d", (mktime(0, 0, 0, $mon + 1, 1, $year) - 1)); ``` ### Ejemplo de Uso Imaginemos que queremos obtener el último día del mes para diferentes fechas: ```php echo getLastDayMonth('2024-06-14'); // Salida: 2024-06-30 echo getLastDayMonth('2024-02-10'); // Salida: 2024-02-29 (Año bisiesto) echo getLastDayMonth('2023-12-01'); // Salida: 2023-12-31 ``` ## Ventajas de la Función - **Simplicidad**: La función es fácil de entender y de implementar. - **Flexibilidad**: Funciona para cualquier fecha en formato YYYY-MM-DD. - **Compatibilidad**: Utiliza funciones nativas de PHP, garantizando un amplio soporte en diferentes entornos. ## Conclusión Con esta función getLastDayMonth, calcular el último día de cualquier mes es una tarea sencilla en PHP. Su implementación eficiente y clara facilita su integración en cualquier proyecto que maneje fechas y calendarios.

Días transcurridos entre dos Fechas

En el mundo de la programación, calcular la diferencia entre dos fechas es una tarea común que puede ser crucial en aplicaciones que necesitan rastrear eventos, calcular vencimientos, o analizar datos históricos. En esta entrada del blog, vamos a analizar una función en PHP que calcula la cantidad de días transcurridos entre dos fechas. Revisaremos su código, explicaremos su funcionamiento paso a paso, y discutiremos cómo podemos utilizarla en un entorno de producción. ## Código de la Función Aquí está la función que vamos a revisar: ```php public static function getDaysPassed($dateStart, $dateEnd) { $dateInit = strtotime($dateStart); $dateEnd = strtotime($dateEnd); if ($dateEnd > $dateInit) { $dias = ($dateEnd - $dateInit) / 86400; $dias = abs($dias); $dias = floor($dias); return intval($dias); } else { throw new \Exception("La fecha final no puede ser menor que la fecha inicial", 1); } } ``` ## Desglosando la Función ### Declaración de la Función ```php public static function getDaysPassed($dateStart, $dateEnd) ``` - public: La función es accesible desde fuera de la clase. - static: La función pertenece a la clase y no a una instancia específica. - function getDaysPassed: Define el nombre de la función y sus parámetros. - $dateStart, $dateEnd: Son las dos fechas de entrada que deben proporcionarse en formato de cadena (por ejemplo, "2024-01-01"). ### Conversión de Fechas a Timestamps ```php $dateInit = strtotime($dateStart); $dateEnd = strtotime($dateEnd); ``` - strtotime: Convierte una cadena de fecha en un timestamp Unix (el número de segundos desde la "Época Unix", es decir, el 1 de enero de 1970). - $dateInit y $dateEnd: Ahora contienen los valores de timestamp correspondientes a las fechas proporcionadas. ### Comparación de Fechas ```php if ($dateEnd > $dateInit) ``` Compara los timestamps para asegurarse de que la fecha final no sea anterior a la fecha de inicio. Si $dateEnd es mayor, significa que $dateEnd es una fecha posterior a $dateStart. ### Cálculo de la Diferencia en Días ```php $dias = ($dateEnd - $dateInit) / 86400; ``` - **($dateEnd - $dateInit)**: Calcula la diferencia en segundos entre las dos fechas. - **86400**: Es el número de segundos en un día **(60 segundos * 60 minutos * 24 horas).** - **$dias**: Contiene la diferencia en días entre las dos fechas. ### Asegurando que el resultado no sea negativo ```php $dias = abs($dias); $dias = floor($dias); return intval($dias); ``` - **abs($dias)**: Toma el valor absoluto de la diferencia para asegurarse de que el número de días no sea negativo. - **floor($dias)**: Redondea hacia abajo para obtener un número entero de días. - **intval($dias)**: Convierte el resultado final a un entero antes de devolverlo. ### Manejo de Excepciones ```php else { throw new \Exception("La fecha final no puede ser menor que la fecha inicial", 1); } ``` - Si la fecha final es menor que la fecha inicial, lanza una excepción con un mensaje descriptivo. La función getDaysPassed es una solución simple y efectiva para calcular la cantidad de días transcurridos entre dos fechas en PHP. Siguiendo las mejores prácticas de validación y manejo de excepciones, puedes integrar esta función de manera segura en tus aplicaciones de producción.

Script Bash para backups automáticos de archivos y bases de datos

Si tenés un servidor en producción, tarde o temprano algo se va a romper. Un disco que se llena, una tabla que se borra por error, un `rm -rf` mal puesto, un update de sistema operativo que sale mal. En todos esos casos, la diferencia entre un "uh, qué mal" y un "se perdió todo" es si tenés un backup actualizado y, más importante, si sabés cómo restaurarlo. En este post vamos a armar un script en Bash que se encargue de las dos cosas que más me pidieron a lo largo de los años: respaldar directorios de archivos (el código de la app, configs de Nginx, archivos subidos por usuarios) y exportar bases de datos MySQL. El script va a ser ejecutable a mano, pero pensado para que lo metas en un cron y te olvides de que existe. ## Qué tiene que hacer el script Antes de escribir una línea, listemos los requisitos. Esto es lo que yo necesito en cualquier servidor de producción: 1. **Respaldar archivos críticos** comprimidos con `tar.gz`. En mi caso suele ser `/var/www/miapp` (el código), `/etc/nginx` (las configs del servidor web) y a veces `/etc/letsencrypt` (los certificados). 2. **Exportar todas las bases de datos MySQL** con `mysqldump`, en formato `.sql` comprimido con `gzip`. 3. **Nombrar los archivos con la fecha** para que sea fácil identificar cuándo se hizo cada backup. 4. **Borrar los backups viejos** según una cantidad de días configurable, así no se llena el disco. 5. **Registrar todo en un log** para poder revisar después qué pasó en cada ejecución. 6. **Fallar rápido** si algo sale mal. Un script de backup que termina con código 0 cuando en realidad no pudo respaldar algo es peor que no tener backup, porque te da una falsa sensación de seguridad. Con esos seis puntos claros, vamos a escribir el script. ## El script completo Acá está la versión final, comentada por secciones. Después de la versión completa explico cada bloque en detalle. ```bash #!/bin/bash # # backup.sh - Script de backup automático para archivos y MySQL # Uso: sudo ./backup.sh # Crontab sugerido: 0 3 * * * /opt/scripts/backup.sh # set -euo pipefail # ============================================ # CONFIGURACIÓN - EDITAR ESTOS VALORES # ============================================ BACKUP_DIR="/var/backups/miapp" LOG_FILE="/var/log/backup.log" RETENTION_DAYS=7 # Directorios a respaldar (separados por espacio) DIRS_TO_BACKUP=( "/var/www/miapp" "/etc/nginx" "/etc/letsencrypt" ) # Credenciales de MySQL (idealmente leer de un archivo seguro) MYSQL_USER="backup_user" MYSQL_PASS="tu_password_seguro" MYSQL_HOST="localhost" # ============================================ # FIN DE LA CONFIGURACIÓN # ============================================ FECHA=$(date +"%Y-%m-%d") HORA=$(date +"%H%M%S") DEST_DIR="$BACKUP_DIR/$FECHA" # Función de logging log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE" } # Validaciones iniciales if [[ $EUID -ne 0 ]]; then echo "Este script debe ejecutarse como root (sudo)" exit 1 fi if ! command -v mysqldump &> /dev/null; then log "ERROR: mysqldump no está instalado" exit 1 fi # Crear directorio del día mkdir -p "$DEST_DIR" log "Iniciando backup en $DEST_DIR" # Backup de archivos log "Respaldando directorios de archivos..." for DIR in "${DIRS_TO_BACKUP[@]}"; do if [[ -d "$DIR" ]]; then NOMBRE=$(basename "$DIR") ARCHIVO="$DEST_DIR/files-${NOMBRE}-${FECHA}.tar.gz" tar -czf "$ARCHIVO" -C "$(dirname "$DIR")" "$NOMBRE" 2>> "$LOG_FILE" log " ✓ $DIR -> $ARCHIVO" else log " ⚠ Directorio no existe, se omite: $DIR" fi done # Backup de MySQL log "Exportando bases de datos MySQL..." DUMP_FILE="$DEST_DIR/mysql-${FECHA}-${HORA}.sql.gz" mysqldump \ --user="$MYSQL_USER" \ --password="$MYSQL_PASS" \ --host="$MYSQL_HOST" \ --single-transaction \ --quick \ --routines \ --triggers \ --events \ --all-databases \ 2>> "$LOG_FILE" | gzip > "$DUMP_FILE" if [[ -s "$DUMP_FILE" ]]; then log " ✓ MySQL dump -> $DUMP_FILE" else log " ✗ El dump de MySQL está vacío o falló" exit 1 fi # Calcular tamaños log "Resumen de tamaños:" du -sh "$DEST_DIR"/* 2>> "$LOG_FILE" | tee -a "$LOG_FILE" # Aplicar rotación: borrar backups más viejos que RETENTION_DAYS log "Aplicando rotación: borrando backups con más de $RETENTION_DAYS días..." find "$BACKUP_DIR" -maxdepth 1 -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \; 2>> "$LOG_FILE" log "Rotación completada" log "Backup finalizado correctamente" exit 0 ``` Copiá este script a `/opt/scripts/backup.sh` (o donde te quede cómodo), dale permisos de ejecución con `chmod 700` y ya lo podés correr. Ahora vamos bloque por bloque. ## Bloque 1: Configuración Las primeras líneas después del shebang son las variables que vas a tocar cuando migres de servidor o cambies de proyecto. Por convención las pongo todas juntas al inicio para que sea fácil encontrarlas. ```bash BACKUP_DIR="/var/backups/miapp" LOG_FILE="/var/log/backup.log" RETENTION_DAYS=7 ``` `BACKUP_DIR` es donde van a quedar todos los backups organizados por fecha. `LOG_FILE` es el archivo donde se registra cada ejecución, ideal para debuggear cuando algo falla a las 3 AM. `RETENTION_DAYS` es cuántos días de historial querés conservar. Para un backup diario con retención semanal, 7 está bien. Si querés un mes de historial, 30. El array `DIRS_TO_BACKUP` acepta varias rutas. Cada elemento se procesa por separado en el loop, así un directorio que no existe no rompe todo el backup. ```bash DIRS_TO_BACKUP=( "/var/www/miapp" "/etc/nginx" "/etc/letsencrypt" ) ``` Para las credenciales de MySQL, hay una decisión importante que tomar. La opción más simple es hardcodear la contraseña en el script, pero eso es un riesgo de seguridad: si alguien ve el archivo, ve la contraseña de la base de datos. La opción más segura es leerla de un archivo separado con permisos 600: ```bash # Archivo /root/.mybackup.cnf [client] user=backup_user password=tu_password_seguro host=localhost ``` Y en el script: ```bash chmod 600 /root/.mybackup.cnf mysqldump --defaults-file=/root/.mybackup.cnf ... ``` Si en tu proyecto tenés un usuario de MySQL dedicado solo para backups (lo cual es una buena práctica), esto te queda limpio. Si no querés complicarte, dejá la contraseña en el script pero asegurate de que el archivo tenga permisos 600 y sea solo accesible por root. ## Bloque 2: set -euo pipefail y validaciones Esta línea es la más importante del script y mucha gente la saltea: ```bash set -euo pipefail ``` Cada flag hace algo: - `-e`: si cualquier comando falla, el script termina inmediatamente con código de error. - `-u`: si usás una variable que no está definida, el script falla (en lugar de tratarla como string vacío). - `-o pipefail`: si en un pipe como `comando1 | comando2` falla `comando1`, el pipe entero se considera fallido. Sin esta flag, solo importa el exit code del último comando. Juntas, estas tres flags hacen que el script falle rápido en lugar de seguir ejecutándose cuando algo salió mal. Es exactamente lo que querés en un script de backup. Después vienen las validaciones previas a empezar a respaldar: ```bash if [[ $EUID -ne 0 ]]; then echo "Este script debe ejecutarse como root (sudo)" exit 1 fi if ! command -v mysqldump &> /dev/null; then log "ERROR: mysqldump no está instalado" exit 1 fi ``` La primera chequea que estés corriendo como root (necesario para leer `/etc/letsencrypt` y `/etc/nginx`). La segunda verifica que `mysqldump` esté instalado antes de seguir, así no llegás a la mitad del backup y te explotás. ## Bloque 3: Backup de archivos Acá es donde se comprimen los directorios. El comando `tar` con `-czf` crea un archivo `.tar.gz` y `-C` cambia al directorio padre para que el path dentro del archivo sea relativo. ```bash for DIR in "${DIRS_TO_BACKUP[@]}"; do if [[ -d "$DIR" ]]; then NOMBRE=$(basename "$DIR") ARCHIVO="$DEST_DIR/files-${NOMBRE}-${FECHA}.tar.gz" tar -czf "$ARCHIVO" -C "$(dirname "$DIR")" "$NOMBRE" 2>> "$LOG_FILE" log " ✓ $DIR -> $ARCHIVO" else log " ⚠ Directorio no existe, se omite: $DIR" fi done ``` La parte clave es el `-C "$(dirname "$DIR")"`. Si haces `tar -czf backup.tar.gz /var/www/miapp`, cuando descomprimís te queda un directorio `/var/www/miapp` adentro, lo cual es un quilombo para restaurar. Con `-C /var/www miapp` te queda directamente `miapp/` en la raíz del archivo, que es mucho más limpio. Notá también que cada directorio se guarda en un archivo separado (`files-www-2026-07-03.tar.gz`, `files-nginx-2026-07-03.tar.gz`, etc). Esto es útil cuando necesitás restaurar un solo directorio sin tener que tocar los demás. ## Bloque 4: Dump de MySQL El comando `mysqldump` tiene un montón de flags, pero para un backup de producción estándar los que importan son estos: ```bash mysqldump \ --user="$MYSQL_USER" \ --password="$MYSQL_PASS" \ --host="$MYSQL_HOST" \ --single-transaction \ --quick \ --routines \ --triggers \ --events \ --all-databases ``` - `--single-transaction`: hace el dump dentro de una transacción, así las tablas InnoDB no se lockean durante el proceso. Imprescindible si tu base está en producción. - `--quick`: hace que `mysqldump` vuelque las filas de a una en lugar de cargar todo en memoria. Es la diferencia entre que el script funcione con tablas grandes o que te tire un "out of memory". - `--routines`, `--triggers`, `--events`: incluye stored procedures, triggers y eventos programados. Si no los ponés, el día que necesites restaurar te van a faltar cosas sin saber por qué. - `--all-databases`: exporta todas las bases. Si querés ser más selectivo, podés usar `--databases db1 db2 db3` o incluso `--ignore-table=db.tabla_grande_que_no_necesitas`. Después, el output se comprime con gzip en el mismo pipe: ```bash | gzip > "$DUMP_FILE" ``` El chequeo posterior es importante: ```bash if [[ -s "$DUMP_FILE" ]]; then log " ✓ MySQL dump -> $DUMP_FILE" else log " ✗ El dump de MySQL está vacío o falló" exit 1 fi ``` `-s` chequea que el archivo exista y no esté vacío. Si el dump falló silenciosamente, este chequeo lo detecta. Hay un caso clásico donde esto salva: las credenciales están mal y `mysqldump` no puede conectarse, pero como el comando igual crea el archivo de salida (vacío), sin este chequeo creerías que tenés un backup válido. ## Bloque 5: Rotación Esta es la parte que evita que el disco se llene: ```bash find "$BACKUP_DIR" -maxdepth 1 -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \; ``` El comando `find` busca directorios dentro de `$BACKUP_DIR` (sin recursionar, por eso `-maxdepth 1`) que tengan más de `RETENTION_DAYS` días de antigüedad y los borra con `rm -rf`. Los directorios con nombre `2026-07-03`, `2026-07-04`, etc. entran en esta categoría cuando son más viejos que el cutoff. El `-mtime +7` significa "más de 7 días" (estrictamente, son 8 o más). Si querés ser más preciso y conservar exactamente 7, usá `-mtime +6` que cuenta días completos desde la última modificación. ## Programación con cron Una vez que el script está probado y funcionando, lo metés en un cron para que corra solo: ```bash sudo crontab -e ``` Y agregás una línea como esta: ``` 0 3 * * * /opt/scripts/backup.sh >> /var/log/backup-cron.log 2>&1 ``` Esto corre todos los días a las 3:00 AM. La hora es importante: elegí un momento de poca actividad en tu sitio. Las 3 AM es la convención porque es cuando casi nadie usa internet. La parte `>> /var/log/backup-cron.log 2>&1` redirige la salida estándar y los errores a un archivo separado, así no perdés información si algo sale mal. Para verificar que el cron está bien configurado, podés listar las tareas con `crontab -l`. Y para testear, cambiá la hora a un par de minutos en el futuro y esperá. ## Cómo restaurar (lo que casi nadie testea) Hacer un backup es la mitad del trabajo. La otra mitad es poder restaurarlo. Te dejo los comandos básicos para que los pruebes antes de necesitarlos en una emergencia. Para restaurar un directorio desde un `.tar.gz`: ```bash # Restaurar en el directorio actual tar -xzf files-www-2026-07-03.tar.gz # Restaurar en una ruta específica tar -xzf files-www-2026-07-03.tar.gz -C / ``` Para restaurar la base de datos MySQL: ```bash # Descomprimir el dump gunzip mysql-2026-07-03-030000.sql.gz # Importar todas las bases mysql -u root -p < mysql-2026-07-03-030000.sql ``` Mi recomendación: hacé un restore de prueba en otro servidor (o en un contenedor Docker) cada tres meses, así te asegurás de que el backup se pueda restaurar y de que sabés los comandos de memoria cuando los necesitás. Un backup que no se restaura no es un backup. ## Mejoras opcionales que valen la pena Una vez que el script base funcione, hay varias mejoras que podés sumarle según tu proyecto: **Subir a un servidor remoto con rsync:** ```bash rsync -avz --delete "$BACKUP_DIR/" backup@backup-server:/backups/miapp/ ``` **Notificación por email cuando termina:** ```bash echo "Backup completado en $(date)" | mail -s "Backup OK" tu@email.com ``` **Encriptar el backup con GPG antes de subirlo:** ```bash gpg --symmetric --cipher-algo AES256 "$DUMP_FILE" ``` **Verificar la integridad con un hash:** ```bash md5sum "$DUMP_FILE" > "$DUMP_FILE.md5" # Al restaurar, verificar md5sum -c mysql-2026-07-03-030000.sql.gz.md5 ``` **Lock file para evitar ejecuciones simultáneas:** ```bash LOCKFILE="/var/run/backup.lock" if [ -e "$LOCKFILE" ]; then log "ERROR: ya hay un backup en ejecución" exit 1 fi touch "$LOCKFILE" trap "rm -f $LOCKFILE" EXIT ``` Esta última es clave si tu backup puede llegar a demorar más de un día por algún motivo, o si el cron se superpone con una corrida anterior. ## Errores comunes que vale la pena evitar - **No probar el restore.** El error más caro de todos. Un backup no es válido hasta que lo restaurás al menos una vez. - **Dejar la contraseña de MySQL hardcodeada y el script con permisos 644.** Cualquier usuario del sistema puede leer tu base de datos. Usá `chmod 600` siempre. - **No poner `set -e` y tener un script que "termina bien" cuando falló a mitad de camino.** El exit code 0 te miente, el cron te avisa con un mail, pero si no configurás el mail te quedás sin saber. - **Olvidar la regla 3-2-1 de backups.** Tres copias, en dos medios distintos, una fuera del servidor. Si el servidor se incendia y el backup estaba en el mismo disco, perdiste todo. - **Hacer el backup en el mismo disco que la base de datos.** Si el disco muere, te llevás puesta la base y el backup juntos. ## Conclusión Con este script ya tenés una base sólida para respaldar tu servidor. Es la versión que uso en mis proyectos personales y la he ido refinando con el tiempo. La parte más importante no es el script en sí, sino el hábito de probarlo periódicamente y de mantener la rotación para no quedarte sin espacio. En el próximo post vamos a ver otra cosa clave: monitoreo de recursos del servidor con Bash, así podés anticiparte a problemas antes de que se conviertan en caídas. Si tenés alguna mejora al script o un caso de uso particular, me encantaría leerlo en los comentarios.

Monitoreo de recursos del servidor con Bash: CPU, RAM y disco

Un servidor en producción sin monitoreo es como manejar un auto sin tablero: puedes ir a 200 km/h sin saberlo, quedarte sin combustible en medio de la ruta o reventar el motor sin que te avise nada. Las herramientas de monitoreo como Grafana, Prometheus o Datadog son excelentes, pero para un VPS chico o un proyecto personal, armar tu propio script de monitoreo en Bash es más que suficiente y te da un control total sobre qué métricas ver y cómo verlas. En este post vamos a construir un script que te muestra el estado completo de tu servidor en una sola ejecución: CPU, RAM, disco, los procesos que más consumen y alertas automáticas cuando algo está por explotar. Todo en texto plano, sin dependencias raras, listo para correr a mano o programar con cron. ## Qué tiene que reportar el script Antes de escribir código, definamos qué información necesitamos. Esto es lo que yo reviso cada vez que entro a un servidor: 1. **Información general del sistema**: hostname, kernel, uptime y cantidad de usuarios conectados. 2. **Uso de CPU**: load average, porcentaje de uso por núcleo y los 5 procesos que más CPU consumen. 3. **Uso de memoria RAM**: total, usada, libre, disponible y los 5 procesos que más RAM consumen. 4. **Uso de disco**: espacio total, usado y disponible por partición, más los directorios que más ocupan. 5. **Alertas automáticas**: si algún recurso supera un umbral configurable, el script lo marca claramente. 6. **Todo en un formato legible**, con barras de progreso en ASCII y colores cuando la terminal lo soporta. Con eso definido, vamos al script. ## El script completo Acá está la versión final. Después de la versión completa explico cada bloque en detalle. ```bash #!/bin/bash # # monitor.sh - Monitoreo de recursos del servidor # Uso: ./monitor.sh # Crontab sugerido: */5 * * * * /opt/scripts/monitor.sh --alert-only >> /var/log/monitor.log # set -euo pipefail # ============================================ # CONFIGURACIÓN - UMBRALES DE ALERTA # ============================================ CPU_ALERT_THRESHOLD=80 RAM_ALERT_THRESHOLD=80 DISK_ALERT_THRESHOLD=85 TOP_N=5 # ============================================ # COLORES (se desactivan si no hay terminal) # ============================================ if [[ -t 1 ]]; then RED='\033[0;31m' YELLOW='\033[1;33m' GREEN='\033[0;32m' CYAN='\033[0;36m' BOLD='\033[1m' RESET='\033[0m' else RED='' YELLOW='' GREEN='' CYAN='' BOLD='' RESET='' fi # ============================================ # FUNCIONES AUXILIARES # ============================================ separator() { echo -e "${CYAN}$(printf '=%.0f' {1..70})${RESET}" } header() { echo "" separator echo -e "${BOLD} $1${RESET}" separator } alert_check() { local value=$1 local threshold=$2 local label=$3 if (( value >= threshold )); then echo -e " ${RED}⚠ ALERTA: $label al ${value}% (umbral: ${threshold}%)${RESET}" else echo -e " ${GREEN}✓ $label: ${value}% (OK)${RESET}" fi } progress_bar() { local percent=$1 local width=40 local filled=$(( percent * width / 100 )) local empty=$(( width - filled )) local color="$GREEN" if (( percent >= 80 )); then color="$RED" elif (( percent >= 60 )); then color="$YELLOW" fi printf " ${color}[" printf '#%.0f' $(seq 1 $filled 2>/dev/null) || true printf '-%.0f' $(seq 1 $empty 2>/dev/null) || true printf "] %3d%%${RESET}\n" "$percent" } # ============================================ # MODO SOLO ALERTAS (para cron) # ============================================ if [[ "${1:-}" == "--alert-only" ]]; then ALERTS=0 CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{printf "%d", $2 + $4}') RAM_PERCENT=$(free | awk '/^Mem:/ {printf "%d", $3/$2 * 100}') while IFS= read -r line; do DISK_PERCENT=$(echo "$line" | awk '{gsub(/%/,""); print $5}') DISK_MOUNT=$(echo "$line" | awk '{print $6}') if (( DISK_PERCENT >= DISK_ALERT_THRESHOLD )); then echo "[$(date '+%Y-%m-%d %H:%M:%S')] ALERTA DISCO: $DISK_MOUNT al ${DISK_PERCENT}%" ALERTS=$((ALERTS + 1)) fi done < <(df -h --output=pcent,target -x tmpfs -x devtmpfs -x squashfs 2>/dev/null | tail -n +2) if (( CPU_USAGE >= CPU_ALERT_THRESHOLD )); then echo "[$(date '+%Y-%m-%d %H:%M:%S')] ALERTA CPU: ${CPU_USAGE}%" ALERTS=$((ALERTS + 1)) fi if (( RAM_PERCENT >= RAM_ALERT_THRESHOLD )); then echo "[$(date '+%Y-%m-%d %H:%M:%S')] ALERTA RAM: ${RAM_PERCENT}%" ALERTS=$((ALERTS + 1)) fi if (( ALERTS == 0 )); then exit 0 fi exit 0 fi # ============================================ # REPORTE COMPLETO # ============================================ echo "" echo -e "${BOLD}╔══════════════════════════════════════════════════════════════════╗${RESET}" echo -e "${BOLD}║ REPORTE DE RECURSOS DEL SERVIDOR ║${RESET}" echo -e "${BOLD}║ $(date '+%Y-%m-%d %H:%M:%S') ║${RESET}" echo -e "${BOLD}╚══════════════════════════════════════════════════════════════════╝${RESET}" # ------------------------------------------ # INFORMACIÓN DEL SISTEMA # ------------------------------------------ header "INFORMACIÓN DEL SISTEMA" echo -e " ${BOLD}Hostname:${RESET} $(hostname)" echo -e " ${BOLD}Kernel:${RESET} $(uname -r)" echo -e " ${BOLD}SO:${RESET} $(cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d'"' -f2 || echo 'Desconocido')" echo -e " ${BOLD}Uptime:${RESET} $(uptime -p 2>/dev/null || uptime | sed 's/.*up/up/')" echo -e " ${BOLD}Usuarios:${RESET} $(who | wc -l) conectados" # ------------------------------------------ # USO DE CPU # ------------------------------------------ header "USO DE CPU" LOAD_AVG=$(cat /proc/loadavg) LOAD_1=$(echo "$LOAD_AVG" | awk '{print $1}') LOAD_5=$(echo "$LOAD_AVG" | awk '{print $2}') LOAD_15=$(echo "$LOAD_AVG" | awk '{print $3}') CPU_CORES=$(nproc) echo -e " ${BOLD}Núcleos:${RESET} $CPU_CORES" echo -e " ${BOLD}Load Average:${RESET} $LOAD_1 (1min) | $LOAD_5 (5min) | $LOAD_15 (15min)" CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{printf "%d", $2 + $4}') echo -e " ${BOLD}Uso total:${RESET} ${CPU_USAGE}%" progress_bar "$CPU_USAGE" alert_check "$CPU_USAGE" "$CPU_ALERT_THRESHOLD" "CPU" echo "" echo -e " ${BOLD}Top $TOP_N procesos por CPU:${RESET}" echo -e " ${CYAN}$(printf '%-8s %-6s %-6s %s' 'PID' '%CPU' '%MEM' 'COMANDO')${RESET}" ps aux --sort=-%cpu | head -n $((TOP_N + 1)) | tail -n $TOP_N | while read -r line; do PID=$(echo "$line" | awk '{print $2}') CPU=$(echo "$line" | awk '{printf "%.1f", $3}') MEM=$(echo "$line" | awk '{printf "%.1f", $4}') CMD=$(echo "$line" | awk '{for(i=11;i<=NF;i++) printf "%s ", $i; print ""}' | xargs) printf " %-8s %-6s %-6s %s\n" "$PID" "$CPU" "$MEM" "$CMD" done # ------------------------------------------ # USO DE MEMORIA RAM # ------------------------------------------ header "USO DE MEMORIA RAM" RAM_INFO=$(free -h) RAM_TOTAL=$(echo "$RAM_INFO" | awk '/^Mem:/ {print $2}') RAM_USED=$(echo "$RAM_INFO" | awk '/^Mem:/ {print $3}') RAM_FREE=$(echo "$RAM_INFO" | awk '/^Mem:/ {print $4}') RAM_AVAILABLE=$(echo "$RAM_INFO" | awk '/^Mem:/ {print $7}') RAM_PERCENT=$(free | awk '/^Mem:/ {printf "%d", $3/$2 * 100}') SWAP_TOTAL=$(echo "$RAM_INFO" | awk '/^Swap:/ {print $2}') SWAP_USED=$(echo "$RAM_INFO" | awk '/^Swap:/ {print $3}') echo -e " ${BOLD}Total:${RESET} $RAM_TOTAL" echo -e " ${BOLD}Usada:${RESET} $RAM_USED" echo -e " ${BOLD}Libre:${RESET} $RAM_FREE" echo -e " ${BOLD}Disponible:${RESET} $RAM_AVAILABLE" echo -e " ${BOLD}Uso:${RESET} ${RAM_PERCENT}%" progress_bar "$RAM_PERCENT" alert_check "$RAM_PERCENT" "$RAM_ALERT_THRESHOLD" "RAM" echo "" echo -e " ${BOLD}Swap:${RESET} $SWAP_USED / $SWAP_TOTAL" echo "" echo -e " ${BOLD}Top $TOP_N procesos por RAM:${RESET}" echo -e " ${CYAN}$(printf '%-8s %-6s %-6s %s' 'PID' '%MEM' '%CPU' 'COMANDO')${RESET}" ps aux --sort=-%mem | head -n $((TOP_N + 1)) | tail -n $TOP_N | while read -r line; do PID=$(echo "$line" | awk '{print $2}') CPU=$(echo "$line" | awk '{printf "%.1f", $3}') MEM=$(echo "$line" | awk '{printf "%.1f", $4}') CMD=$(echo "$line" | awk '{for(i=11;i<=NF;i++) printf "%s ", $i; print ""}' | xargs) printf " %-8s %-6s %-6s %s\n" "$PID" "$MEM" "$CPU" "$CMD" done # ------------------------------------------ # USO DE DISCO # ------------------------------------------ header "USO DE DISCO" echo -e " ${BOLD}Particiones:${RESET}" echo -e " ${CYAN}$(printf '%-20s %-8s %-8s %-8s %-6s %s' 'FILESYSTEM' 'TOTAL' 'USADO' 'LIBRE' '%USO' 'MOUNT')${RESET}" df -h --output=source,size,used,avail,pcent,target -x tmpfs -x devtmpfs -x squashfs 2>/dev/null | tail -n +2 | while read -r line; do FS=$(echo "$line" | awk '{print $1}') SIZE=$(echo "$line" | awk '{print $2}') USED=$(echo "$line" | awk '{print $3}') AVAIL=$(echo "$line" | awk '{print $4}') PCT=$(echo "$line" | awk '{gsub(/%/,""); print $5}') MOUNT=$(echo "$line" | awk '{print $6}') local_color="$GREEN" if (( PCT >= DISK_ALERT_THRESHOLD )); then local_color="$RED" elif (( PCT >= 60 )); then local_color="$YELLOW" fi printf " %-20s %-8s %-8s %-8s ${local_color}%-5s%%${RESET} %s\n" "$FS" "$SIZE" "$USED" "$AVAIL" "$PCT" "$MOUNT" done echo "" echo -e " ${BOLD}Top 10 directorios más pesados en /:${RESET}" du -h --max-depth=2 / 2>/dev/null | sort -rh | head -10 | while read -r size dir; do printf " %-10s %s\n" "$size" "$dir" done echo "" while IFS= read -r line; do DISK_PERCENT=$(echo "$line" | awk '{gsub(/%/,""); print $5}') DISK_MOUNT=$(echo "$line" | awk '{print $6}') alert_check "$DISK_PERCENT" "$DISK_ALERT_THRESHOLD" "Disco ($DISK_MOUNT)" done < <(df -h --output=pcent,target -x tmpfs -x devtmpfs -x squashfs 2>/dev/null | tail -n +2) # ------------------------------------------ # RESUMEN FINAL # ------------------------------------------ header "RESUMEN" alert_check "$CPU_USAGE" "$CPU_ALERT_THRESHOLD" "CPU" alert_check "$RAM_PERCENT" "$RAM_ALERT_THRESHOLD" "RAM" while IFS= read -r line; do DISK_PERCENT=$(echo "$line" | awk '{gsub(/%/,""); print $5}') DISK_MOUNT=$(echo "$line" | awk '{print $6}') alert_check "$DISK_PERCENT" "$DISK_ALERT_THRESHOLD" "Disco ($DISK_MOUNT)" done < <(df -h --output=pcent,target -x tmpfs -x devtmpfs -x squashfs 2>/dev/null | tail -n +2) echo "" echo -e " ${BOLD}Generado:${RESET} $(date '+%Y-%m-%d %H:%M:%S')" separator echo "" ``` Copiá este script a `/opt/scripts/monitor.sh`, dale permisos con `chmod 700` y ya lo podés correr con `./monitor.sh`. Ahora vamos bloque por bloque. ## Bloque 1: Configuración de umbrales Las primeras variables son los umbrales de alerta. Cuando un recurso supera el porcentaje configurado, el script lo marca en rojo y muestra una advertencia. ```bash CPU_ALERT_THRESHOLD=80 RAM_ALERT_THRESHOLD=80 DISK_ALERT_THRESHOLD=85 TOP_N=5 ``` El umbral de disco es más alto (85%) porque los discos suelen tener más margen que la RAM o la CPU. El `TOP_N` define cuántos procesos mostrar en el ranking de consumidores. Estos son los valores que uso habitualmente, pero ajustalos según tu servidor: si tenés una app que normalmente consume 70% de RAM, bajá el umbral a 70 para que te avise antes de que sea un problema. ## Bloque 2: Colores adaptativos Los colores hacen que el reporte sea mucho más fácil de leer de un vistazo, pero si redirigís la salida a un archivo o a un pipe, los códigos de escape ANSI se convierten en basura ilegible. Por eso detectamos si hay una terminal interactiva: ```bash if [[ -t 1 ]]; then RED='\033[0;31m' YELLOW='\033[1;33m' GREEN='\033[0;32m' # ... else RED='' YELLOW='' GREEN='' # ... fi ``` `-t 1` verifica que el file descriptor 1 (stdout) esté conectado a una terminal. Si estás corriendo el script desde cron o redirigiendo la salida, los colores se desactivan automáticamente. Es un detalle chico pero marca la diferencia cuando el output llega a un log. ## Bloque 3: Funciones auxiliares Las funciones `separator`, `header`, `alert_check` y `progress_bar` son las que le dan formato al reporte. La más interesante es `progress_bar`: ```bash progress_bar() { local percent=$1 local width=40 local filled=$(( percent * width / 100 )) local empty=$(( width - filled )) local color="$GREEN" if (( percent >= 80 )); then color="$RED" elif (( percent >= 60 )); then color="$YELLOW" fi printf " ${color}[" printf '#%.0f' $(seq 1 $filled 2>/dev/null) || true printf '-%.0f' $(seq 1 $empty 2>/dev/null) || true printf "] %3d%%${RESET}\n" "$percent" } ``` Genera una barra como `[####################--------------------] 50%` que cambia de color según el porcentaje: verde hasta 59%, amarillo de 60% a 79%, rojo de 80% en adelante. El `|| true` en los `seq` evita que falle cuando `filled` o `empty` es 0. La función `alert_check` es la que usa el resumen final y el bloque de disco para mostrar si un recurso está en estado crítico: ```bash alert_check() { local value=$1 local threshold=$2 local label=$3 if (( value >= threshold )); then echo -e " ${RED}⚠ ALERTA: $label al ${value}% (umbral: ${threshold}%)${RESET}" else echo -e " ${GREEN}✓ $label: ${value}% (OK)${RESET}" fi } ``` ## Bloque 4: Modo solo alertas para cron Esta es la parte que permite usar el script en un cron sin llenar un log con reportes completos cada 5 minutos: ```bash if [[ "${1:-}" == "--alert-only" ]]; then ALERTS=0 CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{printf "%d", $2 + $4}') RAM_PERCENT=$(free | awk '/^Mem:/ {printf "%d", $3/$2 * 100}') while IFS= read -r line; do DISK_PERCENT=$(echo "$line" | awk '{gsub(/%/,""); print $5}') DISK_MOUNT=$(echo "$line" | awk '{print $6}') if (( DISK_PERCENT >= DISK_ALERT_THRESHOLD )); then echo "[$(date '+%Y-%m-%d %H:%M:%S')] ALERTA DISCO: $DISK_MOUNT al ${DISK_PERCENT}%" ALERTS=$((ALERTS + 1)) fi done < <(df -h --output=pcent,target -x tmpfs -x devtmpfs -x squashfs 2>/dev/null | tail -n +2) # ... fi ``` Cuando corrés el script con `--alert-only`, solo imprime líneas si hay algo que supera los umbrales. Si todo está bien, no genera output. Esto es ideal para cron, porque cron te manda un mail cuando un script produce output: si no hay alertas, no hay mail. ## Bloque 5: Información del sistema El bloque más simple, pero útil para cuando tenés muchos servidores y no recordás cuál es cuál: ```bash echo -e " ${BOLD}Hostname:${RESET} $(hostname)" echo -e " ${BOLD}Kernel:${RESET} $(uname -r)" echo -e " ${BOLD}SO:${RESET} $(cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d'"' -f2)" echo -e " ${BOLD}Uptime:${RESET} $(uptime -p 2>/dev/null || uptime | sed 's/.*up/up/')" echo -e " ${BOLD}Usuarios:${RESET} $(who | wc -l) conectados" ``` `uptime -p` da el uptime en formato legible ("up 3 weeks, 2 days, 4 hours"), pero no está disponible en todos los Linux. El fallback con `sed` extrae la parte relevante del output clásico de `uptime`. ## Bloque 6: Uso de CPU Acá medimos dos cosas: el load average y el porcentaje de uso real. ```bash LOAD_AVG=$(cat /proc/loadavg) CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{printf "%d", $2 + $4}') ``` El load average (que leemos de `/proc/loadavg`) te dice cuántos procesos están esperando para usar la CPU. Un load average de 2.0 en un servidor de 4 núcleos está bien; en uno de 1 núcleo, significa que hay cola. Por eso siempre muestro la cantidad de núcleos junto al load: ```bash CPU_CORES=$(nproc) echo -e " ${BOLD}Núcleos:${RESET} $CPU_CORES" echo -e " ${BOLD}Load Average:${RESET} $LOAD_1 (1min) | $LOAD_5 (5min) | $LOAD_15 (15min)" ``` El uso de CPU se calcula con `top` en modo batch (`-bn1`), que corre una sola iteración y sale. Sumamos el `%us` (user) y `%sy` (system) para obtener el uso total. Después listamos los procesos que más CPU consumen: ```bash ps aux --sort=-%cpu | head -n $((TOP_N + 1)) | tail -n $TOP_N ``` El `head -n $((TOP_N + 1))` incluye la cabecera de `ps`, y el `tail -n $TOP_N` la descarta. Así nos quedan solo los 5 procesos (o los que definas en `TOP_N`). ## Bloque 7: Uso de memoria RAM Similar al bloque de CPU, pero usando `free`: ```bash RAM_INFO=$(free -h) RAM_TOTAL=$(echo "$RAM_INFO" | awk '/^Mem:/ {print $2}') RAM_USED=$(echo "$RAM_INFO" | awk '/^Mem:/ {print $3}') RAM_PERCENT=$(free | awk '/^Mem:/ {printf "%d", $3/$2 * 100}') ``` La diferencia entre "libre" y "disponible" es importante: Linux usa la RAM libre para caché de disco, así que "libre" suele ser un número chico incluso cuando todo está bien. "Disponible" es la métrica que importa: te dice cuánta RAM puede usar realmente una aplicación nueva sin swapear. El ranking de procesos por RAM usa el mismo patrón que el de CPU, pero ordenando por `%mem`: ```bash ps aux --sort=-%mem | head -n $((TOP_N + 1)) | tail -n $TOP_N ``` También incluyo el swap porque cuando el swap empieza a usarse, es señal de que la RAM no alcanza y el servidor va a empezar a andar lento: ```bash echo -e " ${BOLD}Swap:${RESET} $SWAP_USED / $SWAP_TOTAL" ``` ## Bloque 8: Uso de disco El comando `df` con `--output` te deja elegir exactamente qué columnas mostrar, y con `-x` excluimos los filesystems virtuales que solo hacen ruido: ```bash df -h --output=source,size,used,avail,pcent,target -x tmpfs -x devtmpfs -x squashfs ``` Después, el `du` de los directorios más pesados es útil para encontrar dónde se está llenando el disco: ```bash du -h --max-depth=2 / 2>/dev/null | sort -rh | head -10 ``` `--max-depth=2` limita la recursión para que no tarde una eternidad, `sort -rh` ordena de mayor a menor en formato humano, y `head -10` nos da los 10 más pesados. El `2>/dev/null` descarta los errores de permiso que aparecen al recorrer directorios como `/proc` o `/root`. ## Programación con cron Para monitoreo automático, lo mejor es correr el modo `--alert-only` cada 5 minutos: ```bash sudo crontab -e ``` Y agregar: ``` */5 * * * * /opt/scripts/monitor.sh --alert-only >> /var/log/monitor-alerts.log 2>&1 ``` Esto solo genera output cuando hay una alerta, así el log se mantiene chico y fácil de revisar. Si querés un reporte completo cada hora para revisar al final del día: ``` 0 * * * * /opt/scripts/monitor.sh >> /var/log/monitor-hourly.log 2>&1 ``` ## Mejoras opcionales que valen la pena Una vez que el script base funciona, hay varias cosas que podés sumarle: **Enviar alertas por email:** ```bash # Dentro del bloque --alert-only, al final: if (( ALERTS > 0 )); then echo "Hay $ALERTS alertas en $(hostname)" | mail -s "Alerta servidor" tu@email.com fi ``` **Notificar por Slack o Discord con un webhook:** ```bash WEBHOOK_URL="https://hooks.slack.com/services/T.../B.../xxx" if (( ALERTS > 0 )); then curl -s -X POST -H 'Content-type: application/json' \ --data "{\"text\":\"⚠ $ALERTS alertas en $(hostname)\"}" \ "$WEBHOOK_URL" fi ``` **Guardar un historial en CSV para graficar después:** ```bash CSV_FILE="/var/log/monitor-history.csv" echo "$(date '+%Y-%m-%d %H:%M:%S'),$CPU_USAGE,$RAM_PERCENT" >> "$CSV_FILE" ``` Con ese CSV podés armar un gráfico simple con gnuplot o importarlo a una planilla para ver tendencias. Muy útil para anticipar cuándo se va a llenar el disco o cuándo necesitás más RAM. **Verificar servicios críticos:** ```bash for SERVICE in nginx mysql php-fpm; do if systemctl is-active --quiet "$SERVICE"; then echo -e " ${GREEN}✓ $SERVICE: activo${RESET}" else echo -e " ${RED}✗ $SERVICE: inactivo${RESET}" fi done ``` Esto es clave si tenés un servidor web: no solo monitoreás recursos, sino que también verificás que los servicios estén corriendo. **Monitorear temperatura (servidores físicos):** ```bash if command -v sensors &> /dev/null; then echo -e " ${BOLD}Temperatura:${RESET}" sensors | grep "Core" | while read -r line; do echo " $line" done fi ``` ## Errores comunes que vale la pena evitar - **Usar `top` interactivo en un script.** Siempre usá `top -bn1` para que corra una sola iteración en modo batch. Sin el `-b`, `top` se queda esperando input y el script nunca termina. - **Confiar en el load average sin saber cuántos núcleos tiene el servidor.** Un load de 4.0 puede ser normal en 8 núcleos o catastrófico en 1 núcleo. Siempre mostrá o verificá `nproc`. - **No excluir filesystems virtuales en `df`.** Sin `-x tmpfs -x devtmpfs`, la salida de `df` se llena de filesystems que no importan y dificulta encontrar el problema real. - **Correr `du` desde `/` sin `--max-depth`.** En un servidor con millones de archivos, esto puede tardar minutos y consumir más recursos de los que estás intentando monitorear. - **No tener en cuenta la diferencia entre RAM "libre" y "disponible".** Si mirás solo la RAM libre, vas a creer que tu servidor está al límite cuando en realidad Linux está usando esa RAM para caché, que se libera instantáneamente cuando una app la necesita. ## Conclusión Con este script ya tenés un sistema de monitoreo funcional, liviano y sin dependencias externas. Lo corrés a mano cuando entrás a revisar un servidor, lo programás con cron para alertas automáticas y le sumás las mejoras que necesites con el tiempo. La clave del monitoreo no es tener la herramienta más sofisticada, sino tener visibilidad constante sobre lo que importa: CPU, RAM y disco. Si esos tres están bien, tu servidor probablemente esté bien. Si alguno se dispara, lo querés saber antes de que los usuarios lo noten. En el próximo post vamos a ver automatización de certificados SSL con Let's Encrypt y Bash, para que tus sitios siempre tengan HTTPS válido sin tener que renovarlos a mano.

Cálculos avanzados de fecha y hora en PHP con DateTime

Trabajar con fechas en PHP es una de esas tareas que parecen simples hasta que te toca calcular el último día del mes, sumar días hábiles a una fecha, convertir una zona horaria o generar el rango de los últimos seis meses para un reporte. Las funciones nativas tipo `date()` resuelven lo básico, pero cuando el proyecto crece necesitas algo más robusto. En este post te voy a mostrar dos approaches: por un lado la API moderna de `DateTime` y `DateTimeZone` que trae PHP, y por el otro una clase helper que tengo en mi repositorio personal desde hace años y que uso en prácticamente todos los proyectos. La llamo `Fechas` y la armé justamente para no estar reinventando la rueda cada vez que tengo que formatear una fecha en español, sumar días hábiles o convertir entre zonas horarias. ## El problema con las funciones nativas sueltas Si alguna vez tuviste que hacer algo más allá de un `date('Y-m-d')`, seguro te topaste con esta clase de código: ```php $fecha = "2026-06-27"; $partes = explode('-', $fecha); $mesEnTexto = array('Enero', 'Febrero', ...)[(int)$partes[1] - 1]; echo $partes[2] . " de " . $mesEnTexto . " del " . $partes[0]; ``` Funciona, pero es feo, repetitivo y está lleno de números mágicos. Si lo copias en cinco archivos distintos, el día que cambies el formato del mes, vas a tener que cazar cada copia. Y ni hablar de los bugs clásicos: usar `strtotime` con una fecha ambigua, olvidar configurar la zona horaria y obtener horas fantasma, o calcular mal el último día de febrero en año bisiesto. La API de `DateTime` te da objetos con métodos claros y zona horaria explícita, lo cual ya es una mejora enorme. Pero aún así, en proyectos reales uno termina creando funciones de envoltura porque la sintaxis se vuelve verbosa para cosas que haces todo el tiempo. Por eso armé la clase `Fechas`. ## La clase Fechas: un helper reutilizable La idea es tener un lugar centralizado con todas las operaciones de fecha que repito en mis proyectos. La clase vive en el namespace `App\Helpers` y todos sus métodos son `static`, así la uso sin necesidad de instanciar nada. ```php modify('+1 day'); echo $fecha->format('Y-m-d'); // "2026-02-01" ``` Mismo resultado, pero queda más claro qué estás haciendo. ## Calcular días entre dos fechas Para calcular la diferencia entre dos fechas hay un método específico. Lo armé para reportes de antigüedad, tiempo transcurrido desde una compra, o cualquier validación tipo "esto no puede tener más de N días". ```php echo Fechas::getDaysPassed("2026-01-15", "2026-06-27"); // 163 ``` La implementación toma ambas fechas, las convierte a timestamp Unix, las resta en segundos, divide por 86400 (segundos en un día) y devuelve el valor absoluto como entero. Si la fecha final es menor que la inicial, lanza una excepción. Un detalle interesante: el cálculo usa `floor`, lo que significa que devuelve días completos. Si querés incluir fracciones de día (por ejemplo para calcular edades o tiempos de servicio), deberías quitar el `floor` y devolver un float. También es importante notar que ignora las horas, así que si pasás `"2026-01-15 23:00"` y `"2026-01-16 01:00"` te va a decir que pasó 1 día, no 2 horas. Para casos donde la hora importa, conviene normalizar ambas fechas a `Y-m-d` antes de pasarlas. ## Último día del mes Esta es una operación que parece trivial pero esconde varios casos especiales. Febrero puede tener 28 o 29 días según si el año es bisiesto. Los meses de 30 y 31 días hay que recordarlos a mano. Por eso vale la pena centralizarla. ```php echo Fechas::getLastDayMonth("2026-02-15"); // "2026-02-28" echo Fechas::getLastDayMonth("2024-02-15"); // "2024-02-29" (2024 es año bisiesto) echo Fechas::getLastDayMonth("2026-04-15"); // "2026-04-30" ``` El truco de la implementación es saltar al primer día del mes siguiente y restar un segundo. No es la forma más elegante, pero funciona y no necesita de una tabla de días por mes. Como bonus, devuelve la fecha en formato `Y-m-d`, lista para insertar en una base de datos o comparar con otras fechas. ## Convertir entre zonas horarias Acá es donde entra la API moderna de PHP. Para trabajar con zonas horarias necesitás dos clases: `DateTime` para la fecha y `DateTimeZone` para la zona destino. ```php echo Fechas::convertDateIsoToTimeZone("2026-06-27 14:00:00", "America/Mexico_City"); // "2026-06-27 08:00:00" ``` El método toma la fecha (asume que está en la zona horaria por defecto del servidor) y la convierte a la zona horaria destino usando `DateTime::setTimezone`. La lista de zonas válidas la podés sacar de la [documentación oficial de PHP](https://www.php.net/manual/es/timezones.php), que incluye todas las zonas IANA. Un caso de uso típico: tu servidor está en UTC y guardás todo en UTC, pero necesitás mostrarle al usuario la hora en su zona local. Si tenés la zona del usuario guardada en su perfil, esto es directo: ```php $zonaUsuario = "America/Buenos_Aires"; echo Fechas::convertDateIsoToTimeZone($evento->created_at, $zonaUsuario); ``` Importante: para que esto funcione correctamente, la zona horaria del servidor tiene que estar bien configurada con `date_default_timezone_set` en el bootstrap de la aplicación, o seteada en el `php.ini`. Si la fecha de entrada ya tiene la zona incluida (formato ISO 8601 con offset como `2026-06-27T14:00:00+00:00`), PHP la respeta automáticamente. ## Sumar días hábiles Esta función la armé para sistemas de gestión donde los plazos se cuentan solo en días laborables. Por ejemplo, "entrega en 5 días hábiles" o "vencimiento en 10 días hábiles a partir de hoy". ```php echo Fechas::addWeekDay(5, "2026-06-26"); // "Mie 01 de Julio" ``` El primer parámetro es la cantidad de días hábiles a sumar y el segundo es la fecha de inicio. Si no pasás fecha, toma la actual. El formato de salida incluye el nombre abreviado del día y el mes completo, ideal para mostrar en una pantalla de "fecha estimada de entrega". La lógica de cálculo es interesante: toma el día de la semana de la fecha de inicio (1 para lunes, 7 para domingo en formato ISO), suma los días solicitados, calcula cuántos fines de semana completos hay en el medio y los suma al total. Después agrega esa cantidad de segundos a la fecha original. El truco está en los casos especiales de los bordes (cuando caés justo en sábado o domingo) que están manejados con los `if` que ajustan `$findesemana`. Hay una versión "raw" que devuelve la fecha sin formatear, útil cuando solo necesitás el cálculo: ```php echo Fechas::getNexBusinessDay(5, "2026-06-26"); // "2026-07-01" ``` ## Listar los últimos N meses Para reportes con un selector de período, muchas veces necesitás generar un array con los últimos 6 o 12 meses y sus nombres, así el usuario puede elegir. Eso es lo que hace `getListMonthPast`: ```php $meses = Fechas::getListMonthPast(); foreach ($meses as $mes) { echo $mes['name'] . " - " . $mes['date'] . "\n"; } // Junio - 2026-06 // Mayo - 2026-05 // Abril - 2026-04 // Marzo - 2026-03 // Febrero - 2026-02 // Enero - 2026-01 ``` Itera desde el mes actual hacia atrás, generando el par `nombre + periodo`. Es ideal para llenar un select en un formulario de filtros, y la primera entrada siempre es el mes en curso. Si necesitás solo 3 meses, podés cortar con `array_slice($meses, 0, 3)`. ## Cuándo conviene usar DateTime puro La clase `Fechas` resuelve el 90% de los casos que me encuentro, pero hay situaciones donde conviene ir directo a `DateTime`: - **Cuando necesitás hacer cálculos con locales específicos** (por ejemplo, fechas en japonés con `IntlDateFormatter`). - **Cuando operás con intervalos** (`DateInterval` permite hacer diff entre fechas y obtener años, meses y días por separado, no solo total de días). - **Cuando el formato de entrada es ambiguo** y querés ser estricto con `DateTime::createFromFormat` y manejar errores de parseo. - **Cuando hacés muchas operaciones encadenadas** sobre la misma fecha (sumar, restar, formatear varias veces), porque mantener una instancia es más eficiente que parsear strings una y otra vez. Un ejemplo concreto con `DateTime` y `DateInterval` que la clase `Fechas` no cubre: ```php $inicio = new DateTime("2026-01-15"); $fin = new DateTime("2026-06-27"); $diff = $inicio->diff($fin); echo $diff->y . " años, " . $diff->m . " meses, " . $diff->d . " días"; // "0 años, 5 meses, 12 días" ``` Esto es útil para calcular edades o antigüedad en formato "X años, Y meses", algo común en sistemas de recursos humanos o contratos. ## Conclusión La regla que sigo es: para el 90% de operaciones repetidas en mis proyectos, tener una clase helper como `Fechas` me ahorra tiempo y mantiene consistencia. Para cálculos más complejos, cálculos con locales específicos, o cuando necesito el poder completo de la API moderna, voy directo a `DateTime` y `DateInterval`. Lo que recomiendo es no empezar con la clase completa el día uno. Empezá con dos o tres métodos que más uses, sumá los que vayas necesitando, y refactorizá a `DateTime` cuando te topes con un caso que el helper no cubra bien. La idea es tener un toolkit propio que crezca con tu experiencia, no un mostruo de 30 métodos que no usás. En el próximo post vamos a meternos con arrays, y después con el manejo de sesiones y cookies. Si tenés tu propia clase helper o alguna función de fecha que uses seguido, me encantaría leerla en los comentarios.

Domina los arrays en PHP: map, filter, reduce y más

Los arrays son quizá la estructura de datos más usada en PHP. Desde listar productos de una tienda, filtrar resultados de una base de datos, ordenar usuarios o agrupar estadísticas, casi todo pasa por un array en algún momento. En este post te voy a enseñar las funciones que más uso para transformar, filtrar, combinar y ordenar arrays, con ejemplos reales que puedes copiar y adaptar directamente a tus proyectos. ## Transformar datos con array_map() `array_map()` aplica una función a cada elemento de un array y devuelve un nuevo array con los resultados. Es ideal cuando necesitas transformar una colección sin modificar la original. ```php $precios = [100, 250, 80, 430]; $conIva = array_map(function ($precio) { return $precio * 1.16; }, $precios); print_r($conIva); // [116, 290, 92.8, 498.8] ``` También puedes usar funciones con nombre o arrow functions de PHP 7.4+: ```php $nombres = ["juan", "maria", "pedro"]; $capitalizados = array_map('ucfirst', $nombres); print_r($capitalizados); // ["Juan", "Maria", "Pedro"] ``` **Caso de uso real:** Formatear una lista de precios para mostrar en una tabla. ```php $productos = [ ['nombre' => 'Mouse', 'precio' => 350], ['nombre' => 'Teclado', 'precio' => 750], ['nombre' => 'Monitor', 'precio' => 3200], ]; $preciosFormateados = array_map(function ($producto) { return [ 'nombre' => $producto['nombre'], 'precio' => '$' . number_format($producto['precio'], 2), ]; }, $productos); ``` ## Filtrar elementos con array_filter() `array_filter()` devuelve un nuevo array con solo los elementos que cumplen una condición. La clave original se conserva, así que si necesitas índices consecutivos, recuerda usar `array_values()`. ```php $numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; $pares = array_filter($numeros, function ($numero) { return $numero % 2 === 0; }); print_r($pares); // [1 => 2, 3 => 4, 5 => 6, 7 => 8, 9 => 10] $pares = array_values($pares); // [2, 4, 6, 8, 10] ``` **Ejemplo práctico:** Filtrar productos que tienen stock disponible. ```php $productos = [ ['nombre' => 'Mouse', 'stock' => 12], ['nombre' => 'Teclado', 'stock' => 0], ['nombre' => 'Monitor', 'stock' => 3], ]; $disponibles = array_filter($productos, function ($producto) { return $producto['stock'] > 0; }); ``` Si omites la función de callback, `array_filter()` elimina los valores que son "falsos" (`false`, `0`, `""`, `null`, `[]`): ```php $valores = [0, 1, "", "hola", null, [], true]; $limpio = array_filter($valores); print_r($limpio); // [1 => 1, 3 => "hola", 6 => true] ``` ## Reducir arrays con array_reduce() `array_reduce()` convierte un array en un único valor acumulado. Es perfecto para sumar totales, construir strings, contar elementos o transformar una lista en una estructura diferente. ```php $ventas = [120, 340, 560, 90]; $total = array_reduce($ventas, function ($acumulador, $venta) { return $acumulador + $venta; }, 0); echo $total; // 1110 ``` **Caso de uso real:** Calcular el total de un carrito de compras con productos y cantidades. ```php $carrito = [ ['producto' => 'Mouse', 'precio' => 350, 'cantidad' => 2], ['producto' => 'Teclado', 'precio' => 750, 'cantidad' => 1], ]; $total = array_reduce($carrito, function ($acumulador, $item) { return $acumulador + ($item['precio'] * $item['cantidad']); }, 0); echo $total; // 1450 ``` También puedes usar `array_reduce()` para construir estructuras más complejas: ```php $usuarios = [ ['nombre' => 'Ana', 'rol' => 'admin'], ['nombre' => 'Luis', 'rol' => 'editor'], ['nombre' => 'Sofía', 'rol' => 'admin'], ]; $porRol = array_reduce($usuarios, function ($acumulador, $usuario) { $acumulador[$usuario['rol']][] = $usuario['nombre']; return $acumulador; }, []); print_r($porRol); // [ // "admin" => ["Ana", "Sofía"], // "editor" => ["Luis"] // ] ``` ## Combinar arrays con array_merge() `array_merge()` une dos o más arrays en uno solo. Si las claves son numéricas, se reindexan automáticamente. Si son strings, los valores posteriores sobrescriben a los anteriores. ```php $frutas = ["manzana", "pera"]; $verduras = ["zanahoria", "espinaca"]; $alimentos = array_merge($frutas, $verduras); print_r($alimentos); // ["manzana", "pera", "zanahoria", "espinaca"] ``` **Ejemplo práctico:** Unir configuraciones por defecto con configuraciones personalizadas del usuario. ```php $defaultConfig = [ 'theme' => 'light', 'lang' => 'es', 'notifications' => true, ]; $userConfig = [ 'theme' => 'dark', 'lang' => 'en', ]; $config = array_merge($defaultConfig, $userConfig); print_r($config); // ['theme' => 'dark', 'lang' => 'en', 'notifications' => true] ``` ## Eliminar duplicados con array_unique() `array_unique()` elimina los valores duplicados de un array, conservando la primera aparición de cada valor. ```php $tags = ["php", "mysql", "php", "linux", "mysql", "bash"]; $tagsUnicos = array_unique($tags); print_r($tagsUnicos); // ["php", "mysql", "linux", "bash"] ``` **Caso real:** Limpiar una lista de correos antes de enviar una newsletter. ```php $emails = [ "juan@email.com", "maria@email.com", "juan@email.com", "pedro@email.com", ]; $emailsUnicos = array_values(array_unique($emails)); // ["juan@email.com", "maria@email.com", "pedro@email.com"] ``` ## Ordenar arrays con sort() y usort() PHP ofrece muchas funciones para ordenar arrays. Las más comunes son: - `sort()` - Ordena un array indexado de menor a mayor. - `rsort()` - Ordena un array indexado de mayor a menor. - `asort()` / `arsort()` - Ordenan arrays asociativos preservando las claves. - `ksort()` / `krsort()` - Ordenan arrays asociativos por sus claves. - `usort()` - Ordena con una función de comparación personalizada. ```php $numeros = [5, 2, 8, 1, 9]; sort($numeros); print_r($numeros); // [1, 2, 5, 8, 9] ``` **Ejemplo con array asociativo:** ```php $usuarios = [ ['nombre' => 'Carlos', 'edad' => 30], ['nombre' => 'Ana', 'edad' => 25], ['nombre' => 'Luis', 'edad' => 35], ]; usort($usuarios, function ($a, $b) { return $a['edad'] <=> $b['edad']; }); print_r($usuarios); // Ana (25), Carlos (30), Luis (35) ``` El operador spaceship `<=>` compara dos valores y devuelve `-1`, `0` o `1`, lo que hace que `usort()` sea muy limpio de leer. ## Combinando funciones: el poder real La verdadera potencia de estas funciones aparece cuando las combinas. Imagina que tienes una lista de productos y necesitas filtrar los disponibles, calcular el total con IVA y formatear el resultado. ```php $productos = [ ['nombre' => 'Mouse', 'precio' => 350, 'stock' => 12], ['nombre' => 'Teclado', 'precio' => 750, 'stock' => 0], ['nombre' => 'Monitor', 'precio' => 3200, 'stock' => 3], ['nombre' => 'Webcam', 'precio' => 1200, 'stock' => 8], ]; $totalConIva = array_reduce( array_filter($productos, fn($p) => $p['stock'] > 0), fn($total, $p) => $total + ($p['precio'] * 1.16), 0 ); echo number_format($totalConIva, 2); // 5559.00 ``` Otro patrón común: obtener una lista limpia de valores únicos a partir de datos crudos. ```php $registros = [ ['ciudad' => 'CDMX', 'venta' => 100], ['ciudad' => 'Guadalajara', 'venta' => 200], ['ciudad' => 'CDMX', 'venta' => 150], ]; $ciudades = array_values(array_unique(array_map( fn($r) => $r['ciudad'], $registros ))); print_r($ciudades); // ["CDMX", "Guadalajara"] ``` ## Funciones adicionales útiles Estas no las cubrimos en detalle pero vale la pena conocerlas: - `array_column()` - Extrae una sola columna de un array multidimensional. - `array_search()` - Busca un valor y devuelve su clave. - `in_array()` - Verifica si un valor existe en un array. - `array_key_exists()` - Verifica si una clave existe. - `array_slice()` - Extrae una porción de un array. - `array_splice()` - Elimina o reemplaza una porción de un array. - `array_chunk()` - Divide un array en fragmentos más pequeños. ```php $usuarios = [ ['id' => 1, 'nombre' => 'Ana'], ['id' => 2, 'nombre' => 'Luis'], ]; $nombres = array_column($usuarios, 'nombre'); // ["Ana", "Luis"] $ids = array_column($usuarios, 'id', 'nombre'); // ["Ana" => 1, "Luis" => 2] ``` ## Conclusión Dominar estas funciones te permite escribir código PHP más limpio, declarativo y fácil de mantener. En lugar de llenar tu código con bucles `foreach` anidados, puedes expresar la intención de tu lógica de forma clara con `map`, `filter` y `reduce`. Mi recomendación: identifica en tu proyecto actual dónde estás transformando, filtrando o reduciendo listas y reemplaza esos bloques con las funciones adecuadas. Con la práctica, empezarás a ver patrones de procesamiento de datos de forma natural. ¡Espero que estos ejemplos te sean útiles para tu próximo proyecto PHP!

Validación de datos en PHP: sanitizar y asegurar entradas de usuario

Cada formulario de tu aplicación es una puerta de entrada a tu sistema. Y cada campo de ese formulario es una oportunidad para que alguien malintencionado te mande código SQL, JavaScript, comandos de shell, o simplemente un email con un formato tan raro que revienta tu función de envío. Si no validás y sanitizás lo que te llega, no estás haciendo desarrollo web, estás jugando a la ruleta rusa con tu base de datos. En este post vamos a recorrer `filter_var`, que es la función nativa de PHP dedicada a esto, y vamos a armar un set de funciones reutilizables que podés copiar a tus proyectos para tener una capa de validación consistente. No es la cobertura más exhaustiva del tema (hay libros enteros sobre seguridad web), pero es lo mínimo que necesitás para dormir tranquilo. ## Validar vs sanitizar: no es lo mismo Antes de meternos con código, hay una diferencia conceptual que confunde a mucha gente: - **Validar** es comprobar que un dato cumple con un formato esperado. ¿Es un email válido? ¿Es un número entero positivo? ¿Está la cadena dentro de cierto rango? La validación responde con "sí" o "no". - **Sanitizar** es limpiar un dato para hacerlo seguro, removiendo o escapando los caracteres problemáticos. La sanitización transforma el dato. Por ejemplo: si el usuario escribe `" juan@email.com "`, sanitizar te devuelve `"juan@email.com"` (sin espacios) y validar te dice que el formato es correcto. Si escribe `""`, sanitizar te devuelve un string inofensivo (con los tags escapados o removidos) y validar te dice que no es un formato aceptable para un campo de email. El orden correcto siempre es: **primero sanitizar, después validar**. Si sanitizás bien, la validación va a pasar en la mayoría de los casos legítimos. Si no sanitizás, terminás rechazando emails válidos con espacios o rechazando entradas que eran perfectamente seguras. ## filter_var: el caballito de batalla PHP trae una función专门 pensada para esto: `filter_var()`. Recibe el valor a procesar, un ID de filtro, y opciones opcionales. La misma función sirve para validar y para sanitizar, lo que cambia es el ID del filtro. ```php filter_var($valor, FILTER_VALIDATE_EMAIL); filter_var($valor, FILTER_SANITIZE_EMAIL); ``` Empecemos por la sanitización, que es donde menos se mete la gente. ## Sanitizar strings El caso más común. Tenés un input de texto libre y querés sacarle todo lo que no debería estar ahí. El filtro `FILTER_SANITIZE_FULL_SPECIAL_CHARS` escapa HTML, comillas y otros caracteres especiales, y es ideal para datos que vas a mostrar después en una página. ```php $nombre = ""; $limpio = filter_var($nombre, FILTER_SANITIZE_FULL_SPECIAL_CHARS); echo $limpio; // "<script>alert('hola')</script>" ``` El string original sigue ahí, pero escapado. Cuando lo renderices en HTML, el navegador lo va a mostrar como texto literal en lugar de ejecutarlo como JavaScript. Esto por sí solo ya te protege de la mayoría de los ataques XSS reflejados. Otros filtros de sanitización útiles: ```php // Quitar tags HTML completos (más agresivo) $limpio = filter_var($texto, FILTER_SANITIZE_STRING); // PHP 8.1+ deprecado // Eliminar todo lo que no sea letras, números y espacios $limpio = filter_var($texto, FILTER_SANITIZE_NUMBER_INT); // Quitar caracteres no numéricos (deja el punto y el signo menos) $precio = filter_var("$1,250.50", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION); echo $precio; // "1250.50" // Limpiar un email (quita caracteres que no son válidos en emails) $email = filter_var(" juan@@email .com ", FILTER_SANITIZE_EMAIL); echo $email; // "juan@email.com" // Limpiar una URL (elimina caracteres no permitidos) $url = filter_var("https://ejemplo.com/path