{
"cells": [
{
"cell_type": "markdown",
"id": "cc3a69f4-f804-4564-a0df-b6baa1551386",
"metadata": {},
"source": [
"# Pontificia Universidad Católica del Ecuador\n",
"## Maestría Virtual en Biología Computacional\n",
"### Programación para las ciencias biológicas\n",
"#### BASH\n",
"Charles Escobar\n",
"2025\n",
"\n",
"**Nombre del estudiante:** "
]
},
{
"cell_type": "markdown",
"id": "2a6deee2-1f5b-4183-baba-c286cdbdf353",
"metadata": {},
"source": [
"## **Ejercicios de automatización en el procesamiento de grandes volúmenes de datos biológicos**\n",
"\n",
"**¿Qué esperamos aprender en esta libreta?**\n",
"\n",
"En esta libreta de trabajo, vamos a explorar los siguientes temas:\n",
"1. Trabajar con múltiples carpetas y archivos\n",
"3. Usar el wildcard \"*\"\n",
"4. Programar tareas con `cron`\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "83972e53-ba19-480f-9746-ddde35aea5a4",
"metadata": {},
"source": [
"## Trabajar con múltiples carpetas\n",
"\n",
"Desde el punto de vista del **usuario** en GNU/Linux, trabajar con múltiples carpetas sobre las que tiene permisos se basa en la **gestión de accesos y la organización personalizada de archivos**. Cada usuario tiene un **directorio personal** (en `/home/jupyter`), donde tiene permisos completos (lectura, escritura y ejecución) para crear, modificar y eliminar carpetas y archivos. Esto permite al usuario organizar su espacio de trabajo de manera eficiente, creando subcarpetas para proyectos, documentos, descargas, etc. Fuera de su directorio personal, el usuario solo puede acceder a carpetas y archivos específicos si tiene los **permisos adecuados** (asignados por el administrador o por políticas del sistema). Esto garantiza la **seguridad** y la **privacidad**, ya que los usuarios no pueden acceder o modificar carpetas ajenas sin autorización. Además, el uso de comandos como `ls -l` para ver permisos, `chmod` para modificarlos y `cd` para navegar entre carpetas, permite al usuario gestionar su entorno de trabajo de manera autónoma y segura, siempre dentro de los límites de sus permisos asignados.\n",
"\n",
"Para realizar **acciones masivas sobre grupos de carpetas** en GNU/Linux, se utilizan comandos y técnicas que permiten operar sobre múltiples directorios de manera eficiente. Por ejemplo, con el comando `find`, se puede buscar carpetas específicas y ejecutar acciones sobre ellas, como mover, copiar o eliminar. El uso de **wildcards** (como `*`) en comandos como `cp`, `mv`, o `rm` permite aplicar acciones a todos los archivos o carpetas que coincidan con un patrón. Además, herramientas como `xargs` permiten procesar grupos de carpetas en paralelo, combinándose con `find` para ejecutar comandos en lotes. Por ejemplo, para eliminar todas las carpetas vacías dentro de un directorio, puedes usar: \n",
"\n",
"```bash\n",
"find /ruta/al/directorio -type d -empty -delete\n",
"```\n",
"\n",
"O para copiar todas las carpetas que comienzan con \"proyecto\":\n",
"\n",
"```bash\n",
"cp -r /ruta/origen/proyecto* /ruta/destino/\n",
"```\n",
"\n",
"Estas técnicas permiten automatizar tareas repetitivas, ahorrando tiempo y reduciendo errores al trabajar con grandes grupos de carpetas o archivos.\n",
"\n",
"Por ejemplo si se quiere listar todos los archivos hasta dos niveles mas abajo en la carpeta `sampledata` se puede usar la siguiente instrucción:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a652715e-332e-463e-be3c-04d8e06a5846",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"ls sampledata/*/*|grep '.fasta'$"
]
},
{
"cell_type": "markdown",
"id": "c7def7cf-7c1b-44d5-b266-cd249409101d",
"metadata": {},
"source": [
"Y para contarlos:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6d1357ce-7e3f-4b52-981c-6074fd61895d",
"metadata": {},
"outputs": [],
"source": [
"ls sampledata/*/*|grep '.fasta'$|wc -l"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0a853b84-2c00-4082-b976-23e1de7225d4",
"metadata": {},
"outputs": [],
"source": [
"ls sampledata/*/*|grep '.sql'$"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fe3c5ca8-6004-41de-8365-32b9d2562e9d",
"metadata": {},
"outputs": [],
"source": [
"ls sampledata/*/*/*|grep '.sql'$|wc -l"
]
},
{
"cell_type": "markdown",
"id": "cc106494-5a6c-4658-9eab-f557c3713f91",
"metadata": {},
"source": [
"## **Calendarización de scripts con `cron`**\n",
"\n",
"\n",
"`cron` es un **programa planificador de tareas** en sistemas Unix/Linux que permite ejecutar comandos o scripts de manera automática en intervalos de tiempo específicos. Es una herramienta extremadamente útil para automatizar tareas repetitivas, como copias de seguridad, limpieza de archivos temporales, monitoreo del sistema o ejecución de scripts personalizados.\n",
"\n",
"---\n",
"\n",
"### **¿Cómo funciona `cron`?**\n",
"\n",
"1. **Demonio `crond`**:\n",
" - `cron` funciona mediante un **demonio** (un proceso en segundo plano) llamado `crond`.\n",
" - Este demonio se ejecuta continuamente y verifica si hay tareas programadas para ejecutar en el momento actual.\n",
"\n",
"2. **Archivos de configuración**:\n",
" - Las tareas programadas se almacenan en archivos de configuración llamados **crontabs**.\n",
" - Cada usuario tiene su propio archivo crontab, y también existe un crontab global para el sistema (generalmente en `/etc/crontab`).\n",
"\n",
"3. **Formato de una tarea en `cron`**:\n",
" - Cada línea en un crontab define una tarea y sigue este formato:\n",
" ```\n",
" * * * * * comando_a_ejecutar\n",
" ```\n",
" Donde cada `*` representa una unidad de tiempo:\n",
" - **Minuto** (0-59)\n",
" - **Hora** (0-23)\n",
" - **Día del mes** (1-31)\n",
" - **Mes** (1-12)\n",
" - **Día de la semana** (0-7, donde 0 y 7 son domingo)\n",
"\n",
" - Ejemplo: Para ejecutar un script todos los días a las 8:00 AM, se usaría:\n",
" ```\n",
" 0 8 * * * /ruta/al/script.sh\n",
" ```\n",
"\n",
"4. **Comandos principales**:\n",
" - **`crontab -e`**: Edita el archivo crontab del usuario actual.\n",
" - **`crontab -l`**: Lista las tareas programadas del usuario actual.\n",
" - **`crontab -r`**: Elimina todas las tareas programadas del usuario actual.\n",
"\n",
"---\n",
"\n",
"### **Ejemplos de uso de `cron`**\n",
"\n",
"1. **Ejecutar un script cada 5 minutos**:\n",
" ```\n",
" */5 * * * * /ruta/al/script.sh\n",
" ```\n",
"\n",
"2. **Ejecutar un comando todos los días a medianoche**:\n",
" ```\n",
" 0 0 * * * /ruta/al/comando\n",
" ```\n",
"\n",
"3. **Ejecutar un script todos los lunes a las 6:00 AM**:\n",
" ```\n",
" 0 6 * * 1 /ruta/al/script.sh\n",
" ```\n",
"\n",
"4. **Ejecutar un comando el primer día de cada mes a las 12:00 PM**:\n",
" ```\n",
" 0 12 1 * * /ruta/al/comando\n",
" ```\n",
"\n",
"---\n",
"\n",
"### **Consideraciones importantes**\n",
"\n",
"1. **Rutas absolutas**:\n",
" - Asegúrese de usar rutas absolutas en los comandos o scripts, ya que `cron` no tiene el mismo entorno de usuario que una sesión de terminal.\n",
"\n",
"2. **Permisos**:\n",
" - Los scripts ejecutados por `cron` deben tener permisos de ejecución (`chmod +x script.sh`).\n",
"\n",
"3. **Registro de salidas**:\n",
" - Si desea guardar la salida de un comando o script, redirija la salida a un archivo de log:\n",
" ```\n",
" * * * * * /ruta/al/script.sh >> /ruta/al/log.txt 2>&1\n",
" ```\n",
"\n",
"4. **Variables de entorno**:\n",
" - `cron` no carga automáticamente las variables de entorno del usuario. Si el script depende de variables como `$PATH`, defínalas explícitamente en el crontab.\n",
"\n",
"---\n"
]
},
{
"cell_type": "markdown",
"id": "9adc8221-76b1-4fcc-9b0e-3a450b2091bd",
"metadata": {},
"source": [
"## Creación de un script en Bash que recolecte la información solicitada y la guarde en un archivo de log que será programado para que se ejecute cada 10 minutos usando `cron`.\n",
"\n",
"---\n",
"\n",
"**Paso 1: Crear el script**\n",
"\n",
"1. Crée un archivo de script en la ubicación deseada:\n",
" ```bash\n",
" /home/jupyter/Scripts/info_sistema.sh\n",
" ```\n",
"\n",
"2. Añada el siguiente contenido al script:\n",
"\n",
"---\n",
" ```bash\n",
" #!/bin/bash\n",
"\n",
" # Ruta del archivo de log\n",
" archivo_log=\"/home/jupyter/Scripts/info_sistema.log\"\n",
"\n",
" # Obtener la fecha y hora actual\n",
" echo \"Fecha y hora: $(date)\" >> $archivo_log\n",
"\n",
" # Obtener el nombre de la máquina\n",
" echo \"Nombre de la máquina: $(hostname)\" >> $archivo_log\n",
"\n",
" # Obtener el sistema operativo\n",
" echo \"Sistema Operativo: $(lsb_release -d | cut -f2)\" >> $archivo_log\n",
"\n",
" # Obtener la versión del sistema operativo\n",
" echo \"Versión del Sistema Operativo: $(lsb_release -r | cut -f2)\" >> $archivo_log\n",
"\n",
" # Obtener el espacio de disco usado y libre en formato legible (-h)\n",
" echo -e \"Espacio de disco:\\n$(df -h)\\n\" >> $archivo_log\n",
"\n",
" # Separador para mejor legibilidad\n",
" echo -e \"========================================\\n\" >> $archivo_log\n",
" ```\n",
"---\n",
"3. Guarde y cierre el archivo \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9d09101b-bb6d-40d5-b836-39c1af213d57",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"ls -l /home/jupyter/Scripts/info_sistema.sh"
]
},
{
"cell_type": "markdown",
"id": "d4d5a297-60c3-42b9-94c1-001db0d00d77",
"metadata": {},
"source": [
"4. Dele permisos de ejecución al script:\n",
"\n",
"```bash\n",
"chmod +x /home/jupyter/Scripts/info_sistema.sh\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7ae25394-2ffd-42cc-affc-5192e365fe05",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "990604b2-1ada-4dfa-9847-8c55561f4613",
"metadata": {},
"source": [
"**Paso 2: Probar el script**\n",
"\n",
"1. Ejecute el script manualmente para verificar que funciona correctamente:\n",
"\n",
"```bash\n",
"/home/jupyter/Scripts/info_sistema.sh\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76e5989d-ee15-43d4-878c-d7d1bf0b35f4",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "6011cbb8-c380-4717-bf3f-cd366a01452d",
"metadata": {},
"source": [
"2. Revise el contenido del archivo generado `/home/jupyter/Scripts/info_sistema.log` para confirmar que la información se ha guardado:\n",
"\n",
" ```bash\n",
" cat /home/jupyter/Scripts/info_sistema.log\n",
" ```\n",
"\n",
" Debería ver algo como esto:\n",
" ```\n",
" Fecha y hora: Lun Oct 2 12:34:56 UTC 2023\n",
" Nombre de la máquina: mi_equipo\n",
" Sistema Operativo: Sistema_Operativo\n",
" Versión del Sistema Operativo: 22.04\n",
" Espacio de disco:\n",
" Sistema de archivos Tamaño Usados Disp Uso% Montado en\n",
" /dev/sda1 50G 20G 30G 40% /\n",
"\n",
" ========================================\n",
" ```\n",
"\n",
"---"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4c43db8e-31be-4042-99c7-0afd2e9dca4e",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "ad1a1a39-1ab6-4042-b1cf-0f83595aac9b",
"metadata": {},
"source": [
"Observe que cada vez que se ejecuta el archivo se agrega un nuevo bloque de información"
]
},
{
"cell_type": "markdown",
"id": "5dfab0e1-9e47-4d4c-8fb2-f2714cd6248f",
"metadata": {},
"source": [
"**Paso 3: Programar el script con `cron`**\n",
"\n",
"Lo siguiente debe ejecutar desde unterminal, no desde este cuaderno de trabajo\n",
"\n",
"1. Abra el archivo de configuración de `cron`:\n",
" ```bash\n",
" crontab -e\n",
" ```\n",
"\n",
"2. Añada la siguiente línea para ejecutar el script cada 10 minutos:\n",
" ```\n",
" */10 * * * * /home/jupyter/Scripts/info_sistema.sh\n",
" ```\n",
"\n",
" - `*/10 * * * *`: Significa \"cada 10 minutos\".\n",
" - `/home/jupyter/Scripts/info_sistema.sh`: Es la ruta completa al script.\n",
"\n",
"3. Guarde y cierre el archivo (en `nano`, presiona `Ctrl + O` para guardar y `Ctrl + X` para salir).\n",
"\n",
"---\n",
"\n",
"### **Paso 4: Verificar que `cron` está ejecutando el script**\n",
"\n",
"1. Para verificar que la tarea se ha añadido correctamente, lista las tareas programadas:\n",
" ```bash\n",
" crontab -l\n",
" ```\n",
"\n",
" Deberías ver algo como:\n",
" ```\n",
" */10 * * * * /home/jupyter/Scripts/info_sistema.sh\n",
" ```\n",
"\n",
"2. Espera unos minutos y revisa el archivo de log para confirmar que se está actualizando automáticamente:\n",
" ```bash\n",
" cat /home/jupyter/Scripts/info_sistema.log\n",
" ```\n",
"\n",
"Ahora tiene un script que recopila información del sistema cada 10 minutos y la guarda en un archivo de log."
]
},
{
"cell_type": "markdown",
"id": "7f8950e4-5f73-41a3-b210-6d34eaccd041",
"metadata": {},
"source": [
"Para **eliminar la tarea programada en `cron`** que ejecuta el script `/home/jupyter/Scripts/info_sistema.sh`, siga estos pasos en un terminal, no en este cuaderno de trabajo:\n",
"\n",
"---\n",
"\n",
"### **Paso 1: Abrir el archivo crontab**\n",
"\n",
"1. Abre el archivo de configuración de `cron` para editarlo:\n",
" ```bash\n",
" crontab -e\n",
" ```\n",
"\n",
" Esto abrirá el archivo crontab del usuario actual en el editor de texto predeterminado (generalmente `nano` o `vim`).\n",
"\n",
"---\n",
"\n",
"### **Paso 2: Localizar y eliminar la tarea**\n",
"\n",
"1. Busca la línea que programó la ejecución del script. Debería verse algo como esto:\n",
" ```\n",
" */10 * * * * /home/jupyter/Scripts/info_sistema.sh\n",
" ```\n",
"\n",
"2. Elimina la línea completa que corresponde a la tarea.\n",
"\n",
"3. Guarda y cierra el archivo:\n",
" - En `nano`: Presiona `Ctrl + O` para guardar y `Ctrl + X` para salir.\n",
" - En `vim`: Presiona `Esc`, luego escribe `:wq` y presiona `Enter`.\n",
"\n",
"---\n",
"\n",
"### **Paso 3: Verificar que la tarea ha sido eliminada**\n",
"\n",
"1. Lista las tareas programadas en `cron` para confirmar que la tarea ha sido eliminada:\n",
" ```bash\n",
" crontab -l\n",
" ```\n",
"\n",
" Si la tarea ya no aparece en la lista, significa que ha sido eliminada correctamente.\n",
"\n",
"---\n",
"\n",
"### **Paso 4: Eliminar el archivo de log (opcional)**\n",
"\n",
"Si ya no necesitas el archivo de log generado por el script, puedes eliminarlo con el siguiente comando:\n",
"```bash\n",
"rm /home/jupyter/Scripts/info_sistema.log\n",
"```\n",
"\n",
"---\n",
"\n",
"### **Resumen**\n",
"\n",
"1. **Abrir crontab**: `crontab -e`.\n",
"2. **Eliminar la línea** que ejecuta el script.\n",
"3. **Guardar y salir** del editor.\n",
"4. **Verificar** con `crontab -l` que la tarea ha sido eliminada.\n",
"5. **Opcional**: Eliminar el archivo de log si ya no es necesario.\n",
"\n",
"---\n",
"\n",
"Si sigue estos pasos, la tarea programada en `cron` ha sido eliminada correctamente."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "20721340-d48a-44db-9571-ccd7fe6a557d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "21033c71-d10d-4e4e-9b27-6be9b94d3fe1",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "241b1dfc-e532-4924-bba3-f00897885a81",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "16eb7afe-725e-41b2-bfeb-8949113102b6",
"metadata": {},
"source": [
"## Tarea \n",
"\n",
"### 1. Práctica\n",
"Deje correr el script programado en `cron` por una hora y suba el log resultado a la plataforma"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "512a7034-95e5-4919-90f1-3c663a9fbb93",
"metadata": {},
"outputs": [],
"source": [
"# Código y respuesta"
]
},
{
"cell_type": "markdown",
"id": "8dc2cde3-5fb1-4f81-b08b-57be9aed9d72",
"metadata": {},
"source": [
"### 2. Cuestionario\n",
"\n",
"Conteste las siguientes preguntas"
]
},
{
"cell_type": "markdown",
"id": "cd6ee19e-f1bd-48c2-9a09-96d96d9a80a4",
"metadata": {},
"source": [
"#### 2.1 ¿Qué comando se utiliza para editar las tareas programadas en `cron` y cómo se accede a él desde la terminal?"
]
},
{
"cell_type": "markdown",
"id": "eafb90a2-e69f-40e4-aa9f-3e9fffc26f3c",
"metadata": {},
"source": [
"ponga aquí su respuesta"
]
},
{
"cell_type": "markdown",
"id": "183f4dba-97a8-414d-b1d5-0db21a6674c2",
"metadata": {},
"source": [
"#### 2.2 Si ha programado un script en `cron` para que se ejecute cada 10 minutos, pero decide eliminar esta tarea, ¿qué pasos debes seguir para asegurarse de que la tarea ha sido eliminada correctamente?"
]
},
{
"cell_type": "markdown",
"id": "6fb2473f-c95c-4436-9ea9-e8258accd070",
"metadata": {},
"source": [
"ponga aquí su respuesta"
]
},
{
"cell_type": "markdown",
"id": "43d4a574-cf62-466a-8aa2-1db6d23be1af",
"metadata": {},
"source": [
"#### 2.3 Después de eliminar una tarea de cron, ¿qué comando puedes usar para verificar que la tarea ya no está programada? Además, si el script generaba un archivo de log, ¿qué comando usarías para eliminar ese archivo si ya no es necesario?"
]
},
{
"cell_type": "markdown",
"id": "caf51f7c-0cdb-41ee-b117-5f0f980f457f",
"metadata": {},
"source": [
"ponga aquí su respuesta"
]
},
{
"cell_type": "markdown",
"id": "059d0f2e-003c-4c7c-9318-e08f01c71e04",
"metadata": {},
"source": [
"# Conclusiones y Recomendaciones\n",
"\n",
"Una vez ejecutado este cuaderno de trabajo y seguido las instrucciones que en el se detallan, desarrolle por lo menos tres conclusiones y recomendaciones delimitadas exclusivamente a las actividades ejecutadas en este cuaderno de trabajo."
]
},
{
"cell_type": "markdown",
"id": "f794f0d0-b583-42a8-ab0b-3caf6c58860f",
"metadata": {},
"source": [
"## Conclusiones\n",
"1. Conclusión 1\n",
"2. Conclusión 2\n",
"3. Conclusión 3"
]
},
{
"cell_type": "markdown",
"id": "b300a9e8-dfb2-47f1-b2b4-5768889dcefd",
"metadata": {},
"source": [
"## Recomendaciones\n",
"1. Recomendación 1\n",
"2. Recomendación 2\n",
"3. Recomendación 3"
]
},
{
"cell_type": "markdown",
"id": "b66302a9-89cb-464e-873d-d6f94bd23c85",
"metadata": {},
"source": [
"|RÚBRICA Y CRITERIOS DE EVALUACIÓN |||||\n",
"|:-|:-:|:-:|:-:|:-|\n",
"|PARÁMETROS|100%|50%|0%|Total parcial|\n",
"|Desempeño en el desarrollo del cuaderno de trabajo (toma de datos, realización de cálculos, ejecución de comandos, realización de programas, obtención de resultados, obtención de un producto, aplicación de una herramienta, realización de un procedimiento para experimento, etc.)|El estudiantes demuestra solvencia al desempeñarse durante la práctica|El estudiante demuestra parcialmente solvencia al desempeñarse durante la práctica |El estudiante no demuestra solvencia al desempeñarse durante la práctica |40%|\n",
"|Cuestionario|El estudiante contesta el cuestionario de forma correcta |El estudiante contesta la mitad del cuestionario de forma correcta|El estudiante contesta el cuestionario de forma incorrecta|30%|\n",
"|Conclusiones y Recomendaciones|Todas las conclusiones son adecuadas, objetivas y aplicables exclusivamente a la práctica|Las conclusiones son parcialmente adecuadas, objetivas y aplicables|Las conclusiones no son adecuadas, objetivas y aplicables|30%|\n",
"|TOTAL||||100%|"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Bash",
"language": "bash",
"name": "bash"
},
"language_info": {
"codemirror_mode": "shell",
"file_extension": ".sh",
"mimetype": "text/x-sh",
"name": "bash"
}
},
"nbformat": 4,
"nbformat_minor": 5
}