Curso de Terminal y Bash

Tus primeros comandos

Ahora que ya sabes abrir la terminal y ejecutar un comando, vamos a conocer algunos comandos básicos que te ayudarán a orientarte. Piensa en estos como las primeras palabras que aprendes en un idioma nuevo.

El comando echo ya lo conoces: repite lo que le escribas. Pero hay otros igual de sencillos:

echo "Hola mundo"     # Imprime texto en pantalla
whoami                 # Muestra tu nombre de usuario
date                   # Muestra la fecha y hora actual
cal                    # Muestra el calendario del mes
clear                  # Limpia la pantalla (o Ctrl+L)

Prueba cada uno de estos comandos en tu terminal. No necesitas memorizarlos, solo familiarízate con la idea de que cada comando tiene un nombre corto y hace una tarea específica. Con el tiempo los irás recordando de forma natural.

El sistema de archivos: cómo se organiza todo

Antes de aprender a moverte por el sistema, necesitas entender cómo está organizado. En tu computador, los archivos están guardados dentro de carpetas (también llamadas directorios), y esas carpetas pueden contener otras carpetas, formando una estructura como un árbol invertido.

En Linux y macOS, todo parte de un directorio raíz llamado / (una barra diagonal). Desde ahí se ramifica todo lo demás:

/
├── home/          # Aquí viven los directorios de cada usuario
│   └── tu-usuario/
│       ├── Documentos/
│       ├── Descargas/
│       └── ...
├── etc/           # Archivos de configuración del sistema
├── var/           # Datos variables (logs, bases de datos)
├── tmp/           # Archivos temporales
└── usr/           # Programas instalados

Lo más importante para ti ahora es la carpeta home (representada por ~). Es tu espacio personal dentro del sistema. Cuando abres la terminal, normalmente empiezas ahí. Es como tu escritorio, pero en la terminal.

Saber dónde estás: pwd

Cuando navegas por carpetas en la interfaz gráfica, puedes ver en qué carpeta estás mirando la barra de direcciones. En la terminal, usas el comando pwd (que significa “print working directory”, o “imprime el directorio de trabajo”):

pwd

Este comando es tu brújula. Cada vez que te sientas perdido, escribe pwd y sabrás exactamente dónde estás.

Ver qué hay alrededor: ls

Una vez que sabes dónde estás, querrás ver qué archivos y carpetas hay en ese lugar. Para eso usas ls (de “list”):

# Ver qué hay en el directorio actual
ls

# Ver con más detalle (permisos, tamaño, fecha)
ls -l

# Incluir archivos ocultos (los que empiezan con un punto)
ls -la

# Tamaños en formato legible (KB, MB, GB en vez de bytes)
ls -lh

¿Qué son los archivos ocultos? En Linux, cualquier archivo o carpeta cuyo nombre empiece con un punto (.) está oculto por defecto. Estos suelen ser archivos de configuración. Por ejemplo, .bashrc es el archivo de configuración de Bash. El flag -a le dice a ls que los muestre también.

Moverse entre carpetas: cd

Para entrar a una carpeta, usas cd (de “change directory”). Para salir, usas cd .. (los dos puntos significan “el directorio de arriba”):

Vamos a practicar la navegación paso a paso:

# Primero, veamos dónde estamos
pwd
# ¿Qué hay aquí?
ls
# Documentos  Descargas  Escritorio  Imágenes

# Entremos a Documentos
cd Documentos

# Verificamos que nos movimos
pwd
# /home/tu-usuario/Documentos

# Subimos un nivel (volvemos a home)
cd ..

# Verificamos
pwd
# /home/tu-usuario

# Vamos directo al home desde cualquier lugar
cd ~

Rutas absolutas vs relativas

Hay dos formas de decirle a la terminal a qué carpeta quieres ir. Entender la diferencia es importante porque la usarás en todo momento.

Una ruta absoluta empieza siempre desde la raíz /. Es como dar una dirección completa: “Chile, Santiago, calle X, número Y”. No importa dónde estés, la ruta absoluta siempre te lleva al mismo lugar:

cd /home/usuario/Documentos/proyecto

Una ruta relativa empieza desde donde tú estás ahora. Es como decir “la tienda de la esquina”: depende de dónde te encuentres en ese momento:

# Si estás en /home/usuario, esto te lleva a /home/usuario/Documentos/proyecto
cd Documentos/proyecto

# Los dos puntos (..) significan "sube un nivel"
cd ../otro-proyecto

Símbolos especiales de ruta

Estos símbolos los usarás constantemente. Vale la pena entenderlos bien:

Autocompletado con Tab: tu mejor herramienta

Si hay un truco que debes aprender de este curso, es este: la tecla Tab autocompleta nombres. No necesitas escribir nombres completos de archivos o carpetas. Escribe las primeras letras y presiona Tab; la terminal completa el resto por ti.

# Escribe "cd Doc" y presiona Tab
cd Doc⇥  # Se completa a: cd Documentos/

# Si hay varias opciones que empiezan igual, presiona Tab dos veces
# y la terminal te muestra todas las posibilidades
cd D⇥⇥
# Descargas/  Documentos/  Desktop/

Esto no solo te ahorra tiempo: evita errores de escritura. Si Tab no completa nada, probablemente el archivo o carpeta no existe, o escribiste mal las primeras letras.

Historial de comandos

La terminal recuerda todos los comandos que has escrito. Esto es increíblemente útil porque rara vez necesitas escribir un comando desde cero:

• Flecha arriba: Muestra el comando anterior. Sigue presionando para ir más atrás.
• Flecha abajo: Vuelve hacia comandos más recientes.
• history: Muestra el historial completo de comandos.
• Ctrl + R: Busca un comando en el historial. Escribes parte del comando y te encuentra la coincidencia.
• !!: Repite exactamente el último comando.

# Ver los últimos 10 comandos que ejecutaste
history | tail -10

# Buscar un comando que usaste antes
# Presiona Ctrl+R, escribe parte del comando (ej: "git") y aparecerá

Ejercicios del módulo

Practica cada uno de estos ejercicios en tu terminal:

1. Ejecuta whoami, date y cal uno por uno. ¿Qué te muestra cada uno?
2. Usa pwd para ver dónde estás. Luego usa ls para ver qué hay en tu directorio home.
3. Usa ls -la y compara con ls. ¿Qué archivos nuevos aparecen? (Pista: busca los que empiezan con punto)
4. Navega a una carpeta cualquiera con cd, luego usa pwd para confirmar dónde estás. Vuelve al home con cd ~.
5. Practica el autocompletado: escribe cd seguido de las primeras 2 letras de una carpeta y presiona Tab. ¿Se completó?
6. Ejecuta history y mira los comandos que has escrito en esta sesión. Luego presiona Ctrl + R y busca el comando date.
7. Navega a /tmp con ruta absoluta, luego vuelve a tu home con cd ~. Ahora usa cd -. ¿A dónde te lleva?

En el módulo anterior aprendiste a crear y mover archivos. Ahora vas a aprender a ver lo que hay dentro de esos archivos, a buscar texto específico y a conectar comandos entre sí. Estas habilidades son las que realmente hacen poderosa a la terminal.

Ver el contenido de un archivo: cat

El comando más simple para ver el contenido de un archivo es cat (de “concatenate”). Muestra todo el contenido de una vez en la pantalla:

cat notas.txt

cat funciona bien para archivos cortos. Pero si el archivo tiene cientos o miles de líneas, el texto pasará tan rápido que no podrás leerlo. Para esos casos, hay mejores opciones.

Navegar archivos largos: less

Cuando necesitas leer un archivo largo, less te permite navegar página por página, como un visor de documentos:

less archivo-largo.txt

Dentro de less, usas estas teclas para moverte:

Ver solo el inicio o el final: head y tail

A veces no necesitas ver todo el archivo, solo las primeras o las últimas líneas. Para eso existen head y tail:

# Ver las primeras 10 líneas (por defecto)
head archivo.txt

# Ver las primeras 20 líneas
head -n 20 datos.csv

# Ver las últimas 10 líneas
tail archivo.txt

# Ver las últimas 5 líneas
tail -n 5 log.txt

tail tiene un truco especialmente útil: el flag -f (de “follow”) te permite monitorear un archivo en tiempo real. Cada vez que se agrega una nueva línea al archivo, aparece automáticamente en tu pantalla. Esto es invaluable para monitorear logs:

# Monitorear un archivo de log en tiempo real
tail -f /var/log/syslog

# Presiona Ctrl+C para dejar de monitorear

Contar líneas, palabras y caracteres: wc

El comando wc (de “word count”) cuenta las líneas, palabras y caracteres de un archivo:

wc archivo.txt
#  42  318 1847 archivo.txt
# (42 líneas, 318 palabras, 1847 caracteres)

# Si solo te interesa la cantidad de líneas
wc -l archivo.txt

Buscar texto dentro de archivos: grep

grep es uno de los comandos más útiles que vas a aprender. Te permite buscar una palabra o patrón de texto dentro de uno o varios archivos. Su nombre viene de “Global Regular Expression Print”, pero no te preocupes por eso: piensa en grep como “buscar texto”.

La sintaxis básica es grep "lo que buscas" dónde buscas:

# Buscar la palabra "error" en un archivo de log
grep "error" log.txt

# La terminal mostrará todas las líneas que contengan "error"

Ahora veamos las opciones más útiles de grep, una por una:

# Ignorar mayúsculas/minúsculas (-i)
# Encuentra "Error", "ERROR", "error", etc.
grep -i "error" log.txt

# Mostrar el número de línea donde aparece (-n)
grep -n "error" log.txt
# 23: [2024-01-15] error de conexión
# 47: [2024-01-15] error de timeout

# Buscar en todos los archivos de una carpeta, recursivamente (-r)
grep -r "TODO" ./src/

# Mostrar líneas que NO contienen el texto (-v)
# Útil para filtrar: "todo excepto las líneas de debug"
grep -v "debug" log.txt

# Contar cuántas veces aparece (-c)
grep -c "error" log.txt
# 15

# Solo mostrar los nombres de archivo que contienen el texto (-l)
grep -rl "password" ./config/

Pipes (tuberías): conectar comandos con |

Aquí es donde la terminal se vuelve realmente poderosa. El pipe (representado por el símbolo |) toma la salida de un comando y la pasa como entrada al siguiente. Piensa en él como una tubería que conecta la salida de una herramienta con la entrada de otra.

Imagina que tienes una lista de 1000 archivos y quieres encontrar solo los que contienen “datos”. Sin pipes, tendrías que guardar la lista en un archivo, luego buscar en ese archivo. Con pipes, lo haces en una sola línea:

# Sin pipes (engorroso)
ls > lista.txt
grep "datos" lista.txt
rm lista.txt

# Con pipes (una sola línea)
ls | grep "datos"

Algunos ejemplos prácticos que usarás frecuentemente:

# Listar archivos y filtrar por nombre
ls -la | grep ".txt"

# Contar cuántos archivos hay en el directorio
ls | wc -l

# Ver procesos y buscar uno específico
ps aux | grep "python"

# Ver el historial y buscar un comando
history | grep "git"

# Ordenar líneas de un archivo y eliminar duplicados
cat nombres.txt | sort | uniq

Fíjate cómo puedes encadenar varios pipes. Cada | pasa el resultado al siguiente comando. Es como una línea de ensamblaje: cada estación hace una tarea y pasa el resultado a la siguiente.

Redirecciones: guardar la salida en archivos

Los pipes conectan comandos entre sí. Las redirecciones envían la salida de un comando a un archivo en vez de mostrarla en pantalla. Hay dos tipos principales:

> (mayor que) envía la salida a un archivo. Si el archivo existe, lo sobreescribe (borra lo anterior):

# Guardar el listado de archivos en un archivo
ls -la > listado.txt

# Guardar la fecha actual
date > fecha.txt

>> (doble mayor que) agrega al final del archivo, sin borrar lo que ya tenía:

# Agregar una línea al final
echo "primera línea" > notas.txt
echo "segunda línea" >> notas.txt
echo "tercera línea" >> notas.txt

# Ahora notas.txt tiene las tres líneas
cat notas.txt

También puedes redirigir los mensajes de error por separado:

El último ejemplo es muy útil: /dev/null es un “agujero negro” donde puedes enviar lo que no te interesa. Si un comando produce muchos mensajes de error que no necesitas ver, los rediriges a /dev/null:

# find muestra errores de "permiso denegado" en muchas carpetas
# Con 2>/dev/null solo vemos los resultados útiles
find / -name "*.conf" 2>/dev/null

Combinando todo: ejemplos del mundo real

Ahora que conoces pipes y redirecciones, veamos cómo se combinan para resolver problemas reales:

# Encontrar los 5 archivos más grandes del directorio
du -sh * | sort -rh | head -5

# Buscar errores recientes en un log y guardarlos
grep -i "error" /var/log/syslog | tail -20 > errores-recientes.txt

# Contar cuántas líneas tiene cada archivo .txt
wc -l *.txt

# Ver las 10 palabras más frecuentes en un archivo
cat texto.txt | tr ' ' '\n' | sort | uniq -c | sort -rn | head -10

No te preocupes si el último ejemplo parece complejo. El punto es que puedes construir soluciones paso a paso, agregando un pipe a la vez. Primero prueba el primer comando, luego agrega un pipe y el segundo, y así sucesivamente.

Ejercicios del módulo

1. Crea un archivo con echo "Línea 1" > prueba.txt, luego agrega “Línea 2” y “Línea 3” usando >>. Verifica con cat prueba.txt.
2. Usa head -n 1 prueba.txt y tail -n 1 prueba.txt. ¿Qué línea muestra cada uno?
3. Usa wc -l prueba.txt para contar las líneas del archivo. ¿Coincide con lo que esperabas?
4. Ejecuta ls /usr/bin | wc -l para contar cuántos programas hay instalados en tu sistema.
5. Usa ls /usr/bin | grep "python" para ver si tienes Python instalado. ¿Aparece algo?
6. Guarda el resultado de ls -la ~ en un archivo llamado mi-home.txt usando >. Luego abre el archivo con less mi-home.txt.
7. Ejecuta history | grep "cd" para ver todos los comandos cd que has usado en esta sesión.
8. Crea un archivo con varias líneas: echo -e "banana\nmanzana\nnaranja\nbanana\nmanzana" > frutas.txt. Luego usa sort frutas.txt | uniq para ver las frutas sin duplicados.
9. Usa grep -c "banana" frutas.txt para contar cuántas veces aparece “banana”.
10. Desafío: Usa cat frutas.txt | sort | uniq -c | sort -rn para ver cuál es la fruta más frecuente. ¿Qué hace cada parte del comando?

En Linux, cada archivo y cada carpeta tiene permisos que determinan quién puede hacer qué con ellos. Esto es una de las bases de la seguridad del sistema: gracias a los permisos, otros usuarios no pueden leer tus archivos privados, los programas no pueden modificar archivos del sistema sin autorización, y tú mismo estás protegido de borrar cosas importantes por accidente.

Si vienes de Windows o macOS, probablemente nunca te has preocupado por permisos. En Linux, entenderlos es fundamental, especialmente cuando trabajas con scripts, servidores o datos sensibles. Al principio puede parecer complicado, pero en la práctica usarás los mismos patrones una y otra vez. Vamos paso a paso.

Entender los permisos desde la terminal

Los tres tipos de permisos

Cada archivo o carpeta en Linux tiene tres permisos fundamentales. Es importante entender que significan cosas distintas dependiendo de si se aplican a un archivo o a una carpeta:

Veamos esto con ejemplos concretos para que quede claro:

• Un archivo con permiso r pero sin w: puedes leerlo, pero no editarlo. Imagina un documento de referencia que no quieres que nadie modifique.
• Un script .sh sin permiso x: aunque tenga código válido, la terminal te dirá “Permiso denegado” al intentar ejecutarlo. Necesitas darle x para que funcione.
• Una carpeta sin permiso x: no puedes ni entrar con cd ni acceder a los archivos de dentro, aunque tengas r para listarla. Es como tener la lista de contenido de una caja fuerte pero no la llave para abrirla.
• Una carpeta con x pero sin r: puedes entrar si conoces el nombre exacto de lo que buscas, pero no puedes listar su contenido. Es como una habitación oscura donde solo encuentras algo si sabes exactamente dónde está.

Las tres categorías de usuarios

Los permisos se aplican a tres grupos de personas diferentes:

Esto significa que un archivo puede tener permisos distintos para cada categoría. Por ejemplo, tú (owner) puedes leer y editar un archivo, tu equipo (group) solo puede leerlo, y el resto (others) no puede ni verlo.

Identificar permisos con ls -l

Esta es la habilidad más práctica: saber leer los permisos de cualquier archivo o carpeta. Cuando ejecutas ls -l, la primera columna muestra los permisos. Puede parecer críptico al principio, pero tiene una estructura muy clara:

ls -l mi-script.sh
# -rwxr-xr-- 1 paulo users 256 ene 15 10:30 mi-script.sh

Desglosemos esa cadena -rwxr-xr-- carácter por carácter:

- rwx r-x r--
│ │   │   │
│ │   │   └── Others (otros): r-- = solo pueden leer
│ │   └────── Group (grupo):  r-x = pueden leer y ejecutar
│ └────────── Owner (dueño):  rwx = puede leer, escribir y ejecutar
└──────────── Tipo: - = archivo normal (d = directorio, l = enlace)

El primer carácter indica el tipo del elemento:

• - = archivo normal
• d = directorio (carpeta)
• l = enlace simbólico (un atajo a otro archivo)

Los siguientes 9 caracteres se leen en grupos de tres, siempre en el mismo orden: r (lectura), w (escritura), x (ejecución). Si hay un guión - en lugar de una letra, ese permiso está desactivado.

Veamos varios ejemplos para entrenar el ojo:

ls -l
# drwxr-xr-x  carpeta/          ← directorio: todos pueden entrar y listar
# -rw-r--r--  documento.txt     ← archivo: todos leen, solo el dueño edita
# -rwxr-xr-x  programa          ← ejecutable por todos
# -rw-------  clave-privada.pem ← archivo privado: SOLO el dueño accede
# drwx------  .ssh/             ← carpeta privada: solo el dueño puede entrar
# -rwxrwxrwx  peligroso.sh      ← ¡cualquiera puede modificar y ejecutar!

Otros datos que muestra ls -l

Además de los permisos, ls -l muestra información útil en cada columna:

-rwxr-xr-- 1 paulo users 256 ene 15 10:30 mi-script.sh
│           │ │     │     │   │              │
│           │ │     │     │   │              └── Nombre del archivo
│           │ │     │     │   └── Fecha de última modificación
│           │ │     │     └── Tamaño en bytes
│           │ │     └── Grupo propietario
│           │ └── Dueño (owner)
│           └── Número de enlaces
└── Permisos

Esto es especialmente útil para verificar quién es el dueño de un archivo y cuándo fue modificado por última vez.

Modificar permisos con chmod

El comando chmod (de “change mode”) es el que usarás para cambiar los permisos de archivos y carpetas. Hay dos formas de usarlo: el modo simbólico (con letras, más intuitivo) y el modo octal (con números, más rápido). Ambos hacen lo mismo, solo cambia la forma de expresarlo.

Modo simbólico (con letras)

El modo simbólico es el más fácil de entender porque usas letras que ya conoces. La sintaxis es:

chmod [quién][operación][permiso] archivo

Quién:

• u = owner (dueño)
• g = group (grupo)
• o = others (otros)
• a = all (todos, equivale a u, g y o juntos)

Operación:

• + = agregar un permiso
• - = quitar un permiso
• = = establecer permisos exactos (reemplaza los anteriores)

Permiso:

• r = lectura
• w = escritura
• x = ejecución

Veamos ejemplos prácticos:

# Dar permiso de ejecución al dueño
chmod u+x script.sh
# Antes: -rw-r--r--  →  Después: -rwxr--r--

# Quitar permiso de escritura a otros
chmod o-w archivo.txt
# Antes: -rw-r--rw-  →  Después: -rw-r--r--

# Dar lectura y ejecución al grupo
chmod g+rx programa
# Antes: -rwx------  →  Después: -rwxr-x---

# Dar permiso de ejecución a TODOS
chmod a+x script.sh
# Equivalente a: chmod u+x,g+x,o+x script.sh

# Establecer permisos EXACTOS para el dueño (reemplaza los anteriores)
chmod u=rw archivo.txt
# El dueño tendrá SOLO lectura y escritura, sin importar lo que tenía antes

# Quitar TODOS los permisos a otros
chmod o= secreto.txt
# Antes: -rw-r--r--  →  Después: -rw-r-----

# Combinación: dar todo al dueño, solo lectura al resto
chmod u=rwx,g=r,o=r programa

chmod +x mi-script.sh

Modo octal (con números)

El modo numérico es más rápido y es el estándar cuando necesitas establecer todos los permisos de una sola vez. Cada permiso tiene un valor numérico:

Para calcular el número de cada categoría, sumas los valores de los permisos que quieres activar. Luego escribes tres dígitos: uno para el dueño, otro para el grupo y otro para otros.

Veamos un ejemplo paso a paso:

Queremos: rwxr-xr--

  Owner:  r + w + x = 4 + 2 + 1 = 7
  Group:  r + - + x = 4 + 0 + 1 = 5
  Others: r + - + - = 4 + 0 + 0 = 4

Resultado: chmod 754 archivo

Otro ejemplo, esta vez queremos que solo el dueño pueda leer y escribir:

Queremos: rw-------

  Owner:  r + w + - = 4 + 2 + 0 = 6
  Group:  - + - + - = 0 + 0 + 0 = 0
  Others: - + - + - = 0 + 0 + 0 = 0

Resultado: chmod 600 archivo

Esta es la tabla de combinaciones más útiles. No necesitas memorizar todas: con el tiempo las más comunes se vuelven automáticas:

Y los permisos completos más comunes que usarás en la práctica:

Cambiar permisos en carpetas (modo recursivo)

Cuando cambias permisos de una carpeta, los archivos que están dentro no cambian automáticamente. Si quieres cambiar los permisos de una carpeta y todo lo que contiene, usas la opción -R (recursivo):

# Cambiar permisos de la carpeta Y todo lo de adentro
chmod -R 755 mi-proyecto/

# Hacer privada una carpeta y todo su contenido
chmod -R 700 datos-sensibles/

# Carpetas con 755 (se puede entrar y listar)
find mi-proyecto/ -type d -exec chmod 755 {} \;

# Archivos con 644 (se puede leer pero no ejecutar)
find mi-proyecto/ -type f -exec chmod 644 {} \;

La máscara de permisos: umask

Cuando creas un archivo nuevo, ¿qué permisos tiene por defecto? Eso lo controla el umask. La máscara define qué permisos se quitan automáticamente al crear archivos y carpetas nuevos.

# Ver tu máscara actual
umask
# Salida típica: 0022

El valor 0022 significa que a los archivos nuevos se les quita el permiso de escritura (2) para el grupo y para otros. En la práctica:

Esto explica por qué cuando creas un archivo con touch te sale rw-r--r-- y cuando creas una carpeta con mkdir te sale rwxr-xr-x.

# Solo el dueño puede leer y escribir archivos nuevos
umask 077

Las máscaras más comunes:

El superusuario: sudo

En Linux, hay tareas que solo puede hacer el administrador (también llamado root o superusuario): instalar programas, modificar archivos del sistema, gestionar servicios, cambiar permisos de archivos que no te pertenecen, etc.

El comando sudo (de “Super User DO”) te permite ejecutar un solo comando con privilegios de administrador:

# Actualizar la lista de paquetes disponibles
sudo apt update

# Instalar un programa
sudo apt install htop

# Editar un archivo de configuración del sistema
sudo nano /etc/hosts

Cuando usas sudo, el sistema te pedirá tu contraseña. Esto es una medida de seguridad para confirmar que realmente eres tú. La contraseña se “recuerda” por unos minutos, así que no te la pedirá de nuevo inmediatamente.

¿Cuándo necesitas sudo?

La regla general es simple: necesitas sudo cuando quieres hacer algo fuera de tu directorio home o que afecta al sistema:

# Esto NO necesita sudo (es tu archivo, en tu carpeta)
chmod 755 ~/mi-script.sh
nano ~/notas.txt
mkdir ~/proyectos

# Esto SÍ necesita sudo (archivos del sistema o de otros usuarios)
sudo chmod 644 /etc/configuracion.conf
sudo chown usuario:grupo /opt/datos/
sudo apt install python3

Relación entre permisos y sudo

Aquí es donde todo se conecta. Los permisos definen qué puedes hacer como usuario normal. Cuando los permisos te bloquean, tienes dos opciones:

1. Cambiar los permisos (si el archivo es tuyo): chmod +x mi-script.sh
2. Usar sudo (si el archivo no es tuyo o es del sistema): sudo nano /etc/hosts

# Intentas editar un archivo del sistema
nano /etc/hostname
# Error: permiso denegado (no eres root)

# Opción correcta: usar sudo para ese comando específico
sudo nano /etc/hostname

Un truco útil: si olvidaste poner sudo al inicio de un comando y te dio error de permisos, puedes ejecutar sudo !! para repetir el último comando con sudo:

apt update
# Error: permiso denegado

sudo !!
# Equivale a: sudo apt update

Cambiar propietario con chown

El comando chown (de “change owner”) cambia quién es el dueño de un archivo o carpeta. Siempre necesitas sudo para usarlo (salvo que estés cediendo algo que ya es tuyo):

# Cambiar solo el dueño
sudo chown maria archivo.txt

# Cambiar dueño y grupo a la vez
sudo chown maria:equipo-datos archivo.txt

# Cambiar recursivamente (carpeta y todo lo de adentro)
sudo chown -R maria:equipo-datos proyecto/

¿Cuándo necesitas chown? Principalmente cuando:

• Descargas archivos que quedaron con un dueño incorrecto
• Configuras carpetas compartidas en un servidor
• Mueves archivos entre usuarios

# Ver quién es el dueño actual
ls -l datos.csv
# -rw-r--r-- 1 root root 1024 ene 15 10:30 datos.csv
#               ↑    ↑
#            dueño  grupo → ¡El dueño es root! No puedes editarlo

# Cambiarlo a tu usuario
sudo chown paulo:paulo datos.csv

# Ahora puedes editarlo sin sudo
nano datos.csv  # ¡Funciona!

Resumen visual de comandos

Ejercicios del módulo

1. Ejecuta ls -la en tu directorio home. Observa la columna de permisos. Identifica al menos un directorio (d), un archivo oculto (empieza con .), y un archivo con permisos restrictivos.
2. Crea un archivo secreto.txt con echo "datos confidenciales" > secreto.txt. Verifica sus permisos con ls -l secreto.txt. ¿Qué permisos tiene por defecto?
3. Quita todos los permisos a otros usuarios: chmod o-rwx secreto.txt. Verifica con ls -l. ¿Cómo cambió la cadena de permisos?
4. Ahora ponle permisos 600 (solo dueño lee y escribe): chmod 600 secreto.txt. Verifica con ls -l. ¿Ves la diferencia con el paso anterior?
5. Crea un script: echo '#!/bin/bash' > script-test.sh && echo 'echo "funciona"' >> script-test.sh. Intenta ejecutarlo con ./script-test.sh. ¿Qué error te da y por qué?
6. Dale permisos de ejecución con chmod +x script-test.sh. Ahora ejecútalo de nuevo. ¿Funciona? Verifica con ls -l que la x apareció.
7. Usa chmod 755 script-test.sh y verifica con ls -l. Luego usa chmod 700 script-test.sh. ¿Cuál es la diferencia entre ambos?
8. Ejecuta umask para ver tu máscara actual. Luego crea un archivo con touch nuevo.txt y una carpeta con mkdir nueva-carpeta. Verifica los permisos de ambos con ls -l. ¿Coinciden con lo que el umask predice?
9. Intenta editar /etc/hostname con nano /etc/hostname (sin sudo). ¿Qué pasa? Ahora intenta con sudo nano /etc/hostname (pero sal sin guardar con Ctrl + X y luego N).
10. Ejecuta sudo whoami. ¿Qué usuario aparece? Compara con whoami sin sudo. Esto demuestra que sudo te convierte temporalmente en root.
11. Desafío 1: Calcula el número octal para los permisos rwxr--r--. Crea un archivo y aplica esos permisos. Verifica con ls -l.
12. Desafío 2: Crea una carpeta proyecto/ con tres archivos dentro. Usa find con -exec chmod para poner las carpetas en 755 y los archivos en 644. Verifica con ls -lR.

¿Qué es un script de Bash?

Hasta ahora has escrito comandos uno por uno en la terminal. Un script es simplemente un archivo de texto que contiene una serie de comandos que se ejecutan en secuencia. En lugar de escribir 10 comandos a mano, los pones todos en un archivo y lo ejecutas una sola vez.

Piensa en un script como una receta de cocina: es una lista de instrucciones paso a paso que el computador sigue automáticamente. Los scripts son increíblemente útiles para automatizar tareas repetitivas, como hacer respaldos, procesar archivos de datos, o configurar un entorno de trabajo.

¿Por qué Bash si ya existe Python y R?

Si vienes del mundo de ciencia de datos, probablemente te preguntas: ¿para qué aprender Bash scripting si puedo hacer todo en Python o R? La respuesta es que Bash no reemplaza a esos lenguajes, los coordina. Cada uno tiene su rol:

• Python/R: análisis, estadísticas, modelos, visualizaciones
• Bash: automatizar, conectar, mover archivos, preparar datos, orquestar

En la práctica, un flujo de trabajo real de ciencia de datos se ve así:

#!/bin/bash

echo "=== Pipeline de análisis de datos ==="
echo "Inicio: $(date)"

# 1. Descargar los datos frescos
echo "Descargando datos..."
curl -s -o datos_raw.csv https://api.ejemplo.com/datos/export

# 2. Limpiar y transformar con Python
echo "Limpiando datos con Python..."
python3 limpiar_datos.py datos_raw.csv datos_limpios.csv

# 3. Análisis estadístico con R
echo "Ejecutando análisis en R..."
Rscript analisis_estadistico.R datos_limpios.csv resultados/

# 4. Generar reporte
echo "Generando reporte..."
python3 generar_reporte.py resultados/ reporte_final.html

echo "Pipeline completado: $(date)"
echo "Reporte disponible en: reporte_final.html"

Bash es el director de orquesta: descarga datos, llama a Python para limpiarlos, llama a R para analizarlos, y junta todo. Este patrón es la forma estándar de trabajar en Bioinformática, Data Science y DevOps.

Otro ejemplo más simple pero muy útil: preparar tu entorno de trabajo cada día:

#!/bin/bash

# Script para iniciar tu día de trabajo en un proyecto de datos
echo "Preparando entorno de trabajo..."

# Activar el entorno virtual de Python
source ~/envs/mi-proyecto/bin/activate

# Ir al directorio del proyecto
cd ~/proyectos/analisis-salud

# Descargar datos actualizados
echo "Descargando datos del día..."
python3 descargar_datos.py

# Abrir Jupyter Notebook
echo "Abriendo Jupyter..."
jupyter notebook &

echo "¡Todo listo! Jupyter se abrió en tu navegador."

En lugar de recordar y escribir 5 comandos cada mañana, ejecutas ./iniciar-proyecto.sh y todo se prepara solo.

Tu primer script

Vamos a crear un script simple paso a paso. Abre Nano y crea un archivo llamado hola.sh:

nano hola.sh

Escribe lo siguiente:

#!/bin/bash

# Mi primer script de Bash
echo "¡Hola desde mi script!"
echo "Hoy es $(date)"
echo "Estás en: $(pwd)"

Guarda con Ctrl + O + Enter y sal con Ctrl + X.

Antes de poder ejecutarlo, necesitas dos pasos:

# Paso 1: Dar permiso de ejecución
chmod +x hola.sh

# Paso 2: Ejecutar el script
./hola.sh

El shebang: #!/bin/bash

La primera línea #!/bin/bash se llama shebang (o hashbang). Es la línea más importante de cualquier script porque le dice al sistema operativo qué programa debe usar para interpretar las instrucciones que siguen.

#!/bin/bash     ← "Usa Bash para ejecutar este script"

Sin el shebang, el sistema podría intentar ejecutar tu script con el shell equivocado, o directamente no saber qué hacer con él. Siempre incluye el shebang como primera línea.

El shebang no es exclusivo de Bash. Esto es lo que hace tan poderoso el concepto: puedes tener scripts en diferentes lenguajes y el sistema sabe cómo ejecutar cada uno:

#!/bin/bash          # Script de Bash
#!/usr/bin/env python3  # Script de Python
#!/usr/bin/env Rscript  # Script de R
#!/usr/bin/env node     # Script de Node.js

Rutas al ejecutar scripts: ./ y por qué importa

¿Por qué escribimos ./hola.sh y no simplemente hola.sh? Este es un punto que confunde a muchos al principio, pero es fundamental entenderlo.

Cuando escribes un comando en la terminal, el sistema lo busca en una lista de carpetas predefinidas (el PATH). Puedes ver esas carpetas con:

echo $PATH

Si escribes ls, la terminal busca en esas carpetas, encuentra /usr/bin/ls, y lo ejecuta. Pero tu script hola.sh no está en ninguna de esas carpetas — está en tu directorio actual. Por eso necesitas decirle explícitamente dónde está:

# Esto NO funciona (busca hola.sh en el PATH del sistema)
hola.sh
# Error: command not found

# Esto SÍ funciona (el ./ significa "en el directorio actual")
./hola.sh

# Esto también funciona (ruta completa)
/home/paulo/scripts/hola.sh

# Y esto también (ruta relativa desde otro lugar)
../scripts/hola.sh

Repasemos los tipos de rutas, porque entender esto te ahorrará muchos dolores de cabeza:

Ruta absoluta: empieza desde la raíz del sistema (/). Siempre funciona sin importar dónde estés:

/home/paulo/proyectos/analisis/script.sh
/home/paulo/datos/pacientes.csv

Ruta relativa: parte desde tu directorio actual. Cambia según dónde estés:

./script.sh              # En el directorio actual
../datos/pacientes.csv   # Un nivel arriba, luego en datos/
scripts/procesar.sh      # Dentro de la subcarpeta scripts/

Atajos útiles:

.     # Directorio actual
..    # Directorio padre (un nivel arriba)
~     # Tu directorio home (/home/tu-usuario)

# Tu script está en ~/proyectos/scripts/procesar.sh
# Y dentro tiene: python3 limpiar.py datos/raw.csv

# Si lo ejecutas desde ~/proyectos/scripts/
cd ~/proyectos/scripts/
./procesar.sh  # Busca datos/raw.csv dentro de scripts/ ← ¡NO EXISTE!

# Si lo ejecutas desde ~/proyectos/
cd ~/proyectos/
./scripts/procesar.sh  # Busca datos/raw.csv dentro de proyectos/ ← ¡CORRECTO!

#!/bin/bash
# Ir al directorio donde está este script
cd "$(dirname "$0")"

Veamos un ejemplo práctico. Imagina esta estructura de proyecto:

mi-proyecto/
├── scripts/
│   ├── limpiar.sh
│   └── analizar.sh
├── datos/
│   ├── raw/
│   │   └── encuesta.csv
│   └── procesados/
└── resultados/

Dentro de limpiar.sh, podrías escribir las rutas de dos formas:

#!/bin/bash
# Esto solo funciona si ejecutas desde mi-proyecto/
python3 scripts/limpiar_datos.py datos/raw/encuesta.csv datos/procesados/encuesta_limpia.csv

#!/bin/bash
# Primero nos ubicamos en la raíz del proyecto
cd "$(dirname "$0")/.."

# Ahora las rutas son predecibles
python3 scripts/limpiar_datos.py datos/raw/encuesta.csv datos/procesados/encuesta_limpia.csv

echo "Datos procesados en: $(pwd)/datos/procesados/"

La línea cd "$(dirname "$0")/.." hace lo siguiente:

• $0 = la ruta con la que se llamó al script (ej: ./scripts/limpiar.sh)
• dirname "$0" = el directorio donde está el script (ej: ./scripts)
• /.." = subir un nivel (al directorio del proyecto)

Así el script siempre funciona sin importar desde dónde lo ejecutes.

Variables

Las variables te permiten guardar información para usarla más adelante. En Bash, asignas una variable con el signo = y la usas poniendo $ antes del nombre:

#!/bin/bash

# Asignar variables
nombre="Paulo"
edad=30
fecha=$(date +%Y-%m-%d)

# Usar variables con $
echo "Hola, $nombre"
echo "Tienes $edad años"
echo "Fecha: $fecha"

# Usar llaves para delimitar el nombre de la variable
echo "Archivo: ${nombre}_backup.txt"

Las llaves ${nombre} son necesarias cuando la variable va pegada a otro texto. Sin las llaves, $nombre_backup buscaría una variable llamada nombre_backup (que no existe), en lugar de usar la variable nombre seguida del texto _backup.

Variables especiales

Bash tiene variables especiales que se crean automáticamente. Son especialmente útiles cuando tu script recibe información desde la línea de comandos:

Veamos cómo funcionan con un ejemplo:

#!/bin/bash

echo "Este script se llama: $0"
echo "Primer argumento: $1"
echo "Segundo argumento: $2"
echo "Recibí $# argumentos en total"
echo "Todos los argumentos: $@"

chmod +x argumentos.sh
./argumentos.sh hola mundo
# Primer argumento: hola
# Segundo argumento: mundo
# Recibí 2 argumentos en total
# Todos los argumentos: hola mundo

Leer entrada del usuario con read

A veces quieres que tu script le haga preguntas al usuario y espere su respuesta. Para eso usas read:

#!/bin/bash

echo "¿Cómo te llamas?"
read nombre

echo "¿Cuántos años tienes?"
read edad

echo "¡Hola, $nombre! Tienes $edad años."

Puedes hacer lo mismo de forma más compacta con read -p, que muestra el mensaje y espera la respuesta en la misma línea:

read -p "Ingresa tu nombre: " nombre
echo "Hola, $nombre"

# Para passwords (no muestra lo que escribes)
read -sp "Ingresa tu contraseña: " password
echo  # salto de línea (porque -s oculta el Enter también)
echo "Contraseña recibida"

Condicionales: tomar decisiones con if

Los condicionales permiten que tu script tome decisiones: “si se cumple esta condición, haz esto; si no, haz esto otro”. La estructura básica es:

if [ condición ]; then
    # código si la condición es verdadera
elif [ otra_condición ]; then
    # código si la segunda condición es verdadera
else
    # código si ninguna condición se cumplió
fi

Veamos un ejemplo completo:

#!/bin/bash

read -p "¿Cuántos años tienes? " edad

if [ "$edad" -ge 18 ]; then
    echo "Eres mayor de edad"
elif [ "$edad" -ge 13 ]; then
    echo "Eres adolescente"
else
    echo "Eres menor de edad"
fi

Operadores de comparación para números

Operadores para texto (strings)

Operadores para archivos

Estos son especialmente útiles para scripts que trabajan con archivos:

#!/bin/bash

archivo=$1

# Verificar que se proporcionó un argumento
if [ -z "$archivo" ]; then
    echo "Uso: $0 <nombre-de-archivo>"
    echo "Ejemplo: $0 datos.csv"
    exit 1
fi

# Verificar qué es
if [ -f "$archivo" ]; then
    lineas=$(wc -l < "$archivo")
    echo "'$archivo' es un archivo con $lineas líneas"
elif [ -d "$archivo" ]; then
    echo "'$archivo' es un directorio"
else
    echo "'$archivo' no existe"
fi

Bucle for: repetir acciones

El bucle for repite una acción para cada elemento de una lista. Es como decir “para cada X, haz Y”:

#!/bin/bash

# Iterar sobre una lista de palabras
for fruta in manzana pera naranja; do
    echo "Fruta: $fruta"
done
# Fruta: manzana
# Fruta: pera
# Fruta: naranja

Los usos más prácticos de for son recorrer archivos y rangos numéricos:

# Procesar todos los archivos .txt del directorio
for archivo in *.txt; do
    echo "Procesando: $archivo"
    wc -l "$archivo"
done

# Contar del 1 al 5
for i in {1..5}; do
    echo "Número: $i"
done

# Estilo C (si vienes de otro lenguaje)
for ((i = 0; i < 5; i++)); do
    echo "Índice: $i"
done

Ejemplo práctico: renombrar archivos en lote

#!/bin/bash

# Renombrar todos los .txt a .md
for archivo in *.txt; do
    # Verificar que realmente hay archivos .txt
    [ -f "$archivo" ] || continue

    nuevo="${archivo%.txt}.md"
    mv "$archivo" "$nuevo"
    echo "Renombrado: $archivo → $nuevo"
done

La expresión ${archivo%.txt} elimina .txt del final del nombre. Luego le agregamos .md. Es una forma muy útil de manipular nombres de archivo en Bash.

Bucle while: repetir mientras se cumpla una condición

A diferencia de for (que recorre una lista), while repite una acción mientras una condición sea verdadera:

#!/bin/bash

# Contador simple
contador=1
while [ "$contador" -le 5 ]; do
    echo "Contando: $contador"
    ((contador++))
done

Un uso muy práctico de while es leer un archivo línea por línea:

# Leer cada línea de un archivo
while IFS= read -r linea; do
    echo "Línea: $linea"
done < archivo.txt

Menú interactivo con while y case

Este es un patrón muy común en scripts de Bash: un menú que se repite hasta que el usuario elige salir:

#!/bin/bash

while true; do
    echo ""
    echo "=== MENÚ ==="
    echo "1) Mostrar fecha"
    echo "2) Listar archivos"
    echo "3) Uso de disco"
    echo "4) Salir"
    read -p "Elige una opción: " opcion

    case $opcion in
        1) date ;;
        2) ls -la ;;
        3) df -h ;;
        4) echo "¡Adiós!"; break ;;
        *) echo "Opción no válida, intenta de nuevo" ;;
    esac
done

case es la versión Bash de un “switch”: compara el valor de $opcion con cada patrón y ejecuta el código correspondiente. El * es el caso por defecto (si no coincide con nada).

Funciones: reutilizar código

Las funciones te permiten agrupar comandos bajo un nombre y reutilizarlos. Si te encuentras repitiendo el mismo bloque de código varias veces, ponlo en una función:

#!/bin/bash

# Definir una función
saludar() {
    echo "¡Hola, $1!"
}

# Llamar a la función
saludar "Paulo"
saludar "María"
# ¡Hola, Paulo!
# ¡Hola, María!

Los argumentos de las funciones funcionan igual que los del script: $1 es el primer argumento, $2 el segundo, etc.

Ejemplo completo: script de respaldo

Ahora vamos a juntar todo lo que aprendimos en un script útil del mundo real. Este script crea un respaldo comprimido de una carpeta:

#!/bin/bash

# Script de respaldo simple
# Uso: ./respaldo.sh [directorio-origen] [directorio-destino]

ORIGEN="${1:-.}"
DESTINO="${2:-./respaldo}"
FECHA=$(date +%Y%m%d_%H%M%S)
ARCHIVO="respaldo_${FECHA}.tar.gz"

# Verificar que el directorio origen existe
if [ ! -d "$ORIGEN" ]; then
    echo "Error: el directorio '$ORIGEN' no existe"
    exit 1
fi

# Crear directorio destino si no existe
mkdir -p "$DESTINO"

echo "Creando respaldo de '$ORIGEN'..."

# Crear el archivo comprimido
tar -czf "${DESTINO}/${ARCHIVO}" "$ORIGEN"

# Verificar si el comando tuvo éxito
if [ $? -eq 0 ]; then
    tamano=$(du -h "${DESTINO}/${ARCHIVO}" | cut -f1)
    echo "Respaldo creado exitosamente:"
    echo "  Archivo: ${DESTINO}/${ARCHIVO}"
    echo "  Tamaño: ${tamano}"
else
    echo "Error al crear el respaldo"
    exit 1
fi

chmod +x respaldo.sh
./respaldo.sh ./mi-proyecto ./backups
# Creando respaldo de './mi-proyecto'...
# Respaldo creado exitosamente:
#   Archivo: ./backups/respaldo_20260214_153000.tar.gz
#   Tamaño: 2.5M

Analicemos las partes nuevas:

• ${1:-.} significa “usa el primer argumento, y si no hay ninguno, usa .” (directorio actual).
• tar -czf crea un archivo comprimido (.tar.gz). -c = crear, -z = comprimir con gzip, -f = nombre del archivo.
• $? contiene el código de salida del último comando. 0 significa éxito, cualquier otro número significa error.

Bash como herramienta de ciencia de datos

Ya vimos cómo Bash coordina herramientas. Pero Bash también puede hacer procesamiento de datos básico por sí solo, sin necesidad de Python o R. Esto es útil para exploración rápida, limpieza preliminar, o cuando trabajas en un servidor sin entorno gráfico.

Explorar un CSV desde la terminal

#!/bin/bash

# Script para exploración rápida de un archivo CSV
archivo="${1:?Uso: $0 archivo.csv}"

if [ ! -f "$archivo" ]; then
    echo "Error: '$archivo' no existe"
    exit 1
fi

echo "=== Exploración de $archivo ==="
echo ""

# ¿Cuántas filas tiene? (restamos 1 por el encabezado)
total=$(wc -l < "$archivo")
filas=$((total - 1))
echo "Filas de datos: $filas"

# ¿Cuántas columnas?
columnas=$(head -1 "$archivo" | tr ',' '\n' | wc -l)
echo "Columnas: $columnas"

# Mostrar los nombres de las columnas
echo ""
echo "Nombres de columnas:"
head -1 "$archivo" | tr ',' '\n' | nl

# Primeras 5 filas
echo ""
echo "Primeras 5 filas:"
head -6 "$archivo" | column -t -s ','

# Tamaño del archivo
tamano=$(du -h "$archivo" | cut -f1)
echo ""
echo "Tamaño: $tamano"

chmod +x explorar-csv.sh
./explorar-csv.sh datos_pacientes.csv
# === Exploración de datos_pacientes.csv ===
#
# Filas de datos: 1523
# Columnas: 8
#
# Nombres de columnas:
#      1  id
#      2  nombre
#      3  edad
#      4  diagnostico
#      ...

Procesar múltiples archivos de datos

Imagina que recibes datos mensuales en archivos separados y necesitas unirlos:

#!/bin/bash

# Unir múltiples CSV en uno solo (mismo formato, con encabezado)
directorio="${1:-.}"
salida="${2:-datos_combinados.csv}"

# Tomar el encabezado del primer archivo
primer_archivo=$(ls "$directorio"/*.csv 2>/dev/null | head -1)

if [ -z "$primer_archivo" ]; then
    echo "No se encontraron archivos CSV en '$directorio'"
    exit 1
fi

# Escribir encabezado
head -1 "$primer_archivo" > "$salida"

# Agregar datos de todos los archivos (sin encabezado)
for archivo in "$directorio"/*.csv; do
    tail -n +2 "$archivo" >> "$salida"
    echo "  Agregado: $archivo ($(tail -n +2 "$archivo" | wc -l) filas)"
done

total=$(tail -n +2 "$salida" | wc -l)
echo "Archivo combinado: $salida ($total filas totales)"

Ejercicios del módulo

1. Crea un script saludo.sh que reciba un nombre como argumento ($1) y diga “¡Hola, [nombre]!”. Si no recibe argumento, que diga “¡Hola, mundo!”.
2. Crea un script info.sh que muestre tu usuario, la fecha, el directorio actual y cuántos archivos hay en él.
3. Crea un script que reciba un número como argumento y diga si es positivo, negativo o cero.
4. Crea un script con read -p que pida el nombre de un archivo y diga si existe o no (usa [ -f "$archivo" ]).
5. Crea un script con un bucle for que cree 5 archivos: archivo1.txt, archivo2.txt, …, archivo5.txt.
6. Crea un script que recorra todos los archivos .txt del directorio actual y muestre cuántas líneas tiene cada uno.
7. Crea un menú interactivo con while y case que tenga al menos 3 opciones útiles (fecha, archivos, espacio en disco, etc.).
8. Modifica el script de respaldo del ejemplo para que muestre un mensaje de confirmación antes de crear el respaldo (“¿Estás seguro? (s/n)”).
9. Crea una función contar_archivos que reciba un directorio como argumento y diga cuántos archivos contiene.
10. Crea un script explorar.sh que reciba un archivo CSV como argumento y muestre: número de filas, número de columnas, nombres de las columnas, y las primeras 3 filas de datos.
11. Desafío 1: Crea un script que reciba una extensión como argumento (ej: txt) y cuente cuántos archivos con esa extensión hay en el directorio actual y sus subdirectorios (usa find).
12. Desafío 2: Crea un mini-pipeline: un script que (1) cree un archivo CSV de prueba con datos inventados, (2) llame a otro script que cuente las filas y columnas, y (3) muestre un resumen final. Practica la coordinación entre scripts.