Manipulación de Archivos - Curso Bash Scripting

Comandos Fundamentales

La manipulación de archivos es una habilidad esencial en Linux. Estos cuatro comandos te permitirán realizar el 90% de las operaciones de archivos que necesitarás.

touch

Crear archivos vacíos

Crea nuevos archivos o actualiza la fecha de archivos existentes

cp

Copiar archivos

Duplica archivos y directorios manteniendo el original

mv

Mover/Renombrar

Mueve archivos a otra ubicación o cambia su nombre

rm

Eliminar archivos

Borra archivos y directorios permanentemente

Comando touch - Crear Archivos

El comando touch es la forma más simple de crear archivos vacíos. También puede actualizar las fechas de modificación de archivos existentes.

Uso Básico

# Crear un archivo vacío
$ touch nuevo_archivo.txt
$ ls -l nuevo_archivo.txt
-rw-r--r-- 1 usuario grupo 0 oct 15 12:00 nuevo_archivo.txt

# Crear múltiples archivos a la vez
$ touch archivo1.txt archivo2.txt archivo3.txt
$ ls
archivo1.txt  archivo2.txt  archivo3.txt  nuevo_archivo.txt

# Crear archivos con espacios en el nombre (usar comillas)
$ touch "mi archivo con espacios.txt"
$ ls -la
-rw-r--r-- 1 usuario grupo 0 oct 15 12:05 mi archivo con espacios.txt

# Crear archivos con extensiones específicas
$ touch script.sh config.yaml datos.json
$ ls
config.yaml  datos.json  script.sh

Opciones Avanzadas

# Ver fecha actual de un archivo
$ ls -l archivo1.txt
-rw-r--r-- 1 usuario grupo 0 oct 15 12:00 archivo1.txt

# Actualizar solo la fecha de acceso
$ touch -a archivo1.txt

# Actualizar solo la fecha de modificación
$ touch -m archivo1.txt

# Establecer una fecha específica
$ touch -t 202310151030 archivo_antiguo.txt
$ ls -l archivo_antiguo.txt
-rw-r--r-- 1 usuario grupo 0 oct 15 10:30 archivo_antiguo.txt

# Crear archivo solo si no existe (no actualizar fecha)
$ touch -c archivo_inexistente.txt  # No crea el archivo
$ ls archivo_inexistente.txt
ls: cannot access 'archivo_inexistente.txt': No such file or directory

Crear Estructura de Directorios

# Crear directorios primero, luego archivos
$ mkdir -p proyecto/src proyecto/docs proyecto/tests
$ touch proyecto/README.md
$ touch proyecto/src/main.py proyecto/src/utils.py
$ touch proyecto/docs/manual.md proyecto/tests/test_main.py

# Ver la estructura creada
$ tree proyecto
proyecto/
├── README.md
├── docs/
│   └── manual.md
├── src/
│   ├── main.py
│   └── utils.py
└── tests/
    └── test_main.py

¿Por qué usar touch?

Touch es útil para:

Crear archivos de configuración vacíos
Preparar estructura de proyectos
Crear archivos de log para aplicaciones
Actualizar fechas para hacer "trigger" de procesos automáticos

Comando cp - Copiar Archivos

El comando cp (copy) duplica archivos y directorios. Es esencial para crear respaldos y distribuir archivos.

Copiar Archivos

# Copiar un archivo
$ echo "Contenido de prueba" > original.txt
$ cp original.txt copia.txt
$ ls -l
-rw-r--r-- 1 usuario grupo 20 oct 15 12:10 copia.txt
-rw-r--r-- 1 usuario grupo 20 oct 15 12:10 original.txt

# Verificar que el contenido se copió
$ cat copia.txt
Contenido de prueba

# Copiar a un directorio específico
$ mkdir backup
$ cp original.txt backup/
$ ls backup/
original.txt

# Copiar con un nombre diferente
$ cp original.txt backup/archivo_respaldo.txt
$ ls backup/
archivo_respaldo.txt  original.txt

# Copiar múltiples archivos a un directorio
$ touch archivo1.txt archivo2.txt archivo3.txt
$ cp archivo1.txt archivo2.txt archivo3.txt backup/
$ ls backup/
archivo1.txt  archivo2.txt  archivo3.txt  archivo_respaldo.txt  original.txt

Opciones Importantes de cp

Opción	Descripción	Ejemplo
`-r, -R`	Copiar directorios recursivamente	`cp -r directorio/ backup/`
`-i`	Preguntar antes de sobrescribir	`cp -i archivo.txt copia.txt`
`-u`	Copiar solo si es más nuevo	`cp -u *.txt backup/`
`-v`	Modo verboso (mostrar qué se copia)	`cp -v archivo.txt backup/`
`-p`	Preservar atributos (permisos, fechas)	`cp -p archivo.txt backup/`
`-a`	Archivo completo (equivale a -pPR)	`cp -a directorio/ backup/`

Copiar Directorios

# Crear estructura de ejemplo
$ mkdir -p proyecto/src proyecto/docs
$ echo "código principal" > proyecto/src/main.py
$ echo "documentación" > proyecto/docs/readme.md

# Intentar copiar sin -r (fallará)
$ cp proyecto proyecto_copia
cp: -r not specified; omitting directory 'proyecto'

# Copiar directorio correctamente
$ cp -r proyecto proyecto_copia
$ ls -la proyecto_copia/
total 16
drwxr-xr-x 4 usuario grupo 4096 oct 15 12:20 .
drwxr-xr-x 3 usuario grupo 4096 oct 15 12:20 ..
drwxr-xr-x 2 usuario grupo 4096 oct 15 12:20 docs
drwxr-xr-x 2 usuario grupo 4096 oct 15 12:20 src

# Copiar preservando todos los atributos
$ cp -a proyecto proyecto_completo
$ ls -l proyecto_completo/src/
-rw-r--r-- 1 usuario grupo 16 oct 15 12:15 main.py

# Copiar con confirmación interactiva
$ cp -ri proyecto proyecto_interactivo
cp: overwrite 'proyecto_interactivo/src/main.py'? n
cp: overwrite 'proyecto_interactivo/docs/readme.md'? y

Patrones y Comodines

# Copiar todos los archivos de texto
$ cp *.txt backup/

# Copiar archivos que empiecen con 'config'
$ cp config* configuraciones/

# Copiar archivos con extensiones específicas
$ cp *.{jpg,png,gif} imagenes/

# Copiar solo archivos más nuevos
$ cp -u *.txt backup/  # Solo copia si son más nuevos que los existentes

Buenas Prácticas con cp

Usa siempre -i para evitar sobrescribir accidentalmente
Usa -a para respaldos completos que preserven todo
Verifica el contenido después de copiar archivos importantes
Usa -v para ver el progreso en operaciones grandes

Comando mv - Mover y Renombrar

El comando mv (move) sirve para dos propósitos: mover archivos a diferentes ubicaciones y renombrar archivos. A diferencia de cp, no mantiene el archivo original.

Renombrar Archivos

# Crear archivo de prueba
$ touch archivo_temporal.txt
$ ls
archivo_temporal.txt

# Renombrar archivo
$ mv archivo_temporal.txt archivo_definitivo.txt
$ ls
archivo_definitivo.txt

# Renombrar con confirmación
$ touch otro_archivo.txt
$ mv -i archivo_definitivo.txt otro_archivo.txt
mv: overwrite 'otro_archivo.txt'? y
$ ls
otro_archivo.txt

# Renombrar múltiples archivos (usando un bucle)
$ touch file1.tmp file2.tmp file3.tmp
$ for file in *.tmp; do mv "$file" "${file%.tmp}.txt"; done
$ ls
file1.txt  file2.txt  file3.txt  otro_archivo.txt

Mover Archivos

# Crear estructura de directorios
$ mkdir documentos imagenes scripts
$ touch documento.pdf foto.jpg mi_script.sh

# Mover archivos a directorios apropiados
$ mv documento.pdf documentos/
$ mv foto.jpg imagenes/
$ mv mi_script.sh scripts/

# Verificar que se movieron
$ ls documentos/
documento.pdf
$ ls imagenes/
foto.jpg
$ ls scripts/
mi_script.sh

# Mover múltiples archivos
$ touch doc1.pdf doc2.pdf doc3.pdf
$ mv doc*.pdf documentos/
$ ls documentos/
doc1.pdf  doc2.pdf  doc3.pdf  documento.pdf

# Mover con un nombre nuevo
$ touch reporte.txt
$ mv reporte.txt documentos/reporte_final.txt
$ ls documentos/
doc1.pdf  doc2.pdf  doc3.pdf  documento.pdf  reporte_final.txt

Mover Directorios

# Crear directorio con contenido
$ mkdir proyecto_viejo
$ touch proyecto_viejo/archivo1.txt proyecto_viejo/archivo2.txt

# Renombrar directorio
$ mv proyecto_viejo proyecto_nuevo
$ ls
documentos/  imagenes/  proyecto_nuevo/  scripts/

# Mover directorio dentro de otro
$ mkdir proyectos
$ mv proyecto_nuevo proyectos/
$ ls proyectos/
proyecto_nuevo/
$ ls proyectos/proyecto_nuevo/
archivo1.txt  archivo2.txt

# Mover contenido de un directorio a otro
$ mkdir temporal
$ touch temporal/file1.txt temporal/file2.txt
$ mv temporal/* documentos/  # Mueve el contenido, no el directorio
$ ls temporal/               # Directorio vacío
$ ls documentos/
doc1.pdf  doc2.pdf  doc3.pdf  documento.pdf  file1.txt  file2.txt  reporte_final.txt

Opciones de mv

Opción	Descripción	Ejemplo
`-i`	Preguntar antes de sobrescribir	`mv -i archivo.txt destino/`
`-u`	Mover solo si es más nuevo	`mv -u *.txt destino/`
`-v`	Modo verboso	`mv -v archivo.txt destino/`
`-f`	Forzar (no preguntar)	`mv -f archivo.txt destino/`
`-n`	No sobrescribir archivos existentes	`mv -n archivo.txt destino/`

Patrón de Trabajo Común

Organizar archivos por tipo es una tarea común:

# Crear directorios por tipo
mkdir -p organizados/{documentos,imagenes,audio,video,codigo}

# Mover archivos según su extensión
mv *.pdf *.doc *.docx organizados/documentos/
mv *.jpg *.png *.gif *.jpeg organizados/imagenes/
mv *.mp3 *.wav *.flac organizados/audio/
mv *.mp4 *.avi *.mkv organizados/video/
mv *.py *.js *.html *.css organizados/codigo/

Comando rm - Eliminar Archivos

El comando rm (remove) elimina archivos y directorios permanentemente. Es poderoso pero peligroso, ya que no hay "papelera de reciclaje" en la terminal.

¡ADVERTENCIA CRÍTICA!

Los archivos eliminados con rm no se pueden recuperar fácilmente. No hay "Ctrl+Z" o papelera de reciclaje. Siempre verifica dos veces antes de usar rm, especialmente con las opciones -r y -f.

Eliminar Archivos

# Crear archivos de prueba
$ touch archivo1.txt archivo2.txt archivo_no_deseado.txt

# Eliminar un archivo específico
$ rm archivo_no_deseado.txt
$ ls
archivo1.txt  archivo2.txt

# Eliminar múltiples archivos
$ touch basura1.tmp basura2.tmp basura3.tmp
$ rm basura1.tmp basura2.tmp basura3.tmp
$ ls
archivo1.txt  archivo2.txt

# Eliminar con confirmación (RECOMENDADO para principiantes)
$ touch archivo_importante.txt
$ rm -i archivo_importante.txt
rm: remove regular empty file 'archivo_importante.txt'? n
$ ls  # El archivo sigue ahí porque dijimos 'n'
archivo1.txt  archivo2.txt  archivo_importante.txt

# Eliminar usando patrones
$ touch test1.tmp test2.tmp test3.tmp
$ rm *.tmp
$ ls
archivo1.txt  archivo2.txt  archivo_importante.txt

Eliminar Directorios

# Crear directorio con contenido
$ mkdir directorio_prueba
$ touch directorio_prueba/archivo1.txt directorio_prueba/archivo2.txt

# Intentar eliminar directorio (fallará)
$ rm directorio_prueba
rm: cannot remove 'directorio_prueba': Is a directory

# Eliminar directorio vacío con rmdir
$ mkdir directorio_vacio
$ rmdir directorio_vacio
$ ls | grep directorio_vacio  # No debería aparecer

# Eliminar directorio con contenido usando -r (PELIGROSO)
$ rm -r directorio_prueba
$ ls | grep directorio_prueba  # No debería aparecer

# Método más seguro: eliminar contenido primero
$ mkdir otro_directorio
$ touch otro_directorio/archivo.txt
$ rm otro_directorio/archivo.txt  # Eliminar contenido
$ rmdir otro_directorio            # Eliminar directorio vacío

Opciones de rm

Opción	Descripción	Nivel de Riesgo
`-i`	Preguntar antes de eliminar	Seguro
`-v`	Mostrar qué se elimina	Seguro
`-r, -R`	Eliminar directorios recursivamente	Cuidado
`-f`	Forzar (no preguntar, ignorar archivos inexistentes)	Peligroso
`-rf`	Eliminar todo sin preguntar	MUY PELIGROSO

Alternativas Más Seguras

# Mover a una "papelera" en lugar de eliminar directamente
$ mkdir ~/.papelera
$ mv archivo_no_deseado.txt ~/.papelera/

# Usar find para eliminar archivos específicos de forma controlada
$ find . -name "*.tmp" -type f -delete

# Crear un script de "eliminación segura"
$ cat > rm_seguro.sh << 'EOF'
#!/bin/bash
if [ ! -d "$HOME/.papelera" ]; then
    mkdir "$HOME/.papelera"
fi
mv "$@" "$HOME/.papelera/"
echo "Archivos movidos a ~/.papelera/"
EOF
$ chmod +x rm_seguro.sh

# Usar el script seguro
$ ./rm_seguro.sh archivo1.txt archivo2.txt
Archivos movidos a ~/.papelera/
$ ls ~/.papelera/
archivo1.txt  archivo2.txt

NUNCA hagas esto

rm -rf /

rm -rf /*

rm -rf ~/*

Estos comandos pueden destruir tu sistema

Usa con cuidado

rm -rf directorio/

rm -f archivo

Siempre verifica la ruta dos veces

Métodos seguros

rm -i archivo

rm -v archivo

mv archivo ~/.papelera/

Siempre usa confirmación

Comando mkdir - Crear Directorios

El comando mkdir (make directory) crea nuevos directorios. Es esencial para organizar tus archivos.

# Crear un directorio simple
$ mkdir mi_proyecto
$ ls -ld mi_proyecto
drwxr-xr-x 2 usuario grupo 4096 oct 15 13:00 mi_proyecto

# Crear múltiples directorios
$ mkdir docs src tests
$ ls -l
drwxr-xr-x 2 usuario grupo 4096 oct 15 13:05 docs
drwxr-xr-x 2 usuario grupo 4096 oct 15 13:05 mi_proyecto
drwxr-xr-x 2 usuario grupo 4096 oct 15 13:05 src
drwxr-xr-x 2 usuario grupo 4096 oct 15 13:05 tests

# Crear estructura de directorios anidados
$ mkdir -p proyecto/src/main proyecto/src/utils proyecto/tests/unit proyecto/tests/integration
$ tree proyecto
proyecto/
├── src/
│   ├── main/
│   └── utils/
└── tests/
    ├── integration/
    └── unit/

# Crear directorios con permisos específicos
$ mkdir -m 755 directorio_publico
$ mkdir -m 700 directorio_privado
$ ls -l
drwxr-xr-x 2 usuario grupo 4096 oct 15 13:10 directorio_publico
drwx------ 2 usuario grupo 4096 oct 15 13:10 directorio_privado

# Crear directorio solo si no existe (evitar errores)
$ mkdir directorio_existente
$ mkdir directorio_existente
mkdir: cannot create directory 'directorio_existente': File exists
$ mkdir -p directorio_existente  # No da error si ya existe

Opción -p (parents)

La opción -p es extremadamente útil porque:

Crea directorios padre si no existen
No da error si el directorio ya existe
Permite crear estructuras completas en una sola línea

Comando rmdir - Eliminar Directorios Vacíos

El comando rmdir elimina directorios, pero solo si están vacíos. Es más seguro que rm -r.

# Crear directorios de prueba
$ mkdir directorio_vacio directorio_con_contenido
$ touch directorio_con_contenido/archivo.txt

# Eliminar directorio vacío
$ rmdir directorio_vacio
$ ls | grep directorio_vacio  # No debería aparecer

# Intentar eliminar directorio con contenido (fallará)
$ rmdir directorio_con_contenido
rmdir: failed to remove 'directorio_con_contenido': Directory not empty

# Eliminar contenido primero, luego el directorio
$ rm directorio_con_contenido/archivo.txt
$ rmdir directorio_con_contenido

# Eliminar estructura de directorios vacíos
$ mkdir -p estructura/nivel1/nivel2/nivel3
$ rmdir -p estructura/nivel1/nivel2/nivel3  # Elimina toda la cadena si está vacía

Comando find - Buscar Archivos

El comando find es una herramienta poderosa para localizar archivos basándose en diversos criterios.

# Buscar archivos por nombre
$ find . -name "*.txt"
./archivo1.txt
./documentos/reporte.txt
./proyecto/readme.txt

# Buscar directorios
$ find . -type d -name "test*"
./tests
./proyecto/tests

# Buscar archivos por tamaño
$ find . -size +1M  # Archivos mayores a 1MB
$ find . -size -1k  # Archivos menores a 1KB

# Buscar archivos modificados recientemente
$ find . -mtime -1  # Modificados en las últimas 24 horas
$ find . -mtime +7  # Modificados hace más de 7 días

# Buscar y ejecutar comandos
$ find . -name "*.tmp" -delete  # Encontrar y eliminar archivos .tmp
$ find . -name "*.log" -exec ls -l {} \;  # Listar archivos .log detalladamente

# Buscar archivos por permisos
$ find . -perm 755  # Archivos con permisos exactos 755
$ find . -perm -644  # Archivos con al menos permisos 644

# Buscar archivos vacíos
$ find . -empty
$ find . -type f -empty  # Solo archivos vacíos
$ find . -type d -empty  # Solo directorios vacíos

Flujo de Trabajo Práctico

Veamos cómo combinar todos estos comandos en un flujo de trabajo real para organizar un proyecto.

Paso 1: Crear Estructura del Proyecto

# Crear estructura completa del proyecto
$ mkdir -p mi_aplicacion/{src,docs,tests,config,logs,backup}
$ tree mi_aplicacion/
mi_aplicacion/
├── backup/
├── config/
├── docs/
├── logs/
├── src/
└── tests/

Paso 2: Crear Archivos Base

# Crear archivos principales
$ touch mi_aplicacion/README.md
$ touch mi_aplicacion/src/{main.py,utils.py,config.py}
$ touch mi_aplicacion/tests/{test_main.py,test_utils.py}
$ touch mi_aplicacion/docs/{manual.md,api.md}
$ touch mi_aplicacion/config/{app.conf,database.conf}

Paso 3: Organizar Archivos Existentes

# Supongamos que tenemos archivos desordenados
$ touch archivo1.py archivo2.py manual.txt config.cfg log1.txt log2.txt

# Organizar por tipo
$ mv *.py mi_aplicacion/src/
$ mv *.txt mi_aplicacion/logs/
$ mv *.cfg mi_aplicacion/config/
$ mv manual.txt mi_aplicacion/docs/manual_adicional.txt

Paso 4: Crear Respaldo

# Crear respaldo completo del proyecto
$ cp -a mi_aplicacion mi_aplicacion_backup_$(date +%Y%m%d)
$ ls
mi_aplicacion/  mi_aplicacion_backup_20231015/

# Verificar estructura del respaldo
$ tree mi_aplicacion_backup_20231015/

Paso 5: Limpieza y Mantenimiento

# Eliminar archivos temporales
$ find mi_aplicacion -name "*.tmp" -delete
$ find mi_aplicacion -name "*~" -delete

# Eliminar logs antiguos (más de 30 días)
$ find mi_aplicacion/logs -name "*.log" -mtime +30 -delete

# Eliminar directorios vacíos
$ find mi_aplicacion -type d -empty -delete

Ejercicio Integral

Laboratorio Completo de Manipulación de Archivos

Este ejercicio integra todos los comandos aprendidos en un escenario realista:

Ejercicio completo paso a paso Copiar

# EJERCICIO: Organizar una oficina digital desordenada

# Paso 1: Crear el escenario desordenado
mkdir laboratorio_archivos
cd laboratorio_archivos

# Crear archivos "desordenados"
touch reporte2023.pdf carta.docx foto_vacaciones.jpg
touch script_backup.sh config.txt log_sistema.log
touch video_presentacion.mp4 datos.csv nota_personal.txt
touch archivo_temporal.tmp otro_temporal.tmp basura.tmp

# Paso 2: Crear estructura organizacional
mkdir -p organizados/{documentos/{reportes,cartas,notas},multimedia/{fotos,videos},codigo/{scripts,configs},logs,temporal}

# Paso 3: Organizar archivos por categoría
# Documentos
mv *.pdf organizados/documentos/reportes/
mv *.docx organizados/documentos/cartas/
mv *nota*.txt organizados/documentos/notas/

# Multimedia  
mv *.jpg *.jpeg *.png organizados/multimedia/fotos/
mv *.mp4 *.avi *.mkv organizados/multimedia/videos/

# Código y configuraciones
mv *.sh organizados/codigo/scripts/
mv config.txt organizados/codigo/configs/
mv *.csv organizados/codigo/  # Datos van con código

# Logs
mv *.log organizados/logs/

# Temporales (para revisar después)
mv *.tmp organizados/temporal/

# Paso 4: Verificar organización
echo "=== ESTRUCTURA FINAL ==="
tree organizados/

# Paso 5: Crear respaldos
echo "=== CREANDO RESPALDOS ==="
cp -r organizados organizados_backup_$(date +%Y%m%d_%H%M)
echo "Respaldo creado"

# Paso 6: Establecer permisos apropiados
echo "=== CONFIGURANDO PERMISOS ==="
chmod 755 organizados/codigo/scripts/*.sh  # Scripts ejecutables
chmod 644 organizados/documentos/reportes/*  # Reportes solo lectura
chmod 700 organizados/temporal/  # Temporal privado

# Paso 7: Crear archivos de índice
echo "=== CREANDO ÍNDICES ==="
ls -la organizados/documentos/reportes/ > organizados/indice_reportes.txt
ls -la organizados/multimedia/ > organizados/indice_multimedia.txt

# Paso 8: Limpieza de temporales viejos (simulamos)
echo "=== LIMPIEZA ==="
# Crear algunos archivos "viejos" para el ejemplo
touch -t 202309150900 organizados/temporal/viejo.tmp
find organizados/temporal -name "*.tmp" -mtime +30 -ls  # Solo listar, no eliminar aún

# Paso 9: Verificación final
echo "=== VERIFICACIÓN FINAL ==="
echo "Archivos totales organizados:"
find organizados/ -type f | wc -l

echo "Directorios creados:"
find organizados/ -type d | wc -l

echo "Archivos por categoría:"
echo "Documentos: $(find organizados/documentos -type f | wc -l)"
echo "Multimedia: $(find organizados/multimedia -type f | wc -l)"
echo "Código: $(find organizados/codigo -type f | wc -l)"
echo "Logs: $(find organizados/logs -type f | wc -l)"
echo "Temporales: $(find organizados/temporal -type f | wc -l)"

# Paso 10: Crear script de mantenimiento
cat > mantenimiento.sh << 'EOF'
#!/bin/bash
echo "=== SCRIPT DE MANTENIMIENTO ==="
echo "Fecha: $(date)"

# Limpiar archivos temporales antiguos
echo "Limpiando archivos temporales antiguos..."
find organizados/temporal -name "*.tmp" -mtime +7 -delete

# Crear respaldo si no existe uno del día
backup_dir="organizados_backup_$(date +%Y%m%d)"
if [ ! -d "$backup_dir" ]; then
    echo "Creando respaldo diario..."
    cp -r organizados "$backup_dir"
    echo "Respaldo creado: $backup_dir"
else
    echo "Respaldo del día ya existe"
fi

# Mostrar estadísticas
echo "Estadísticas actuales:"
echo "Archivos totales: $(find organizados/ -type f | wc -l)"
echo "Espacio usado: $(du -sh organizados/)"
EOF

chmod +x mantenimiento.sh
echo "Script de mantenimiento creado"

# Paso 11: Ejecutar mantenimiento
./mantenimiento.sh

echo "=== EJERCICIO COMPLETADO ==="
echo "Revisa la estructura con: tree organizados/"

Objetivos del Ejercicio

Al completar este laboratorio habrás practicado:

Crear estructuras de directorios complejas
Organizar archivos sistemáticamente
Crear respaldos seguros
Establecer permisos apropiados
Usar find para búsquedas complejas
Crear scripts de automatización