¿Cuáles son las cosas más importantes que debo saber sobre el uso seguro y efectivo de los comandos de terminal en Linux?

Question

Accepted Answer

La gran regla de seguridad es esta: el terminal usualmente hace exactamente lo que escribiste, no lo que querías decir. `rm` no tiene Papelera, `>` sobrescribe archivos, `dd` puede borrar discos silenciosamente, `sudo` convierte pequeños errores en daños a todo el sistema, y `kill -9` detiene un proceso sin limpieza. Usa pasos de vista previa primero: `pwd`, `ls`, `ls -l`, `lsblk`, `find ... -print` y opciones interactivas como `rm -i`, `cp -i` y `mv -i`.

## 1. Trata los comandos de eliminación como armas cargadas

`rm` elimina archivos permanentemente. No los mueve a una papelera.

```bash
rm archivo.txt
```

elimina `archivo.txt`.

Para directorios:

```bash
rm -r dir_antiguo
```

elimina un directorio recursivamente.

La versión peligrosa es:

```bash
rm -rf nombre_carpeta
```

Eso significa recursivo + forzar. Sin preguntas. Sin deshacer. Elimina la carpeta y todo su contenido.

Nunca ejecutes:

```bash
rm -rf /
```

o:

```bash
sudo rm -rf /
```

Eso puede borrar todo el sistema.

Hábitos más seguros:

```bash
pwd
ls
rm -i archivo.txt
rm -ri carpeta_antigua/
```

Usa `rm -i` cuando quieras confirmación antes de cada eliminación.

Si quieres comportamiento tipo Papelera en lugar de eliminación permanente:

```bash
trash-put archivo.txt
```

## 2. Ten cuidado con las sobrescrituras

El operador `>` sobrescribe el archivo destino:

```bash
comando > archivo
```

Ejemplo:

```bash
ls -l > lista_archivos.txt
```

Esto reemplaza el contenido previo de `lista_archivos.txt`.

Para añadir en lugar de sobrescribir:

```bash
comando >> archivo
```

Ejemplo:

```bash
echo "otra vez" >> archivo.txt
```

Para redirigir solo errores:

```bash
comando 2> archivo_errores
```

Para redirigir tanto salida normal como errores:

```bash
cmd > archivo 2>&1
```

Un error brutal es redirigir salida a un dispositivo de disco:

```bash
comando >/dev/sda
```

Eso puede sobrescribir el disco.

## 3. Usa `sudo` solo cuando sea necesario

`sudo` ejecuta un comando con privilegios elevados:

```bash
sudo comando
```

Eso es útil para tareas administrativas, pero peligroso si no entiendes el comando. Después de `sudo su`, cada comando se ejecuta como root, lo que significa que incluso errores normalmente inofensivos pueden dañar el sistema.

Si olvidaste `sudo`, usa:

```bash
sudo !!
```

Eso vuelve a ejecutar el comando anterior con privilegios de superusuario. Pero recuerda: repite el último comando exactamente.

## 4. Previsualiza comandos destructivos con `find` antes de eliminar

Antes de hacer esto:

```bash
find /ruta/a/buscar -name "temp*.txt" -delete
```

o esto:

```bash
find /var/log -name "*.log" | xargs rm -f
```

previsualiza primero:

```bash
find /var/log -name "*.log" -mtime +30 -print
```

Solo elimina después de que la lista impresa sea exactamente lo que esperas.

Cuando uses `find` con `-exec rm -rf`, limita la búsqueda a un directorio específico y verifica las coincidencias primero.

## 5. Cita rutas con espacios o caracteres especiales

Esto crea dos directorios:

```bash
mkdir otra carpeta
```

Crea `otra` y `carpeta`.

Esto crea un directorio:

```bash
mkdir "otra carpeta"
```

Usa comillas alrededor de rutas que contengan espacios o caracteres especiales:

```bash
mv "archivo viejo.txt" "archivo nuevo.txt"
```

Las comillas simples preservan texto literal. Las dobles permiten expansión de variables.

## 6. Entiende los globs antes de usarlos con `rm` o `mv`

Los globs como `*` y `?` se expanden a nombres de archivos que coinciden.

```bash
rm *.log
```

elimina todos los archivos `.log` que coincidan en el directorio actual.

Antes de usar un glob nuevo de forma destructiva, pruébalo:

```bash
ls *.log
```

Los archivos ocultos necesitan cuidado. Para coincidir con entradas ocultas excepto `.` y `..`, usa ambos:

```bash
.[!.]* ..?*
```

Si quieres que un carácter comodín sea literal, escápalo con una barra invertida.

## 7. Prefiere la terminación suave de procesos antes de forzar

La forma normal:

```bash
kill 1234
```

envía SIGTERM, señal 15. Pide al proceso que se cierre de forma ordenada.

Equivalente:

```bash
kill -15 1234
```

Solo si eso falla, usa:

```bash
kill -9 1234
```

`kill -9` envía SIGKILL. No puede ser capturado ni ignorado, y el proceso no tiene oportunidad de limpiar.

Para nombres de procesos:

```bash
pkill nginx
```

mata procesos que coincidan.

Forzadamente:

```bash
pkill -9 app_no_responde
```

Pero verifica coincidencias primero:

```bash
pgrep nombre_proceso
```

Para coincidencia completa de línea de comandos:

```bash
pkill -f 'python3 /opt/myapp/server.py'
```

Ten cuidado: el patrón incorrecto puede matar el proceso equivocado.

## 8. Sabe que los procesos zombie no pueden matarse directamente

Un proceso zombie ya está muerto. Solo permanece porque su padre no ha recogido su estado de salida.

Encuentra zombies:

```bash
ps -eo pid,ppid,stat,comm | grep -w Z
```

No puedes arreglar uno con `kill -9` contra el zombie mismo. En cambio, estimula al padre:

```bash
kill -SIGCHLD <pid_padre>
```

Si es necesario, arregla o termina al padre para que PID 1 pueda recoger al zombie.

## 9. Verifica dos veces dispositivos de disco antes de usar `dd`, `mkfs` o `wipefs`

`dd` no pide confirmación. Si inviertes entrada y salida, puedes destruir datos.

Ejemplo de copia en bruto:

```bash
dd if=/dev/sda of=/dev/sdb bs=4M
```

Antes de ejecutarlo:

```bash
lsblk
```

Confirma la fuente y destino exactos.

Para monitorear progreso de forma segura en una tubería:

```bash
pv archivo.iso | dd of=/dev/sdb
```

Comandos como estos borran datos:

```bash
dd if=/dev/zero of=/dev/sda
mkfs.ext3 /dev/sda
wipefs -a /dev/sdx
```

Usa la ruta correcta de disco completo o partición deliberadamente.

## 10. Usa protección interactiva para sobrescritura con copia y movimiento

Por defecto, `cp` y `mv` pueden sobrescribir archivos existentes.

Copia un archivo:

```bash
cp origen destino
```

Copia con confirmación de sobrescritura:

```bash
cp -i origen destino
```

Nunca sobrescribas:

```bash
cp -n origen destino
```

Copia un directorio recursivamente:

```bash
cp -r dir_origen dir_destino
```

Preserva permisos, propiedad y marcas de tiempo:

```bash
cp -p /origen/archivo /destino/
```

Copia estilo archivo:

```bash
cp -a origen destino
```

Mover o renombrar:

```bash
mv nombre_viejo nombre_nuevo
```

Pedir confirmación antes de sobrescribir:

```bash
mv -i origen destino
```

Nunca sobrescribir:

```bash
mv -n viejo.txt nuevo.txt
```

Forzar sobrescritura:

```bash
mv -f origen destino
```

Además: `mv` no soporta `-R`.

## 11. Usa la herramienta de permisos correcta

`chmod` cambia permisos:

```bash
chmod u+x script.sh
```

o:

```bash
chmod 600 clave_secreta.key
```

`chown` cambia propietario:

```bash
sudo chown usuario:usuario archivo.txt
```

Recursivamente:

```bash
chown -R usuario:grupo dir
```

Ten mucho cuidado con cambios recursivos de permisos. Esto es peligroso:

```bash
chmod -R 777 /
```

Otorga permisos de lectura, escritura y ejecución a todos en todo el sistema.

También peligroso:

```bash
chown -R usuario:usuario /
```

Archivos críticos del sistema requieren propiedad específica.

## 12. Haz los scripts ejecutables correctamente

Comienza un script Bash con:

```bash
#!/bin/bash
```

Hazlo ejecutable:

```bash
chmod u+x miScriptBash.sh
```

Ejecuta como ejecutable:

```bash
./miScriptBash.sh
```

Matiz importante: el shebang se usa cuando ejecutas el script como ejecutable. Si

Manual del usuario de Linux sobre comandos de terminal y seguridad del sistema

Sobre esta cápsula

Cubierto en esta cápsula

IA genérica vs esta cápsula

1. Trata los comandos de eliminación como armas cargadas

Etiquetas

Relacionadas en Tecnología

IA como Asistente: Privacidad, Control y Juicio Humano

Distorsión de Calidez Analógica: La Verdad Sobre la Calidad Superior

Guía para Propietarios sobre el Control de Hogares Inteligentes

Economía del auge de la IA: beneficios, costos de cómputo y riesgo de burbuja