Skip to content

Linux Hoja de referencia

Núcleo de sistema operativo tipo Unix de código abierto y sus distribuciones.

01

Primeros pasos

Comandos básicos de archivos

ls -la muestra cada archivo, incluidos los ocultos. cd ~ va al home, cd - alterna al directorio anterior. mkdir -p crea los directorios padre según sea necesario. rm -r es necesario para directorios no vacíos.

linux
# list files
ls -la          # long format, all files
ls -lh          # human-readable sizes
ls -lt          # sort by modification time

# current directory
pwd

# change directory
cd /home/user
cd ..           # go up one level
cd ~            # go home
cd -            # go to previous directory

# create/remove directories
mkdir newdir
mkdir -p path/to/dir   # create parents
rmdir emptydir
rm -r nonempty          # remove recursively

Obtener ayuda

man es el sistema de documentación principal. Secciones: 1=comandos, 2=syscalls, 3=librería, 4=dispositivos, 5=formatos de archivo, 8=administración. man -k (o apropos) busca en las descripciones. --help da un resumen conciso. tldr ofrece ejemplos prácticos y se instala aparte (npm install -g tldr).

linux
# manual pages
man ls                  # full documentation
man 5 crontab           # section 5 (file formats)
man -k password         # search by keyword (apropos)

# info pages (GNU tools, more detailed)
info coreutils
info ls

# quick help flags
command --help
ls --help
git --help

# tldr: community cheat sheets (install separately)
tldr tar
tldr find

# whatis: one-line description
whatis ls

# where is the binary / source / man page
whereis python3

Historial de comandos y atajos

!! repite el último comando (sudo !! es el clásico arreglo de 'me olvidé sudo'). !N ejecuta el comando N del historial. !$ es el último argumento. Ctrl+R es la búsqueda inversa interactiva — pulsa de nuevo para encontrar coincidencias anteriores. El historial se guarda en ~/.bash_history; HISTSIZE controla el tamaño en memoria, HISTFILESIZE el del archivo.

linux
# history expansion
history                 # show command history
!!                      # repeat last command
sudo !!                 # repeat last command as root
!42                     # run command #42 from history
!ls                     # run last command starting with ls
!$                      # last argument of last command
!!:gs/old/new/          # substitute in last command

# search history (interactive)
# Ctrl+R then type to search backward

# clear history
history -c              # clear current session
# edit ~/.bashrc HISTSIZE and HISTFILESIZE

# save and reload history
history -a              # append to history file
history -r              # reload from file

Tipos de archivo e identificación

file inspecciona los magic bytes de un archivo para determinar su tipo real — mucho más fiable que la extensión. ls -F añade indicadores de tipo (* ejecutable, / directorio, @ symlink, = socket). stat muestra los metadatos completos del inode incluidas las tres marcas de tiempo: Access (atime), Modify (mtime, contenido), Change (ctime, metadatos).

linux
# identify file type by content (not extension)
file document.pdf       # PDF document
file image.png          # PNG image data
file script.sh          # ASCII text executable
file /bin/ls            # ELF 64-bit LSB executable

# file with multiple files
file *.txt

# show MIME type
file --mime-type video.mp4   # video/mp4

# ls -F shows type indicator
ls -F
# file*       (executable)
# dir/        (directory)
# link@       (symlink)
# socket=     (socket)

# stat: detailed file info
stat file.txt
# Size, Blocks, IO Block, Device, Inode, Links,
# Access/Modify/Change/Birth times

Atajos de navegación en la terminal

Estos atajos de Readline funcionan en bash y la mayoría de shells. Ctrl+A/E saltan al inicio/fin de la línea. Ctrl+W/U/K borran texto — Ctrl+Y lo pega de nuevo (kill ring). Ctrl+R busca en el historial. Ctrl+L limpia la pantalla. Ctrl+S congela la salida (causa común de 'terminal congelada' — Ctrl+Q reanuda). Aprenderlos acelera dramáticamente la edición en la línea de comandos.

linux
# cursor movement
Ctrl+A     # move to beginning of line
Ctrl+E     # move to end of line
Ctrl+B     # move back one char
Ctrl+F     # move forward one char

# editing
Ctrl+D     # delete char under cursor (or EOF/exit)
Ctrl+H     # delete char before cursor (backspace)
Ctrl+W     # delete word before cursor
Ctrl+U     # delete from cursor to beginning
Ctrl+K     # delete from cursor to end
Ctrl+Y     # paste (yank) deleted text back

# job control
Ctrl+C     # send SIGINT (interrupt)
Ctrl+Z     # suspend (send SIGTSTP)
Ctrl+D     # end of input / exit shell

# screen
Ctrl+L     # clear screen (same as clear)
Ctrl+S     # stop output (freeze)
Ctrl+Q     # resume output

# Alt shortcuts
Alt+B / Alt+F    # move back/forward by word
Alt+Backspace    # delete word backward

Variables de entorno

Las variables de entorno las heredan los procesos hijos cuando se exportan. $PATH determina dónde busca el shell los comandos — los directorios se buscan en orden, separados por dos puntos. ~/.bashrc se carga en shells interactivos sin login; ~/.profile o ~/.bash_profile en shells con login. Haz siempre source del archivo tras editarlo para aplicar los cambios. Usa printenv VAR para comprobar una sola variable sin expansión.

linux
# view all environment variables
env
printenv

# view specific variable
echo $HOME
echo $PATH
echo $USER

# set a variable (current shell only)
MYVAR="hello"
echo $MYVAR

# export to child processes
export PATH="$PATH:/opt/bin"
export EDITOR=nano

# set and export in one step
export MYVAR="hello"

# unset a variable
unset MYVAR

# common variables
# $HOME    user home directory
# $PATH    command search path
# $USER    current username
# $SHELL   current shell path
# $PWD     current working directory
# $OLDPWD  previous directory
# $PS1     prompt string

# persistent: add to ~/.bashrc or ~/.profile
echo 'export EDITOR=vim' >> ~/.bashrc
source ~/.bashrc
02

Operaciones con archivos

Copiar archivos (cp)

cp copia archivos. -r (o -R) es obligatorio para directorios. -i pregunta antes de sobrescribir (recomendado para evitar pérdida de datos). -p conserva los metadatos; -a es modo archivo (conserva el conjunto completo, incluidos los symlinks — ideal para respaldos). -u solo actualiza si la fuente es más nueva. Usa siempre -i en scripts donde sobrescribir sea arriesgado.

linux
# copy a file
cp source.txt dest.txt

# copy to a directory
cp file.txt /backup/

# copy multiple files to a directory
cp file1.txt file2.txt /backup/

# copy directories recursively
cp -r src_dir/ dest_dir/

# interactive (prompt before overwrite)
cp -i file.txt /backup/

# preserve attributes (timestamps, permissions, ownership)
cp -p file.txt /backup/
cp -a src_dir/ dest_dir/    # archive mode (-rdp)

# only copy if source is newer
cp -u file.txt /backup/

# verbose (show what is being copied)
cp -v file.txt /backup/

# force overwrite
cp -f file.txt /backup/

Mover y renombrar (mv)

mv sirve tanto para mover como para renombrar — actualiza la entrada del directorio sin copiar datos (instantáneo en el mismo sistema de archivos). -i pregunta antes de sobrescribir. mv -n impide sobrescribir archivos existentes. El comando rename (basado en Perl en Debian/Ubuntu) usa regex para renombrar en lote — mucho más potente que los bucles con mv. Ojo: la sintaxis de rename difiere entre distribuciones (versión util-linux vs perl).

linux
# rename a file
mv oldname.txt newname.txt

# move file to another directory
mv file.txt /target/dir/

# move multiple files
mv file1.txt file2.txt /target/dir/

# interactive (prompt before overwrite)
mv -i file.txt /target/

# force overwrite
mv -f file.txt /target/

# no overwrite (don't replace existing)
mv -n file.txt /target/

# move only if newer
mv -u file.txt /target/

# verbose
mv -v olddir/ newdir/

# rename batch with rename command
rename 's/\.txt$/.md/' *.txt
rename .JPG .jpg *.JPG

Eliminar archivos (rm)

rm elimina archivos permanentemente (sin papelera). -r es obligatorio para directorios. -rf es peligroso — elimina recursivamente sin preguntar; verifica siempre la ruta dos veces. Nunca ejecutes rm -rf / o rm -rf $VAR/ cuando $VAR pueda estar vacío. Considera trash-cli para una eliminación recuperable. find -delete es más seguro para eliminar por patrón porque puedes probar sin -delete primero.

linux
# remove a file
rm file.txt

# remove multiple files
rm file1.txt file2.txt

# interactive (prompt for each file)
rm -i file.txt

# force (ignore nonexistent, no prompt)
rm -f file.txt

# remove directory recursively
rm -r directory/
rm -rf directory/        # force + recursive (DANGEROUS)

# verbose
rm -v *.tmp

# remove files matching pattern
find . -name "*.bak" -delete
find . -name "*.log" -mtime +30 -delete

# safer alternative: trash-cli
trash-put file.txt
trash-list
trash-restore

Crear archivos (touch)

touch crea archivos vacíos o actualiza las marcas de tiempo de los existentes. Sin opciones, fija tanto atime como mtime a la hora actual. -t fija una marca de tiempo específica. -r copia la marca de tiempo de un archivo de referencia. Para crear un archivo con contenido, usa redirección (>) o un here-document. touch se usa comúnmente para crear archivos marcadores o forzar que make reconstruya objetivos.

linux
# create an empty file
touch newfile.txt

# create multiple empty files
touch file1.txt file2.txt file3.txt

# update access and modification time to now
touch existing.txt

# set specific time (YYYYMMDDHHMM format)
touch -t 202401011200 file.txt       # Jan 1, 2024 12:00

# set only access time
touch -a file.txt

# set only modification time
touch -m file.txt

# use time from another file
touch -r reference.txt target.txt

# create file with content
echo "content" > file.txt
cat > file.txt << 'EOF'
line 1
line 2
EOF

Enlaces duros y simbólicos (ln)

Los enlaces duros comparten el mismo inode (datos) — borrar uno no elimina los datos hasta que se eliminan la totalidad de los enlaces. No pueden cruzar sistemas de archivos ni enlazar a directorios. Los symlinks son referencias de ruta — se rompen si el objetivo se mueve o se elimina, pero pueden cruzar sistemas de archivos y enlazar a directorios. Usa ln -s para symlinks (lo más común). readlink -f resuelve la cadena completa hasta el archivo real.

linux
# hard link (same inode, same filesystem only)
ln original.txt hardlink.txt

# symbolic link (symlink, path reference)
ln -s /path/to/target symlink_name
ln -s original.txt softlink.txt

# force recreate a symlink
ln -sf /new/target symlink_name

# symbolic link to a directory
ln -s /var/log /home/user/logs

# view link target
readlink symlink
readlink -f symlink        # canonical absolute path
ls -l symlink              # show what it points to

# find broken symlinks
find . -type l ! -exec test -e {} \; -print

# count hard links to a file
ls -li file.txt            # 2nd column is link count

# remove a symlink
rm symlink_name
unlink symlink_name

Metadatos de archivo (stat, basename, dirname)

stat muestra los metadatos completos del inode. basename y dirname descomponen rutas — esenciales en scripts que procesan listas de archivos. realpath resuelve rutas relativas y symlinks a rutas canónicas absolutas. stat -c permite formatos de salida personalizados (%n=nombre, %s=tamaño, %y=mtime, %a=permisos octales) — útil en scripts. Estas herramientas reemplazan la expansión de parámetros frágil para la manipulación de rutas.

linux
# stat: full file information
stat file.txt
# Size: 1024  Blocks: 8  IO Block: 4096
# Device: 801h/2049d  Inode: 1234567
# Links: 1
# Access: (0644/-rw-r--r--)  Uid: 1000  Gid: 1000
# Access/Modify/Change: 2024-01-01 12:00:00

# custom format
stat -c '%n %s bytes' file.txt
stat -c '%y' file.txt            # modification time

# basename: extract filename from path
basename /var/log/syslog         # syslog
basename /var/log/syslog.log .log  # syslog

# dirname: extract directory from path
dirname /var/log/syslog          # /var/log

# realpath: resolve to absolute path
realpath ../file.txt
realpath -s symlink              # physical path (no symlink resolution)

# file size only
stat -c %s file.txt              # bytes
du -h file.txt | cut -f1         # human-readable
03

Operaciones con directorios

Crear directorios (mkdir)

mkdir -p crea los directorios padre según sea necesario y no da error si el directorio ya existe — esencial para scripts idempotentes. -m fija los permisos directamente (anula el umask). La expansión de llaves ({a,b,c}) combinada con mkdir -p crea árboles de directorios complejos en un solo comando. Es un patrón común para andamiar estructuras de proyecto.

linux
# create a single directory
mkdir newdir

# create nested directories
mkdir -p path/to/deep/dir

# create multiple directories
mkdir dir1 dir2 dir3

# create with specific permissions
mkdir -m 755 publicdir
mkdir -m 700 privatedir

# verbose output
mkdir -v newdir

# create parent dirs with permissions
mkdir -p -m 755 /opt/myapp/{bin,lib,etc}

# create a directory tree at once
mkdir -p project/{src,tests,docs}
mkdir -p project/src/{main,utils}
mkdir -p project/{src/{main,utils},tests,docs}

Eliminar directorios (rmdir, rm)

rmdir solo elimina directorios vacíos — seguro pero limitado. rm -r elimina directorios no vacíos recursivamente. rm -rf es la opción nuclear: verifica siempre la ruta primero. El patrón find -empty -delete elimina solo los directorios vacíos sin tocar los poblados. En scripts, comprueba siempre que la variable no esté vacía antes de rm -rf para no borrar / accidentalmente.

linux
# remove an empty directory
rmdir emptydir

# remove directory with contents
rm -r directory/

# force remove (no prompt)
rm -rf directory/

# remove empty directories recursively (find)
find . -type d -empty -delete
find . -type d -empty -exec rmdir {} \;

# remove directory with confirmation
rm -ri directory/

# safe removal pattern in scripts
DIR="/tmp/mydir"
if [ -n "$DIR" ] && [ -d "$DIR" ]; then
    rm -rf "$DIR"
fi

# move to trash instead
trash-put directory/

Listado de directorios y árbol

ls -d */ lista solo los directorios. tree ofrece una jerarquía visual — -L limita la profundidad, -I excluye patrones (increíblemente útil para excluir node_modules/.git). Para árboles de directorios grandes, combina tree -d -L 2 para una visión rápida. ls -1 (el número uno) lista un archivo por línea — útil para pasar por pipe a wc -l y contar.

linux
# list directory contents
ls -la                    # all files, long format
ls -lh                    # human-readable sizes
ls -lt                    # sort by time (newest first)
ls -lS                    # sort by size (largest first)
ls -lr                    # reverse order
ls -R                     # recursive listing
ls -d */                  # list only directories

# tree view (install separately: apt install tree)
tree                      # show directory tree
tree -L 2                 # limit depth to 2
tree -d                   # directories only
tree -a                   # include hidden files
tree -h                   # show file sizes
tree --dirsfirst          # dirs before files
tree -I 'node_modules|.git'  # ignore patterns
tree -H . -o tree.html    # output as HTML

# count files in directory
ls -1 | wc -l
find . -maxdepth 1 -type f | wc -l

Tamaño de directorio (du)

du mide el uso de disco. -s (resumen) muestra solo el total, -h lo hace legible para humanos. du -sh */ da los tamaños de los subdirectorios inmediatos. sort -rh ordena por tamaño legible en reversa (mayor primero). --exclude se salta patrones. La diferencia entre apparent-size y el modo por defecto: apparent muestra el tamaño lógico del archivo, el por defecto muestra los bloques de disco reales asignados (que pueden ser mayores por el tamaño de bloque).

linux
# size of current directory (total)
du -sh .

# size of specific directories
du -sh /var/log /tmp /home

# size of all subdirectories
du -sh */

# sort directories by size (largest first)
du -sh * | sort -rh

# find the 10 largest directories
du -sh * | sort -rh | head -10

# include hidden files/dirs
du -sh .[!.]*

# maximum depth
du -h --max-depth=1
du -h -d 1                  # short form

# apparent size vs disk usage
du -sh --apparent-size file  # logical size
du -sh file                   # actual disk blocks

# exclude directories
du -sh --exclude='*.log' .
du -sh --exclude=node_modules .

Pila de directorios (pushd, popd)

pushd/popd gestionan una pila de directorios — pushd guarda el directorio actual y navega a uno nuevo; popd vuelve al guardado. dirs muestra la pila. Es más potente que cd - (que solo alterna entre dos directorios). Útil en scripts que necesitan navegar entre varios directorios y regresar. La sintaxis +N rota o elimina por posición.

linux
# push directory onto stack and cd into it
pushd /var/log
# pushes current dir, then cd to /var/log

# push another
pushd /tmp
# stack: /tmp /var/log /home/user

# pop back to previous directory
popd
# returns to /var/log

# list the directory stack
dirs
dirs -v           # verbose (numbered)
dirs -c           # clear the stack

# navigate by index
pushd +2          # rotate to 3rd entry
popd +1           # remove 2nd entry

# practical: save current dir, work, return
pushd /etc
cp config.conf ~/backup/
popd              # back to where we were

# alternative: use cd - for simple toggle
cd /var/log
cd -              # back to previous directory
04

Visualización de archivos

cat y tac

cat vuelca el archivo entero a stdout — bien para archivos pequeños, pero usa less/head para los grandes. cat -n numera las líneas. cat -A revela caracteres ocultos (tabulaciones, finales de línea) — útil para depurar problemas de formato. tac invierte el orden de las líneas (cat al revés). cat también sirve para concatenar archivos y redirigir entrada. Para ver archivos grandes de forma interactiva, usa less.

linux
# display entire file
cat file.txt

# concatenate multiple files
cat file1.txt file2.txt > combined.txt

# display with line numbers
cat -n file.txt

# display with non-printing characters
cat -A file.txt           # show tabs as ^I, line ends as $
cat -v file.txt           # show non-printing chars
cat -e file.txt           # show line ends as $
cat -t file.txt           # show tabs as ^I

# append to a file
cat >> file.txt << 'EOF'
appended line
EOF

# tac: reverse line order
tac file.txt              # last line first

# create file from stdin
cat > newfile.txt
# type content, Ctrl+D to end

Paginador less

less es el paginador estándar — mucho mejor que more porque permite navegar hacia atrás. Los atajos son tipo vim (j/k/g/G). / busca hacia adelante, ? hacia atrás. F entra en 'modo seguimiento' (como tail -f) para vigilar logs. less maneja automáticamente los archivos comprimidos si lesspipe está configurado. Pulsa v para abrir el archivo actual en tu $EDITOR y editar rápido.

linux
# view a file
less file.txt

# view command output
dmesg | less
ls -la /etc | less

# navigation inside less:
#   space / f     forward one page
#   b             backward one page
#   j / k         down / up one line
#   g             go to beginning
#   G             go to end
#   /pattern      search forward
#   ?pattern      search backward
#   n             next match
#   N             previous match
#   v             open in editor ($EDITOR)
#   F             follow mode (like tail -f)
#   q             quit

# useful flags
less -N file.txt          # show line numbers
less -S file.txt          # chop long lines
less -i file.txt          # case-insensitive search
less +/pattern file.txt   # open at first match

# view compressed files
less file.gz              # auto-decompresses (if lesspipe installed)

head y tail

head muestra el principio y tail el final de un archivo. tail -f es esencial para monitorear archivos de log en tiempo real. tail -F (mayúscula) maneja la rotación de archivos (cuando los logs se renombran/truncan) reabriendo el archivo. head -n -N muestra el archivo salvo las últimas N líneas. Para archivos grandes, head/tail son instantáneos (no leen el archivo entero).

linux
# first 10 lines (default)
head file.txt
# last 10 lines (default)
tail file.txt

# first N lines
head -n 20 file.txt
head -20 file.txt

# last N lines
tail -n 20 file.txt
tail -20 file.txt

# all but last N lines
head -n -5 file.txt       # all except last 5 lines

# first N bytes
head -c 100 file.txt
tail -c 100 file.txt

# follow a log file (live updates)
tail -f /var/log/syslog

# follow with retry (handles log rotation)
tail -F /var/log/app.log

# show last 5 lines, then follow
tail -n 5 -f app.log

# multiple files
tail -n 5 file1.txt file2.txt

Ver líneas concretas

sed -n 'Np' imprime números de línea concretos. awk con NR (número de registro) es más flexible para rangos y condiciones. El truco (head; tail) muestra ambos extremos de un archivo grande. nl y cat -n numeran las líneas. hexdump/xxd muestran archivos binarios en hex — esencial para inspeccionar archivos no textuales, depurar formatos de archivo o recuperar datos.

linux
# show line N (e.g., line 10)
sed -n '10p' file.txt

# show lines M to N
sed -n '10,20p' file.txt
awk 'NR>=10 && NR<=20' file.txt

# show first and last N lines
(head -5; echo "..."; tail -5) < file.txt

# show lines matching pattern
sed -n '/pattern/p' file.txt
awk '/pattern/' file.txt

# show every Nth line
awk 'NR % 3 == 0' file.txt     # every 3rd line
sed -n '0~3p' file.txt          # every 3rd line (GNU)

# number lines
nl file.txt
cat -n file.txt
grep -n "" file.txt

# show file in hex
hexdump -C file.bin
xxd file.bin
od -A x -t x1z file.bin

Conteo de palabras y líneas (wc)

wc (word count) reporta líneas (-l), palabras (-w), bytes (-c), caracteres (-m, respeta la codificación) y la longitud de la línea más larga (-L). Con varios archivos, muestra conteos por archivo y un total. El patrón grep | wc -l cuenta las líneas coincidentes — pero grep -c es más eficiente (sin pipe). Para contar archivos, ls -1 | wc -l es rápido, pero find es más preciso para conteos recursivos.

linux
# count lines, words, and bytes
wc file.txt
#   10   50  300 file.txt
#  lines words bytes

# count lines only
wc -l file.txt

# count words only
wc -w file.txt

# count characters only
wc -m file.txt

# count bytes only
wc -c file.txt

# count the longest line length
wc -L file.txt

# count files in a directory
ls -1 | wc -l
find . -type f | wc -l

# count total lines in multiple files
wc -l *.py

# count matching lines (grep + wc)
grep "error" log.txt | wc -l

# count unique lines
sort file.txt | uniq | wc -l
07

Procesamiento de texto

sed — editor de flujos

sed edita flujos de texto de forma no interactiva. s sustituye (g para global); d elimina; p imprime. -i edita en el sitio (prueba siempre sin -i primero, o usa -i.bak para un respaldo). El delimitador puede ser cualquier carácter — usa | o # para rutas y evitar escapar barras. -E habilita la regex extendida con una sintaxis de grupos de captura más limpia. sed procesa línea por línea.

linux
# substitute (replace first occurrence per line)
sed 's/old/new/' file.txt

# substitute all occurrences (global)
sed 's/old/new/g' file.txt

# case-insensitive (GNU sed)
sed 's/old/new/gi' file.txt

# in-place editing
sed -i 's/old/new/g' file.txt
sed -i.bak 's/old/new/g' file.txt   # keep backup

# delete lines
sed '/^#/d' file.txt           # delete comment lines
sed '/^$/d' file.txt           # delete blank lines
sed '5d' file.txt              # delete line 5
sed '5,10d' file.txt           # delete lines 5-10

# print specific lines
sed -n '10,20p' file.txt       # lines 10-20
sed -n '/pattern/p' file.txt   # matching lines

# different delimiter for paths
sed 's|/usr/local|/opt|g' paths.txt

# extended regex with capture groups
sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/' dates.txt

# multiple commands
sed -e 's/a/A/g' -e 's/b/B/g' file.txt

awk — procesamiento por columnas

awk es un mini lenguaje de programación para datos columnares. $1, $2... son campos; $0 es la línea entera; $NF es el último campo. -F fija el separador de entrada; OFS el de salida. BEGIN corre antes del procesamiento, END después. NR es el número de registro (línea); NF es el conteo de campos. awk es ideal para procesar CSV/TSV, analizar logs y reportes — mucho más potente que cut.

linux
# print columns (default separator: whitespace)
awk '{print $1}' file.txt           # first column
awk '{print $1, $3}' file.txt       # columns 1 and 3
awk '{print $NF}' file.txt          # last column
awk -F: '{print $1}' /etc/passwd    # split on :

# filter and print
awk '$3 > 100' file.txt             # col 3 > 100
awk '$1 == "ERROR" {print $2}' log  # col 2 of ERROR lines
awk 'NR == 5' file.txt              # 5th line only
awk 'NR >= 10 && NR <= 20' file.txt # lines 10-20

# BEGIN and END blocks (sum, average)
awk '{sum += $1} END {print sum}' nums.txt
awk '{sum += $2; count++} END {print sum/count}' data.txt

# field separator and output
awk -F, 'BEGIN {OFS="|"} {print $1, $2}' csv.txt

# count lines matching pattern
awk '/error/ {count++} END {print count}' log

# built-in variables: NR (row), NF (fields), FS, OFS
awk '{print NR, NF, $0}' file.txt

cut y paste

cut extrae campos (-f con -d delimitador) o posiciones de caracteres (-c). Es rápido pero limitado — sin soporte de comillas, así que los CSV con comas entre comillas lo rompen. paste fusiona archivos lado a lado. join combina archivos por un campo común ordenado (como un SQL JOIN). expand/unexpand convierten entre tabulaciones y espacios. Para procesamiento CSV complejo, usa awk o una herramienta dedicada como csvkit.

linux
# cut: extract fields by delimiter
cut -d: -f1 /etc/passwd            # field 1, delimiter :
cut -d, -f2,3 data.csv             # fields 2 and 3

# cut: extract character positions
cut -c1-5 file.txt                 # characters 1-5
cut -c1- file.txt                  # from char 1 to end

# cut: extract bytes (for multibyte)
cut -b1-10 file.txt

# paste: merge files line by line
paste file1.txt file2.txt          # tab-separated
paste -d',' file1.txt file2.txt    # comma-separated

# paste: serial (all lines of file1, then file2)
paste -s file1.txt                 # lines into one line
paste -s -d',' file1.txt file2.txt

# join: combine on a common field
join -t, -1 1 -2 1 file1.csv file2.csv

# expand/unexpand tabs
expand file.txt                    # tabs to spaces
unexpand -a file.txt               # spaces to tabs

sort y uniq

sort ordena líneas (-n numérico, -r inverso, -h legible para humanos, -k campo, -t delimitador). uniq solo elimina duplicados ADYACENTES — pasa siempre primero por sort. uniq -c cuenta; sort -rn da el ranking de frecuencias. comm compara dos archivos ORDENADOS: -12 muestra los comunes, -23 solo los del primero, -13 solo los del segundo. El patrón sort | uniq -c | sort -rn es el pipeline clásico de análisis de frecuencias.

linux
# sort lines
sort file.txt                      # alphabetical
sort -n nums.txt                   # numeric
sort -rn nums.txt                  # reverse numeric
sort -h sizes.txt                  # human-readable (1K, 2M, 3G)
sort -R file.txt                   # random order
sort -u file.txt                   # sort + unique

# sort by field
sort -t: -k3 -n /etc/passwd        # by 3rd field, numeric
sort -t, -k2 data.csv              # by 2nd field

# sort by multiple keys
sort -k1,1 -k2n file.txt           # key1 alpha, key2 numeric

# uniq: filter adjacent duplicates
sort file.txt | uniq               # unique lines
sort file.txt | uniq -c            # count occurrences
sort file.txt | uniq -d            # only duplicates
sort file.txt | uniq -u            # only unique lines

# top 10 most frequent lines
sort file.txt | uniq -c | sort -rn | head -10

# compare two sorted files
comm -12 <(sort a.txt) <(sort b.txt)   # common lines
comm -23 <(sort a.txt) <(sort b.txt)   # only in a
comm -13 <(sort a.txt) <(sort b.txt)   # only in b

tr — traducir caracteres

tr traduce o elimina caracteres (no regex — solo conjuntos de caracteres). -d elimina, -s comprime repeticiones, -c complementa (invierte el conjunto). Es perfecto para conversión de mayúsculas, intercambio de delimitadores y limpieza de datos. tr ',' '\n' convierte un CSV a un valor por línea. tr -cd '0-9' extrae solo dígitos. Ojo: tr trabaja con caracteres, no con cadenas, así que no puede reemplazar patrones de varios caracteres — usa sed para eso.

linux
# translate characters
echo "Hello" | tr 'a-z' 'A-Z'       # HELLO (uppercase)
echo "Hello" | tr 'A-Z' 'a-z'       # hello (lowercase)

# swap characters
echo "abc" | tr 'abc' 'bca'         # bca

# delete characters
echo "hello" | tr -d 'l'            # heo
echo "Hello World" | tr -d ' '      # HelloWorld

# squeeze repeated characters
echo "aaabbbccc" | tr -s 'abc'      # abc
tr -s ' ' < file.txt                # squeeze repeated spaces

# complement (delete everything except)
echo "Hello123" | tr -cd '0-9'      # 123 (keep digits only)
echo "Hello123" | tr -cd 'A-Za-z'   # Hello

# convert delimiter
echo "a,b,c" | tr ',' '\n'          # a\nb\nc (one per line)
echo "a,b,c" | tr ',' '\t'          # tab-separated

# ROT13 cipher
echo "Hello" | tr 'A-Za-z' 'N-ZA-Mn-za-m'

# remove non-printable characters
tr -cd '\11\12\15\40-\176' < file.txt

tee y column

tee reparte la salida entre un archivo y stdout — esencial para registrar en logs dentro de pipelines. sudo tee escribe en archivos que requieren root sin correr el pipeline entero como root. column -t alinea el texto en columnas ordenadas (genial para mostrar CSVs). -s especifica el delimitador de entrada, -o el de salida. fmt y fold reorganizan el texto — fmt une párrafos, fold fuerza el ajuste a un ancho.

linux
# tee: write to file AND stdout
echo "hello" | tee file.txt
echo "hello" | tee -a file.txt       # append

# tee to multiple files
echo "data" | tee f1.txt f2.txt f3.txt

# tee in a pipeline (log while transforming)
ls -la | tee output.txt | grep ".py"

# tee with sudo (write to privileged file)
echo "config" | sudo tee /etc/myapp.conf

# column: format as aligned columns
column -t file.txt
echo -e "a b c\n1 2 3" | column -t

# column with custom delimiter
column -t -s, data.csv
column -t -s: /etc/passwd

# column with specific separator for output
column -t -o " | " file.txt

# fmt: reformat paragraph width
fmt -w 60 file.txt

# fold: wrap lines at width
fold -w 80 file.txt
fold -w 80 -s file.txt   # break at spaces only
08

Permisos y propiedad

Ver permisos

Los permisos son tres tríos: dueño, grupo, otros. Cada posición es r(4), w(2), x(1). Así 755 = rwxr-xr-x, 644 = rw-r--r--. Para directorios, x significa 'puede acceder' (hacer cd), r significa 'puede listar', w significa 'puede crear/eliminar archivos'. stat -c '%a' muestra los permisos octales. El primer carácter de ls -l es el tipo de archivo (- archivo, d dir, l symlink, b bloque, c carácter).

linux
# view file permissions
ls -l file.txt
# -rw-r--r-- 1 user group 1024 Jan 1 10:00 file.txt
#  ^^^ ^^^ ^^^
#  owner group others
#  rwx  r-x  r-x  = 755

# permission breakdown:
# - = regular file, d = directory, l = symlink
# r = read (4), w = write (2), x = execute (1)

# view all files in directory
ls -la

# view permissions recursively
ls -lR /var/www

# view in octal format
stat -c '%a %n' file.txt        # 644 file.txt
stat -c '%a %n' *

# check current umask
umask                           # e.g., 0022

# directory permissions:
# r = list contents
# w = create/delete files
# x = access (cd into) directory

chmod — modo numérico

Notación numérica (octal): cada dígito representa dueño, grupo, otros. r=4, w=2, x=1 — súmalos. 755 (rwxr-xr-x) para directorios y ejecutables; 644 (rw-r--r--) para archivos normales; 600 (rw-------) para archivos privados. Para servidores web, el estándar es dirs=755, files=644. El patrón recursivo basado en find aplica permisos distintos a directorios y archivos — chmod -R no puede hacer eso.

linux
# numeric (octal) notation
chmod 755 script.sh        # rwxr-xr-x
chmod 644 file.txt         # rw-r--r--
chmod 600 secrets.txt      # rw------- (private)
chmod 777 publicdir/       # rwxrwxrwx (DANGEROUS)
chmod 700 ~/.ssh           # rwx------ (for SSH)

# common patterns
chmod 755 directory/       # dirs: owner full, others read+execute
chmod 644 file.txt         # files: owner read+write, others read
chmod 600 config.env       # sensitive files: owner only
chmod 666 shared.txt       # everyone read+write (no execute)
chmod 444 readonly.txt     # everyone read only

# recursive
chmod -R 755 project/
chmod -R 644 *.txt          # won't work; use find

# recursive: dirs 755, files 644 (common web server setup)
find . -type d -exec chmod 755 {} \;
find . -type f -exec chmod 644 {} \;

# permission reference:
# 7=rwx 6=rw 5=rx 4=r 3=wx 2=w 1=x 0=none

chmod — modo simbólico

La notación simbólica es más legible para cambios incrementales: u/g/o/a (quién), +/-/= (acción), r/w/x/X (qué). X (mayúscula) fija ejecución solo para directorios o archivos que ya la tienen — perfecto para chmod recursivo. --reference copia permisos de otro archivo. El sticky bit (+t) en un directorio significa que solo los dueños de archivos pueden eliminar los suyos (usado en /tmp).

linux
# symbolic notation
chmod u+x script.sh        # add execute for user
chmod g-w file.txt         # remove write for group
chmod o+r file.txt         # add read for others
chmod a+x script.sh        # add execute for all (a=all)

# combined changes
chmod u+x,g-w,o=r file.txt # user +x, group -w, others = read only
chmod ug+x file.txt        # add execute for user and group
chmod a=r file.txt         # set everyone to read only

# copy permissions from reference
chmod --reference=template.txt file.txt

# recursive
chmod -R u+rwX,go+rX .     # X = execute only for dirs/executables

# symbolic targets:
# u = user (owner)
# g = group
# o = others
# a = all (default)
# operators: + (add), - (remove), = (set exactly)
# permissions: r, w, x, X (execute if dir or already exec), s (SUID/SGID), t (sticky)

# set sticky bit on directory
chmod +t /tmp/shared
chmod 1777 /tmp/shared

chown y chgrp

chown cambia la propiedad (requiere root o sudo). Formato: dueño:grupo — omite el grupo para cambiar solo el dueño, omite el dueño (con dos puntos) para cambiar solo el grupo. -R recursa en directorios. chgrp es un atajo de chown :grupo. --from solo cambia si el dueño actual coincide (condicional). Para servidores web, chown -R www-data:www-data es el estándar. Usa siempre -h con symlinks para cambiar el enlace, no el objetivo.

linux
# change owner
chown alice file.txt
chown alice file1.txt file2.txt

# change owner and group
chown alice:developers file.txt
chown alice:developers project/

# recursive
chown -R alice:developers project/

# change group only
chgrp developers file.txt
chown :developers file.txt        # alternative

# verbose
chown -v alice file.txt

# reference (copy ownership from another file)
chown --reference=reference.txt file.txt

# change ownership only if currently owned by specific user
chown --from=bob alice file.txt

# symbolic links (by default, changes the link target)
chown -h alice symlink            # change the link itself

# common patterns
chown -R www-data:www-data /var/www
chown root:root /etc/sudoers

# view ownership
ls -l file.txt                    # shows owner and group
stat -c '%U:%G' file.txt          # just owner:group

umask

umask fija los permisos por defecto para archivos y directorios recién creados. Es una máscara — los bits se restan del valor por defecto (666 para archivos, 777 para dirs). Valores comunes: 022 (estándar, archivos 644/dirs 755), 077 (privado, archivos 600/dirs 700), 002 (compartido por grupo, archivos 664/dirs 775). Fíjalo en ~/.bashrc o /etc/profile para persistencia. Ojo: umask no puede AÑADIR permisos, solo quitarlos.

linux
# view current umask
umask                  # e.g., 0022
umask -S               # symbolic: u=rwx,g=rx,o=rx

# set umask
umask 022              # new files: 644, dirs: 755
umask 077              # new files: 600, dirs: 700 (private)
umask 002              # new files: 664, dirs: 775 (group-writable)

# how umask works:
# default file perms: 666 (rw-rw-rw-)
# default dir perms:  777 (rwxrwxrwx)
# umask is SUBTRACTED (mask removed)
# umask 022: file = 666-022 = 644, dir = 777-022 = 755
# umask 077: file = 666-077 = 600, dir = 777-077 = 700

# set permanently: add to ~/.bashrc
echo 'umask 022' >> ~/.bashrc

# for security-sensitive environments
umask 077              # only owner can access new files

# for shared group work
umask 002              # group members can write new files

# umask does not affect execute bit on files
# (files are created without execute by default)

Permisos especiales (SUID, SGID, sticky)

SUID (4xxx): el programa corre con los privilegios del dueño del archivo — passwd necesita esto para modificar /etc/shadow como root. SGID (2xxx): en ejecutables, corre con privilegios de grupo; en directorios, los archivos nuevos heredan el grupo del directorio (útil para proyectos compartidos). Sticky bit (1xxx): en directorios, solo el dueño del archivo (o el dueño del dir/root) puede eliminar archivos — usado en /tmp. Audita los archivos SUID/SGID regularmente, pues son vectores de escalada de privilegios.

linux
# SUID (Set User ID): runs as file owner
chmod u+s /usr/bin/passwd       # 4755 -> rwsr-xr-x
chmod 4755 myprogram

# SGID (Set Group ID): runs as group owner
chmod g+s /shared/dir           # dirs: new files inherit group
chmod 2755 /shared/project

# Sticky bit: only file owner can delete
chmod +t /tmp                   # 1777 -> rwxrwxrwt
chmod 1777 /shared/upload

# view special permissions
ls -l /usr/bin/sudo
# -rwsr-xr-x  (s in user position = SUID)
ls -ld /tmp
# drwxrwxrwt  (t in others position = sticky)

# find SUID files (security audit)
find / -perm -4000 -type f 2>/dev/null

# find SGID files
find / -perm -2000 -type f 2>/dev/null

# find sticky directories
find / -perm -1000 -type d 2>/dev/null

# numeric special bits:
# 1 = sticky, 2 = SGID, 4 = SUID
# chmod 4755 = SUID + 755
# chmod 2755 = SGID + 755
# chmod 1777 = sticky + 777

# uppercase S/T means execute bit is NOT set (usually an error)
# rws = SUID + execute, rwS = SUID without execute
09

Usuarios y grupos

Gestión de usuarios

useradd crea usuarios (de bajo nivel; adduser es un envoltorio más amigable en Debian). -m crea el directorio home; -s fija el shell; -c fija el nombre completo; -G añade a grupos suplementarios. usermod -aG añade a grupos sin quitar los existentes (usa siempre -a con -G). userdel -r elimina el directorio home. passwd fija contraseñas. /etc/passwd guarda la información de usuarios; /etc/shadow guarda los hashes de contraseñas.

linux
# add a new user
sudo useradd -m -s /bin/bash alice
# -m: create home directory
# -s: specify login shell

# add user with full options
sudo useradd -m -s /bin/bash -c "Alice Smith" -G sudo,docker alice

# set password
sudo passwd alice

# delete a user
sudo userdel alice
sudo userdel -r alice         # remove home directory too

# modify user
sudo usermod -aG docker alice   # append to group (-a = append)
sudo usermod -s /bin/zsh alice  # change shell
sudo usermod -L alice           # lock account
sudo usermod -U alice           # unlock account
sudo usermod -l newname oldname # rename user

# view user info
id alice                      # uid, gid, groups
finger alice                  # detailed info (if installed)

# change login shell
chsh -s /bin/zsh

# list all users
cat /etc/passwd | cut -d: -f1
getent passwd | cut -d: -f1

Gestión de grupos

Los grupos organizan usuarios para acceso compartido. groupadd/groupdel/groupmod gestionan grupos. usermod -aG (añadir a grupo) es la forma estándar de añadir un usuario — sin -a, reemplazarías la totalidad de sus grupos suplementarios. gpasswd es una herramienta alternativa. /etc/group guarda las definiciones de grupos. newgrp arranca un shell nuevo con un grupo primario distinto (útil al crear archivos que deban ser propiedad del grupo).

linux
# create a group
sudo groupadd developers

# create group with specific GID
sudo groupadd -g 2000 developers

# delete a group
sudo groupdel developers

# modify group
sudo groupmod -n devs developers    # rename
sudo groupmod -g 2001 developers    # change GID

# add user to group
sudo usermod -aG docker alice       # append to group
sudo gpasswd -a alice developers    # alternative

# remove user from group
sudo gpasswd -d alice developers
sudo deluser alice developers       # Debian/Ubuntu

# list groups
cat /etc/group | cut -d: -f1
getent group

# view groups for a user
groups alice
id alice

# set group administrator
sudo gpasswd -A alice developers

# temporarily switch primary group
newgrp developers                  # new shell with group as primary

# view group members
getent group developers            # lists members
grep developers /etc/group

Gestión de contraseñas

passwd cambia contraseñas. -l bloquea una cuenta (añade ! al hash); -u desbloquea. -e fuerza un cambio de contraseña en el próximo login. chage gestiona las políticas de envejecimiento de contraseñas: -M (días máximos), -m (días mínimos), -W (días de aviso), -E (fecha de expiración). Los hashes de contraseñas se guardan en /etc/shadow (legible solo por root), no en /etc/passwd. Una buena política de contraseñas exige cambios regulares con requisitos de complejidad.

linux
# change your own password
passwd

# change another user's password (requires root)
sudo passwd alice

# set password interactively
sudo passwd alice
# Enter new password: ******
# Retype new password: ******

# lock/unlock a password
sudo passwd -l alice          # lock (prepends !)
sudo passwd -u alice          # unlock

# force password change on next login
sudo passwd -e alice
sudo chage -d 0 alice

# set password aging policy
sudo chage -M 90 alice        # max 90 days
sudo chage -m 7 alice         # min 7 days between changes
sudo chage -W 7 alice         # warn 7 days before expiry
sudo chage -E 2025-12-31 alice # expire on date

# view password aging info
chage -l alice

# password quality: /etc/login.defs
# PASS_MAX_DAYS   90
# PASS_MIN_DAYS   7
# PASS_MIN_LEN    12
# PASS_WARN_AGE   7

# check password hash in /etc/shadow
sudo grep alice /etc/shadow

Comandos de información de usuario

whoami muestra tu nombre de usuario actual; id muestra uid/gid/grupos. who lista cada usuario conectado; w añade qué están ejecutando. last muestra el historial de logins desde /var/log/wtmp; lastb los intentos fallidos desde /var/log/btmp. getent passwd consulta la base de datos de usuarios (incluido LDAP si está configurado). Estos comandos son esenciales para la administración del sistema y la auditoría de actividad de usuarios.

linux
# who am I
whoami                       # current username
id                           # uid, gid, groups
echo $USER                   # from environment

# who is logged in
who                          # all logged-in users
w                            # detailed (what they're doing)
users                        # just usernames

# last logins
last                         # recent logins
last -n 10                   # last 10 logins
last alice                   # alice's logins
last reboot                  # reboot history

# failed login attempts
lastb                       # bad login attempts (requires root)

# user account info
finger alice                 # detailed info (if installed)
getent passwd alice          # /etc/passwd entry

# group membership
groups                       # your groups
groups alice                 # alice's groups
id alice                     # uid, gid, all groups

# check if user exists
id alice && echo "exists" || echo "not found"
getent passwd alice

# list all users with home directories
getent passwd | awk -F: '{print $1, $6}'

su y sudo

su cambia de usuario (necesita la contraseña del usuario objetivo); sudo ejecuta un comando como root (necesita tu contraseña). su - arranca un shell de login (carga el perfil del usuario objetivo). sudo es preferido por auditoría: los comandos se registran en /var/log/auth.log. visudo edita /etc/sudoers con seguridad (valida la sintaxis antes de guardar). Las reglas NOPASSWD son convenientes pero reducen la seguridad. sudo !! repite el último comando como root — el clásico arreglo de 'me olvidé sudo'.

linux
# switch to root
su                           # needs root password
su -                         # login shell (loads root's profile)

# switch to another user
su - alice                   # login as alice
su alice                     # as alice, keep current env

# run a single command as root
sudo command
sudo apt update

# run a command as another user
sudo -u alice command
sudo -u www-data php script.php

# edit a file as root
sudo vim /etc/fstab
sudoedit /etc/fstab          # safer alternative

# sudo with environment
sudo -E command              # preserve environment variables

# list sudo privileges
sudo -l                      # what can I run?
sudo -l -U alice             # what can alice run?

# sudo configuration
sudo visudo                  # edit /etc/sudoers safely
# /etc/sudoers.d/ for individual rules
# alice ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx

# run previous command as root
sudo !!                      # classic fix for forgetting sudo

# sudo timeout: 5 min by default
sudo -v                      # extend timeout
sudo -k                      # kill timeout (require password next time)
10

Gestión de procesos

ps — listar procesos

ps muestra una instantánea de los procesos. aux (BSD) y -ef (System V) son los dos estilos comunes. El patrón 'ps aux | grep' está por todas partes (usa el truco [n]ginx para no coincidir con grep). pstree muestra las relaciones padre-hijo. --sort=-%mem ordena por uso de memoria (encuentra los devoradores de recursos). Estados clave: R=corriendo, S=dormido, D=sueño ininterrumpible, Z=zombie, T=detenido. Para monitoreo en tiempo real, usa top o htop.

linux
# list processes (BSD style)
ps aux                       # all processes, full format
ps aux | grep nginx          # find specific process

# list processes (System V style)
ps -ef                       # all processes
ps -ef | grep python

# list processes in a tree
ps auxf                      # forest/tree view
pstree                       # dedicated tree tool
pstree -p                    # with PIDs

# show specific user's processes
ps -u alice

# show process by PID
ps -p 1234
ps -p 1234 -o pid,ppid,cmd

# custom output format
ps -eo pid,ppid,user,%mem,%cpu,cmd --sort=-%mem | head

# show threads
ps -eLf | grep java          # show threads (LWP)

# ps output columns:
# PID    process ID
# PPID   parent process ID
# USER   owner
# %CPU   CPU usage
# %MEM   memory usage
# VSZ    virtual memory size (KB)
# RSS    resident set size (KB)
# STAT   process state (R=running, S=sleeping, Z=zombie)
# START  start time
# TIME   CPU time
# CMD    command

top y htop

top es el monitor de procesos en tiempo real integrado. Comandos clave: M (ordenar por memoria), P (ordenar por CPU), k (matar), q (salir). El modo -b (batch) da salida de texto para scripting. htop es una alternativa superior (con color, desplazable, soporte de ratón, vista de árbol) — instala con apt install htop. glances ofrece una visión completa del sistema. Para encontrar qué consume recursos, top/htop ordenado por %CPU o %MEM es la herramienta de referencia.

linux
# real-time process monitor
top

# top interactive commands:
#   P       sort by CPU usage
#   M       sort by memory usage
#   N       sort by PID
#   T       sort by running time
#   k       kill a process (enter PID)
#   r       renice (change priority)
#   1       show per-CPU stats
#   u       filter by user
#   H       show threads
#   c       toggle full command path
#   W       write settings to ~/.toprc
#   q       quit

# run top with specific sorting
top -o %MEM                  # sort by memory
top -o %CPU                  # sort by CPU

# batch mode (for scripts)
top -b -n 1                  # one snapshot
top -b -n 1 | head -20       # top 20 processes

# monitor specific user
top -u alice

# htop: better interactive viewer (install separately)
htop                         # colorized, mouse support
htop -p 1234                 # monitor specific PID

# glance: alternative system monitor
glances                      # needs installation

kill y killall

kill envía señales por PID; killall/pkill por nombre. Prueba siempre SIGTERM (por defecto) primero — permite una limpieza elegante. SIGKILL (-9) es contundente e inmediato; el proceso no puede capturarlo, así que puede dejar recursos en mal estado. Úsalo como último recurso. pkill -f coincide con la línea de comandos completa. kill -l lista todas las señales. El patrón 'kill; sleep; kill -9' da al proceso la oportunidad de limpiarse antes de forzar.

linux
# send signal to a process by PID
kill 12345                   # SIGTERM (graceful, default)
kill -15 12345               # SIGTERM explicitly
kill -9 12345                # SIGKILL (force, cannot be caught)
kill -HUP 12345              # SIGHUP (reload config)

# kill by name
killall nginx                # kill all nginx processes
pkill -f "python app.py"     # match full command line
pkill -u alice               # kill all of alice's processes

# common signals
kill -l                      # list all signals
# SIGTERM (15)  - graceful termination (default)
# SIGKILL (9)   - force kill (cannot be caught)
# SIGINT (2)    - interrupt (Ctrl+C)
# SIGHUP (1)    - hangup (often reload config)
# SIGSTOP (19)  - pause (cannot be caught)
# SIGCONT (18)  - resume
# SIGUSR1/USR2  - user-defined signals

# graceful then forceful
kill 12345; sleep 2; kill -9 12345 2>/dev/null

# kill background job
kill %1                      # kill job 1

# find and kill by port
fuser -k 8080/tcp            # kill process using port 8080
kill $(lsof -t -i:8080)      # alternative

Trabajos en segundo plano y control de trabajos

Añadir & corre en segundo plano. jobs lista los trabajos activos; fg/bg mueven entre primer y segundo plano. Ctrl+Z suspende el trabajo en primer plano. wait bloquea hasta que los trabajos en segundo plano terminen. nohup y disown evitan que el proceso muera al cerrar la terminal — nohup para comandos nuevos, disown para los ya en marcha. Para trabajo persistente, usa tmux o screen.

linux
# run in background (append &)
sleep 100 &
# [1] 12345   (job 1, PID 12345)

# list jobs
jobs
jobs -l                      # with PIDs

# bring to foreground / send to background
fg                           # foreground the current job
fg %1                        # foreground job 1
bg %2                        # background job 2

# Ctrl+Z: suspend foreground job, then resume in background
# Ctrl+Z sends SIGTSTP
bg                           # resume in background

# wait for background jobs
wait                         # wait for all
wait $!                      # wait for last background job
wait 12345                   # wait for specific PID

# disown: detach from shell (survives logout)
long_task &
disown %1

# nohup: run immune to hangups (survives logout)
nohup ./script.sh > output.log 2>&1 &

# run at lower priority
nice -n 10 ./backup.sh &

# parallel execution
cmd1 & cmd2 & cmd3 &
wait                         # wait for all to finish

nice y renice — prioridad de procesos

Los valores de nice van de -20 (máxima prioridad) a 19 (mínima). Los usuarios normales solo pueden bajar la prioridad (valores positivos); root puede subirla (negativos). El valor por defecto es 0. nice arranca un proceso con una prioridad; renice cambia uno en marcha. Para tareas intensivas en I/O, ionice controla la prioridad de I/O de disco (clases: 1=tiempo real, 2=mejor esfuerzo, 3=inactivo). cpulimit limita el uso de CPU — útil para tareas en segundo plano que no deben estorbar.

linux
# nice: start a process with adjusted priority
nice ./script.sh             # default: +10 (lower priority)
nice -n 10 ./backup.sh       # priority 10 (lower)
nice -n -5 ./critical.sh     # higher priority (needs root)

# renice: change priority of running process
renice 5 -p 12345            # PID 12345 to priority 5
renice 10 -u alice           # all of alice's processes
renice -5 -p 12345           # higher priority (needs root)

# view priorities
ps -l                        # NI column shows nice value
top                          # NI column

# nice values:
#  -20  highest priority (most favorable)
#    0  default
#   19  lowest priority (least favorable)
# only root can set negative (higher) priority

# practical: run CPU-intensive task at low priority
nice -n 19 make -j4 &

# ionice: I/O priority
ionice -c 3 ./backup.sh      # idle I/O priority
ionice -c 2 -n 7 ./backup.sh # best-effort, low

# cpulimit: limit CPU usage (install separately)
cpulimit -p 12345 -l 50      # limit to 50% CPU

Sistema de archivos /proc

/proc es un sistema de archivos virtual (sin almacenamiento en disco) que expone información del kernel y de los procesos. /proc/PID/ contiene datos por proceso. /proc/cpuinfo y /proc/meminfo muestran el hardware. /proc/sys/ contiene parámetros ajustables del kernel (equivalente a sysctl). Escribir en /proc/sys/ cambia la configuración del kernel de inmediato (pero usa sysctl para persistencia). /proc/mounts muestra los sistemas de archivos montados actualmente. Es la interfaz principal entre el espacio de usuario y el kernel.

linux
# /proc: virtual filesystem with kernel/process info
# process info by PID
cat /proc/1234/status        # process status
cat /proc/1234/cmdline       # command line (null-separated)
ls -l /proc/1234/fd/         # open file descriptors
cat /proc/1234/environ       # environment variables (null-separated)

# system info
cat /proc/cpuinfo            # CPU information
cat /proc/meminfo            # memory information
cat /proc/version            # kernel version
cat /proc/uptime             # uptime in seconds
cat /proc/loadavg            # load average

# network info
cat /proc/net/tcp            # TCP connections
cat /proc/net/dev            # network interface stats

# kernel settings
ls /proc/sys/                # sysctl parameters
cat /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv4/ip_forward  # enable IP forwarding

# mount info
cat /proc/mounts             # mounted filesystems
cat /proc/filesystems        # supported filesystem types

# view process memory maps
cat /proc/1234/maps          # memory mappings
pmap 1234                    # formatted version
11

Información del sistema

uname y hostname

uname muestra información del kernel (-a para el detalle completo). hostname muestra/fija el nombre del sistema — hostnamectl set-hostname lo hace persistente. /etc/os-release es la forma estándar de identificar la distribución (funciona en cualquier Linux moderno). lscpu da información detallada de la arquitectura de CPU. dmidecode lee datos de BIOS/SMBIOS. Estos comandos son el primer paso de cualquier tarea de administración para entender con qué estás trabajando.

linux
# kernel and system info
uname                        # kernel name: Linux
uname -a                     # all info
uname -r                     # kernel release: 5.15.0-91-generic
uname -m                     # machine hardware: x86_64
uname -n                     # network node (hostname)
uname -p                     # processor type
uname -o                     # operating system: GNU/Linux

# hostname
hostname                     # current hostname
hostname -f                  # fully qualified domain name
hostname -I                  # all IP addresses

# set hostname (persistent)
sudo hostnamectl set-hostname myserver

# distribution info
cat /etc/os-release          # distro name and version
lsb_release -a               # Ubuntu/Debian specific
cat /etc/debian_version      # Debian version

# kernel version
cat /proc/version
dmesg | grep "Linux version"

# system architecture
arch                         # e.g., x86_64
dpkg --print-architecture    # Debian/Ubuntu

# BIOS/hardware info
sudo dmidecode -t system     # system info
sudo dmidecode -t bios       # BIOS info
lshw                         # hardware list
lscpu                        # CPU details

df — espacio libre en disco

df reporta el espacio en disco de los sistemas de archivos. -h (legible para humanos) es esencial. -T muestra el tipo de sistema de archivos (ext4, xfs, btrfs, tmpfs, nfs). -i muestra el uso de inodes — puedes quedarte sin inodes antes que sin espacio (común con muchos archivos pequeños). -x excluye tipos de sistemas de archivos (útil para filtrar los virtuales como tmpfs). Cuando el disco esté lleno, revisa primero df -h y luego usa du para encontrar los directorios que consumen espacio.

linux
# show disk space for all filesystems
df                           # all mounted filesystems
df -h                        # human-readable (K, M, G)
df -H                        # SI units (KB, MB, GB)

# specific filesystem
df -h /home                  # space for /home
df -h /dev/sda1              # specific device

# filesystem type
df -T                        # show type (ext4, xfs, tmpfs, etc.)
df -Th                       # human-readable + type

# exclude specific types
df -x tmpfs -x devtmpfs      # exclude virtual filesystems

# inodes (file count limit)
df -i                        # inode usage
df -ih                       # human-readable inode usage

# local filesystems only
df -l

# show total
df -h --total

# find the filesystem using the most space
df -h | sort -rh -k5 | head

# real-time: watch disk space
watch -n 5 df -h

du — uso de disco

du mide el uso de disco. -s (resumen) muestra solo totales; -h es legible para humanos. du -sh */ da los tamaños de los subdirectorios inmediatos. sort -rh ordena por valores legibles. --apparent-size muestra el tamaño lógico del archivo frente a los bloques reales. --exclude se salta patrones. Para encontrar qué consume el disco, el flujo es: df -h (qué sistema de archivos está lleno) → du -sh * (qué directorio) → find (qué archivos).

linux
# size of current directory
du -sh .

# size of specific directories
du -sh /var/log /tmp /home

# size of all immediate subdirectories
du -sh */
du -sh * | sort -rh          # sorted largest first

# top 10 largest directories
du -sh * | sort -rh | head -10

# maximum depth
du -h -d 1                   # depth 1 only
du -h --max-depth=2

# include hidden files
du -sh .[!.]*

# apparent size (logical, not disk blocks)
du -sh --apparent-size file

# exclude patterns
du -sh --exclude='*.log' .
du -sh --exclude=node_modules .

# total of multiple directories
du -sh /var/log /var/lib /tmp | tail -1

# find largest files (not just directories)
find / -type f -exec ls -lhS {} + 2>/dev/null | head -10
find . -type f -printf '%s %p\n' | sort -rn | head -10

# sort all subdirectories by size
du -sh ./*/* | sort -rh | head -20

free — uso de memoria

free muestra el uso de memoria. La columna 'available' es la más significativa — estima cuánta memoria hay disponible para arrancar aplicaciones nuevas sin hacer swap. Linux usa intencionalmente la RAM libre como caché (buff/cache) para acelerar las lecturas de disco; se reclama bajo demanda, así que un 'free' bajo es normal. El uso de swap debería monitorearse — un uso alto de swap con intercambio activo (si/so en vmstat) indica presión de memoria.

linux
# show memory usage
free                         # in KB
free -h                      # human-readable
free -m                      # in MB
free -g                      # in GB

# continuous update
free -h -s 1                 # update every 1 second
watch -n 1 free -h           # alternative

# output:
#               total   used   free   shared  buff/cache  available
# Mem:           16G     4G     2G     0.5G       10G          11G
# Swap:          8G      0G     8G

# detailed memory info
cat /proc/meminfo

# key fields:
# total       total RAM
# used        used by applications
# free        completely free
# buff/cache  kernel buffers and page cache
# available   estimate of memory available for new apps

# IMPORTANT: Linux uses free RAM for cache
# 'available' is more meaningful than 'free'
# Cache is reclaimed on demand, so don't panic if 'free' is low

# swap info
swapon --show                # show swap devices
cat /proc/swaps

# clear cache (requires root, use with caution)
sudo sysctl vm.drop_caches=3   # free pagecache, dentries, inodes

# process memory usage
ps aux --sort=-%mem | head -10  # top memory consumers

uptime y carga del sistema

uptime muestra cuánto lleva el sistema en marcha y la carga media (promedios de 1/5/15 minutos). La carga media representa el número promedio de procesos esperando CPU — debería estar generalmente por debajo del número de núcleos de CPU. vmstat muestra estadísticas de CPU, memoria e I/O en tiempo real — la columna 'r' (procesos ejecutables) y 'si/so' (swap entrada/salida) son indicadores clave. iostat y sar (del paquete sysstat) proporcionan datos detallados de I/O e históricos.

linux
# system uptime and load average
uptime
# 10:30:00 up 5 days,  3:21,  2 users,  load average: 0.50, 0.35, 0.25

# load average: 1min, 5min, 15min
#   = average number of processes waiting for CPU
#   rule of thumb: should be < number of CPU cores

# check CPU count
nproc                         # number of CPU cores
lscpu | grep "^CPU(s):"

# detailed load and context switches
cat /proc/loadavg
# 0.50 0.35 0.25 2/500 12345

# vmstat: system stats over time
vmstat 1 5                    # every 1 second, 5 times
# procs --memory-- ---swap-- -----io---- -system-- ------cpu-----
# r  b   swpd   free   buff  cache  si  so    bi    bo   in   cs us sy id wa

# iostat: I/O statistics (needs sysstat package)
iostat 1                      # every 1 second
iostat -x 1                   # extended stats

# mpstat: per-CPU statistics
mpstat -P ALL 1

# sar: historical system activity
sar -u                        # CPU usage history
sar -r                        # memory usage history

# who is logged in
who
w                             # with what they're doing
12

Redes

ping y traceroute

ping prueba la alcanzabilidad y mide la latencia usando ICMP echo. -c limita el conteo (si no corre para siempre). traceroute muestra cada salto hasta el destino — útil para diagnosticar dónde falla la conectividad. mtr combina traceroute con ping continuo (excelente para diagnosticar problemas intermitentes). dig consulta registros DNS (más detallado que nslookup). nc (netcat) -z prueba si un puerto TCP está abierto sin enviar datos.

linux
# test connectivity
ping google.com
ping -c 4 google.com         # 4 packets then stop
ping -i 0.5 google.com       # 0.5s interval
ping -W 2 google.com         # 2s timeout per packet

# ping with timestamp
ping -D google.com           # unix timestamps

# check if host is reachable
ping -c 1 -W 1 host && echo "up" || echo "down"

# trace network path
traceroute google.com
traceroute -n google.com     # no DNS resolution (faster)
mtr google.com               # traceroute + ping (continuous)

# trace with TCP (bypasses ICMP blocking)
tcptraceroute google.com 443

# DNS lookup
dig example.com
dig +short example.com       # just the IP
dig MX example.com           # mail records
dig NS example.com           # name servers
dig @8.8.8.8 example.com     # specific DNS server

# alternative DNS tools
nslookup example.com
host example.com
host -t MX example.com

# check open ports
nc -zv google.com 443        # check if port 443 is open
nc -zv google.com 80 443 22  # check multiple ports

netstat y ss

ss es el reemplazo moderno de netstat — más rápido y detallado. -tlnp muestra los puertos TCP en escucha con nombres de proceso (necesita root para -p). Para encontrar qué usa un puerto: ss -tlnp | grep :PUERTO o lsof -i :PUERTO. ip reemplaza a ifconfig/route (del paquete iproute2). Clave: -n evita la resolución DNS (mucho más rápido). Comprueba 'state established' para las conexiones activas. netstat está obsoleto pero sigue estando muy disponible.

linux
# ss: modern socket statistics (replaces netstat)
ss -tlnp                     # listening TCP ports + process
ss -tunap                    # all TCP/UDP connections
ss -s                        # socket summary

# netstat: classic network statistics
netstat -tlnp                # listening TCP ports
netstat -tunap               # all connections
netstat -rn                  # routing table
netstat -i                   # interface statistics

# common ss/netstat flags:
# -t  TCP
# -u  UDP
# -l  listening sockets only
# -n  numeric (no DNS resolution, faster)
# -a  all sockets
# -p  show process using socket (needs root)
# -r  routing table

# find what's listening on a port
ss -tlnp | grep :80
lsof -i :8080                # alternative

# check established connections
ss -tn state established

# show all connections to a specific host
ss -tn dst google.com

# view network interfaces
ip addr                      # modern
ip a                         # short form
ifconfig                     # legacy

# view routing table
ip route                     # modern
route -n                     # legacy

# view interface statistics
ip -s link
ifconfig eth0

curl — cliente HTTP

curl es el cliente HTTP esencial de la línea de comandos. -X fija el verbo; -d envía datos POST; -H fija headers; -L sigue redirecciones; -O guarda con el nombre del archivo remoto; -s es silencioso (para scripting); -w '%{http_code}' extrae solo el código de estado. Para APIs JSON, combina -H 'Content-Type: application/json' con -d. -u aporta autenticación básica. Para probar APIs REST, curl es el estándar universal.

linux
# basic GET request
curl https://api.example.com/data

# save to file
curl -O https://example.com/file.zip     # save with remote filename
curl -o file.zip https://example.com/file.zip  # custom name

# follow redirects
curl -L https://short.url/abc

# HTTP methods
curl -X POST https://api.example.com/users
curl -X PUT -d '{"name":"Alice"}' https://api.example.com/users/1
curl -X DELETE https://api.example.com/users/1

# send data
curl -d "name=Alice&age=30" https://api.example.com/form
curl -H "Content-Type: application/json" \
     -d '{"name":"Alice"}' https://api.example.com/users

# headers
curl -H "Authorization: Bearer TOKEN" \
     -H "Accept: application/json" \
     https://api.example.com/data

# verbose / headers only
curl -v https://example.com                # verbose
curl -I https://example.com                # headers only

# authentication
curl -u user:pass https://api.example.com  # basic auth
curl --netrc-file ~/.netrc https://...     # netrc

# download with progress bar
curl --progress-bar -O https://example.com/largefile.iso

# get HTTP status code only
curl -s -o /dev/null -w "%{http_code}" https://example.com

# retry on failure
curl --retry 3 --retry-delay 5 https://example.com

# pass query parameters
curl "https://api.example.com/search?q=linux&page=2"

wget — descargar archivos

wget descarga archivos de forma no interactiva. -c reanuda descargas interrumpidas (esencial para archivos grandes). -m espeja sitios web (con -k para conversión de enlaces). -r recursa con -l para profundidad. -i lee URLs de un archivo. wget es mejor que curl para descargas recursivas/espejo y para reanudar — curl usa -C - para reanudar. --limit-rate limita el ancho de banda. wget maneja redirecciones y cookies automáticamente.

linux
# download a file
wget https://example.com/file.zip

# download with custom name
wget -O myfile.zip https://example.com/file.zip

# download in background
wget -b https://example.com/largefile.iso

# resume interrupted download
wget -c https://example.com/largefile.iso

# mirror a website
wget -m https://example.com
wget -m -k -K -E https://example.com  # convert links for local viewing

# recursive download (limited depth)
wget -r -l 2 https://example.com

# download all files of a type
wget -r -A pdf https://example.com/documents/

# continue and retry
wget -t 5 --waitretry=10 https://example.com/file.zip

# quiet mode (no output)
wget -q https://example.com/file.zip

# download from a list of URLs
wget -i urls.txt

# authentication
wget --user=user --password=pass https://example.com/protected

# set user agent
wget --user-agent="Mozilla/5.0" https://example.com

# limit download speed
wget --limit-rate=200k https://example.com/file.zip

# ignore certificate errors
wget --no-check-certificate https://example.com/file.zip

ip y ifconfig

ip (de iproute2) es el reemplazo moderno de ifconfig/route. ip a muestra direcciones; ip link muestra la capa 2; ip route muestra la tabla de enrutado. Los cambios con ip son temporales (se pierden al reiniciar) — para persistencia, edita /etc/netplan/ (Ubuntu), /etc/network/interfaces (Debian), o usa nmcli (NetworkManager). ifconfig está obsoleto pero sigue usándose mucho. Para inalámbrico, usa iw/iwconfig.

linux
# view network interfaces (modern)
ip addr show                  # all interfaces
ip a                          # short form
ip a show eth0                # specific interface

# view link status
ip link show
ip -s link show eth0          # with statistics

# bring interface up/down
sudo ip link set eth0 up
sudo ip link set eth0 down

# assign IP address
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip addr del 192.168.1.100/24 dev eth0

# routing table
ip route show
ip route                      # short form
sudo ip route add default via 192.168.1.1

# view ARP table
ip neigh                      # neighbors (ARP)
arp -a                        # legacy

# DNS configuration
cat /etc/resolv.conf

# ifconfig (legacy, still common)
ifconfig                      # all interfaces
ifconfig eth0                 # specific interface
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0 up

# change MAC address
sudo ip link set dev eth0 address 00:11:22:33:44:55

# view wireless info
iwconfig                      # wireless interfaces
iw list                       # wireless capabilities

# network manager (desktop)
nmcli device status
nmcli connection show

Consulta DNS (dig, nslookup)

dig es la herramienta de consulta DNS más potente. +short da salida concisa. Tipos de registro comunes: A (IPv4), AAAA (IPv6), MX (correo), NS (servidores de nombres), TXT (texto/SPF), CNAME (alias). @servidor consulta un servidor DNS concreto. -x hace búsquedas inversas (IP a hostname). +trace muestra la ruta de resolución completa desde los servidores raíz. host es una alternativa más simple. Las comprobaciones de propagación DNS comparan resultados entre varios servidores.

linux
# dig: detailed DNS lookup
dig example.com
dig +short example.com        # just the IP address
dig example.com A             # A record (IPv4)
dig example.com AAAA          # AAAA record (IPv6)
dig example.com MX            # mail exchange
dig example.com NS            # name servers
dig example.com TXT           # TXT records (SPF, etc.)
dig example.com SOA           # start of authority

# query specific DNS server
dig @8.8.8.8 example.com
dig @1.1.1.1 example.com MX

# reverse DNS lookup
dig -x 1.2.3.4
dig -x 8.8.8.8 +short

# trace DNS resolution path
dig +trace example.com

# JSON output (for scripting)
dig +json example.com

# nslookup: simpler alternative
nslookup example.com
nslookup example.com 8.8.8.8   # use specific server

# host: concise output
host example.com               # IP address
host -t MX example.com        # mail records
host -t NS example.com        # name servers
host 8.8.8.8                   # reverse lookup

# check DNS propagation
# compare results from multiple servers
for dns in 8.8.8.8 1.1.1.1 9.9.9.9; do
    echo "=== $dns ==="
    dig @$dns example.com +short
done

# flush DNS cache
sudo systemd-resolve --flush-caches   # systemd
sudo resolvectl flush-caches          # newer systemd
13

Gestión de paquetes

apt (Debian/Ubuntu)

apt es el frontend amigable de dpkg/apt-get (Debian/Ubuntu). Ejecuta siempre apt update antes de install/upgrade para refrescar la lista de paquetes. upgrade conserva los paquetes; full-upgrade puede eliminar paquetes para resolver dependencias. purge elimina los archivos de configuración. autoremove limpia las dependencias huérfanas. dpkg -S encuentra qué paquete posee un archivo. apt-mark hold impide que un paquete se actualice (útil para versiones fijadas).

linux
# update package list
sudo apt update

# upgrade installed packages
sudo apt upgrade             # upgrade without removing
sudo apt full-upgrade        # upgrade, may remove packages
sudo apt dist-upgrade        # alias for full-upgrade

# install packages
sudo apt install nginx
sudo apt install nginx=1.18* # specific version
sudo apt install -y nginx    # no prompt

# remove packages
sudo apt remove nginx        # remove but keep config
sudo apt purge nginx         # remove including config
sudo apt autoremove          # remove unused dependencies
sudo apt clean               # clean downloaded packages

# search for packages
apt search nginx
apt-cache search web server

# show package info
apt show nginx
apt-cache policy nginx       # available versions

# list installed packages
apt list --installed
dpkg -l | grep nginx

# list files installed by a package
dpkg -L nginx
dpkg -S /usr/bin/curl        # which package owns a file

# add PPA (Ubuntu)
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

# hold package (prevent upgrade)
sudo apt-mark hold nginx
sudo apt-mark unhold nginx

dnf/yum (RHEL/Fedora/CentOS)

dnf reemplaza a yum en Fedora/RHEL/CentOS 8+ modernos. Los comandos son similares. dnf provides (o yum provides) encuentra qué paquete proporciona un archivo — esencial para hallar dependencias faltantes. rpm -ql lista los archivos de un paquete instalado; rpm -qf encuentra el dueño de un archivo. EPEL aporta paquetes adicionales para RHEL/CentOS. dnf groupinstall instala grupos de paquetes (como Development Tools). yum sigue funcionando como symlink a dnf en muchos sistemas.

linux
# dnf: modern Fedora/RHEL/CentOS
sudo dnf install nginx
sudo dnf update              # update all packages
sudo dnf upgrade             # same as update
sudo dnf remove nginx

# search
dnf search nginx
dnf list available           # all available packages
dnf list installed           # installed packages

# package info
dnf info nginx
dnf provides /usr/bin/curl   # which package provides a file

# clean cache
sudo dnf clean all

# group install
dnf groupinstall "Development Tools"
dnf group list

# yum: older CentOS/RHEL (still available)
sudo yum install nginx
sudo yum update
sudo yum remove nginx
yum search nginx
yum provides /usr/bin/curl

# enable EPEL repository (Extra Packages for Enterprise Linux)
sudo dnf install epel-release

# list dependencies
dnf repoquery --requires nginx
dnf repoquery --deplist nginx

# downgrade a package
sudo dnf downgrade nginx

# view package files
rpm -ql nginx                # files installed by package
rpm -qi nginx                # package info
rpm -qf /usr/bin/curl        # which package owns file

pacman (Arch Linux)

pacman es el gestor de paquetes de Arch Linux. -Syu es el comando esencial de actualización del sistema (actualiza siempre el sistema completo, nunca parcial). -S instala, -R elimina, -Q consulta lo local. -Rs elimina con dependencias no usadas; -Rns también elimina la configuración. Arch es rolling release — las actualizaciones parciales no están soportadas y pueden romper el sistema. El AUR (Arch User Repository) aporta paquetes de la comunidad vía helpers como yay/paru.

linux
# update system
sudo pacman -Syu            # sync repos + upgrade all
# ALWAYS update the full system on Arch

# install packages
sudo pacman -S nginx
sudo pacman -S --needed nginx  # don't reinstall if up to date

# remove packages
sudo pacman -R nginx         # remove package only
sudo pacman -Rs nginx        # remove + unused deps
sudo pacman -Rns nginx       # remove + deps + config

# search packages
pacman -Ss nginx             # search repos
pacman -Qs nginx             # search installed

# package info
pacman -Si nginx             # info from repos
pacman -Qi nginx             # info from installed
pacman -Ql nginx             # list files
pacman -Qo /usr/bin/curl     # which package owns file

# list orphaned packages
pacman -Qdt

# clean cache
sudo pacman -Sc             # clean old packages
sudo pacman -Scc            # clean all cache

# query local database
pacman -Q                   # all installed packages
pacman -Qe                  # explicitly installed
pacman -Qm                  # foreign (AUR) packages

# AUR (Arch User Repository)
# install yay or paru for AUR support
yay -S package-name         # install from AUR

# downgrade a package
sudo pacman -U /var/cache/pacman/pkg/package-1.0-1.x86_64.pkg.tar.zst

Encontrar paquetes

Encontrar paquetes por palabra clave (apt/dnf search) o por archivo (apt-file/dnf provides/pacman -F) es esencial cuando recibes 'command not found'. La consulta 'qué paquete posee este archivo' (dpkg -S / rpm -qf / pacman -Qo) es inestimable para entender qué está instalado. apt-file (Debian) y pacman -F (Arch) buscan en las bases de datos de archivos de paquetes aún no instalados — útil para hallar qué paquete proporciona un header o librería necesarios.

linux
# Debian/Ubuntu
apt search keyword
apt-cache search keyword
apt list --installed | grep keyword

# RHEL/Fedora
dnf search keyword
yum search keyword

# Arch
pacman -Ss keyword

# search by file name/path
# Debian: apt-file (separate package)
sudo apt install apt-file
sudo apt-file update
apt-file find /usr/bin/curl
apt-file search curl.h

# RHEL/Fedora
dnf provides /usr/bin/curl
dnf provides *curl.h
yum whatprovides /usr/bin/curl

# Arch
pacman -F /usr/bin/curl
pacman -Fy                  # update file database first

# check if package is installed
dpkg -l | grep nginx         # Debian
rpm -q nginx                 # RHEL
pacman -Q nginx              # Arch

# list files installed by a package
dpkg -L nginx                # Debian
rpm -ql nginx                # RHEL
pacman -Ql nginx             # Arch

# find which package owns a file
dpkg -S /usr/bin/curl         # Debian
rpm -qf /usr/bin/curl         # RHEL
pacman -Qo /usr/bin/curl      # Arch

# show package dependencies
apt-cache depends nginx      # Debian
dnf repoquery --requires nginx  # RHEL
pacman -Si nginx             # Arch

Gestión de repositorios

Los repositorios son fuentes de paquetes. En Debian/Ubuntu, los PPAs (Personal Package Archives) aportan software de terceros — añade siempre la clave de firma para verificar los paquetes. /etc/apt/sources.list.d/ guarda los archivos de repos personalizados. En RHEL/Fedora, dnf config-manager gestiona los repos; EPEL es esencial para RHEL. En Arch, edita /etc/pacman.conf. Verifica siempre las claves GPG para no instalar paquetes maliciosos. apt policy y dnf repolist muestran los repositorios configurados.

linux
# Debian/Ubuntu: add repository
sudo add-apt-repository ppa:deadsnakes/ppa
sudo add-apt-repository "deb https://packages.example.com/ubuntu jammy main"

# remove repository
sudo add-apt-repository --remove ppa:deadsnakes/ppa

# add repository manually
echo "deb https://packages.example.com/ubuntu jammy main" | \
    sudo tee /etc/apt/sources.list.d/example.list

# add signing key (Debian)
wget -qO- https://example.com/key.gpg | \
    sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/example.gpg

# list repositories
apt policy                   # show configured repos
grep -r "" /etc/apt/sources.list.d/

# RHEL/Fedora: enable repository
sudo dnf config-manager --add-repo https://example.com/repo.repo
sudo dnf install epel-release  # enable EPEL
sudo dnf repolist              # list enabled repos
sudo dnf repolist all          # list all repos

# enable/disable a repo
sudo dnf config-manager --set-enabled epel
sudo dnf config-manager --set-disabled epel

# Arch: edit /etc/pacman.conf
# [custom]
# Server = https://example.com/$repo/os/$arch

# verify package integrity
dpkg --verify                 # Debian
rpm -Va                       # RHEL
14

Gestión de servicios (systemd)

Control de servicios

systemctl gestiona los servicios de systemd. start/stop/restart son las operaciones básicas. reload envía una señal para releer la configuración sin reinicio completo (elegante). status muestra el estado actual y los logs recientes. mask impide por completo que un servicio se inicie (incluso manualmente) — más fuerte que disable. is-active e is-enabled son útiles para scripts (devuelven 0 si está activo/habilitado).

linux
# start/stop/restart services
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl reload nginx    # reload config without restart

# try-restart (only if running)
sudo systemctl try-restart nginx

# reload or restart (reload if possible, otherwise restart)
sudo systemctl reload-or-restart nginx

# send signal to service
sudo systemctl kill nginx
sudo systemctl kill -s HUP nginx

# check service status
sudo systemctl status nginx
systemctl is-active nginx       # active/inactive
systemctl is-enabled nginx      # enabled/disabled
systemctl is-failed nginx       # failed/running

# show service logs (recent)
sudo systemctl status nginx

# mask a service (prevent from starting)
sudo systemctl mask nginx
sudo systemctl unmask nginx

# reset failed state
sudo systemctl reset-failed

# emergency: reboot/poweroff
sudo systemctl reboot
sudo systemctl poweroff
sudo systemctl halt
sudo systemctl suspend

Estado y detalles del servicio

systemctl status da una visión completa: estado, PID, uso de memoria/CPU y logs recientes. systemctl cat muestra el archivo unit (incluyendo cualquier override). systemctl edit crea un archivo de override drop-in sin modificar el original — seguro para personalizar servicios del fabricante. Tras editar archivos unit, corre daemon-reload para informar a systemd de los cambios. list-dependencies muestra qué requiere un servicio.

linux
# detailed status
systemctl status nginx
# Shows: loaded state, active state, recent log entries, cgroup info

# just the active state
systemctl is-active nginx       # "active" or "inactive"

# is it enabled at boot?
systemctl is-enabled nginx      # "enabled" or "disabled"

# check if service failed
systemctl is-failed nginx

# list dependencies
systemctl list-dependencies nginx

# show service file
systemctl cat nginx
systemctl cat nginx.service

# show service properties
systemctl show nginx
systemctl show -p ExecStart nginx

# view service file location
systemctl show -p FragmentPath nginx

# edit service file (override)
sudo systemctl edit nginx       # creates override file
sudo systemctl edit --full nginx  # edit full unit file

# reload systemd after editing unit files
sudo systemctl daemon-reload

# list sockets
systemctl list-sockets

# check all failed services
systemctl --failed

Habilitar/deshabilitar servicios

enable hace que un servicio arranque al iniciar (crea symlinks); disable elimina los symlinks. --now combina enable/disable con start/stop. list-unit-files muestra cada servicio disponible (instalados pero quizá no corriendo); list-units muestra los cargados/activos. El target por defecto (multi-user = modo texto, graphical = GUI) reemplaza a los runlevels tradicionales. Usa --state= para filtrar por estado.

linux
# enable service to start at boot
sudo systemctl enable nginx

# enable and start in one command
sudo systemctl enable --now nginx

# disable (don't start at boot)
sudo systemctl disable nginx

# disable and stop in one command
sudo systemctl disable --now nginx

# re-enable (apply symlink changes)
sudo systemctl reenable nginx

# check if enabled
systemctl is-enabled nginx

# list enabled services
systemctl list-unit-files --state=enabled

# list all service unit files
systemctl list-unit-files --type=service

# list running services
systemctl list-units --type=service --state=running

# list all loaded services
systemctl list-units --type=service

# list services by state
systemctl list-units --type=service --state=failed
systemctl list-units --type=service --state=exited

# default boot target
systemctl get-default          # usually graphical.target or multi-user.target

# change boot target
sudo systemctl set-default multi-user.target  # text mode (runlevel 3)
sudo systemctl set-default graphical.target    # GUI mode (runlevel 5)

Listar y filtrar servicios

list-units muestra lo cargado actualmente en memoria; list-unit-files muestra lo instalado en disco. --type filtra por tipo de unit (service, socket, timer, mount, target). --state filtra por estado (running, exited, failed, enabled, disabled). Los timers (systemd timers) son el reemplazo nativo de systemd para los trabajos cron — soportan programación basada en dependencias y son visibles vía list-timers. --reverse muestra qué depende de una unit.

linux
# list all active units
systemctl list-units

# list only services
systemctl list-units --type=service

# list by state
systemctl list-units --type=service --state=running
systemctl list-units --type=service --state=exited
systemctl list-units --type=service --state=failed

# list all unit files (installed)
systemctl list-unit-files --type=service

# list by state (unit files)
systemctl list-unit-files --state=enabled
systemctl list-unit-files --state=disabled
systemctl list-unit-files --state=masked

# list by target (runlevel)
systemctl list-units --type=target

# list sockets
systemctl list-units --type=socket
systemctl list-sockets

# list timers (replaces cron for many tasks)
systemctl list-timers
systemctl list-timers --all

# list mounts
systemctl list-units --type=mount

# show all units (including inactive)
systemctl list-units --all

# show specific unit type
systemctl list-units --type=service --all

# count services by state
systemctl list-units --type=service --no-legend | wc -l
systemctl list-units --type=service --state=running --no-legend | wc -l

# find services that depend on a unit
systemctl list-dependencies --reverse nginx

journalctl — logs del sistema

journalctl consulta el journal de systemd (logging estructurado). -f sigue en tiempo real. -u filtra por unit (servicio). -b filtra por arranque (-b -1 = arranque anterior). --since/--until usan expresiones de tiempo flexibles. -p filtra por prioridad (emerg a debug). El journal persiste entre reinicios (guardado en /var/log/journal/). --vacuum-time y --vacuum-size controlan el uso de disco. journalctl reemplaza a /var/log/messages en sistemas systemd.

linux
# view all logs (newest last)
journalctl

# follow logs (like tail -f)
journalctl -f

# today's logs
journalctl --since today
journalctl -u nginx --since today

# specific time range
journalctl --since "2024-01-01" --until "2024-01-02"
journalctl --since "1 hour ago"
journalctl --since "30 min ago"

# logs for a specific service
journalctl -u nginx
journalctl -u nginx -f          # follow
journalctl -u nginx --since "1 hour ago"

# logs for current boot
journalctl -b                   # current boot
journalctl -b -1                # previous boot
journalctl --list-boots         # list all boots

# filter by priority
journalctl -p err               # errors only
journalctl -p warning           # warnings and above
# 0=emerg, 1=alert, 2=crit, 3=err, 4=warning, 5=notice, 6=info, 7=debug

# filter by process
journalctl _PID=1234
journalctl _UID=1000

# show kernel messages only
journalctl -k

# output format
journalctl -o json              # JSON format
journalctl -o short-iso         # ISO timestamps
journalctl --no-pager           # no pager (for scripts)

# clear old logs
sudo journalctl --vacuum-time=7d    # keep last 7 days
sudo journalctl --vacuum-size=100M  # keep 100MB max
15

Tareas programadas (Cron)

Fundamentos de crontab

crontab -e edita tus tareas programadas. El formato es: minuto hora día-del-mes mes día-de-la-semana comando. * significa 'cualquier valor'. */N significa 'cada N'. Cron corre con un entorno mínimo — usa siempre rutas absolutas para comandos y scripts. Los scripts deberían fijar PATH explícitamente. La salida se envía por correo al usuario (configura MAILTO en crontab) o redirígela a un archivo de log. Las tareas a nivel de sistema van en /etc/crontab o los directorios /etc/cron.*/.

linux
# edit your crontab
crontab -e

# list your crontab entries
crontab -l

# remove all crontab entries
crontab -r

# edit another user's crontab (requires root)
sudo crontab -u alice -e
sudo crontab -u alice -l

# crontab entry format:
# minute hour day-of-month month day-of-week command
# 0-59   0-23 1-31          1-12  0-6 (0=Sunday)
#
# *  *  *  *  *  command to execute
# |  |  |  |  |
# |  |  |  |  +----- day of week (0-7) (0 or 7 is Sunday)
# |  |  |  +------- month (1-12)
# |  |  +--------- day of month (1-31)
# |  +----------- hour (0-23)
# +------------- minute (0-59)

# examples:
# run every day at 2:30 AM
30 2 * * * /home/user/backup.sh

# run every Monday at 9 AM
0 9 * * 1 /home/user/weekly-report.sh

# run every 15 minutes
*/15 * * * * /home/user/check.sh

# run at reboot
@reboot /home/user/startup.sh

# system-wide cron: /etc/crontab
# adds a user column:
# minute hour day month week USER command
*/30 * * * * root /usr/local/bin/check.sh

# cron directories (run all scripts inside)
/etc/cron.daily/    # daily
/etc/cron.hourly/   # hourly
/etc/cron.weekly/   # weekly
/etc/cron.monthly/  # monthly

Sintaxis de programación cron

Cron usa 5 campos: minuto (0-59), hora (0-23), día-del-mes (1-31), mes (1-12), día-de-la-semana (0-7, donde 0 y 7 son domingo). * significa cualquier valor; */N significa cada N; las comas separan valores; los guiones definen rangos. El día de la semana y el día del mes se combinan con OR cuando ambos se especifican (no con AND). El truco del último día del mes comprueba si mañana es el día 1. Prueba siempre las programaciones cron con un simple echo antes de desplegar tareas reales.

linux
# every minute
* * * * * command

# every 5 minutes
*/5 * * * * command

# every hour at minute 0
0 * * * * command

# every day at midnight
0 0 * * * command

# every day at 2:30 AM
30 2 * * * command

# every Monday at 8 AM
0 8 * * 1 command

# every weekday (Mon-Fri) at 9 AM
0 9 * * 1-5 command

# every weekend (Sat and Sun) at 10 AM
0 10 * * 0,6 command

# every month on the 1st at midnight
0 0 1 * * command

# every quarter (Jan, Apr, Jul, Oct) on the 1st
0 0 1 1,4,7,10 * command

# every 15 minutes during business hours
*/15 9-17 * * 1-5 command

# twice a day (midnight and noon)
0 0,12 * * * command

# every 2 hours
0 */2 * * * command

# last day of month (tricky — use date check)
0 0 28-31 * * [ "$(date +%d -d tomorrow)" = "01" ] && /script.sh

# run on specific date (Jan 1 at midnight)
0 0 1 1 * command

Cadenas especiales de cron

Las cadenas especiales (@daily, @weekly, etc.) son abreviaturas de programaciones comunes — más legibles que el formato de 5 campos. @reboot corre una vez al arrancar el sistema. MAILTO controla a dónde se envía la salida por correo — fíjalo vacío para desactivarlo. Cron usa un entorno mínimo (PATH limitado, sin perfil de shell) — fija PATH explícitamente o usa rutas absolutas. La redirección de salida es esencial: sin ella, la salida se envía por correo o se pierde.

linux
# predefined special strings (GNU cron)
@reboot     command    # run once at startup
@yearly     command    # once a year: 0 0 1 1 *
@annually   command    # same as @yearly
@monthly    command    # once a month: 0 0 1 * *
@weekly     command    # once a week: 0 0 * * 0
@daily      command    # once a day: 0 0 * * *
@midnight   command    # same as @daily
@hourly     command    # once an hour: 0 * * * *

# examples
@reboot /home/user/startup.sh
@daily /home/user/backup.sh >> /var/log/backup.log 2>&1
@hourly /usr/local/bin/health-check.sh

# set MAILTO for email notifications
MAILTO="[email protected]"
@daily /home/user/report.sh

# disable email (discard output)
MAILTO=""
@daily /home/user/cleanup.sh > /dev/null 2>&1

# environment variables in crontab
PATH=/usr/local/bin:/usr/bin:/bin
SHELL=/bin/bash
HOME=/home/user
@daily /home/user/script.sh

# redirect output to log
@daily /home/user/script.sh >> /home/user/cron.log 2>&1

# log with timestamp
@daily echo "$(date): starting" >> /home/user/cron.log; /home/user/script.sh >> /home/user/cron.log 2>&1

# check cron service is running
systemctl status cron
systemctl status crond

anacron

anacron está diseñado para máquinas que no están siempre encendidas (portátiles, escritorio). A diferencia de cron, corre los trabajos perdidos cuando el sistema arranca. Solo soporta granularidad diaria/semanal/mensual. El campo de retardo añade una espera aleatoria para evitar que el conjunto de trabajos arranque a la vez. Los systemd timers son la alternativa moderna — soportan programación tipo cron, pueden correr trabajos perdidos (Persistent=true) y se integran con journalctl para logging.

linux
# anacron: run periodic jobs even if system was off
# /etc/anacrontab format:
# period  delay  job-id  command
#   1     5      daily   /home/user/daily.sh
#   7     10     weekly  /home/user/weekly.sh
#   30    15     monthly /home/user/monthly.sh

# view anacron config
cat /etc/anacrontab

# anacron directories (system-wide)
ls /etc/cron.daily/
ls /etc/cron.weekly/
ls /etc/cron.monthly/

# run anacron manually
sudo anacron -d            # run jobs in foreground with debug
sudo anacron -f            # force run all jobs
sudo anacron -u            # update timestamps only (don't run)

# run a specific job
sudo anacron -j daily      # run the 'daily' job

# check when jobs last ran
ls -l /var/spool/anacron/

# difference between cron and anacron:
# cron:
#   - requires system to be running at scheduled time
#   - minimum resolution: 1 minute
#   - per-user crontabs
#
# anacron:
#   - catches up missed jobs after downtime
#   - minimum resolution: 1 day
#   - system-wide only (runs as root)
#   - good for laptops/desktops that aren't always on

# systemd timers: modern alternative to cron
systemctl list-timers
sudo systemctl enable --now mytask.timer

at — tareas programadas puntuales

at programa comandos puntuales (a diferencia de la programación recurrente de cron). Los tiempos pueden ser absolutos (10:30 AM, medianoche) o relativos (now + 30 minutos). atq lista los trabajos pendientes; atrm los elimina. batch corre cuando la carga del sistema está por debajo de 0.8 (configurable). Los trabajos at corren con el entorno del usuario. Requiere el servicio atd. Útil para recordatorios, tareas diferidas o programar un apagado sin permanecer conectado.

linux
# schedule a command for later
echo "backup.sh" | at midnight
echo "shutdown -h now" | at 2am tomorrow

# interactive scheduling
at 2:30 PM
at> /home/user/report.sh
at> Ctrl+D                  # press Ctrl+D to submit

# schedule relative to now
at now + 30 minutes
at> echo "30 min passed" > /tmp/notice.txt
at> Ctrl+D

at now + 2 hours
at now + 1 day
at now + 1 week

# schedule for a specific time
at 10:30 AM
at 10:30 AM tomorrow
at 10:30 AM 2025-12-25
at 10:30 AM Dec 25

# list pending jobs
atq
at -l

# view a specific job
at -c 5                      # show job #5

# remove a job
atrm 5                       # remove job #5
at -d 5                      # alternative

# batch: run when load is low
batch
at> /home/user/heavy-computation.sh
at> Ctrl+D

# enable atd service
sudo systemctl enable --now atd

# check atd is running
systemctl status atd
16

Archivos y compresión

tar — crear y extraer

tar agrupa archivos en un único archivo comprimido (sin compresión por defecto). Los flags son nemotécnicos: c=crear, x=eXtraer, t=listar, f=archivo, v=verboso. -C especifica el directorio de extracción. --exclude se salta patrones. tar conserva permisos, propiedad y marcas de tiempo. Usa siempre tar -tf para previsualizar el contenido antes de extraer de fuentes no confiables. El flag -f debe ir seguido del nombre del archivo.

linux
# create a tar archive (no compression)
tar -cf archive.tar file1.txt file2.txt
tar -cf archive.tar directory/

# extract a tar archive
tar -xf archive.tar
tar -xf archive.tar -C /target/dir/    # extract to specific directory

# list contents without extracting
tar -tf archive.tar
tar -tvf archive.tar          # verbose (with details)

# verbose create/extract
tar -cvf archive.tar dir/     # show files being added
tar -xvf archive.tar          # show files being extracted

# append files to existing archive
tar -rf archive.tar newfile.txt

# extract specific files
tar -xf archive.tar path/to/file.txt
tar -xf archive.tar "file*.txt"

# exclude files
tar -cf archive.tar dir/ --exclude="*.log"
tar -cf archive.tar dir/ --exclude="node_modules"

# common flags:
# c = create
# x = extract
# t = list
# f = file (specify archive name)
# v = verbose
# r = append
# u = update (only newer files)
# C = change to directory

# preserve permissions (default for root)
tar -cpf archive.tar dir/     # p = preserve permissions

# show what would be done (dry run)
tar -tf archive.tar | head -10

tar con compresión

tar soporta múltiples algoritmos de compresión vía flags: z (gzip), j (bzip2), J (xz), --zstd (zstd). gzip es el estándar (rápido, en todas partes); bzip2 comprime mejor pero es más lento; xz tiene el mejor ratio pero es el más lento; zstd es moderno (el más rápido, buen ratio). El tar moderno detecta automáticamente la compresión al extraer, así que -xf funciona con cualquier formato. El nivel de compresión (1-9) intercambia velocidad por tamaño. Para respaldos, se prefieren xz o zstd.

linux
# tar + gzip (most common, .tar.gz or .tgz)
tar -czf archive.tar.gz dir/        # create
tar -xzf archive.tar.gz             # extract
tar -tzf archive.tar.gz             # list

# tar + bzip2 (better compression, slower)
tar -cjf archive.tar.bz2 dir/       # create
tar -xjf archive.tar.bz2            # extract
tar -tjf archive.tar.bz2            # list

# tar + xz (best compression, slowest)
tar -cJf archive.tar.xz dir/        # create
tar -xJf archive.tar.xz             # extract
tar -tJf archive.tar.xz             # list

# tar + zstd (fast + good ratio, modern)
tar --zstd -cf archive.tar.zst dir/ # create
tar --zstd -xf archive.tar.zst      # extract

# specify compression level (1-9, default 6)
GZIP=-9 tar -czf archive.tar.gz dir/    # max gzip compression
XZ_OPT=-9e tar -cJf archive.tar.xz dir/ # max xz compression

# compression comparison:
# gzip:  fast, medium compression (.tar.gz)
# bzip2: medium, good compression (.tar.bz2)
# xz:    slow, best compression (.tar.xz)
# zstd:  fastest, good compression (.tar.zst)

# extract: tar auto-detects compression
tar -xf archive.tar.gz    # works without -z flag
tar -xf archive.tar.xz    # works without -J flag

# compress to stdout (for piping)
tar -cz dir/ | ssh user@host "cat > backup.tar.gz"

zip y unzip

zip es común en Windows y ampliamente soportado. -r recursa directorios; -e cifra con contraseña (preguntada); -x excluye patrones; -s divide en varias partes (útil para archivos grandes). unzip -l lista; -d extrae a un directorio; -t prueba la integridad. A diferencia de tar+gzip, zip comprime cada archivo individualmente, permitiendo acceso aleatorio a los archivos dentro del archivo comprimido. Para compartir entre plataformas, zip es la elección más segura.

linux
# create a zip archive
zip archive.zip file1.txt file2.txt

# zip a directory recursively
zip -r archive.zip directory/

# zip with password (encryption)
zip -e -r archive.zip directory/
zip -P password archive.zip file.txt   # password on command line (insecure)

# zip with specific compression level (0-9)
zip -9 -r archive.zip directory/       # maximum compression

# zip excluding files
zip -r archive.zip dir/ -x "*.log" -x "*/node_modules/*"

# split archive into parts
zip -s 100m archive.zip largefile.iso   # 100MB parts

# update/add files to existing zip
zip archive.zip newfile.txt

# list contents
unzip -l archive.zip
unzip -v archive.zip            # verbose with details

# extract
unzip archive.zip
unzip archive.zip -d /target/dir/

# extract specific files
unzip archive.zip file1.txt

# test archive integrity
unzip -t archive.zip

# extract to stdout
unzip -p archive.zip file.txt

# zipinfo: detailed listing
zipinfo archive.zip
zipinfo -1 archive.zip          # just filenames

gzip y gunzip

gzip comprime archivos individuales (no archivos agrupados — usa tar para varios). Reemplaza el original por un .gz; usa -k para conservarlo. -c muestra por stdout (útil para pipes). zcat/zless leen archivos comprimidos sin extraer. gzip solo maneja un archivo a la vez, así que tar + gzip es el estándar para directorios. El nivel de compresión 9 da el archivo más pequeño pero tarda más; el nivel 1 es el más rápido.

linux
# compress a single file (replaces original)
gzip file.txt                # creates file.txt.gz, removes file.txt

# keep the original file
gzip -k file.txt             # keep original
gzip -c file.txt > file.txt.gz  # alternative (to stdout)

# set compression level (1-9, default 6)
gzip -1 file.txt             # fastest, least compression
gzip -9 file.txt             # slowest, best compression

# decompress
gunzip file.txt.gz           # creates file.txt, removes .gz
gzip -d file.txt.gz          # same as gunzip
gunzip -c file.txt.gz > file.txt  # keep original
gunzip -k file.txt.gz        # keep original (GNU)

# compress multiple files (each gets its own .gz)
gzip file1.txt file2.txt file3.txt

# recursive (compress all files in directory)
gzip -r directory/

# test integrity
gzip -t file.txt.gz

# list compression info
gzip -l file.txt.gz
# compressed  uncompressed  ratio  uncompressed_name
#       1234        5678    78.3%  file.txt

# zcat: view compressed file without extracting
zcat file.txt.gz
zcat file.txt.gz | grep "error"

# zless: pager for compressed files
zless file.txt.gz

# concatenate and decompress
cat file1.txt.gz file2.txt.gz | gunzip > combined.txt

# compress stdin
echo "data" | gzip > data.gz
tar -cf - dir/ | gzip > archive.tar.gz

xz y bzip2

bzip2 comprime mejor que gzip pero es más lento. xz (LZMA) ofrece el mejor ratio de compresión pero es el más lento — ideal para archivar. zstd es la elección moderna: la descompresión más rápida con buen ratio. lz4 es extremadamente rápido pero con menor ratio. Para distribuir software, se prefiere xz (la descarga más pequeña). Para compresión en tiempo real, zstd o lz4. bzcat/xzcat/zcat leen archivos comprimidos sin extraer — útil para análisis de logs.

linux
# bzip2: better compression than gzip
bzip2 file.txt               # compress (replaces original)
bzip2 -k file.txt            # keep original
bunzip2 file.txt.bz2         # decompress
bzip2 -d file.txt.bz2        # same as bunzip2

# bzip2 compression level (1-9, default 9)
bzip2 -9 file.txt

# bzcat: view bzip2-compressed file
bzcat file.txt.bz2 | grep "pattern"

# xz: best compression ratio
xz file.txt                  # compress (replaces original)
xz -k file.txt               # keep original
xz -d file.txt.xz            # decompress
unxz file.txt.xz             # same as xz -d

# xz compression level (0-9, default 6)
xz -9 file.txt               # maximum compression

# xz with extreme compression (very slow)
xz -9e file.txt

# xzcat: view xz-compressed file
xzcat file.txt.xz

# zstd: fast modern compressor
zstd file.txt                # compress
zstd -d file.txt.zst         # decompress
zstd -19 file.txt            # max compression
zstd -k file.txt             # keep original

# lz4: extremely fast
lz4 file.txt                 # compress
lz4 -d file.txt.lz4          # decompress

# compare compression ratios
ls -lh file.txt file.txt.gz file.txt.bz2 file.txt.xz

# benchmark compression
time gzip -9 file.txt
time xz -9 file.txt
17

SSH y acceso remoto

Conexión SSH

ssh se conecta a máquinas remotas de forma segura. -p especifica un puerto no estándar; -i selecciona una clave privada. ssh-copy-id instala tu clave pública para autenticación sin contraseña (mucho más seguro que las contraseñas). -v ayuda a diagnosticar problemas de conexión (negociación de claves, pasos de autenticación). -X habilita el reenvío X11 para apps GUI remotas. Para conexiones frecuentes, configura ~/.ssh/config con alias.

linux
# basic connection
ssh user@hostname
ssh [email protected]
ssh [email protected]

# specify port (default 22)
ssh -p 2222 user@host

# use a specific private key
ssh -i ~/.ssh/id_ed25519 user@host

# run a single command and exit
ssh user@host "uname -a"
ssh user@host "ls -la /var/log"

# verbose (debug connection issues)
ssh -v user@host
ssh -vv user@host            # more verbose
ssh -vvv user@host           # most verbose

# forward X11 (GUI applications)
ssh -X user@host
ssh -Y user@host             # trusted X11 forwarding

# compression (slow connections)
ssh -C user@host

# keep alive
ssh -o ServerAliveInterval=60 user@host

# force SSH version
ssh -1 user@host             # SSH protocol 1 (insecure, avoid)
ssh -2 user@host             # SSH protocol 2 (default, secure)

# copy SSH key to remote (passwordless login)
ssh-copy-id user@host
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host
ssh-copy-id -p 2222 user@host

# test connection without running commands
ssh -T user@host

Gestión de claves SSH

Las claves Ed25519 son las recomendadas (más pequeñas, rápidas y seguras que RSA). La clave privada debe tener chmod 600 o SSH la rechaza. ssh-agent cachea las contraseñas en memoria para que la teclees una vez por sesión; ssh-add -l lista las claves cargadas. ssh-keygen -R elimina un host de known_hosts (útil tras reinstalar un servidor). Verifica siempre las huellas del host por un canal aparte para prevenir ataques man-in-the-middle. Nunca compartas ni subas tu clave privada.

linux
# generate an SSH key pair (Ed25519, recommended)
ssh-keygen -t ed25519 -C "[email protected]"

# generate RSA key (4096 bits, if Ed25519 not supported)
ssh-keygen -t rsa -b 4096 -C "[email protected]"

# generate with custom filename
ssh-keygen -t ed25519 -f ~/.ssh/id_server -C "server key"

# generate without passphrase (automated scripts)
ssh-keygen -t ed25519 -N "" -f ~/.ssh/deploy_key

# copy public key to remote server
ssh-copy-id user@host

# view public key
cat ~/.ssh/id_ed25519.pub

# view fingerprint
ssh-keygen -l -f ~/.ssh/id_ed25519.pub

# key files:
# ~/.ssh/id_ed25519       private key (keep secret! chmod 600)
# ~/.ssh/id_ed25519.pub   public key (can share)

# authorized_keys on remote server
# add your public key to: ~/.ssh/authorized_keys
cat ~/.ssh/id_ed25519.pub | ssh user@host "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

# SSH agent (manages keys in memory)
eval "$(ssh-agent -s)"        # start agent
ssh-add ~/.ssh/id_ed25519     # add key to agent
ssh-add -l                   # list loaded keys
ssh-add -D                   # remove all keys from agent

# remove or change a key passphrase
ssh-keygen -p -f ~/.ssh/id_ed25519

# verify host key fingerprint (avoid MITM)
ssh-keygen -l -f /etc/ssh/ssh_host_ed25519_key.pub

# known_hosts management
ssh-keygen -R 192.168.1.100   # remove a host entry
ssh-keygen -F 192.168.1.100   # find a host entry

# key permissions (critical!)
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

SCP — copia segura

scp usa SSH para transferencia de archivos cifrada. -r para directorios, -P (¡mayúscula!) para el puerto (ssh usa -p minúscula). Para transferencias grandes o frecuentes, prefiere rsync sobre scp — rsync reanuda transferencias interrumpidas y solo envía diferencias. scp se está desaconsejando en favor de sftp en versiones recientes de OpenSSH, pero sigue muy disponible y es simple para copias rápidas.

linux
# copy local file to remote
scp file.txt user@host:/path/to/dest/
scp file.txt user@host:~/        # home directory

# copy remote file to local
scp user@host:/var/log/syslog ./
scp -r user@host:/var/log /tmp/  # recursive (directory)

# copy between two remote hosts
scp user1@host1:/file user2@host2:/dest

# specify port
scp -P 2222 file.txt user@host:/dest

# preserve attributes (timestamps, perms)
scp -p file.txt user@host:/dest

# compress during transfer
scp -C bigfile.tar user@host:/dest

# limit bandwidth (KB/s)
scp -l 1000 file user@host:/dest    # ~1 MB/s

Archivo de configuración SSH

~/.ssh/config te permite crear alias para hosts, evitando comandos ssh largos con muchos flags. Con solo 'ssh dev' te conectas con los ajustes correctos. Los comodines (*.internal) se aplican a los hosts que coincidan. Este archivo debe tener chmod 600. IdentitiesOnly yes evita que SSH pruebe una a una las claves de ~/.ssh (lo que puede causar 'too many authentication failures'). Es la mayor mejora de calidad de vida de SSH.

linux
# ~/.ssh/config - simplify connections
Host dev
    HostName dev.example.com
    User alice
    Port 2222
    IdentityFile ~/.ssh/id_dev

Host prod
    HostName prod.example.com
    User deploy
    IdentityFile ~/.ssh/id_deploy
    ServerAliveInterval 60

# wildcard: all hosts in a domain
Host *.internal
    User admin
    ForwardAgent yes

# use: ssh dev  (instead of ssh -p 2222 [email protected])
#      scp file prod:/tmp/

# common useful options
Host *
    ServerAliveInterval 60      # keep connection alive
    ServerAliveCountMax 3       # disconnect after 3 missed
    AddKeysToAgent yes          # auto-add keys to agent
    IdentitiesOnly yes          # only use specified keys

Reenvío de puertos y túneles

El reenvío de puertos tunela el tráfico por el canal cifrado de SSH. -L (local) expone un servicio remoto en tu máquina; -R (remoto) hace lo inverso (útil para alcanzar una máquina tras NAT); -D crea un proxy SOCKS. -fN corre en segundo plano sin shell. ProxyJump (-J) es la forma moderna de saltar a través de hosts bastión — mucho más limpia que el SSH anidado. Son esenciales para acceder a servicios internos con seguridad.

linux
# local forward: access remote service locally
# local:8080 -> remote:80
ssh -L 8080:localhost:80 user@host
# then open http://localhost:8080 in browser

# local forward to a third host via jump server
ssh -L 8080:internal.db:3306 user@jumphost

# remote forward: expose local service to remote
# remote:8080 -> local:80
ssh -R 8080:localhost:80 user@host

# dynamic forward (SOCKS proxy)
ssh -D 1080 user@host
# then configure browser to use SOCKS5 proxy at localhost:1080

# run in background (no command, no terminal)
ssh -fN -L 8080:localhost:80 user@host

# jump host / proxy jump (OpenSSH 7.3+)
ssh -J user@jumphost [email protected]
# or in ~/.ssh/config:
#   Host internal
#       ProxyJump jumphost

# forward ports in config file
Host db
    HostName db.internal
    LocalForward 3306 localhost:3306
18

Gestión de discos

Listar dispositivos de bloque

lsblk es la forma moderna de listar discos y particiones (reemplazando a fdisk -l para visualizar). df muestra el espacio en disco de los sistemas de archivos (-h legible, -i para inodes — si los inodes se llenan, no puedes crear archivos incluso con espacio libre). du mide los tamaños de directorio; el patrón 'sort -rh | head' encuentra los devoradores de espacio. Corre du con --max-depth para limitar la profundidad de recursión.

linux
# list block devices (modern, recommended)
lsblk                         # tree view
lsblk -f                      # with filesystem info
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT
lsblk -d                      # don't print partitions

# old way: list disks and partitions
sudo fdisk -l
sudo fdisk -l /dev/sda        # specific disk

# view partition table
sudo parted -l
sudo parted /dev/sda print

# filesystem disk space
df -h                         # human-readable
df -hT                        # with filesystem type
df -i                         # inode usage
df -h /                       # specific mount

# directory space usage
du -sh /path                  # summary
du -sh /*                     # top-level dirs
du -h --max-depth=1 /var      # one level deep
du -ah /var | sort -rh | head -10   # 10 largest

Montar y desmontar

mount adjunta sistemas de archivos; umount los desadjunta. Si 'target is busy', usa -l (lazy) para desadjuntar cuando deje de usarse. /etc/fstab define los montajes que ocurren al arrancar — ¡prueba siempre con 'mount -a' tras editarlo antes de reiniciar! La forma UUID= es más fiable que /dev/sdX (que puede cambiar al reiniciar). findmnt da una vista más limpia que mount.

linux
# mount a filesystem
sudo mount /dev/sdb1 /mnt/data
sudo mount -t ext4 /dev/sdb1 /mnt/data

# mount with options
sudo mount -o ro /dev/sdb1 /mnt/data          # read-only
sudo mount -o noexec /dev/sdb1 /mnt/data      # no executables
sudo mount -o uid=1000,gid=1000 /dev/sdb1 /mnt  # set owner

# mount an ISO image
sudo mount -o loop ubuntu.iso /mnt/iso

# unmount
sudo umount /mnt/data
sudo umount /dev/sdb1

# lazy unmount (busy filesystem)
sudo umount -l /mnt/data

# force unmount
sudo umount -f /mnt/data

# list mounted filesystems
mount | column -t
findmnt                        # cleaner tree view

# /etc/fstab - persistent mounts
# <device>  <mount>  <type>  <options>  <dump>  <pass>
# /dev/sdb1  /data    ext4   defaults   0       2

Crear y formatear particiones

Usa GPT (etiqueta gpt) para discos de más de 2TB; MBR (msdos) es el valor por defecto heredado. ext4 es el valor por defecto seguro de Linux; XFS es común en RHEL/CentOS; Btrfs ofrece snapshots y compresión. ¡Comprueba SIEMPRE dos veces el nombre del dispositivo antes de mkfs — destruye la totalidad de los datos! fsck comprueba/repara sistemas de archivos (corre sobre sistemas desmontados por seguridad). parted es no interactivo y scriptable, a diferencia de fdisk.

linux
# interactive partition editor
sudo fdisk /dev/sdb
#   m = help, n = new, p = print, d = delete, w = write, q = quit

# GPT partitioning (for disks > 2TB)
sudo parted /dev/sdb mklabel gpt
sudo parted /dev/sdb mkpart primary ext4 0% 100%

# MBR partitioning
sudo parted /dev/sdb mklabel msdos
sudo parted /dev/sdb mkpart primary ext4 1MiB 100%

# format filesystem
sudo mkfs.ext4 /dev/sdb1           # ext4 (Linux default)
sudo mkfs.xfs /dev/sdb1            # XFS (RHEL default)
sudo mkfs.btrfs /dev/sdb1          # Btrfs
sudo mkfs.ntfs /dev/sdb1           # NTFS (Windows)
sudo mkfs.vfat /dev/sdb1           # FAT32

# label a filesystem
sudo e2label /dev/sdb1 mydata      # ext4
sudo xfs_admin -L mydata /dev/sdb1 # xfs

# check filesystem for errors
sudo fsck /dev/sdb1
sudo fsck -y /dev/sdb1             # auto-repair

Gestión de volúmenes lógicos (LVM)

LVM abstrae discos físicos en volúmenes lógicos flexibles. Ventaja clave: puedes redimensionar volúmenes y abarcar varios discos. La jerarquía es PV (físico) -> VG (grupo de volúmenes, un pool) -> LV (volumen lógico, lo que formateas/montas). El redimensionado es en línea para ext4 (resize2fs) y XFS (xfs_growfs, solo crecer). Los snapshots habilitan respaldos consistentes. LVM es estándar en RHEL/Fedora.

linux
# LVM layers: PV -> VG -> LV
# physical volume (disk/partition)
sudo pvcreate /dev/sdb /dev/sdc
sudo pvdisplay
sudo pvs                        # summary

# volume group (pool of PVs)
sudo vgcreate myvg /dev/sdb /dev/sdc
sudo vgdisplay
sudo vgs

# logical volume (carved from VG)
sudo lvcreate -L 50G -n mylv myvg
sudo lvcreate -l 100%FREE -n mylv myvg   # use all space
sudo lvdisplay
sudo lvs

# use the LV (path: /dev/<vg>/<lv>)
sudo mkfs.ext4 /dev/myvg/mylv
sudo mount /dev/myvg/mylv /mnt/data

# resize LV (ext4)
sudo lvextend -L +10G /dev/myvg/mylv
sudo resize2fs /dev/myvg/mylv    # grow filesystem

# resize LV (xfs)
sudo lvextend -L +10G /dev/myvg/mylv
sudo xfs_growfs /mnt/data

# snapshot (point-in-time copy)
sudo lvcreate -L 5G -s -n mysnap /dev/myvg/mylv

Swap y memoria

El swap extiende la memoria física usando espacio en disco. Los archivos de swap (creados con fallocate/mkswap) son más simples que las particiones de swap e igual de eficientes en kernels modernos. swappiness (0-100) controla con qué agresividad hace swap el kernel — valores menores conservan más en RAM (bueno para bases de datos). free -h es el resumen rápido de memoria; /proc/meminfo tiene el desglose detallado. vmstat 1 muestra estadísticas continuas de memoria/cpu/io.

linux
# show swap usage
swapon --show
free -h

# create a swap file (modern method)
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# make permanent (add to /etc/fstab)
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# remove swap file
sudo swapoff /swapfile
sudo rm /swapfile

# adjust swappiness (0-100, lower = less swap use)
cat /proc/sys/vm/swappiness       # default 60
sudo sysctl vm.swappiness=10      # runtime
# permanent: add to /etc/sysctl.conf

# memory info
free -h                           # summary
cat /proc/meminfo                 # detailed
vmstat 1                          # continuous
19

Pipes y redirección

Flujos estándar y redirección

Cada proceso tiene tres flujos: stdin (0), stdout (1), stderr (2). > redirige stdout (>> añade); 2> redirige stderr. 2>&1 fusiona stderr en el destino de stdout (el orden importa — ponlo al final). &> es el atajo de Bash para >archivo 2>&1. Los here-docs (<<EOF) alimentan entrada multilínea; entrecomillar el delimitador ('EOF') desactiva la expansión de variables. /dev/null es el agujero negro para descartar salida.

linux
# three standard streams:
#   stdin  (0) - input
#   stdout (1) - normal output
#   stderr (2) - error output

# redirect stdout to file (overwrite)
echo "hello" > file.txt

# append stdout to file
echo "world" >> file.txt

# redirect stderr to file
ls /nonexistent 2> errors.log

# redirect both stdout and stderr
ls / /nonexistent > all.log 2>&1
ls / /nonexistent &> all.log        # bash shortcut

# discard output (send to /dev/null)
command > /dev/null 2>&1

# redirect stdin from file
sort < unsorted.txt
wc -l < file.txt

# here-string (feed string to stdin)
grep "error" <<< "some error text"

# here-document (multi-line input)
cat << EOF
Line one
Line two with $HOME expanded
EOF

# quoted here-doc (no expansion)
cat << 'EOF'
$HOME stays literal
EOF

Pipes y pipelines

Los pipes (|) conectan el stdout de un comando al stdin de otro, construyendo pipelines potentes. tee reparte la salida entre un archivo y stdout (genial para registrar en log mientras visualizas). La sustitución de procesos <(cmd) trata la salida de un comando como un archivo temporal — esencial para comandos como diff y comm que esperan argumentos de archivo. Por defecto, el estado de salida de un pipeline es el del último comando; set -o pipefail hace que falle si cualquier etapa falla.

linux
# pipe: connect stdout to stdin
command1 | command2

# count files
ls | wc -l

# find and kill
ps aux | grep nginx | grep -v grep

# filter and sort
cat access.log | grep "404" | sort | uniq -c | sort -rn | head

# chain transformations
cat data.csv | cut -d, -f2 | sort | uniq -c | sort -rn

# tee: write to file AND stdout
command | tee output.log
command | tee -a output.log        # append

# pipe stderr too
command 2>&1 | grep error

# pipefail: catch failures in pipeline
set -o pipefail                    # pipeline fails if any command fails

# process substitution (command as file)
diff <(ls dir1) <(ls dir2)
comm <(sort file1) <(sort file2)
while read line; do echo "$line"; done < <(grep pattern file)

xargs y ejecución en paralelo

xargs convierte stdin en argumentos de comando — esencial para pasar la salida de find a comandos como rm, cp o grep. Usa SIEMPRE -0 con find -print0 para manejar nombres de archivo con espacios/saltos de línea. -I {} te permite colocar el argumento en cualquier parte del comando. -P N corre N comandos en paralelo. GNU parallel es una alternativa más potente (barras de progreso, ejecución remota, reintento). Nunca corras 'xargs rm' sin probar antes — usa -t para previsualizar o -p para confirmar.

linux
# xargs: build arguments from stdin
echo "a b c" | xargs mkdir

# one argument per line
find . -name "*.bak" | xargs rm

# handle spaces in filenames (null-delimited)
find . -name "*.log" -print0 | xargs -0 rm

# limit arguments per command
find . -name "*.txt" | xargs -n 1 cp -t /dest/

# show commands before running
find . -name "*.bak" | xargs -t rm

# prompt before each command
find . -name "*.bak" | xargs -p rm

# replace string with argument
find . -name "*.jpg" | xargs -I {} convert {} {}.png

# parallel execution (GNU parallel is more powerful)
find . -name "*.png" | xargs -P 4 -I {} convert {} {}.jpg   # 4 parallel

# GNU parallel (if installed)
parallel -j 4 convert {} {.}.jpg ::: *.png
parallel gzip ::: *.log

Sustitución de comandos y agrupación

$() captura la salida de un comando (preferido sobre los backticks — anida limpiamente, sin necesidad de escapar). { } agrupa comandos en el shell actual (ojo con los espacios y el ; final); ( ) corre en un subshell (los cambios como cd no afectan al padre). && y || son operadores de cortocircuito — 'A && B || C' imita un ternario pero tiene bugs si B puede fallar. Úsalos para one-liners concisos, pero prefiere if/else para scripts robustos.

linux
# command substitution: use output as argument
files=$(ls *.txt)
today=$(date +%Y-%m-%d)
echo "Today is $today"

# backtick form (legacy, avoid)
files=`ls *.txt`

# arithmetic expansion
result=$(( 5 * 3 ))
count=$(( count + 1 ))

# group commands with { } (runs in current shell)
{ cd /tmp; ls; pwd; } > output.txt

# subshell with ( ) (runs in child process)
(cd /tmp && make clean && make)    # doesn't change your cwd

# sequential execution
cmd1 ; cmd2            # run cmd2 regardless of cmd1
cmd1 && cmd2           # run cmd2 only if cmd1 succeeds
cmd1 || cmd2           # run cmd2 only if cmd1 fails

# background
cmd &                  # run in background
cmd1 & cmd2 &          # both in parallel

# conditional pipeline
grep -q "error" log.txt && echo "found" || echo "not found"

Patrones útiles de pipeline

Estos patrones combinan pipes, redirección y herramientas de texto en one-liners potentes. El patrón 'sort | uniq -c | sort -rn | head' es el analizador de frecuencias universal. awk + sort + uniq es el kit estándar de análisis de logs. La sustitución de procesos <(sort ...) alimenta entrada ordenada a join/comm. Entrecomilla siempre los caracteres especiales en los patrones de tr. Estos pipelines encarnan la filosofía Unix: herramientas pequeñas combinadas para resolver problemas complejos.

linux
# top 10 largest files
du -ah . | sort -rh | head -10

# find most frequent log entries
cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head

# extract and count HTTP status codes
awk '{print $9}' access.log | sort | uniq -c | sort -rn

# find files modified in last 24h, grouped by size
find . -mtime -1 -type f -exec du -h {} + | sort -rh

# unique IPs that hit /admin
grep "/admin" access.log | awk '{print $1}' | sort -u

# word frequency in a text file
tr -s ' ' '\n' < file.txt | sort | uniq -c | sort -rn | head

# join CSV files on first field
join -t, <(sort -t, -k1 file1.csv) <(sort -t, -k1 file2.csv)

# parallel downloads
cat urls.txt | xargs -n 1 -P 4 wget -q

# find which process uses the most memory
ps aux | sort -nk 4 | tail -5

# count lines matching pattern across files
grep -c "ERROR" *.log | awk -F: '{sum+=$2} END {print sum}'

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.