«El puerto está ocupado» en un servidor
La primera entrada de la tabla inversa: ss -tulnp | grep :8080 localiza el PID, luego kill <PID> o directamente kill -9 $(lsof -t -i :8080).
Cargando…
Guide
La guía rápida de comandos Linux ordena los 160 comandos que se teclean a diario en la terminal en ocho categorías —archivos y directorios, ver y editar contenido, tratamiento de texto, permisos y usuarios, procesos y servicios, red, compresión y empaquetado, e información y administración del sistema—, y cada uno trae una explicación y varias líneas de ejemplo que se pueden copiar tal cual; los comandos con muchas opciones, como ls, find, grep, sed, awk, tar, curl, ss o journalctl, añaden una tabla de opciones frecuentes que se despliega al momento.
Actualizado el 2026-09-094 sources10 min read
La guía rápida de comandos Linux ordena los 160 comandos que se teclean a diario en la terminal en ocho categorías —archivos y directorios, ver y editar contenido, tratamiento de texto, permisos y usuarios, procesos y servicios, red, compresión y empaquetado, e información y administración del sistema—, y cada uno trae una explicación y varias líneas de ejemplo que se pueden copiar tal cual; los comandos con muchas opciones, como ls, find, grep, sed, awk, tar, curl, ss o journalctl, añaden una tabla de opciones frecuentes que se despliega al momento.
Resuelve dos formas de buscar. Una es conocer el nombre del comando y haber olvidado el parámetro (busca tar o chmod); la otra es saber solo qué quieres ver —«qué proceso ocupa el 8080», «qué directorio llena más el disco», «por qué no arranca este servicio»—, y para eso hay una tabla inversa de «quiero ver… → qué comando uso» que primero enuncia el objetivo y luego da 2–3 comandos que lo consiguen, del recomendado al compatible.
Al final de la página hay una terminal simulada que funciona en el navegador: un sistema de archivos en memoria y un intérprete de shell con más de 60 comandos que admite tuberías, redirecciones, comodines y un subconjunto habitual de sed y awk, con 8 niveles de práctica que van de crear una estructura de directorios a contar registros con tuberías. No accede a tu ordenador ni tiene red, así que si te equivocas con rm -rf solo hay que reiniciar el nivel.
help lista todos los comandos que admite el simulador y Tab completa nombres de archivo.Buscar «puerto» encuentra a la vez la tabla de comandos y la inversa:
Una resolución completa del nivel 8, «combinación de tuberías», en la terminal simulada:
Quiero ver: qué proceso ocupa un puerto
ss -tulnp | grep :8080
lsof -i :8080
netstat -tulnp | grep 8080 sistemas antiguos
Red › ss -tulnp puertos a la escucha y su proceso (alternativa a netstat)
Red › lsof -i :<puerto> qué proceso ocupa un puertouser@toolun-lab:~$ awk '{print $2}' access.log | sort | uniq -c | sort -rn
3 /index.html
2 /api/list
2 /about
✔ Nivel superado: combinación de tuberías: las rutas más visitadas.Dos principios del diseño de Unix determinan la forma de esta tabla. «Todo es un archivo»: los dispositivos, la información de los procesos (/proc) y los sockets se exponen como archivos, así que funcionan usos que parecen raros como cat /proc/cpuinfo, ls -l /dev/sd* o echo > /dev/tcp/host/port. «Cada programa hace una cosa y la hace bien»: grep solo filtra, sort solo ordena, uniq solo fusiona duplicados adyacentes y wc solo cuenta. Por separado son diminutos; su potencia sale de encadenarlos con tuberías.
Por eso en los ejemplos de la guía aparece tanto |: awk '{print $1}' access.log | sort | uniq -c | sort -rn | head compone con cinco programas pequeños las «IP que más acceden»; entender la entrada y la salida de cada tramo es más útil que memorizar el comando entero.
Cada proceso arranca con tres «archivos» ya abiertos: la entrada estándar (0), la salida estándar (1) y la salida de error (2). > escribe la salida estándar en un archivo, 2> gestiona el flujo de error, 2>&1 une el error a la salida y &> es la forma abreviada de bash. La combinación más habitual del día a día es cmd > out.log 2>&1 &: la salida normal y los errores van al registro y el proceso queda en segundo plano. Olvidar 2>&1 es la causa número uno de «por qué no hay errores en el log».
La primera columna de ls -l, -rwxr-xr-x, tiene cuatro partes: el tipo (- archivo, d directorio, l enlace) y luego tres bits de lectura (4), escritura (2) y ejecución (1) para el propietario, el grupo y el resto. La suma de los tres da la notación numérica: rwx=7, r-x=5 y r--=4, de modo que 755 es «yo puedo todo y los demás solo leer y ejecutar», y 644 es «yo leo y escribo, los demás solo leen». En un directorio, la x significa «se puede entrar»: con solo r no se listan los contenidos. 600/700 se usan para claves privadas y ~/.ssh, porque el cliente SSH rechaza archivos de clave con permisos demasiado abiertos. Para ver más combinaciones, marca casillas en la Calculadora chmod.
El nombre de kill engaña: solo envía una señal al proceso. La predeterminada, TERM (15), es «por favor, sal» y el programa puede guardar su estado; KILL (9) lo termina directamente el núcleo, sin dar ninguna oportunidad. Por eso se usa kill primero y, si en unos segundos no funciona, kill -9. HUP (1) se interpreta en los demonios como «recarga la configuración», y nginx -s reload lo usa por dentro.
Las distribuciones modernas gestionan los servicios con systemd: systemctl los arranca, los para y los habilita al inicio, y journalctl recoge sus registros de forma unificada. La ruta fija para diagnosticar «el servicio no arranca» es systemctl status para ver el estado y las últimas líneas del registro → journalctl -u <servicio> -n 100 para ver el error completo → ss -tlnp para comprobar si el puerto ya está ocupado.
ifconfig, netstat, route y arp pertenecen a net-tools, que ya no recibe mantenimiento y no viene instalado por defecto en los sistemas nuevos; sus equivalentes son ip addr, ss, ip route y ip neigh de iproute2. La guía lista los dos y la tabla inversa pone delante las herramientas nuevas. Las cinco letras de ss -tulnp son TCP, UDP, listening, puertos numéricos y procesos: prácticamente la apertura fija de cualquier problema de puertos.
El -i del sed de GNU puede ir sin argumento; el sed de BSD (el que trae macOS) exige un sufijo de copia de seguridad detrás de -i, así que hay que escribir sed -i '' 's/a/b/' file. Otras diferencias parecidas son date -d (GNU) frente a date -v (BSD), y readlink -f, que no existe en macOS antiguos. La guía toma como referencia la versión GNU y anota las diferencias de macOS en las notas de cada entrada; brew install coreutils gnu-sed instala las versiones de GNU.
yast), comandos de entornos de escritorio ni las CLI que traen los lenguajes de programación.sed solo soporta s///, N,Mp y Nd, y awk solo {print $N}; no hay red (curl, ssh y apt explican el motivo), no hay procesos reales (ps, top y kill devuelven datos de demostración fijos) ni editores interactivos (para escribir archivos se usan echo > y cat >>).La primera entrada de la tabla inversa: ss -tulnp | grep :8080 localiza el PID, luego kill <PID> o directamente kill -9 $(lsof -t -i :8080).
El grupo «tratamiento de texto» va de grep -A3 -B1 para ver el contexto a las estadísticas con awk/sort/uniq -c y al seguimiento de un registro que rota con tail -F: un conjunto completo, y los niveles 3 y 8 de la terminal de práctica son exactamente esas dos cosas.
tar -czvf → scp / rsync -avz → tar -xzvf -C /var/www/, tres comandos seguidos; la trampa de rsync --delete está en las notas.
Recorre el grupo «información y administración del sistema» en este orden: cat /etc/os-release, nproc, free -h, df -h, ss -tlnp y systemctl list-units, y en diez minutos tendrás una idea general del equipo.
Básicamente no. Linux no tiene papelera: rm libera el inodo directamente. Antes de tocar un directorio importante, confirma la ruta con ls, entrecomilla las variables y comprueba que no estén vacías en los scripts (rm -rf "${DIR:?}"/), o usa herramientas como trash-cli en lugar de rm.
Casi siempre es que el terminal y el archivo no comparten codificación. Comprueba la codificación con file nombre-de-archivo; si es GBK, conviértelo a UTF-8 con iconv -f GBK -t UTF-8 y vuelve a buscar. grep -a permite tratar como texto un archivo que se detectó como binario por error.
Las columnas de ss -tulnp son Netid, State, Recv-Q, Send-Q, Local Address:Port, Peer Address:Port y Process. Para un puerto mira la columna Local Address:Port (*:8080 o 0.0.0.0:8080 significa que escucha en todas las interfaces); para el proceso, mira la última columna: users:(("node",pid=842,fd=18)).
Porque se ejecuta en el navegador, no tiene pila de red y no debería lanzar peticiones en tu nombre; esos comandos devuelven una explicación y remiten a la entrada de la guía. La práctica se centra en archivos, texto y permisos, que sí funcionan por completo en el sistema de archivos en memoria.
Los archivos que puedes leer con tus permisos no lo necesitan; para cambiar directorios del sistema (/etc, /usr), escuchar en puertos por debajo de 1024, ver información detallada de procesos de otros o gestionar servicios y paquetes hace falta root. sudo te deja ejecutar un comando como root, que es más seguro que cambiar a root para una sesión larga.
Los datos de la guía, la tabla inversa y la terminal simulada son contenido estático que se descarga con la página y se ejecuta en el navegador; buscar, copiar y practicar no envían ninguna petición. Los favoritos se guardan en el localStorage de este equipo. El sistema de archivos de la terminal simulada solo existe en la memoria de la página actual y se vacía al refrescar: no lee ni escribe tus archivos reales.
ls, cp, sort y cut.ss(8), ip(8), find(1) y grep(1).Actualizado el 2026-09-09
160 comandos Linux/Shell agrupados por archivos, texto, permisos, procesos, red, compresión y sistema, con tablas de opciones y ejemplos reales; índice inverso «qué quiero ver → qué comando uso»; búsqueda, copia, favoritos y terminal de práctica
Esta herramienta no está traducida por completo; parte del contenido usa el idioma de origen o uno de reserva.
Búsqueda inversa por objetivo: primero se indica qué se quiere saber y luego se ofrecen 2–3 comandos que lo muestran, del más nuevo al más antiguo y del recomendado al compatible.
pwd # /var/www/site
ls -la # detallado + archivos ocultos ls -lh # tamaño legible por humanos ls-lt | head # Ver lo último en orden inverso al tiempo de modificación
| -l | Forma larga: permisos, propietario, tamaño, tiempo |
| -a | Contiene archivos ocultos que comienzan con . |
| -h | Tamaño en K/M/G |
| -t | Ordenar por hora de modificación |
| -S | Ordenar por tamaño |
| -R | Subdirectorio recursivo |
| -d | Enumere solo el directorio en sí y no ingrese en él. |
cd /var/log cd .. # Nivel anterior cd - # Regresar al directorio anterior cd # Directorio de inicio (igual que cd ~)
mkdir -p app/src/{components,utils}
mkdir -m 700 private| -p | Crear recursivamente, no se informará ningún error si ya existe |
| -m | Especificar permisos |
| -v | Mostrar lo que se creó |
touch README.md touch -d "2026-01-01" old.log # Especificar hora
cp a.txt b.txt cp -r src/ backup/ # El directorio requiere -r cp -a /etc/nginx ~/nginx-bak # Reservar permisos y tiempo
| -r / -R | Copiar directorios recursivamente |
| -a | Archivo: igual a -dR --preserve=all |
| -i | Pregunta antes de la cobertura |
| -n | No sobrescribir archivos existentes |
| -u | Copiar solo cuando se actualice la fuente |
| -v | mostrar proceso |
mv antiguo.txt nuevo.txt # Cambiar nombre mv *.log logs/ # Movimiento por lotes mv -i a.txt dir/ # Preguntar antes de sobrescribir
| -i | Pregunta antes de la cobertura |
| -n | No cubierto |
| -f | Cobertura de fuerza |
| -v | mostrar proceso |
rm file.txt rm -r build/ # Eliminar directorio rm -rf node_modules # No confirmar ni ignorar la inexistencia
rm no ingresa a la papelera de reciclaje. Antes de rm -rf, haga eco de la variable de ruta para ver si está vacía: rm -rf "$DIR"/ es igual a rm -rf / cuando DIR está vacío.
| -r | Eliminar directorios recursivamente |
| -f | No preguntes, ignora que no existe. |
| -i | Confirmar uno por uno |
| -d | Eliminar directorios vacíos |
| -- | Los siguientes parámetros son opciones inapropiadas (eliminar archivos que comienzan con -) |
rmdir empty-dir rmdir -p a/b/c # junto con el directorio principal vacío
ln -s /opt/app/current ~/app ln -sf enlace de nuevo destino # Sobrescribir enlaces existentes readlink -f link # Ver hacia dónde apunta el enlace
find . -name "*.log"
buscar /var -type f -size +100M # Archivos de más de 100MB
encontrar . -mtime -7 -name "*.js" # Modificado en 7 días
find . -name "*.tmp" -delete
find . -type f -exec chmod 644 {} \;| -name / -iname | Por nombre (-iname ignora mayúsculas y minúsculas) |
| -type f|d|l | Archivo/Directorio/Enlace |
| -size +10M / -1k | por tamaño |
| -mtime -N / +N | Modificado dentro de N días/Hace N días |
| -maxdepth N | limitar la profundidad |
| -exec cmd {} \; | Ejecutar comando para cada resultado. |
| -delete | Quitar coincidencias |
| -empty | Archivo o directorio vacío |
sudo updatedb locate nginx.conf
which python3 escriba ls # bash integrado, podrá ver alias/comandos integrados/externos comando -v nodo # Determinar si el comando existe en el script
tree -L 2 árbol -a -I "node_modules|.git" # excluir
file photo.bin # photo.bin: JPEG image data, ...
stat app.log stat -c "%s %n" * # Solo tamaño y nombre
du -sh . du -sh * | ordenar -rh | head # ¿Quién ocupa más espacio? du -h --max-depth=1 /var
| -s | Mostrar solo el total |
| -h | legible por humanos |
| --max-depth=N | Nivel de restricción |
| -a | Contiene archivos |
df -h df -h /home df -i # uso de inodo (completo cuando hay demasiados archivos)
basename /var/log/syslog # syslog basename report.pdf .pdf # report dirname /var/log/syslog # /var/log
realpath ../config.yml
rsync -avz --progress src/ user@host:/srv/app/ rsync -av --delete ./dist/ /var/www/site/ # También elimina archivos redundantes en el destino rsync -avn src/ dst/ # -n solo vista previa
La presencia o ausencia de / al final del directorio fuente tiene diferentes significados: src/ sincroniza el contenido y src sincroniza el directorio mismo.
| -a | Modo de archivo (recursivo + conservar atributos) |
| -v | mostrar proceso |
| -z | compresión de transmisión |
| --delete | Eliminar archivos redundantes en el lado de destino |
| -n / --dry-run | Sólo vista previa |
| --exclude=PAT | excluir |
| -P | Progreso + reanudación desde el punto de interrupción |
scp app.tar.gz user@1.2.3.4:/tmp/ scp -r user@host:/var/log/app ./logs scp -P 2222 archivo usuario@host:~ # Especificar puerto (P mayúscula)
cat config.yml cat -n app.js # con número de línea cat a.txt b.txt > all.txt # Empalme
| -n | Número de línea |
| -A | Mostrar caracteres invisibles (^M es CRLF) |
| -s | Comprimir líneas en blanco consecutivas |
less /var/log/syslog #/búsqueda de palabra clave n siguiente G hasta el final g hasta el principio q salir F seguir (como cola -f)
| -N | Mostrar número de línea |
| -S | No rompas la línea |
| +F | Ingrese al modo de seguimiento |
| -i | La búsqueda ignora el caso |
head -n 20 app.log head -c 100 file.bin # primeros 100 bytes head -n -5 archivo # excepto las últimas 5 líneas
tail -n 50 app.log tail -f /var/log/nginx/access.log tail -F app.log # Continuar después de rotar el archivo
| -n N | Siguientes N líneas |
| -f | Sigue y agrega |
| -F | Siga y maneje la reconstrucción de archivos |
| -n +N | Desde la línea N hasta el final |
wc -l access.log ls | wc -l #¿Cuántos elementos hay en el directorio? gato *.py | wc -l # Número de líneas de código
diff -u old.conf new.conf diff -r dir1 dir2 # Comparar directorios diff <(sort a) <(sort b) # Compara el contenido ordenado
| -u | formato unificado |
| -r | Comparar directorios recursivamente |
| -q | Informar sólo si difiere |
| -w | ignorar los espacios en blanco |
| -i | ignorar caso |
cmp a.bin b.bin
nl -ba script.sh # Las líneas vacías también están numeradas
tac app.log | less
strings app.bin | grep -i version
xxd file.bin | head -20 xxd -r dump.txt > archivo.bin # Restaurar
nano /etc/hosts # Ctrl+O Guardar Ctrl+X Salir Ctrl+W Buscar Ctrl+K Cortar línea
vim app.conf # :wq Guardar y salir :q! Salir sin guardar/búsqueda de palabras dd eliminar línea u deshacer: establecer nu número de línea
make 2>&1 | tee build.log eco "texto" | sudo tee /etc/file # Utilice sudo para escribir archivos protegidos cmd | tee -a log.txt # Agregar
ls > list.txt echo "line" >> notes.txt cmd > out.log 2>&1 # Registrar todo cmd 2>/dev/null # descartar errores cmd &> all.log # abreviatura de bash
ps aux | grep nginx cat log | grep ERROR | wc -l history | tail -20
grep -rn "TODO" src/
grep -i error app.log
grep -v "^#" nginx.conf | grep -v "^$" # Eliminar comentarios y líneas en blanco
grep -E "5[0-9]{2}" access.log # Expresión regular extendida
grep -l "main" *.c # Listar solo nombres de archivos
grep -A3 -B1 "Exception" app.log # Primera y última 3 líneas de contexto| -r / -R | directorio recursivo |
| -n | Mostrar número de línea |
| -i | ignorar caso |
| -v | Invertir selección (filas sin patrón) |
| -E | Expresión regular extendida (igual que egrep) |
| -F | como cuerda fija |
| -w | coincidencia de palabras completas |
| -c | Solo cuenta el número de líneas. |
| -l | Mostrar solo nombres de archivos coincidentes |
| -o | Solo genera la parte correspondiente |
| -A/-B/-C N | Después/antes/antes y después de N líneas de contexto |
| --include="*.js" | Limitar los nombres de archivos al recurrir |
rg "TODO" --type ts
rg -n "fetch\(" src/sed 's/foo/bar/g' a.txt # Genera el resultado del reemplazo sed -i 's/foo/bar/g' a.txt # Modificar archivos directamente (GNU) sed -i.bak 's/8080/80/' app.conf # Haz una copia de seguridad antes de realizar cambios sed 's#/usr/local#/opt#g' f # El delimitador se puede reemplazar
| -i | Modificar en su lugar (macOS requiere -i '') |
| -n | Imprime solo las líneas seleccionadas por el comando p |
| -e | múltiples guiones |
| -E | regular extendido |
| g bandera | Reemplazar todo en una línea |
sed -n '10,20p' app.log # Líneas 10–20 sed '5d' f.txt # Eliminar línea 5 sed '/^$/d' f.txt # Eliminar líneas vacías sed '3i\nueva línea' f.txt # Insertar antes de la línea 3
awk '{imprimir $1}' acceso.log | ordenar | único -c | ordenar -rn | head # Las IP más visitadas
awk -F: '{imprimir $1}' /etc/passwd # nombre de usuario
awk '$3 > 100 {print $0}' data.txt # La tercera columna tiene más de 100 filas
awk '{suma += $2} END {imprimir suma}' f # Suma| -F <separador> | Separador de campo (en blanco predeterminado) |
| $0 / $1 / $NF | Fila completa / 1.ª columna / última columna |
| NR | Número de línea actual |
| BEGIN{} / END{} | Ejecutar antes del inicio/después del final |
| /regular/{…} | Procesar solo filas coincidentes |
cut -d, -f1,3 data.csv cut -d: -f1 /etc/passwd cortar -c1-8 archivo # por posición de carácter
sort names.txt ordenar -n nums.txt # Por valor numérico sort -k2 -t, -r data.csv # Ordenar por columna 2 en orden inverso sort -u list.txt # Ordenar y eliminar duplicados ordenar -h tamaños.txt # Según el tamaño K/M/G
| -n | por valor |
| -r | orden inverso |
| -k N | por la columna N |
| -t <separador> | Separador de columnas |
| -u | Eliminar duplicados |
| -h | tamaño legible por humanos |
| -V | Clasificación del número de versión (1.2 < 1.10) |
sort words.txt | uniq -c | sort -rn ordenar un.txt | uniq -d # Mostrar solo duplicados ordenar un.txt | uniq -u # Mostrar solo los únicos
echo hello | tr a-z A-Z # HELLO tr -d '\r' < win.txt > unix.txt # Eliminar CR tr -s ' ' < f # Comprimir espacios consecutivos eco $RUTA | tr ':' '\n' # Uno por línea
find . -name "*.log" | xargs rm
encontrar . -nombre "*.txt" -print0 | xargs -0 wc -l # El nombre del archivo contiene espacios
URL del gato.txt | xargs -n1 -P4 curl -sO # paralelo de 4 vías
echo a b c | xargs -I{} echo "item: {}"| -0 | NUL separado (con find -print0) |
| -n N | Pase N parámetros cada vez |
| -I {} | Utilice {} para ocupar espacio |
| -P N | norte paralelo |
| -r | No ejecutar cuando la entrada esté vacía |
paste -d, names.txt emails.txt
join -t, -1 1 -2 1 <(sort a.csv) <(sort b.csv)
cat /etc/fstab | column -t mount | column -t
echo abc | rev # cba
doblar -w 80 -s long.txt # -s doblar en espacios
iconv -f GBK -t UTF-8 gbk.txt > utf8.txt iconov -l | grep -i gb # Listar codificaciones soportadas
dos2unix script.sh sed -i "s/\r$//" script.sh # Cuando dos2unix no está instalado
curl -s https://api.github.com/repos/git/git | jq .stargazers_count jq ".items[] | .name" data.json jq -r ".[].id" list.json # -r cadena original sin comillas gato a.json | jq. # Formato
echo "Hello" echo -e "a\tb\nc" echo $HOME echo "PATH=$PATH" >> ~/.bashrc
printf "%-10s %5d\n" name 42 printf "%.2f\n" 3.14159 printf "%s\n" *.txt # Un nombre de archivo por línea
seq 1 10 secuencia 0 5 100 # tamaño de paso 5 for i in $(seq 1 3); do echo $i; done
echo "2^10" | bc echo "scale=3; 10/3" | bc eco "obase=16; 255" | bc # Convertir a hexadecimal
chmod 755 script.sh # rwxr-xr-x chmod 644 file.txt # rw-r--r-- chmod 600 ~/.ssh/id_ed25519 # Sólo tú puedes leer y escribir chmod -R 755 público/ # recursivo
| 755 | Valores comunes para directorio/ejecutable |
| 644 | Valores comunes para archivos ordinarios |
| 600 | Archivos de clave privada y contraseña |
| 700 | Directorio privado (como ~/.ssh) |
| -R | recursividad |
chmod +x implementar.sh # Agregar ejecutable chmod u+w,go-w file # El propietario puede escribir, otros no chmod a-x file chmod g+s compartido/ # Directorio setgid: nuevo grupo de herencia de archivos
sudo chown www-data:www-data -R /var/www/site sudo chown $USER file.txt Proyecto de desarrolladores chgrp/# solo reproducción aleatoria
umask umask 027 # Grupo de solo lectura, otros no tienen permisos
sudo apt update sudo -i # Cambiar al shell interactivo raíz sudo -u postgres psql # Ejecutar como otro usuario sudo!! # Usa sudo para volver a ejecutar el anterior
su - deploy salir # volver
whoami id id implementar # Ver otros usuarios
sudo useradd -m -s /bin/bash deploy sudo passwd deploy sudo usermod -aG sudo implementar # Unirse al grupo sudo
sudo usermod -aG docker $USER newgrp docker # O inicie sesión nuevamente para que surta efecto
sudo userdel -r olduser
passwd sudo passwd deploy sudo passwd -l implementar # Bloquear cuenta
groups groups www-data cat /etc/group | grep docker
who w last -n 10 lastlog
ssh-keygen -t ed25519 -C "me@example.com" cat ~/.ssh/id_ed25519.pub ssh-copy-id usuario@host # Instalar la clave pública en el servidor
ssh user@1.2.3.4 ssh -p 2222 usuario@host #Especificar puerto ssh -i ~/.ssh/key.pem ubuntu@host ssh -L 8080:localhost:80 usuario@host # Reenvío de puertos ssh user@host "uptime" # Ejecutar solo un comando
| -p | puerto |
| -i | archivo de clave privada |
| -L local:destino:puerto | reenvío de puerto local |
| -N | Sólo el reenvío no abre el shell |
| -v | Depuración de problemas de conexión |
Host prod
HostName 1.2.3.4
User deploy
Port 2222
IdentityFile ~/.ssh/prod_keyps aux | grep nginx ps -ef | grep java ps auxiliar --sort=-%mem | head # El que más memoria consume ps -p 1234 -o pid,etime,cmd # ¿Cuánto tiempo lleva ejecutándose un proceso?
| aux | Estilo BSD: todos los usuarios, incluidos terminales, detallado |
| -ef | Estilo UNIX: todos los procesos, incluido el proceso principal |
| --sort=-%cpu | Ordenar por CPU en orden inverso |
| -p PID | Especificar proceso |
| -o campo | Columnas personalizadas |
pgrep -f "node server.js" pgrep -l nginx # con nombre pkill -f "node server.js" # Buscar y eliminar
top top -o %MEM top -p 1234 # Ver solo un proceso determinado
htop htop -u www-data
kill 1234 matar -9 1234 # Matar si es desobediente kill -HUP 1234 # Deja que el servicio recargue la configuración matar -l # lista de señales
| -15 / -TERM | Predeterminado: Solicitar salida normal |
| -9 / -KILL | Final forzado sin dar oportunidad de limpiar |
| -1 / -HUP | Comúnmente utilizado para sobrecargar la configuración. |
| -2 / -INT | Igual a Ctrl+C |
| -STOP / -CONT | Pausar / Reanudar |
killall node killall -9 chrome
npm run build & jobs fg %1 # Ctrl+Z pausa la tarea actual en primer plano, luego pulsa para continuarla en segundo plano
nohup python server.py > server.log 2>&1 & eco$! # PID recién iniciado
tmux new -s work # Ctrl+B y luego d para separar tmux ls tmux attach -t work tmux kill-session -t work
systemctl status nginx estado systemctl --failed # Servicio fallido
sudo systemctl restart nginx sudo systemctl reload nginx # Recargar la configuración sin interrumpir la conexión
sudo systemctl enable --now docker sudo systemctl disable apache2 systemctl is-enabled nginx
systemctl list-units --type=service --state=running systemctl list-unit-files | grep enabled
journalctl -u nginx -f journalctl -u app -n 200 --no-pager journalctl --since "1 hour ago" journalctl -p err -b # Errores desde este arranque sudo journalctl --vacuum-size=500M # Limpiar
| -u <unidad> | un servicio |
| -f | seguir |
| -n N | Últimas N líneas |
| --since / --until | rango de tiempo |
| -p err | Filtrar por nivel |
| -b | esta startup |
| -k | Mensajes del núcleo |
crontab -e # Copia de seguridad todos los días a las 3:30 30 3 * * * /opt/scripts/backup.sh >> /var/log/backup.log 2>&1 # cada 5 minutos */5 * * * * /usr/bin/curl -s https://example.com/ping crontab -l # Ver
echo "systemctl restart app" | at 03:00 atq #cola atrm 3 # eliminar
watch -n 2 "df -h" ver -d gratis -m # -d resaltar cambios
time ./build.sh time curl -s https://example.com > /dev/null
timeout 10 ping example.com timeout -s KILL 30 ./stuck.sh
lsof -p 1234 lsof +D /var/log # ¿Quién utiliza los archivos de este directorio? lsof | grep eliminado # Archivos eliminados pero ocupados (el disco no se libera)
strace -p 1234 strace -f -e trace=network node app.js strace -c ./cmd # Estadísticas
nice -n 19 tar czf big.tgz data/ renice -n 10 -p 1234
ss -tulnp ss -tlnp | grep :80 ss -s # estadísticas de conexión ss -tan state established
| -t / -u | TCP / UDP |
| -l | Solo monitorear |
| -n | El puerto numérico no resuelve el nombre del servicio |
| -p | Mostrar procesos (requiere root para verlos todos) |
| -a | Conectar todo |
netstat -tulnp | grep 3000 netstat -an | grep ESTABLISHED | wc -l
lsof -i :8080 lsof -i tcp -sTCP:LISTEN kill -9 $(lsof -t -i :3000) # Mata al ocupante directamente
ip addr ip -4 -br addr # agilizar nombre de host -I # Sólo IP
ip route ip route get 8.8.8.8 # ¿Qué camino tomar para llegar a una dirección determinada?
ping -c 4 example.com ping -i 0.2 -c 20 10.0.0.1
traceroute example.com mtr -rw example.com
curl -I https://example.com # Solo lee encabezados de respuesta
curl -sS https://api.example.com/x | jq. # Silencioso pero reportando un error
curl -o file.zip -L https://…/file.zip # Descargar y seguir redirecciones
curl -X POST -H "Content-Type: application/json" -d '{"a":1}' https://api.example.com/items
curl -u user:pass https://…
curl -w "%{http_code} %{time_total}\n" -o /dev/null -s https://example.com| -I | Solicitar solo encabezado (HEAD) |
| -L | seguir redirección |
| -o archivo / -O | Guardar en archivo/usar nombre de archivo remoto |
| -X método | Método de solicitud |
| -H "encabezado:valor" | Encabezado de solicitud |
| -d datos | Cuerpo de la solicitud (POST predeterminada) |
| -s / -S | Silencioso/Silencioso con errores |
| -v | Mostrar interacción completa |
| -k | Ignorar errores de certificado (para depurar) |
| -w formato | Código de estado de salida, consumo de tiempo, etc. |
wget https://example.com/file.tar.gz wget -c https://…/big.iso # Continuar descarga wget -qO- https://ejemplo.com | head # Salida a la pantalla wget -r -np -nH --cut-dirs=1 https://example.com/docs/
dig example.com dig +short example.com dig MX example.com dig @8.8.8.8 ejemplo.com # Especificar DNS dig -x 93.184.216.34 # Comprobación inversa
nslookup example.com nslookup -type=txt example.com
host example.com
sudo nano /etc/hosts 127.0.0.1 dev.example.com
nc -zv example.com 443 nc -l 8080 # Monitorear 8080 eco "hola" | nc host 8080 # Enviar datos
telnet smtp.example.com 25
sudo ufw status sudo ufw allow 22 sudo ufw allow 80/tcp sudo ufw allow from 10.0.0.0/8 to any port 5432 sudo ufw enable
Asegúrese de liberar 22 antes de abrirlo; de lo contrario, SSH se bloqueará por sí solo.
sudo firewall-cmd --list-all sudo firewall-cmd --add-port=8080/tcp --permanent sudo firewall-cmd --reload
sudo iptables -L -n -v --line-numbers sudo iptables -A INPUT -p tcp --dport 8080 -j ACCEPT
sudo tcpdump -i eth0 port 80 -nn sudo tcpdump -i cualquier host 10.0.0.5 -w cap.pcap # Guarde el archivo en Wireshark
sudo iftop -i eth0 nload
ip neigh arp -a
tar -czvf site.tar.gz site/ tar -czf logs.tgz --exclude="*.tmp" logs/ tar -cJvf site.tar.xz site/ # xz comprime más pequeño y más lento
| -c | crear |
| -x | Desatar |
| -t | listar contenido |
| -z / -j / -J | gzip / bzip2 / xz |
| -v | mostrar archivo |
| -f archivo | Nombre del archivo comprimido (debe seguir al nombre del archivo) |
| -C directorio | Cambie al directorio y luego opere |
| --exclude=PAT | excluir |
tar -xzvf site.tar.gz tar -xzvf site.tar.gz -C /var/www/ tar -xf any.tar.* # La nueva versión de tar reconoce automáticamente el formato de compresión tar -tzvf site.tar.gz # Veamos primero qué hay dentro
gzip big.log # obtener big.log.gz gzip -k big.log # Conserva el archivo original gunzip big.log.gz zcat big.log.gz | grep ERROR # Ver directamente sin descomprimir
zip -r project.zip project/ -x "*/node_modules/*" zip -e secreto.zip archivo.txt # Cifrado
unzip archive.zip unzip archive.zip -d out/ descomprimir -l archive.zip # solo ver la lista unzip -O gbk cn.zip # Cuando los nombres de archivos chinos de Windows están confusos
7z x archive.7z 7z a -mx9 out.7z dir/ 7z x file.rar
xz -9 big.sql xz -d big.sql.xz bzip2 -k file
split -b 100M big.iso part_ cat part_* > big.iso
sha256sum ubuntu.iso sha256sum -c SHA256SUMS md5sum file.zip
sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress && sync dd if=/dev/zero of=test.bin bs=1M count=100 # archivo de prueba de 100 MB
of= Si escribe el dispositivo incorrecto, el disco se borrará directamente. Confirme con lsblk tres veces antes de ejecutar.
uname -a uname -m # x86_64 / aarch64 cat /etc/os-release # Versión de lanzamiento
hostnamectl sudo hostnamectl set-hostname web-01
uptime # Carga > Número de núcleos de CPU (nproc) indica cola
free -h free -m -s 2 # Actualizar cada 2 segundos
nproc lscpu | grep -E "Model name|^CPU\(s\)"
lsblk lsblk -f # Con sistema de archivos y UUID sudo fdisk -l
sudo mount /dev/sdb1 /mnt/usb sudo umount /mnt/usb montar | columna -t # Montado cat /etc/fstab # Montar automáticamente en el arranque
vmstat 1 10
iostat -x 1 5
sudo dmesg -T | tail -50 sudo dmesg -T | grep -i "proceso eliminado" # ¿Quién recibió OOMed?
env | sort printenv HOME echo $PATH | tr ":" "\n"
export JAVA_HOME=/usr/lib/jvm/java-17 export PATH="$HOME/.local/bin:$PATH" echo 'export EDITOR=vim' >> ~/.bashrc && source ~/.bashrc
alias ll="ls -alF" alias gs="git status" unalias ll alias # lista
history | grep ssh !105 sudo !! historial -c # Borrar
sudo apt update && sudo apt upgrade sudo apt install htop apt search nginx apt show nginx sudo apt remove --purge pkg && sudo apt autoremove
| update | Actualizar el índice de fuentes de software |
| upgrade | Actualizar paquete instalado |
| install / remove | Instalar/desinstalar |
| search / show | Buscar / Detalles |
| autoremove | Ya no es necesario limpiar las dependencias |
| list --installed | Lista instalada |
sudo dnf install -y git sudo dnf update dnf search nginx sudo yum install epel-release # Sistema antiguo
sudo pacman -Syu sudo pacman -S neovim pacman -Ss keyword sudo pacman -Rns pkg
brew install jq brew upgrade brew list brew search ripgrep
sudo snap install code --classic snap list
sudo dpkg -i app.deb sudo apt -f install dpkg -l | grep nginx dpkg -L nginx #¿Qué archivos están empaquetados?
sudo shutdown -h now sudo reboot sudo apagado -r +10 "Reiniciar el mantenimiento después de 10 minutos" sudo apagado -c # Cancelar
date date "+%Y-%m-%d %H:%M:%S" date -d "yesterday" +%F fecha +%s # marca de tiempo date -d @1700000000 # Convertir marca de tiempo a fecha
timedatectl sudo timedatectl set-timezone Asia/Shanghai timedatectl list-timezones | grep Asia
cal cal 2026 cal -3 # un mes antes y después
lsmod | grep nvidia sudo modprobe br_netfilter
lspci | grep -i vga lsusb
ulimit -n ulimit -n 65535 # Sesión actual cat /proc/sys/fs/file-max
chsh -s $(which zsh) echo $SHELL
source ~/.bashrc . ~/.zshrc # Sinónimo
#!/usr/bin/env bash set -euo pipefail # Detener en caso de error, error de variable no definida, transmisión de error de tubería for f in *.log; do eco "proceso $f" done
man tar man 5 crontab # Sección 5: Formato de archivo tar --help | less tldr tar # Versión de muestra comunitaria (requiere instalación)
Un pequeño sistema de archivos y un intérprete de shell en memoria: admite ls / cd / cat / grep / sed / awk / find / chmod / tar y más de 60 comandos, con tuberías, redirecciones y comodines; 8 niveles van de «crear un árbol de directorios» a «estadísticas con tuberías». No se conecta a la red ni toca los archivos reales. La práctica de comandos de Git está enReferencia de comandos de Git.