Comandos de Linux que Todo Desarrollador Debe Conocer en 2026

La terminal de Linux es una de las herramientas más poderosas que tiene un desarrollador a su disposición. Aunque puede parecer intimidante al principio, dominar los comandos esenciales te hace más productivo y te da control total sobre tu entorno de desarrollo y servidores. Esta guía cubre los comandos que uso a diario como desarrollador backend y DevOps.

Navegación y exploración del sistema de archivos

Estos son los comandos que más vas a usar — navegar entre directorios y ver qué hay en ellos:

# Mostrar el directorio actual
pwd

# Listar archivos y directorios
ls              # listado básico
ls -la          # listado detallado con archivos ocultos
ls -lah         # igual pero con tamaños legibles (KB, MB, GB)
ls -lt          # ordenar por fecha de modificación (más reciente primero)

# Cambiar de directorio
cd /var/log          # ir a una ruta absoluta
cd proyecto/src      # ir a una ruta relativa
cd ..                # subir un nivel
cd ~                 # ir al directorio home
cd -                 # volver al directorio anterior

# Crear directorios
mkdir mi-proyecto
mkdir -p proyecto/src/components   # crear toda la estructura de golpe

# Ver el árbol de directorios (instalar: apt install tree)
tree -L 2            # mostrar 2 niveles de profundidad
tree -I node_modules # excluir directorio

Manipulación de archivos

# Crear archivos
touch archivo.txt                # crear archivo vacío
echo "contenido" > archivo.txt   # crear con contenido (sobreescribe)
echo "más" >> archivo.txt        # agregar contenido al final

# Copiar archivos y directorios
cp archivo.txt copia.txt         # copiar archivo
cp -r carpeta/ copia_carpeta/    # copiar directorio completo

# Mover / renombrar
mv archivo.txt nueva_ruta/       # mover
mv viejo.txt nuevo.txt           # renombrar

# Eliminar
rm archivo.txt                   # eliminar archivo
rm -r carpeta/                   # eliminar directorio y contenido
rm -rf carpeta/                  # forzar sin confirmación (cuidado)

# Ver contenido de archivos
cat archivo.txt                  # mostrar todo el contenido
less archivo.txt                 # ver con paginación (q para salir)
head -20 archivo.txt             # primeras 20 líneas
tail -20 archivo.txt             # últimas 20 líneas
tail -f /var/log/syslog          # seguir logs en tiempo real

# Buscar archivos
find . -name "*.js"              # buscar archivos .js en directorio actual
find . -name "*.log" -mtime -7   # archivos .log modificados en últimos 7 días
find . -size +100M               # archivos de más de 100MB
find . -empty -delete            # eliminar archivos vacíos

Búsqueda y filtrado de contenido

La búsqueda de texto en archivos es fundamental para debugging y desarrollo:

# grep: buscar texto en archivos
grep "error" archivo.log                    # buscar "error" en un archivo
grep -r "TODO" ./src/                       # buscar recursivamente en directorio
grep -rn "function" ./src/ --include="*.js" # con número de línea, solo en .js
grep -i "warning" *.log                     # búsqueda sin importar mayúsculas
grep -c "error" archivo.log                 # contar ocurrencias
grep -v "debug" archivo.log                 # mostrar líneas que NO contienen "debug"

# Herramientas modernas (más rápidas que grep)
# ripgrep (rg) - instalar: apt install ripgrep
rg "patron" ./src/
rg -t js "import"                           # buscar solo en archivos .js

# Combinar con pipes
cat access.log | grep "404" | wc -l         # contar errores 404
ps aux | grep node                          # buscar procesos de Node.js
history | grep "docker"                     # buscar en historial de comandos

Permisos y propiedad de archivos

Entender permisos es esencial cuando trabajas con servidores. Cada archivo tiene 3 niveles: usuario (u), grupo (g), otros (o), y 3 tipos de permiso: lectura (r=4), escritura (w=2), ejecución (x=1).

# Ver permisos de archivos
ls -la
# -rw-r--r--  1 user group  1234 Feb 26 10:00 archivo.txt
# drwxr-xr-x  2 user group  4096 Feb 26 10:00 carpeta/

# Cambiar permisos con números (octal)
chmod 755 script.sh     # rwxr-xr-x (propietario: todo, grupo/otros: leer+ejecutar)
chmod 644 config.txt    # rw-r--r-- (propietario: leer+escribir, grupo/otros: leer)
chmod 600 .env          # rw------- (solo el propietario puede leer/escribir)

# Cambiar permisos con letras (más legible)
chmod +x script.sh      # agregar permiso de ejecución
chmod u+w archivo.txt   # dar escritura al propietario
chmod go-w archivo.txt  # quitar escritura a grupo y otros

# Cambiar propietario
chown usuario:grupo archivo.txt
chown -R www-data:www-data /var/www/   # recursivo para servidores web

# Permisos comunes para proyectos web
chmod -R 755 /var/www/html/            # directorios
find /var/www/html/ -type f -exec chmod 644 {} \;  # archivos
chmod -R 775 storage/ bootstrap/cache/  # Laravel: carpetas de escritura

Procesos y recursos del sistema

# Ver procesos
ps aux                              # todos los procesos
ps aux | grep nginx                 # buscar proceso específico
top                                 # monitor en tiempo real (q para salir)
htop                                # versión mejorada (instalar: apt install htop)

# Matar procesos
kill PID                            # enviar señal de terminación
kill -9 PID                         # forzar terminación inmediata
killall node                        # matar todos los procesos "node"
pkill -f "python script.py"         # matar por nombre de comando

# Uso de disco
df -h                               # espacio en disco de particiones
du -sh *                            # tamaño de cada carpeta en directorio actual
du -sh /var/log/                    # tamaño total de una carpeta
du -h --max-depth=1 / | sort -rh | head  # carpetas más grandes del sistema

# Uso de memoria
free -h                             # RAM total, usada, disponible

# Información del sistema
uname -a                            # info del kernel
cat /etc/os-release                 # info de la distribución
nproc                               # número de cores del CPU
uptime                              # tiempo encendido y carga del sistema

Networking

# Información de red
ip addr                             # ver interfaces y IPs
hostname -I                         # ver IP local

# Verificar conectividad
ping -c 4 google.com                # 4 pings a google
curl -I https://jgstecnologia.com   # ver headers HTTP
curl -s https://api.example.com/data | jq .   # petición API + formatear JSON

# Ver puertos en uso
ss -tlnp                            # puertos TCP en escucha
lsof -i :3000                       # qué proceso usa el puerto 3000

# DNS
nslookup dominio.com
dig dominio.com

# Descargar archivos
wget https://example.com/archivo.zip
curl -O https://example.com/archivo.zip

# Transferir archivos con SCP
scp archivo.txt usuario@servidor:/ruta/destino/
scp -r carpeta/ usuario@servidor:/ruta/  # copiar directorio completo
scp usuario@servidor:/ruta/archivo.txt .  # descargar del servidor

SSH: acceso remoto a servidores

# Conectar a un servidor
ssh usuario@servidor.com
ssh -p 2222 usuario@servidor.com     # puerto personalizado

# Generar clave SSH (autenticación sin contraseña)
ssh-keygen -t ed25519 -C "tu@email.com"

# Copiar tu clave pública al servidor
ssh-copy-id usuario@servidor.com

# Ejecutar un comando remoto sin sesión interactiva
ssh usuario@servidor.com "ls -la /var/www/"
ssh usuario@servidor.com "df -h && free -h"

# Túnel SSH (acceder a un servicio remoto localmente)
ssh -L 3307:localhost:3306 usuario@servidor.com
# Ahora puedes conectarte a MySQL remoto en localhost:3307

Compresión y archivos

# tar (empaquetar)
tar -czf backup.tar.gz mi_carpeta/   # comprimir con gzip
tar -xzf backup.tar.gz               # extraer
tar -tzf backup.tar.gz               # listar contenido sin extraer

# zip
zip -r proyecto.zip proyecto/         # comprimir
unzip proyecto.zip                    # extraer
unzip -l proyecto.zip                 # listar contenido

Redirección y pipes

Los pipes (|) son el pegamento que conecta comandos en Linux. Cada comando recibe la salida del anterior:

# Redirecciones básicas
comando > archivo.txt      # guardar salida (sobreescribe)
comando >> archivo.txt     # agregar al final
comando 2> errores.txt     # redirigir solo errores
comando > todo.txt 2>&1    # redirigir salida y errores

# Pipes útiles para desarrollo
# Contar archivos .js en un proyecto
find . -name "*.js" -not -path "*/node_modules/*" | wc -l

# Ver los 10 archivos más grandes
du -ah . | sort -rh | head -10

# Ver procesos que más memoria usan
ps aux --sort=-%mem | head -10

# Extraer IPs únicas de un log de acceso
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -20

# Monitorear un log filtrando errores en tiempo real
tail -f /var/log/app.log | grep --line-buffered "ERROR"

Scripting básico con Bash

Los scripts Bash automatizan secuencias de comandos. Aquí un ejemplo práctico de script de deployment:

#!/bin/bash
# deploy.sh - Script de deployment simplificado

set -e  # Detener en caso de error

APP_DIR="/var/www/mi-app"
BACKUP_DIR="/var/backups/mi-app"
FECHA=$(date +%Y%m%d_%H%M%S)

echo "=== Iniciando deployment ==="

# 1. Crear backup
echo "Creando backup..."
mkdir -p $BACKUP_DIR
tar -czf "$BACKUP_DIR/backup_$FECHA.tar.gz" -C $APP_DIR .

# 2. Descargar cambios
echo "Descargando cambios..."
cd $APP_DIR
git pull origin main

# 3. Instalar dependencias
echo "Instalando dependencias..."
npm ci --production

# 4. Reiniciar aplicación
echo "Reiniciando aplicación..."
pm2 restart mi-app

# 5. Verificar
echo "Verificando..."
sleep 3
if curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/api/health | grep -q "200"; then
    echo "Deployment exitoso"
else
    echo "ERROR: La aplicación no responde. Revirtiendo..."
    tar -xzf "$BACKUP_DIR/backup_$FECHA.tar.gz" -C $APP_DIR
    pm2 restart mi-app
    echo "Revertido al backup anterior"
    exit 1
fi

echo "=== Deployment completado ==="

# Hacer ejecutable y correr
chmod +x deploy.sh
./deploy.sh

Variables de entorno

# Ver una variable
echo $HOME
echo $PATH

# Definir variable para la sesión actual
export MI_VARIABLE="valor"

# Variables persistentes: agregar al final de ~/.bashrc o ~/.zshrc
echo 'export API_KEY="mi-clave"' >> ~/.bashrc
source ~/.bashrc   # recargar sin cerrar terminal

# Ver todas las variables de entorno
env | sort

Cheat sheet rápida

Recursos para profundizar

• LinuxCommand.org: Tutorial interactivo completo y gratuito.
• ExplainShell: Pega cualquier comando y te explica cada parte.
• tldr pages: Versión simplificada de las man pages (instalar: npm install -g tldr).
• OverTheWire Bandit: Juego CTF para practicar Linux a través de desafíos.

La terminal puede parecer intimidante al principio, pero con práctica diaria se vuelve tu herramienta más rápida. Mi consejo: no intentes memorizar todo. Aprende los comandos de navegación y búsqueda, y para el resto usa man comando o tldr comando cuando lo necesites. Con el tiempo, los comandos más útiles se vuelven automáticos.