Un script de bash es un archivo de texto con comandos, uno detrás de otro, que bash ejecuta en orden como si los escribieras tú. Todo lo que sabes hacer en la terminal sirve dentro de un script: la gracia es que lo escribes una vez y lo repites cuando quieras.

El esqueleto

#!/bin/bash
# Esto es un comentario: bash no lo ejecuta
echo -e "Hola\tamigo"     # \t es un tabulador
ls
date
exit 0                    # termina aquí (0 = todo bien)
echo "Esto no sale nunca"

• La primera línea es el shebang: #! seguido de la ruta del intérprete. Dice quién lee el archivo. Para nosotros, siempre #!/bin/bash.
• Los comentarios empiezan por # (puede haber código antes en la misma línea).
• El ; separa varias órdenes en una misma línea: cd /tmp; ls.
• exit N termina el script en ese momento con el código N. Lo que va detrás ya no se ejecuta.
• La extensión .sh es costumbre, no obligación: Linux no mira la extensión.

Tres formas de ejecutarlo

• ¿Por qué ./ delante? Porque bash solo busca los comandos en las carpetas del PATH, y la carpeta actual no está. Si guardas el script en una carpeta del PATH (por ejemplo ~/.local/bin), ya lo puedes llamar por su nombre.
• source se usa para «cargar» cosas en tu shell: source ~/.bashrc aplica los cambios sin abrir otra terminal.

/bin/sh no siempre es bash

Muchos scripts empiezan por #!/bin/sh. /bin/sh es un enlace a la shell «estándar» del sistema: en Debian y Ubuntu es dash, mucho más simple que bash (no tiene [[ ]], arrays, {1..5}…). Si usas cosas de bash, pon #!/bin/bash.

echo: lo más usado

$ echo "Hola $USER" # comillas dobles: sustituye las variables
Hola xacobo
$ echo 'Hola $USER' # comillas simples: todo tal cual
Hola $USER
$ echo -n "Sin salto" # -n: no añade el salto de línea del final
$ echo -e "a\nb\tc" # -e: interpreta \n (salto), \t (tabulador)…
$ echo -e "\e[31mrojo\e[0m normal" # códigos de color ANSI: 31 rojo, 32 verde, 0 vuelve a lo normal

Para textos con formato, printf es más fiable que echo -e: printf "%-10s %5d\n" "manzanas" 12.

Comprobar un script sin ejecutarlo

• bash -n script.sh revisa la sintaxis (no ejecuta nada).
• bash -x script.sh lo ejecuta enseñando cada orden antes de ejecutarla (con un + delante). Lo mismo con set -x dentro del script.
• shellcheck (sudo apt install shellcheck, o en shellcheck.net) te avisa de los errores típicos: comillas que faltan, [ sin espacios…

Una variable es un nombre que guarda un texto. En bash no se declaran: existen en cuanto les das un valor.

Dar valor y usar el valor

x=32              # SIN espacios alrededor del =
y=$x              # el VALOR de x (32)
z=x               # el texto «x»
echo x y z        # → x y z
echo $x $y $z     # → 32 32 x
nombre="Ana Pérez"   # con espacios, entre comillas

• x = 32 (con espacios) falla: bash cree que x es un comando y le pasa = y 32 como argumentos.
• ${x} es lo mismo que $x, pero marca dónde acaba el nombre: echo ${x}foo (con $xfoo buscaría la variable xfoo).
• $(orden) guarda la salida de una orden: hoy=$(date +%F), n=$(wc -l < notas.txt). La forma antigua es con comillas invertidas: hoy=`date`.
• Por costumbre, las variables del sistema van en MAYÚSCULAS (PATH, HOME) y las tuyas en minúsculas, para no pisarlas.

Comillas: la diferencia que más cae

Variables de shell y de entorno

• Una variable normal solo existe en tu shell. Los programas que lances (y los scripts con ./) no la ven.
• export VAR la convierte en de entorno: la heredan los procesos hijos. export -n VAR la vuelve normal. unset VAR la borra.
• env o printenv muestran las de entorno; set muestra todas (y las funciones).
• Un hijo nunca puede cambiar las variables del padre: por eso un script que hace cd no te cambia de carpeta (salvo con source).
• VAR=valor orden da la variable solo a esa orden: LANG=C ls --help.

read: preguntar al usuario

read nombre                          # lee una línea y la guarda en nombre
read -p "¿Edad? " edad               # -p: pone la pregunta delante
read -s -p "Contraseña: " clave      # -s: no enseña lo que escribes
read -t 5 respuesta                  # -t: espera como mucho 5 segundos
read -n 1 tecla                      # -n: termina tras 1 carácter, sin Intro
read a b resto                       # reparte las palabras: la última se queda con lo que sobre
read -a lista                        # -a: cada palabra a una posición de un array
read -r linea                        # -r: no trata la \ como especial (úsalo siempre)

Si no le das nombre, read guarda la línea en la variable REPLY. El separador de palabras es la variable IFS (espacio, tabulador y salto de línea por defecto): IFS=: read usuario x uid resto parte por los dos puntos.

La trampa de read con una tubería

echo hola | read x; echo $x          # → (nada)

En una tubería cada parte corre en una subshell: read guarda x en una shell que desaparece al acabar la línea. Soluciones: read x <<< "hola" (cadena de entrada), read x < archivo (primera línea de un archivo) o meterlo todo en la misma subshell: echo hola | { read x; echo "$x"; }.

Lo que escribes detrás del nombre de un script son sus argumentos (o parámetros posicionales). Bash los guarda en variables con número.

La tabla que hay que saberse

Un ejemplo

#!/bin/bash
echo "El script se llama: $0"
echo "Primer argumento: $1"
echo "Segundo argumento: $2"
echo "Hay $# argumentos: $*"

$ ./script.sh 34 "hola mundo" 75
El script se llama: ./script.sh
Primer argumento: 34
Segundo argumento: hola mundo
Hay 3 argumentos: 34 hola mundo 75

"$@" frente a "$*"

for a in "$@"; do echo "[$a]"; done     # [34] [hola mundo] [75]  → 3 vueltas
for a in "$*"; do echo "[$a]"; done     # [34 hola mundo 75]     → 1 vuelta
for a in $@;   do echo "[$a]"; done     # [34] [hola] [mundo] [75] → 4: sin comillas se parte

shift y set --

• shift tira $1 y corre los demás: el antiguo $2 pasa a ser $1 y $# baja en uno. shift 2 quita dos. Sirve para procesar opciones: lees $1, haces lo que toque y shift.
• set -- a b c cambia los argumentos del script (ahora $1=a, $2=b, $3=c). Útil para practicar en la terminal.

Comprobar que te han pasado lo necesario

if [ $# -lt 1 ]; then
    echo "Uso: $0 ARCHIVO" >&2     # el mensaje de error, a la salida de errores
    exit 1                         # y un código distinto de 0
fi

También: ${1:?Falta el archivo} corta el script con ese mensaje si $1 está vacío, y ${1:-valor} usa un valor por defecto.

$?: el código de salida

Cada orden termina con un número: 0 si ha ido bien, otro si no (1 error general, 2 mal uso, 126 sin permiso de ejecución, 127 orden no encontrada, 128+N muerto por la señal N, por ejemplo 130 = Ctrl+C).

$ grep -q root /etc/passwd; echo $? # 0: lo ha encontrado
$ grep -q pepito /etc/passwd; echo $? # 1: no lo ha encontrado
$ ls /no-existe; echo $? # 2

Para bash todo es texto: z=$x+$y guarda literalmente «3+4», no 7. Para hacer cuentas hay que pedirlo.

$(( )): la forma recomendada

$ x=3; y=4
$ z=$x+$y; echo $z # → 3+4  (solo ha juntado texto)
$ z=$((x + y)); echo $z # → 7
$ echo $(( (x - 1) * 2 )) # → 4
$ echo $(( 17 / 5 )) # → 3   (división ENTERA: sin decimales)
$ echo $(( 17 % 5 )) # → 2   (resto)
$ echo $(( 2 ** 10 )) # → 1024 (potencia)
$ echo $(( 0x1F )) # → 31  (0x = hexadecimal; 0 delante = octal: 010 vale 8)

• Dentro de $(( )) las variables pueden ir sin $: $((x + y)).
• Operadores: + - * / % **, comparaciones < > <= >= == != (dan 1 o 0), lógicos && || !, y ++, --, +=.
• $[x + y] es la forma antigua (obsoleta) de lo mismo.

(( )) sin $: hacer y comparar

(( n++ ))                 # suma 1 a n (no muestra nada)
(( total += precio ))
if (( edad >= 18 )); then echo "mayor de edad"; fi   # condición con < > == normales

(( )) devuelve código 0 si el resultado es distinto de 0 (verdadero) y 1 si es 0 (falso).

let y declare -i

let a=x*2       # como (( )): sin $ y sin espacios (o con comillas: let "a = x * 2")
declare -i n    # n es entera: lo que le asignes se calcula
n=5+3; echo $n  # → 8

expr: la herramienta antigua

expr es un programa externo; cada número y operador va separado por espacios y el * hay que escaparlo:

$ expr 5 + 3 # → 8
$ expr 5 \* 3 # → 15  (sin \ el * sería un comodín)
$ cadena="Hola amigo"
$ expr length "$cadena" # → 10  (lo mismo que ${#cadena})
$ expr index "$cadena" "la" # → 3   (posición del primer carácter que coincide)
$ expr substr "$cadena" 2 5 # → ola a

Decimales: bc

Bash solo sabe de enteros. Para decimales, la calculadora bc:

$ echo "scale=2; 10/3" | bc # → 3.33  (scale = número de decimales)
$ bc <<< "scale=4; 3/6" # → .5000
$ bc -l <<< "s(1)" # -l carga la librería matemática (seno, logaritmos…)

Números al azar: $RANDOM

$RANDOM vale un número distinto (de 0 a 32767) cada vez que lo lees. Para un rango, usa el resto:

dado=$(( RANDOM % 6 + 1 ))      # de 1 a 6
secreto=$RANDOM                 # guárdalo: si vuelves a leer $RANDOM, será otro número
RANDOM=42                       # fija la «semilla»: a partir de aquí, siempre la misma secuencia

Bash puede recortar y cambiar el texto de una variable sin llamar a ningún programa (ni cut, ni sed, ni basename). Es la «expansión de parámetros». Practícala con ruta=/home/ana/fotos/playa.tar.gz y x=1234567890.

Longitud y trozos

Quitar por delante (#) y por detrás (%)

Buscar y reemplazar

f="foto de playa.jpg"
echo ${f/ /_}          # → foto_de playa.jpg   (solo la primera)
echo ${f// /_}         # → foto_de_playa.jpg   (todas)
echo ${f/#foto/img}    # → img de playa.jpg    (solo si está al principio)
echo ${f/%jpg/png}     # → foto de playa.png   (solo si está al final)

Se pueden usar comodines en lo que buscas: ${f//[aeiou]/} quita todas las vocales.

Mayúsculas y minúsculas

n="ana pérez"
echo ${n^}      # → Ana pérez    (la primera en mayúscula)
echo ${n^^}     # → ANA PÉREZ    (todas)
m="HOLA"
echo ${m,}      # → hOLA         (la primera en minúscula)
echo ${m,,}     # → hola         (todas)

Valores por defecto

destino=${1:-/tmp}       # el primer argumento, o /tmp si no te pasan nada
echo ${d:=hola}; echo $d # → hola  hola

Un ejemplo real: cambiar extensiones

for f in *.jpeg; do
    mv "$f" "${f%.jpeg}.jpg"     # foto.jpeg → foto.jpg
done

Más posibilidades: sección «Parameter Expansion» de man bash.

En bash una condición es cualquier orden: se cumple si termina con código 0. test, [ ], [[ ]] y (( )) son órdenes especiales que solo sirven para eso: comprobar algo y devolver 0 (sí) o 1 (no).

Las cuatro formas

Números

if [ "$edad" -ge 18 ]; then …
if (( edad >= 18 )); then …          # lo mismo

Texto

if [[ "$1" == [Ss]* ]]; then echo "Empieza por S"; fi
if [[ $1 =~ ^-?[0-9]+$ ]]; then echo "Es un número entero"; fi
if [ -z "$1" ]; then echo "No me has pasado nada"; fi

Con =~, lo que encaja queda en el array BASH_REMATCH (${BASH_REMATCH[0]} todo, [1] el primer grupo entre paréntesis).

Archivos

Negar y combinar

[ ! -d "$dir" ]                         # NO es una carpeta (espacio después del !)
[[ -f "$1" && -r "$1" ]]                # y
[[ "$r" == s || "$r" == S ]]            # o
[ -f "$1" ] && [ -r "$1" ]              # con [ ]: mejor dos corchetes unidos con && o ||
[ -f "$1" -a -r "$1" ]                  # -a (y) y -o (o) dentro de [ ]: forma antigua, desaconsejada

Cualquier orden vale como condición

if grep -q "^$usuario:" /etc/passwd; then echo "existe"; fi
if ping -c1 -W1 8.8.8.8 &>/dev/null; then echo "hay red"; fi
if ! mkdir copia 2>/dev/null; then echo "no he podido crearla"; fi

if / elif / else

if [[ $1 -gt 4 ]]
then
    echo "Mayor que 4"
elif [[ $1 -eq 4 ]]
then
    echo "Es 4"
else
    echo "Menor que 4"
fi

• then puede ir en la misma línea si pones ; antes: if [[ … ]]; then.
• elif y else son opcionales; puede haber tantos elif como quieras.
• Solo se ejecuta el primer bloque cuya condición se cumpla: los elif siguientes ya no se miran.
• Se cierra con fi (if al revés).

Una versión corta para cosas sencillas, con && (si va bien) y || (si va mal):

[ -d copia ] || mkdir copia                # si no existe la carpeta, la crea
[ $# -eq 0 ] && { echo "Falta un argumento"; exit 1; }
rm "$1" && echo "Borrado"                  # el echo solo si rm ha ido bien

Ejemplo: crear el archivo si no existe

#!/bin/bash
if [[ $# -eq 0 ]]; then
    echo "Tienes que darme un nombre" >&2
    exit 1
fi
if [[ ! -e "$1" ]]; then
    touch "$1"
    echo "Creado $1"
else
    echo "$1 ya existía"
fi

case: elegir según un valor

Cuando comparas la misma variable con muchos valores, case es más claro que una cadena de elif:

read -p "Elige (a/b/c): " opcion
case $opcion in
    a|A)
        echo "Has elegido fútbol" ;;
    b|B)
        echo "Has elegido baloncesto" ;;
    [0-9]*)
        echo "Eso es un número" ;;
    *)
        echo "Opción no válida" ;;
esac

• Cada caso es un patrón con comodines (*, ?, [ ]), no una expresión regular. | separa alternativas.
• ;; termina el caso y sale del case. *) al final recoge todo lo demás (como el else).
• Se cierra con esac (case al revés).
• Con ;;& en vez de ;; sigue comprobando los patrones siguientes; con ;& ejecuta también el bloque siguiente sin comprobarlo.

El case de los scripts de servicio

Los scripts de arranque clásicos (SysV, en /etc/init.d) tienen esta forma, y aún caen en el examen:

case "$1" in
    start)   arrancar ;;
    stop)    parar ;;
    restart) parar; arrancar ;;
    *)       echo "Uso: $0 {start|stop|restart}"; exit 1 ;;
esac

while: mientras se cumpla

contador=1
while [[ $contador -le 5 ]]
do
    echo "Vuelta $contador"
    contador=$((contador + 1))      # sin esto, el bucle no acaba nunca
done
echo "Fin"

• Primero comprueba la condición; si no se cumple ya al principio, no entra ni una vez.
• Algo de dentro tiene que hacer que la condición deje de cumplirse (aquí, sumar 1). Si no, es un bucle infinito: Ctrl+C para pararlo.

until: hasta que se cumpla

Es el mismo bucle con la condición al revés: repite mientras la condición sea falsa.

n=10
until [ $n -eq 0 ]; do
    echo $n
    n=$((n - 2))
done

Bucle infinito + break

A veces es más claro repetir «para siempre» y salir desde dentro:

secreto=$(( RANDOM % 100 + 1 ))
while true; do
    read -p "Número: " n
    if (( n < secreto )); then echo "Más alto"
    elif (( n > secreto )); then echo "Más bajo"
    else echo "¡Acertaste!"; break
    fi
done

• break sale del bucle (y sigue con lo que hay después del done). break 2 sale de dos bucles anidados.
• continue se salta lo que queda de esta vuelta y pasa a la siguiente.
• true y false son órdenes que siempre terminan con 0 y con 1. También vale while :.

Menú que se repite

while true; do
    echo "a) Ver la fecha   b) Ver quién soy   c) Salir"
    read -p "> " op
    case $op in
        a) date ;;
        b) whoami ;;
        c) break ;;
        *) echo "Opción no válida" ;;
    esac
done

Bash tiene una orden hecha para esto, select: select op in fecha yo salir; do … done numera las opciones y guarda la elegida en op (y el número en REPLY).

Leer un archivo línea a línea

read devuelve 0 mientras lee algo y 1 al llegar al final: es perfecto como condición de un while.

while read -r linea; do
    echo "→ $linea"
done < notas.txt                       # el archivo entra por el done

while IFS=: read -r usuario x uid gid resto; do
    (( uid >= 1000 )) && echo "$usuario"
done < /etc/passwd                     # IFS=: parte cada línea por los dos puntos

Leer carácter a carácter: while IFS= read -r -n1 c; do echo "$c"; done <<< "$texto".

for da una vuelta por cada elemento de una lista, y en cada vuelta la variable vale el siguiente.

Las listas que más se usan

for color in rojo verde azul; do echo "$color"; done      # lista escrita a mano
for n in {1..5}; do echo $n; done                         # 1 2 3 4 5
for n in {10..0..2}; do echo $n; done                     # 10 8 6 4 2 0 (paso 2, hacia atrás)
for n in $(seq 1 3 10); do echo $n; done                  # 1 4 7 10 (seq INICIO PASO FIN)
for f in *.txt; do wc -l "$f"; done                       # comodines: los archivos .txt
for f in /etc/*.conf; do echo "${f##*/}"; done            # solo el nombre
for arg in "$@"; do echo "[$arg]"; done                   # los argumentos del script
for u in $(cut -d: -f1 /etc/passwd); do echo $u; done     # la salida de una orden

• Si omites in …, for x; do recorre los argumentos ("$@").
• Las llaves {a..z} y {1..10} las expande bash: no admiten variables ({1..$n} no funciona; usa seq 1 $n o el for estilo C).

El for estilo C

for ((i = 1; i <= 10; i++)); do
    echo "7 x $i = $((7 * i))"
done

Tres partes: valor inicial; condición para seguir; qué hacer al final de cada vuelta. Las variables van sin $.

La trampa de $(cat archivo)

for linea in $(cat frutas.txt); do …     # NO va línea a línea: va PALABRA a palabra

La salida de $( ) se parte por espacios, tabuladores y saltos (lo que diga IFS). Si una línea tiene «manzana roja», salen dos vueltas. Para líneas, usa while read -r linea; do …; done < archivo (lección B08).

Patrones útiles

# Contar y sumar
total=0
for n in "$@"; do total=$((total + n)); done
echo "Suma: $total"

# Copia de seguridad de cada .conf con la fecha
for f in *.conf; do
    cp -- "$f" "$f.$(date +%F).bak"
done

# Cambiar la extensión de muchos archivos
for f in *.jpeg; do mv -- "$f" "${f%.jpeg}.jpg"; done

-- le dice a la orden que lo que viene ya no son opciones (por si un archivo empieza por guion).

Una función es un trozo de código con nombre. Se escribe una vez y se llama como si fuera una orden más.

Definir y llamar

saluda() {                      # forma habitual
    echo "Hola, $1"
}
function despide {              # forma de bash (también vale function despide() { … })
    echo "Adiós, $1"
}

saluda Ana                      # → Hola, Ana
despide "Luis Pérez"            # → Adiós, Luis Pérez

• Al llamarla no se ponen paréntesis: los argumentos van detrás separados por espacios, como en cualquier orden.
• Dentro de la función, $1, $2, $#, "$@" son los argumentos de la función, no los del script. ($0 sigue siendo el script.)
• Hay que definirla antes de llamarla: bash lee el script de arriba abajo.

Devolver cosas: return frente a echo

Una función tiene dos «salidas», como cualquier orden:

1. Su código de salida (0-255): return N. Sirve para if y &&. Sin return, devuelve el código de su última orden.
2. Lo que muestra: con echo. Se recoge con $( ), como la salida de cualquier orden.

es_par() {
    return $(( $1 % 2 ))        # 0 (verdadero) si es par
}
suma() {
    echo $(( $1 + $2 ))
}

if es_par 8; then echo "8 es par"; fi
resultado=$(suma 3 5)           # → 8
echo "La suma es $(suma 10 20)"

Variables locales

Las variables de un script son globales: la función las ve y las puede cambiar. Con local creas una que solo existe dentro de la función (y tapa a la global del mismo nombre).

a=5
f() {
    echo "global: $a"      # → global: 5
    local a=3
    echo "local: $a"       # → local: 3
    b=7                    # sin local: b existe también fuera
}
f
echo "fuera: $a $b"        # → fuera: 5 7

Funciones en tu shell

• Escritas en ~/.bashrc, quedan disponibles en cada terminal, como los alias pero con argumentos y lógica: mkcd() { mkdir -p "$1" && cd "$1"; }
• declare -f lista las funciones definidas (y su código); declare -F solo los nombres; type mkcd dice que es una función.
• unset -f mkcd la borra. export -f mkcd la pasa a los scripts hijos.
• Bash llama a command_not_found_handle cuando escribes una orden que no existe: es la función que en Ubuntu te sugiere qué paquete instalar.

Una función que corta el juego

intentos=0
cuenta_intento() {
    intentos=$((intentos + 1))           # global: se nota fuera
    if (( intentos > 10 )); then
        echo "GAME OVER"; exit 1         # exit dentro de una función termina TODO el script
    fi
}

Un array es una variable que guarda varios valores, cada uno en una posición (índice) que empieza en 0.

Crear y leer

frutas=(manzana "pera limonera" kiwi)   # tres elementos (las comillas juntan palabras)
frutas[3]=uva                           # añade en la posición 3
frutas+=(fresa melón)                   # añade al final
echo ${frutas[1]}                       # → pera limonera  (¡llaves obligatorias!)
echo ${frutas[@]}                       # todos los elementos
echo ${#frutas[@]}                      # cuántos hay → 6
echo ${!frutas[@]}                      # los índices → 0 1 2 3 4 5
echo ${frutas[-1]}                      # el último → melón
echo ${frutas[@]:1:2}                   # 2 elementos desde el 1
unset 'frutas[0]'                       # borra un elemento (los índices NO se recolocan)
unset frutas                            # borra el array entero

• declare -a lista declara un array vacío (también lista=()).
• Los índices pueden tener huecos: a=([1]=uno [5]=cinco).
• read -a palabras guarda en un array cada palabra que escribas.
• mapfile -t lineas < archivo (o readarray) guarda cada línea de un archivo en una posición.

Recorrerlo

for f in "${frutas[@]}"; do echo "- $f"; done    # con comillas: respeta «pera limonera»
for i in "${!frutas[@]}"; do echo "$i: ${frutas[$i]}"; done

Igual que con "$@" y "$*": "${a[@]}" da cada elemento por separado; "${a[*]}" los junta en una sola cadena.

Arrays asociativos (diccionarios)

En vez de números, los índices son palabras (claves). Hay que declararlos con declare -A:

declare -A capital
capital[Galicia]=Santiago
capital[Asturias]=Oviedo
capital+=([Cantabria]=Santander)
echo ${capital[Galicia]}                 # → Santiago
for region in "${!capital[@]}"; do       # ${!a[@]} da las claves
    echo "$region → ${capital[$region]}"
done

Ejemplo: elegir al azar

DIGITO=(0 1 2 3 4 5 6 7 8 9 A B C D E F)
n1=${DIGITO[$((RANDOM % 16))]}
n2=${DIGITO[$((RANDOM % 16))]}
echo "Byte al azar: $n1$n2"              # así se genera una MAC aleatoria: 00:1f:c6:32:$n1$n2:…

Ejemplo: piedra, papel o tijera

opciones=(piedra papel tijera)
read -p "¿piedra, papel o tijera? " tu
case $tu in piedra) t=0 ;; papel) t=1 ;; tijera) t=2 ;; *) echo "¡Trampa!"; exit 1 ;; esac
o=$(( RANDOM % 3 ))
echo "El ordenador saca ${opciones[$o]}"
if (( t == o )); then echo "Empate"
elif (( (t - o + 3) % 3 == 1 )); then echo "Ganas tú"
else echo "Gana el ordenador"
fi

(papel gana a piedra, tijera a papel, piedra a tijera: el que va «uno por delante» en la lista gana.)

Un script de verdad tiene que avisar bien cuando algo falla, no dejar basura y poder depurarse.

Mensajes y códigos de error

error() { echo "$0: $*" >&2; exit 1; }      # al canal de errores y con código 1
[ -r "$1" ] || error "no puedo leer $1"

• >&2 manda el mensaje a la salida de errores (stderr, el canal 2). Así, si alguien redirige la salida normal a un archivo, el error sigue saliendo en pantalla.
• Termina con exit 0 si todo ha ido bien y con otro número si no: otros scripts lo miran con $?, && o if.

Redirecciones que se usan en scripts

Here documents

cat > config.txt << EOF
usuario=$USER
fecha=$(date +%F)
EOF

Con << 'EOF' (comillas) no se sustituyen las variables. Con <<- EOF se quitan los tabuladores del principio de cada línea.

Canales propios con exec

exec 3> registro.log        # abre el canal 3 hacia un archivo
echo "empiezo" >&3
exec 3>&-                   # lo cierra
exec 2> errores.log         # desde aquí, TODOS los errores del script van a ese archivo

trap: reaccionar a señales

tmp=$(mktemp)                              # un archivo temporal con nombre único
trap 'rm -f "$tmp"; echo "Limpio"' EXIT    # al terminar (bien, mal o con Ctrl+C) se borra
trap 'echo "No me pararás"' INT            # Ctrl+C (señal 2, SIGINT) ya no corta el script
trap '' TERM                               # ignorar SIGTERM (15)
trap - INT                                 # volver al comportamiento normal
trap -p                                    # ver las trampas puestas

• La señal 9 (SIGKILL) y la 19 (SIGSTOP) no se pueden capturar ni ignorar.
• trap '' HUP es un nohup casero: el script sigue aunque cierres la terminal.

Modo estricto y depuración

set -e            # sale en cuanto una orden falla
set -u            # error si usas una variable que no existe (adiós a rm -rf "$DIR_VACIO"/…)
set -o pipefail   # una tubería falla si falla cualquiera de sus órdenes, no solo la última
set -x            # enseña cada orden antes de ejecutarla (set +x lo apaga)

Mucha gente empieza sus scripts con set -euo pipefail. Para depurar: bash -x script.sh, bash -n script.sh y shellcheck.

Ya tienes todas las piezas. Un script completo suele seguir este orden: comprobar los argumentos, preparar variables, definir funciones, hacer el trabajo y salir con el código adecuado. Estos cinco proyectos son los del curso de q2dg, adaptados; el nivel 20 de lpic tiene versiones que se corrigen solas.

1. Adivina el número

#!/bin/bash
secreto=$(( RANDOM % 100 + 1 ))
intentos=0
while true; do
    read -p "Número (1-100): " n
    [[ $n =~ ^[0-9]+$ ]] || { echo "Eso no es un número"; continue; }
    intentos=$((intentos + 1))
    if (( n < secreto )); then echo "Más alto"
    elif (( n > secreto )); then echo "Más bajo"
    else echo "¡Acertaste en $intentos intentos!"; break
    fi
    (( intentos == 10 )) && { echo "GAME OVER: era $secreto"; exit 1; }
done

Piezas: $RANDOM, while true + break, read, =~, (( )), continue.

2. Menú de administración

#!/bin/bash
menu() {
    echo "1) Espacio en disco  2) Memoria  3) Quién está conectado  4) Salir"
}
while true; do
    menu
    read -p "> " op
    case $op in
        1) df -h / ;;
        2) free -h ;;
        3) who ;;
        4) echo "Adiós"; exit 0 ;;
        *) echo "Opción no válida" >&2 ;;
    esac
done

3. Copia de seguridad con fecha

#!/bin/bash
set -euo pipefail
origen=${1:?Uso: $0 CARPETA [DESTINO]}
destino=${2:-$HOME/copias}
[ -d "$origen" ] || { echo "$origen no es una carpeta" >&2; exit 1; }
mkdir -p "$destino"
archivo="$destino/$(basename "$origen")-$(date +%F_%H%M).tar.gz"
tar czf "$archivo" -C "$(dirname "$origen")" "$(basename "$origen")"
echo "Copia creada: $archivo ($(du -h "$archivo" | cut -f1))"

Para hacerla cada noche, una línea en crontab -e: 30 2 * * * $HOME/bin/copia.sh $HOME/Documentos.

4. Informe de un log

#!/bin/bash
log=${1:-/var/log/auth.log}
echo "== Intentos fallidos por IP =="
grep "Failed password" "$log" | grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' | sort | uniq -c | sort -rn | head -5
echo "== Usuarios atacados =="
grep "Failed password" "$log" | sed -E 's/.*for (invalid user )?([^ ]+) from.*/\2/' | sort | uniq -c | sort -rn

5. Usuarios en lote desde un archivo

#!/bin/bash
# usuarios.txt: nombre:grupo, uno por línea
while IFS=: read -r nombre grupo; do
    [[ -z $nombre || $nombre == \#* ]] && continue      # salta líneas vacías y comentarios
    if id "$nombre" &>/dev/null; then
        echo "$nombre ya existe"
    else
        sudo useradd -m -G "$grupo" "$nombre" && echo "Creado $nombre"
    fi
done < usuarios.txt

Cómo atacar un script nuevo

1. Escribe primero, en comentarios, los pasos en castellano.
2. Hazlo funcionar con un caso fácil; luego añade las comprobaciones (argumentos, archivos que no existen…).
3. Pruébalo con bash -x y pásale shellcheck.
4. Pon comillas a todas las variables y local en las funciones.

Shell y terminal no son lo mismo

• La shell es el programa que entiende lo que escribes y lo ejecuta. En Linux la habitual es bash; hay otras: dash, zsh, ksh, tcsh, fish. Cada una tiene su sintaxis.
• La terminal es la ventana o pantalla donde escribes: - Consolas virtuales (Ctrl+Alt+F1…F6): pantallas de texto con su propio inicio de sesión. Se llaman tty1, tty2… (/dev/tty1). - Emuladores de terminal dentro del escritorio (konsole, kitty, gnome-terminal): cada ventana es una pseudoterminal, pts/0, pts/1… (/dev/pts/0).
• La orden tty dice en cuál estás. Linux distingue mayúsculas y minúsculas: Hola, hola y HOLA son tres archivos distintos.

El prompt

xacobo@slimbook:~/Documentos$ te dice el usuario, el equipo, la carpeta actual (~ es tu carpeta personal) y si eres un usuario normal ($) o root (#). Se configura con la variable PS1 (lección T03).

Rutas absolutas y relativas

• Absoluta: empieza por / y se cuenta desde la raíz. Funciona estés donde estés: /etc/ssh/sshd_config.
• Relativa: no empieza por / y se cuenta desde la carpeta actual: Documentos/notas.txt.
• Atajos: . la carpeta actual · .. la de arriba · ~ tu carpeta personal · ~ana la de ana · - (en cd) la anterior.

$ pwd # dónde estoy (print working directory)
$ cd /etc # absoluta
$ cd ssh # relativa: ahora en /etc/ssh
$ cd .. # sube a /etc
$ cd - # vuelve a la anterior (/etc/ssh); usa la variable OLDPWD
$ cd # sin nada: a tu carpeta personal

La jerarquía de carpetas (FHS)

No hay letras de unidad como en Windows: todo cuelga de una única raíz /, y los discos se montan en carpetas.

¿Dónde está este programa?

$ which ls # la ruta del ejecutable que se usaría (busca en el PATH)
$ type ls # qué es: alias, función, orden interna (builtin) o archivo
ls es un alias de «ls --color=auto»
$ type -a echo # todas: builtin y /usr/bin/echo
$ whereis ls # binario, código fuente y página de manual
$ dpkg -S /usr/bin/ls # ¿de qué paquete viene? (rpm -qf en Red Hat) → coreutils

La ayuda

• man orden abre el manual: /palabra busca, n siguiente, N anterior, q sale. Las opciones entre [ ] son opcionales.
• Secciones: 1 órdenes de usuario · 5 formatos de archivos (man 5 passwd) · 8 órdenes de administración · 2 llamadas al sistema · 3 funciones de librerías · 7 miscelánea (man 7 signal).
• man -k palabra (= apropos) busca en las descripciones; whatis orden da la línea de resumen. info orden y orden --help son otras ayudas.

ls y lo que dice ls -l

$ ls -l notas.txt
-rw-r--r-- 1 xacobo xacobo 210 sep  1 10:00 notas.txt

De izquierda a derecha: tipo (- archivo, d carpeta, l enlace simbólico, b/c dispositivos, p tubería, s socket), permisos (rwx del dueño, del grupo y del resto), número de enlaces duros, dueño, grupo, tamaño en bytes, fecha de modificación y nombre.

Copiar, mover, borrar, crear

Comodines (globbing)

La shell los cambia por los nombres que encajan antes de ejecutar la orden:

• Los comodines no encajan con los archivos ocultos salvo que lo pidas (.*) o actives shopt -s dotglob.
• shopt -s globstar activa **: todas las subcarpetas (ls **/*.txt). shopt -s extglob permite !(*.txt) (todo menos los .txt).
• \* o '*' quitan el significado especial.

Llaves (no son comodines)

Las llaves generan texto aunque los archivos no existan:

$ mkdir carpeta{A,B,C} # carpetaA carpetaB carpetaC
$ cp config{,.bak} # = cp config config.bak
$ echo {1..5} {a..e..2} # 1 2 3 4 5 a c e
$ echo {1..3}{x,y} # 1x 1y 2x 2y 3x 3y

Enlaces duros y simbólicos

readlink -f enlace da la ruta real a la que apunta. Ojo con ln -s: la ruta guardada es relativa a donde está el enlace, no a donde estás tú.

Variables del sistema que hay que conocer

Añadir una carpeta al PATH sin perder las que hay: export PATH="$PATH:/opt/miprograma/bin". Si pusieras PATH=/opt/… a secas, dejarías de encontrar ls, cp…

PS1: personalizar el prompt

\u usuario · \h equipo (\H completo) · \w ruta completa · \W solo la carpeta · \d fecha · \t hora (24 h) · \$ # si eres root y $ si no · \n salto de línea · \[\e[32m\] color (entre \[ \] para que bash calcule bien el ancho).

$ SAVE=$PS1 # guárdalo antes de jugar
$ PS1='\t \u@\H:\w\$ '
$ PS1=$SAVE; unset SAVE # y recupéralo

Alias

$ alias ll='ls -lah' # sin espacios junto al =
$ alias # lista los alias
$ unalias ll # lo borra
$ \ls # ejecuta ls saltándose el alias (también: command ls)

Un alias no admite argumentos en medio: para eso, una función (lección B10).

Historial

• history lista las órdenes; history 10 las 10 últimas; history -c borra el de la sesión; history -d 25 borra la 25; history -a / -w las escribe ya en el archivo (~/.bash_history), que si no se actualiza al cerrar la terminal.
• Cada terminal abierta tiene su propio historial en memoria: por eso dos ventanas «no se ven» hasta que se cierran.

• HISTCONTROL=ignoredups no guarda repetidas seguidas; ignorespace no guarda las que empiezan por espacio; ignoreboth las dos cosas; erasedups borra todas las repetidas.
• HISTIGNORE="ls*:cd*" no guarda esas órdenes. HISTTIMEFORMAT="%F %T " añade fecha y hora a history.
• set +o history deja de apuntar; set -o history vuelve a apuntar.

Archivos de inicio

Shell de login: consola virtual, ssh, su -, bash -l. Sin login: abrir una terminal en el escritorio, bash, su sin guion.

Mensajes de bienvenida

/etc/issue sale antes del login en las consolas (admite \n equipo, \l terminal, \r versión del kernel, \d fecha, \4 la IP); /etc/issue.net antes del login remoto; /etc/motd después de entrar (con ~/.hushlogin no se muestra). Para adornarlos: figlet, toilet, cowsay.

Un filtro lee texto (de un archivo o de la entrada), lo transforma y lo escribe en la salida. Se encadenan con |.

Ver y trocear

Las líneas de la 5 a la 8: head -n 8 f | tail -n 4 o sed -n '5,8p' f.

Cortar columnas

$ cut -d: -f1,7 /etc/passwd # campos 1 y 7, separados por «:»
$ cut -d, -f2- ventas.csv # del campo 2 al final
$ cut -c1-4,6 notas.txt # caracteres 1 a 4 y el 6
$ date | cut -d' ' -f4 # un campo de la salida de date (ojo con los espacios dobles)

cut solo admite un carácter separador. Si los campos están separados por varios espacios, antes tr -s ' ' o usa awk.

Ordenar y quitar repetidos

El clásico «¿qué se repite más?»: sort f | uniq -c | sort -rn | head.

Juntar y comparar

Transformar

Cada proceso nace con tres canales abiertos: 0 stdin (entrada, el teclado), 1 stdout (salida, la pantalla) y 2 stderr (errores, también la pantalla). Las redirecciones los cambian de sitio.

Redirecciones

set -o noclobber (set -C) impide que > pise archivos; >| lo fuerza.

Tuberías

orden1 | orden2: la salida de la primera es la entrada de la segunda. Solo pasa stdout; para pasar también los errores, orden1 2>&1 | orden2 o orden1 |& orden2.

$ ls /etc | wc -l # cuántas cosas hay en /etc
$ ls -l /etc | grep '^d' # solo las carpetas
$ grep usuario /etc/shadow | cut -d: -f2 # el hash de la contraseña de «usuario»
$ history | sed -E 's/^ +[0-9]+ +//' | sort | uniq -c | sort -rn | head -5 # tus 5 órdenes más usadas

Muchas órdenes usan - como nombre de archivo para decir «la entrada estándar»: tar cf - . | (cd /destino && tar xf -).

tee: ver y guardar a la vez

$ ls /root 2>&1 | tee registro.log # en pantalla y en el archivo
$ make | tee -a compilacion.log # -a añade en vez de pisar

Diferencias: ls /root 2> f (solo errores al archivo) · ls /root &> f (todo al archivo, nada en pantalla) · ls /root | tee f (la salida a los dos sitios; los errores, solo a la pantalla).

Encadenar órdenes

(date; who) > informe.txt o { date; who; } > informe.txt guardan las dos salidas juntas.

xargs: de la entrada a argumentos

Algunas órdenes (rm, cp, mkdir…) no leen la entrada: quieren argumentos. xargs los construye:

$ find . -name '*.tmp' | xargs rm # rm con todos los archivos encontrados
$ find . -name '*.tmp' -print0 | xargs -0 rm # -0: seguro con nombres con espacios
$ cat lista.txt | xargs -n 2 echo # de 2 en 2
$ ls *.jpg | xargs -I{} cp {} copia/{} # -I{}: dónde poner cada nombre

Más avanzado

• orden <(otra): la salida de otra como si fuera un archivo: diff <(sort a) <(sort b), comm <(sort a) <(sort b).
• mkfifo tubo: una tubería con nombre. En una terminal ls > tubo, en otra head < tubo.
• exec 3> f abre el canal 3; echo hola >&3; exec 3>&- lo cierra. exec 2> errores.log manda todos los errores siguientes al archivo.
• pv entre dos tuberías enseña el progreso: cat grande | pv | gzip > grande.gz.

Una expresión regular (regex) es un patrón para buscar texto. No es lo mismo que los comodines de la shell: aquí * y ? significan otra cosa.

Los símbolos

Clases con nombre (dentro de corchetes): [[:digit:]] cifras · [[:alpha:]] letras · [[:alnum:]] letras y cifras · [[:upper:]] / [[:lower:]] · [[:space:]] espacios, tabuladores y saltos · [[:blank:]] espacio y tabulador · [[:punct:]] signos.

Básicas frente a extendidas

En las básicas (BRE, lo que usa grep y sed sin opciones) + ? { } ( ) | son caracteres normales y para usarlos como especiales hay que escribir \+ \? \{ \} \( \) \|. En las extendidas (ERE: grep -E, egrep, sed -E o sed -r) funcionan tal cual.

$ grep 'ab\{2\}' f # básica
$ grep -E 'ab{2}' f # extendida, lo mismo

grep

$ grep -c 'nologin$' /etc/passwd # cuántos usuarios no pueden entrar
$ grep -vE '^(#|$)' /etc/ssh/sshd_config # la configuración sin comentarios ni líneas vacías
$ grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' access.log | sort | uniq -c # IPs que aparecen
$ grep -rn 'PermitRootLogin' /etc/ssh/ # dónde se configura algo

sed: editar sin abrir el archivo

sed lee línea a línea, aplica órdenes y escribe el resultado en pantalla. No toca el archivo salvo con -i.

locate: rápido, pero de una base de datos

locate palabra busca la palabra en todas las rutas del sistema, pero no en el disco: en una base de datos que se actualiza con updatedb (normalmente una vez al día, desde cron o un timer de systemd).

• Rapidísimo, pero puede enseñar archivos ya borrados y no ver los recién creados. Para ponerla al día: sudo updatedb.
• -i sin mayúsculas · -r con una regex · -n 20 solo 20 resultados · -c cuenta · -e solo los que siguen existiendo.
• Se configura en /etc/updatedb.conf: PRUNEPATHS (carpetas que no se indexan) y PRUNEFS (tipos de sistema de archivos que no).
• Hoy suele ser plocate o mlocate (paquetes distintos, mismas opciones).

find: lento, pero exacto y en tiempo real

find DÓNDE CONDICIONES ACCIONES. Recorre las carpetas de verdad.

Combinar: varias condiciones seguidas son y (-a, implícito); -o es o; ! o -not niega; los paréntesis van escapados:

$ find /usr -name '[a-f]*' -size -10k -user $USER # todas a la vez
$ find . \( -name '*.jpg' -o -name '*.png' \) -mtime -7 # jpg o png de la última semana
$ find /home -type f ! -user root # que NO sean de root

Acciones

$ find /var/log -name '*.gz' -mtime +30 -delete
$ find . -name '*.sh' -exec chmod +x {} \;
$ find / -perm -4000 -type f 2>/dev/null # todos los programas setuid
$ find ~ -type f -size +100M -perm 644 -user $USER

Encontrar órdenes

• which orden: la ruta del ejecutable que se usaría (busca en el PATH).
• whereis orden: binario, fuentes y manual (whereis -m ls solo el manual).
• type orden: si es alias, función, builtin o archivo.

Un proceso es un programa en marcha. Cada uno tiene un PID (su número), un PPID (el PID de su padre), un dueño y un estado. El primero, PID 1, es systemd (o init): todos los demás descienden de él.

ps: una foto

Columnas útiles: TTY (? = no tiene terminal: un demonio) · TIME (tiempo de CPU usado) · VSZ (memoria virtual reservada, KB) · RSS (memoria RAM real que usa ahora, KB) · STAT (estado):

Buscar procesos: pgrep -l ssh (PID y nombre; -u ana, -a con argumentos, -f busca también en los argumentos), pidof sshd (los PID de un programa exacto).

top: la película

Arriba, el resumen: hora, tiempo encendido (uptime), usuarios y carga media (1, 5 y 15 minutos), número de procesos por estado, CPU (us usuario, sy sistema, ni con nice, id libre, wa esperando E/S, hi/si interrupciones, st robado por el hipervisor) y memoria y swap (lo mismo que free -h).

Opciones al lanzarlo: top -d 5 (refrescar cada 5 s), -u ana, -n 1 -b (una sola vez, en modo texto: para scripts). htop es una versión más cómoda.

Carga media: cuántos procesos quieren CPU de media. Si es igual al número de núcleos (nproc), la CPU va justa; si es mayor, hay procesos esperando.

Señales

$ kill 1234 # SIGTERM al PID 1234
$ kill -9 1234 # SIGKILL (también kill -KILL o kill -s SIGKILL)
$ kill -HUP $(pidof nginx)
$ killall firefox # a todos los procesos con ese nombre exacto (-i pregunta, -u por usuario)
$ pkill -u ana # por patrón o por usuario/terminal (-t pts/1)
$ kill -l # lista de señales (man 7 signal)

Primer y segundo plano

Prioridades: nice

El valor nice va de -20 (más prioridad) a 19 (menos). Por defecto 0. Solo root puede bajarlo (dar más prioridad).

$ nice -n 10 ./copia.sh # arrancar con nice 10 (sin -n, suma 10)
$ renice -n 5 -p 1234 # cambiar uno que ya está en marcha (-u ana: todos los de ana)
$ ps -o pid,ni,cmd -p 1234 # columna NI; en top, PR y NI

Memoria y tiempo

• free -h: total, usada, libre, buff/cache (la RAM que Linux usa de caché y suelta si hace falta) y swap.
• uptime: hora, tiempo encendido, usuarios y carga media (la misma línea que arriba de top y de w).
• time orden: cuánto tarda (real = reloj; user + sys = CPU usada).
• watch -n 2 'ps aux | grep ssh': repite una orden cada 2 s (-d resalta lo que cambia).

Nombres de los discos

/dev/sda, /dev/sdb… discos SATA, SCSI y USB; /dev/sda1, /dev/sda2… sus particiones. /dev/nvme0n1 y su partición /dev/nvme0n1p1 para NVMe; /dev/vda en máquinas virtuales; /dev/sr0 el lector de CD/DVD.

Ver lo que hay

Particionar

• MBR (tabla «msdos»): hasta 4 particiones primarias; para más, una de ellas es extendida y dentro van las lógicas (sda5, sda6…). Discos de hasta 2 TiB.
• GPT: hasta 128 particiones, todas iguales (ni extendidas ni lógicas), discos enormes, copia de la tabla al final del disco. Necesaria para arrancar con UEFI.
• Herramientas: fdisk (MBR y GPT), gdisk (GPT), parted (las dos, también sin preguntas) y gráficas como gparted.
• Dentro de fdisk: m ayuda · p ver · n nueva · d borrar · t tipo (82 swap, 83 Linux, 8e LVM) · a marcar arrancable · w guardar y salir · q salir sin guardar.

Esquema de particiones típico

/ (raíz) y swap, como mínimo. Separar /home (reinstalar sin perder los datos), /var (que un log desbocado no llene la raíz), /tmp y /boot (o la ESP en UEFI, FAT32, montada en /boot/efi). En servidores, LVM permite crecer volúmenes en caliente: discos físicos (PV, pvcreate) → grupo de volúmenes (VG, vgcreate) → volúmenes lógicos (LV, lvcreate, /dev/vg/lv).

Formatear

$ mkfs.ext4 -L datos /dev/sdb1 # = mkfs -t ext4; -L etiqueta
$ mkfs.xfs /dev/sdb2
$ mkfs.vfat -F 32 /dev/sdb3 # FAT32 (para la ESP o un USB)
$ mkswap /dev/sdb4 && swapon /dev/sdb4 # swap; swapon --show (o free) para verla, swapoff para quitarla

tune2fs -L nueva /dev/sdb1 cambia la etiqueta de un ext4; tune2fs -c 30 comprobar cada 30 montajes; dumpe2fs enseña sus datos internos. Los valores por defecto de mkfs.ext4 están en /etc/mke2fs.conf.

Comprobar y reparar

fsck /dev/sdb1 (llama a fsck.ext4, fsck.vfat…; para XFS, xfs_repair). Siempre desmontado. -n solo mira, no cambia nada · -y responde sí a todo · -p/-a repara lo seguro sin preguntar · -f aunque parezca limpio · -c (ext) busca bloques defectuosos con badblocks. Lo que recupera sin nombre va a lost+found.

Montar

$ mount /dev/sdb1 /mnt/datos # monta (detecta el tipo; -t ext4 para forzarlo)
$ mount -o ro,noexec /dev/sdb1 /mnt/datos # con opciones
$ mount -o loop imagen.iso /mnt/iso # un archivo .iso como si fuera un disco
$ mount -o remount,rw / # cambiar opciones de algo ya montado
$ umount /mnt/datos # desmontar (por carpeta o por dispositivo)
$ umount -l /mnt/datos # «perezoso»: cuando dejen de usarlo

«target is busy» al desmontar: alguien lo está usando. lsof /mnt/datos o fuser -vm /mnt/datos dicen quién.

/etc/fstab: lo que se monta al arrancar

# dispositivo                              punto       tipo   opciones           dump  pass
UUID=3f1c…-a2b4                            /           ext4   defaults           0     1
UUID=9a7e…-11cd                            /home       ext4   defaults,noatime   0     2
LABEL=datos                                /srv/datos  xfs    defaults,nofail    0     2
/dev/sdb4                                  none        swap   sw                 0     0
//servidor/compartida                      /mnt/smb    cifs   credentials=/root/.smb,_netdev  0  0

• Mejor UUID o LABEL que /dev/sdb1: el nombre puede cambiar si cambias los discos de sitio.
• dump: 1 = hacer copia con la orden dump (casi siempre 0). pass: orden de fsck al arrancar: 1 la raíz, 2 las demás, 0 nunca.
• Opciones: defaults (= rw, suid, dev, exec, auto, nouser, async) · ro/rw · noexec (no ejecutar programas) · nosuid · noauto (no al arrancar, sí a mano) · user (cualquier usuario puede montarlo y solo él desmontarlo) · users (cualquiera las dos cosas) · noatime (no apuntar la fecha de acceso: más rápido) · sync/async · nofail (si no está, arranca igual) · _netdev (es de red).
• mount -a monta todo lo del fstab que no esté montado: pruébalo antes de reiniciar. Con systemd, después systemctl daemon-reload.

dd: copia byte a byte

$ dd if=/dev/sda of=/dev/sdb bs=4M status=progress # clonar un disco entero
$ dd if=/dev/sr0 of=cd.iso # imagen de un CD
$ dd if=ubuntu.iso of=/dev/sdc bs=4M conv=fsync # grabar una ISO en un USB (¡comprueba bien la letra!)
$ dd if=/dev/zero of=archivo.img bs=1M count=100 # un archivo de 100 MB lleno de ceros
$ dd if=/dev/sda of=mbr.bin bs=512 count=1 # copia del MBR (primer sector)

if entrada · of salida · bs tamaño de bloque · count cuántos bloques · skip/seek saltar bloques en la entrada/salida · conv=noerror,sync seguir aunque haya errores de lectura.

Dos cosas distintas que se suelen hacer juntas:

• Empaquetar (archivar): juntar muchos archivos en uno, sin reducir tamaño. tar, cpio.
• Comprimir: reducir el tamaño de un archivo. gzip, bzip2, xz.

Compresores

• Comprimen en el sitio: gzip informe.txt deja informe.txt.gz y borra el original. Con -k se lo queda; con -c escribe en la salida (gzip -c f > f.gz).
• -1 rápido y poca compresión … -9 lento y máxima. -v informa; -t comprueba que no está dañado; -l (gzip) enseña tamaños; -r (gzip) recorre carpetas comprimiendo cada archivo.
• De menos a más compresión (y de más a menos velocidad): gzip → bzip2 → xz.

tar

Las opciones de tar se pueden escribir sin guion (tar czf). Una acción y luego modificadores:

$ tar cvf copia.tar Documentos/ # empaquetar
$ tar czf copia.tar.gz Documentos/ # empaquetar y comprimir con gzip (.tgz)
$ tar cjf copia.tar.bz2 Documentos/ # con bzip2
$ tar cJf copia.tar.xz Documentos/ # con xz
$ tar tzf copia.tar.gz # ver qué hay dentro
$ tar xzf copia.tar.gz -C /tmp # extraer en /tmp
$ tar xf copia.tar.xz # el tar moderno detecta la compresión al extraer
$ tar xzf copia.tar.gz Documentos/notas.txt # extraer solo un archivo
$ tar cf - Documentos | ssh servidor 'tar xf - -C /copias' # copiar una carpeta por la red

• tar quita la / inicial de las rutas absolutas (para no pisar el sistema al extraer); -P la conserva.

cpio

Lee la lista de archivos por la entrada (normalmente de find) y escribe el paquete por la salida:

$ find Documentos | cpio -ov > copia.cpio # -o crear (copy-out)
$ cpio -idv < copia.cpio # -i extraer (copy-in), -d crear carpetas
$ cpio -tv < copia.cpio # listar

Los initramfs de Linux son archivos cpio comprimidos.

Otras

• split -b 100M grande.iso trozo_ parte un archivo; se junta con cat trozo_* > grande.iso.
• dd hace copias byte a byte de discos o particiones (lección T09).
• rsync -av origen/ destino/ sincroniza carpetas copiando solo lo que cambia (también por ssh).

Los tres archivos

/etc/passwd   ana:x:1001:1001:Ana Pérez,,,:/home/ana:/bin/bash
              usuario:contraseña:UID:GID:comentario (GECOS):home:shell
/etc/shadow   ana:$6$sal$hash…:20000:0:99999:7:::
              usuario:hash:último cambio:mín:máx:aviso:inactivo:caduca:(reservado)
/etc/group    desarrollo:x:1005:ana,luis
              grupo:contraseña:GID:miembros (como grupo SECUNDARIO)

• passwd lo lee todo el mundo (permisos 644); por eso las contraseñas van en shadow (640 o 600, solo root). La x del segundo campo dice «está en shadow».
• UID 0 = root, sea cual sea su nombre. Usuarios de sistema (para servicios): UID por debajo de 1000; personas: desde 1000 (UID_MIN en /etc/login.defs).
• Una shell /usr/sbin/nologin o /bin/false impide entrar: típico de los usuarios de servicios.
• En shadow, el hash empieza por el algoritmo: $1$ MD5 · $5$ SHA-256 · $6$ SHA-512 · $y$ yescrypt (el actual en Debian/Ubuntu). Un ! o * delante = cuenta bloqueada; campo vacío = sin contraseña.
• Las fechas de shadow son días desde el 1-1-1970.
• Las contraseñas de grupo están en /etc/gshadow. Para editar passwd/group a mano con bloqueo: vipw y vigr (-s para shadow/gshadow).

Crear, cambiar y borrar

Contraseñas y caducidad

Los valores para usuarios nuevos: PASS_MAX_DAYS, PASS_MIN_DAYS, PASS_WARN_AGE en /etc/login.defs.

Quién soy y quién hay

id (UID, GID y grupos; id -un solo el nombre) · whoami · groups ana · who (quién está conectado; -H cabeceras, -q cuántos) · w (quién y qué hace, con la carga) · users · last (últimos inicios de sesión, de /var/log/wtmp; last -n 10, last ana, last reboot) · lastb (intentos fallidos, /var/log/btmp) · lastlog (último acceso de cada usuario).

su y sudo

• su - (o su -l) abre una shell de login: carga el entorno de root (PATH, HOME). su sin guion conserva tu entorno. su -c 'orden' ana ejecuta solo eso.
• sudo -i shell de login como root · sudo -s shell como root · sudo -l qué puedes hacer · sudo -k olvidar la contraseña ya dada · sudo -u ana orden.

/etc/sudoers

Se edita siempre con visudo (comprueba la sintaxis antes de guardar: un error aquí te deja sin sudo). Mejor aún, un archivo en /etc/sudoers.d/.

# quién    desde_qué_equipo = (como_quién)   qué_órdenes
root       ALL=(ALL:ALL) ALL
%sudo      ALL=(ALL:ALL) ALL                 # % = un grupo (en Red Hat, %wheel)
ana        ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx
Cmnd_Alias RED = /usr/sbin/ip, /usr/bin/ping
luis       ALL = RED
Defaults   timestamp_timeout=10              # minutos que recuerda la contraseña

Para dar sudo a alguien, lo normal es meterlo en el grupo: usermod -aG sudo ana (Debian/Ubuntu) o wheel (Red Hat).

Otros archivos de acceso

• /etc/nologin: si existe, solo root puede entrar (y los demás ven su contenido).
• /etc/securetty: terminales desde las que root puede entrar directamente (en desuso).
• Límites por usuario: ulimit -a (ver), ulimit -n 4096 (archivos abiertos), y para siempre en /etc/security/limits.conf.

Ver el hardware

/proc y /sys: el kernel por dentro

No están en el disco: el kernel los genera en memoria al vuelo.

• /proc: una carpeta por proceso (/proc/1234) y datos del sistema: cpuinfo, meminfo, interrupts (IRQ), ioports, dma, devices, partitions, mounts, cmdline (parámetros con los que arrancó el kernel), modules, version.
• /proc/sys/: parámetros del kernel que se pueden cambiar en caliente: echo 1 > /proc/sys/net/ipv4/ip_forward, o sysctl -w net.ipv4.ip_forward=1; para siempre, en /etc/sysctl.conf o /etc/sysctl.d/.
• /sys (sysfs): los dispositivos ordenados por bus y clase (/sys/class/net/, /sys/block/), con sus atributos.
• /dev: los archivos de dispositivo. Los crea udev al vuelo.

udev: los dispositivos que aparecen y desaparecen

Cuando conectas algo (un USB, por ejemplo), el kernel lo anuncia y udev (systemd-udevd): crea el archivo en /dev, le pone nombre y permisos, carga el módulo que haga falta y avisa al escritorio (vía D-Bus).

• Reglas: /lib/udev/rules.d/ (las de los paquetes) y /etc/udev/rules.d/ (las tuyas, que mandan). Ej.: SUBSYSTEM=="usb", ATTR{idVendor}=="0781", SYMLINK+="mi_usb".
• udevadm monitor ver los eventos en directo · udevadm info /dev/sdb datos de un dispositivo · udevadm control --reload releer reglas.
• Dispositivos coldplug (ya estaban al arrancar) y hotplug (se conectan en marcha).

Módulos del kernel

Un módulo (.ko) es un trozo del kernel que se carga cuando hace falta: drivers, sistemas de archivos… Están en /lib/modules/$(uname -r)/.

Hacerlo permanente

Si el módulo va dentro del kernel o del initrd, sus parámetros se pasan en la línea del kernel (en GRUB): modulo.parametro=valor, y modprobe.blacklist=nouveau para bloquearlo al arrancar.

Las fases del arranque

1. Firmware (BIOS o UEFI): lo primero que se ejecuta. Hace el POST (comprobación del hardware: si falla antes de tener vídeo, pitidos) y busca un gestor de arranque.
2. Gestor de arranque (GRUB 2, systemd-boot, syslinux…): carga en memoria el kernel y el initrd, y le pasa parámetros.
3. Kernel: detecta el hardware, monta el initrd como raíz provisional, carga los módulos necesarios para llegar al disco de verdad, monta la raíz (root=) y lanza el primer proceso.
4. init (PID 1): hoy systemd (antes SysV init o Upstart). Arranca los servicios hasta llegar al objetivo (target) por defecto.

Los mensajes del arranque se ven con dmesg (kernel) y journalctl -b (todo, desde este arranque).

BIOS + MBR

• La BIOS lee el primer sector del disco (512 bytes): el MBR. Allí hay un trocito del gestor de arranque (446 bytes), la tabla de particiones (64 bytes: 4 entradas) y la firma 55AA.
• Como cabe tan poco, el gestor de arranque está partido: el trozo del MBR carga el resto (en GRUB, /boot/grub).
• La tabla MBR admite 4 primarias (o 3 + 1 extendida con lógicas dentro) y discos de hasta 2 TiB. Una partición se marca como activa (arrancable).
• Si instalas Windows después de Linux, el gestor de Windows pisa el MBR y Linux «desaparece» (los datos siguen ahí): se arregla reinstalando GRUB desde un live (lección T14).

UEFI + GPT

• El firmware UEFI entiende sistemas de archivos: busca una partición especial, la ESP (EFI System Partition): FAT32, de unos cientos de MB, marcada con un tipo GUID concreto, montada normalmente en **/boot/efi**.
• Dentro de la ESP hay una carpeta por sistema (EFI/ubuntu/grubx64.efi, EFI/Microsoft/…): varios gestores conviven sin pisarse. El de reserva es EFI/BOOT/BOOTX64.EFI.
• Qué arrancar y en qué orden se guarda en las variables EFI (memoria NVRAM de la placa). Desde Linux: efibootmgr (ver), efibootmgr -o 0001,0002 (orden), efibootmgr -c (crear entrada).
• Usa discos GPT: 128 particiones, todas iguales (sin extendidas, sin «activa»), discos enormes.
• Secure Boot: el firmware solo ejecuta binarios EFI firmados con claves que conoce. Las distribuciones usan un pequeño cargador firmado (shim) que luego carga GRUB.
• Muchas UEFI tienen un modo de compatibilidad (CSM, «legacy») que se comporta como una BIOS.
• El kernel de Linux puede arrancar directamente como programa EFI, sin gestor (EFISTUB).

El initrd (initramfs)

Un pequeño sistema de archivos que el gestor de arranque carga en memoria junto al kernel. Lleva los módulos y programas necesarios para llegar a la raíz de verdad: el driver del disco (RAID, NVMe…), el del sistema de archivos, LVM, cifrado… Así el kernel puede ser genérico y pequeño. Se regenera con update-initramfs -u (Debian) o dracut (Red Hat), y está en /boot/initrd.img-VERSIÓN.

Parámetros del kernel

Se escriben en la línea linux de GRUB (para siempre: GRUB_CMDLINE_LINUX en /etc/default/grub):

Con qué parámetros arrancó: cat /proc/cmdline.

SysV init, Upstart y systemd

• SysV init: niveles de ejecución (runlevels) 0 apagar · 1 (S) un usuario · 2-5 multiusuario (en Red Hat, 3 texto y 5 gráfico) · 6 reiniciar. Configuración en /etc/inittab; scripts en /etc/init.d/ y enlaces en /etc/rcN.d/ (S20apache arrancar, K80apache parar). runlevel dice el actual; telinit 3 / init 3 cambia.
• systemd usa targets: poweroff.target (0), rescue.target (1), multi-user.target (3), graphical.target (5), reboot.target (6). Lección T15.
• Apagar: shutdown -h now, shutdown -r +10 "Reinicio en 10 minutos", shutdown -c (cancelar), poweroff, reboot, halt. wall "mensaje" avisa a todos los conectados.

Dónde está cada cosa

Después de tocar /etc/default/grub o /etc/grub.d/:

$ sudo update-grub # Debian/Ubuntu (es un atajo de lo siguiente)
$ sudo grub-mkconfig -o /boot/grub/grub.cfg # cualquiera
$ sudo grub2-mkconfig -o /boot/grub2/grub.cfg # Red Hat, Fedora

/etc/default/grub

Los scripts de /etc/grub.d

00_header (lee /etc/default/grub) · 05_debian_theme (colores) · 10_linux (busca los kernels de /boot) · 20_memtest86+ · 30_os-prober (otros sistemas) · 40_custom (tus entradas). Se ejecutan por orden de número, que es también el orden del menú. Para quitar una sección: chmod -x /etc/grub.d/20_memtest86+ y regenerar.

Una entrada a mano (en 40_custom)

menuentry "Mi Debian" {
    set root=(hd0,2)                      # disco 0, partición 2 = /dev/sda2
    linux /boot/vmlinuz root=/dev/sda2 ro quiet
    initrd /boot/initrd.img
}
menuentry "Windows" {
    insmod ntfs
    insmod chain
    set root=(hd0,1)
    chainloader +1                        # le pasa el control al gestor de Windows (BIOS)
}

Durante el arranque

• e sobre una entrada: editarla solo para este arranque (por ejemplo, añadir single o systemd.unit=rescue.target al final de la línea linux). Ctrl+X o F10 arranca; Esc vuelve.
• c: consola de GRUB: ls (discos y particiones), ls (hd0,1)/, cat, set root=(hd0,2), linux /vmlinuz root=/dev/sda2, initrd /initrd.img, boot, insmod, help, reboot, halt.

Proteger con contraseña

$ grub-mkpasswd-pbkdf2 # te da el hash grub.pbkdf2.sha512…
# en /etc/grub.d/40_custom (o un 01_password ejecutable):
set superusers="admin"
password_pbkdf2 admin grub.pbkdf2.sha512.10000.…

Así nadie puede editar entradas ni usar la consola sin la contraseña. Con --unrestricted en un menuentry, esa entrada arranca sin pedirla.

Reparar GRUB desde un live

$ sudo mount /dev/sda2 /mnt # la raíz del sistema instalado
$ sudo mount /dev/sda1 /mnt/boot/efi # (UEFI) la ESP
$ for d in dev proc sys; do sudo mount --bind /$d /mnt/$d; done
$ sudo chroot /mnt # «entrar» en el sistema instalado
# grub-install /dev/sda                        # reinstalar (en BIOS va al MBR: se indica el DISCO, no la partición)
# update-grub
# exit

grub-install --boot-directory=/mnt/boot /dev/sda hace lo mismo sin chroot. grub-mkrescue -o rescate.iso crea un CD de rescate.

GRUB Legacy (el antiguo)

Aún aparece en el examen: configuración en /boot/grub/menu.lst (o grub.conf), que sí se editaba a mano, con default, timeout, y entradas title / root (hd0,0) / kernel / initrd. Se instalaba con grub-install o desde su shell con setup (hd0).

systemd es el PID 1 (el primer proceso), el que arranca y vigila los servicios, y mucho más (registros, red, hora…). Todo lo que gestiona es una unidad (unit), descrita en un archivo de texto.

Tipos de unidades

Dónde están

Si hay dos con el mismo nombre, gana la de /etc. Para cambiar solo unas líneas sin copiar el archivo entero: systemctl edit nginx crea /etc/systemd/system/nginx.service.d/override.conf (--full edita una copia completa). systemctl cat nginx enseña el resultado final; systemd-delta lista lo que está sobrescrito.

systemctl

Estados en list-unit-files: enabled (arranca al iniciar), disabled, static (no tiene sección [Install]: solo arranca como dependencia de otra), masked (prohibida), generated, transient.

Un archivo de unidad

[Unit]
Description=Mi copia de seguridad
Documentation=man:rsync(1)
After=network-online.target          # orden: arrancar DESPUÉS de esa
Wants=network-online.target          # dependencia suave (si falla, sigue)
# Requires= dependencia fuerte · Conflicts= no pueden estar a la vez · ConditionPathExists= solo si existe

[Service]
Type=simple                          # simple (por defecto) · forking · oneshot · notify · idle
ExecStartPre=/usr/local/bin/preparar.sh
ExecStart=/usr/local/bin/copia.sh
ExecStop=/bin/kill $MAINPID
Restart=on-failure                   # no · always · on-success · on-failure
RestartSec=5
User=copias

[Install]
WantedBy=multi-user.target           # enable crea un enlace en multi-user.target.wants/

• Type=oneshot para tareas que terminan (con RemainAfterExit=yes se considera «activa» después); forking para demonios clásicos que se van al segundo plano (con PIDFile=).
• Wants/Requires dicen qué arrancar también; After/Before dicen en qué orden. Son cosas distintas.
• Un - delante de una orden (ExecStart=-/ruta) ignora que falle.
• nombre@.service es una plantilla: getty@tty2.service es una instancia; dentro, %i vale tty2.

Targets (los «runlevels» de systemd)

$ systemctl get-default # el target con el que arranca
$ sudo systemctl set-default multi-user.target # arrancar en modo texto (cambia el enlace default.target)
$ sudo systemctl isolate rescue.target # cambiar ahora (como telinit 1)
$ systemctl rescue · systemctl poweroff · systemctl reboot · systemctl suspend

Otros

• systemd-analyze (cuánto tardó el arranque), systemd-analyze blame (qué servicio tardó más).
• systemctl list-timers (los .timer y cuándo toca); systemd-run --on-calendar=… para una tarea de una vez.
• hostnamectl, timedatectl, localectl, loginctl, journalctl: más herramientas de la familia.

Los programas, los servicios y el kernel cuentan lo que pasa en mensajes de registro. En un sistema con systemd los recoge systemd-journald (formato binario, se lee con journalctl); muchos sistemas tienen además rsyslog, que los escribe como texto en /var/log/.

journalctl

Prioridades (de más a menos grave): 0 emerg · 1 alert · 2 crit · 3 err · 4 warning · 5 notice · 6 info · 7 debug.

Guardarlo o no

• Por defecto el journal va a /run/log/journal (en memoria: se pierde al reiniciar) salvo que exista /var/log/journal.
• En /etc/systemd/journald.conf (o un archivo en journald.conf.d/): Storage=persistent (en disco) · volatile (en memoria) · auto (en disco si existe la carpeta) · none.
• Tamaño: SystemMaxUse=500M (disco), RuntimeMaxUse (memoria), MaxRetentionSec=1month.
• journalctl --disk-usage cuánto ocupa · --vacuum-size=200M / --vacuum-time=2weeks borrar lo viejo · --rotate · --verify · --flush (de memoria a disco).
• ForwardToSyslog=yes pasa los mensajes a rsyslog; ForwardToConsole=yes + TTYPath=/dev/tty12 los enseña en una consola.
• Los usuarios normales solo ven sus propios mensajes, salvo que estén en el grupo systemd-journal o adm.

Escribir en el registro

$ logger -t copia -p user.err "La copia ha fallado" # al syslog/journal, con etiqueta y prioridad
$ echo "Copia hecha" | systemd-cat -t copia -p info
$ journalctl -t copia

rsyslog y los archivos de /var/log

La configuración está en /etc/rsyslog.conf y /etc/rsyslog.d/*.conf. Cada regla es instalación.prioridad destino:

auth,authpriv.*          /var/log/auth.log       # todo lo de autenticación
*.*;auth,authpriv.none   -/var/log/syslog        # todo menos auth (el - = no sincronizar cada línea)
kern.warning             /var/log/kern.log       # warning o más grave
mail.=info               /var/log/mail.info      # SOLO info (el =)
*.emerg                  :omusrmsg:*             # a la terminal de todos
*.*                      @@192.168.1.50:514      # a otro servidor (@ UDP, @@ TCP)

• Instalaciones (facilities): auth, authpriv, cron, daemon, kern, lpr, mail, news, syslog, user, local0 … local7.
• prioridad incluye esa y las más graves; =prioridad solo esa; none ninguna; * todas.
• Archivos típicos: /var/log/syslog (Debian) o /var/log/messages (Red Hat), auth.log o secure, kern.log, dmesg, boot.log.
• Binarios que no se leen con cat: wtmp (last), btmp (lastb), lastlog (lastlog).
• Recibir de otras máquinas: activar imudp/imtcp en rsyslog.conf (puerto 514).

logrotate

Evita que los registros llenen el disco: cada cierto tiempo renombra syslog → syslog.1 → syslog.2.gz… y borra los más viejos. Configuración: /etc/logrotate.conf y /etc/logrotate.d/ (uno por programa). Se lanza a diario (cron o timer).

/var/log/miapp/*.log {
    weekly            # daily · weekly · monthly · size 100M
    rotate 4          # cuántas copias guardar
    compress          # comprimir las viejas (delaycompress: no la más reciente)
    missingok         # sin error si no existe
    notifempty        # no rotar si está vacío
    create 0640 root adm
    postrotate
        systemctl reload miapp
    endscript
}

Librerías compartidas

Un programa no lleva dentro todo su código: usa librerías compartidas (.so, shared object), que se cargan al ejecutarlo y comparten todos los programas. La principal es la libc (glibc): printf, malloc, open…

• Nombres: libssl.so.3 (el soname, con la versión) suele ser un enlace a libssl.so.3.0.13.
• ldd /usr/bin/ssh lista las librerías que necesita un programa y dónde las encuentra (not found = falta una).
• Quien las busca y las carga es el cargador dinámico: /lib64/ld-linux-x86-64.so.2 (ld.so). Mira, por este orden: 1. LD_LIBRARY_PATH (variable de entorno, carpetas separadas por :; útil para probar, no para siempre) 2. la caché /etc/ld.so.cache 3. /lib y /usr/lib (y sus variantes de 64 bits)
• La caché se genera con **ldconfig** a partir de /etc/ld.so.conf, que incluye /etc/ld.so.conf.d/*.conf (una carpeta por línea). Si instalas librerías en /opt/miapp/lib: añade esa ruta en un .conf de ld.so.conf.d/ y ejecuta sudo ldconfig.
• ldconfig -p lista las librerías que hay en la caché. ldconfig -v enseña lo que va encontrando.
• Una librería estática (.a) se copia dentro del programa al compilarlo: no hace falta luego, pero el programa pesa más.

Espiar lo que hace un programa

• strace orden enseña las llamadas al sistema (lo que el programa le pide al kernel): open, read, write, connect, execve… -e trace=open,openat solo esas (-e trace=file, network, process) · -p PID a uno en marcha · -f también a los hijos · -c resumen · -o archivo. Truco: strace -e trace=openat programa 2>&1 | grep -v ENOENT dice qué archivos de configuración lee de verdad.
• ltrace orden enseña las llamadas a funciones de librerías (printf, strlen, getenv…).

Paquetes en Debian/Ubuntu (.deb)

Repositorios en /etc/apt/sources.list y /etc/apt/sources.list.d/ (deb http://deb.debian.org/debian bookworm main contrib). Caché de descargas: /var/cache/apt/archives/.

Paquetes en Red Hat/Fedora/SUSE (.rpm)

Repositorios en /etc/yum.repos.d/*.repo; configuración en /etc/dnf/dnf.conf (o /etc/yum.conf). En SUSE, zypper (zypper install, zypper se, zypper ref).

Compilar desde el código fuente

./configure (comprueba el sistema y prepara) → make (compila) → sudo make install (copia, normalmente a /usr/local).

cron: tareas que se repiten

El demonio cron (cron o crond) mira cada minuto si toca hacer algo. Las tareas se escriben en tablas crontab.

### Formato

# ┌───── minuto (0-59)
# │ ┌──── hora (0-23)
# │ │ ┌─── día del mes (1-31)
# │ │ │ ┌── mes (1-12 o jan…dec)
# │ │ │ │ ┌─ día de la semana (0-7: 0 y 7 son domingo; o sun…sat)
# │ │ │ │ │
  30 2 * * *     /usr/local/bin/copia.sh           # todos los días a las 2:30
  0 */4 * * *    /usr/local/bin/sincroniza.sh      # cada 4 horas en punto
  15 9 * * 1-5   /usr/local/bin/informe.sh         # de lunes a viernes a las 9:15
  0 0 1,15 * *   /usr/local/bin/factura.sh         # los días 1 y 15 a medianoche
  */10 * * * *   /usr/local/bin/comprueba.sh       # cada 10 minutos
  @reboot        /usr/local/bin/al_arrancar.sh     # también @daily, @weekly, @monthly, @yearly, @hourly

• * todos · , lista · - rango · /N cada N (*/15 = 0, 15, 30, 45; 4-10/2 = 4, 6, 8, 10).
• Si pones día del mes y día de la semana, se ejecuta cuando se cumpla cualquiera de los dos.
• La salida de la tarea se envía por correo al usuario (variable MAILTO= al principio de la tabla; MAILTO="" para nada). Para guardarla: >> /var/log/copia.log 2>&1.
• cron usa un PATH muy corto: pon rutas completas o define PATH= arriba. Ojo con %: en crontab significa salto de línea; escríbelo \% (date +\%F).

### Tablas de usuario y del sistema

• crontab -l lista tu tabla · crontab -e la edita · crontab -r la borra entera · crontab -u ana -l la de ana (root) · crontab archivo la sustituye por la de un archivo.
• Quién puede usar cron: si existe /etc/cron.allow, solo los que estén ahí; si no, todos menos los de /etc/cron.deny. (Root siempre puede.)

anacron: para equipos que no están siempre encendidos

cron no recupera lo que no hizo con el ordenador apagado; anacron sí: apunta cuándo hizo cada tarea (en /var/spool/anacron/) y, si hace más de N días, la ejecuta. Trabaja en días (no horas ni minutos) y no es un demonio: se lanza al arrancar o cada hora.

# /etc/anacrontab
# días  retraso(min)  nombre          orden
1       5             cron.daily      run-parts /etc/cron.daily
7       10            cron.weekly     run-parts /etc/cron.weekly
@monthly 15           cron.monthly    run-parts /etc/cron.monthly

anacron -T comprueba la sintaxis. START_HOURS_RANGE=3-22 y RANDOM_DELAY=30 limitan cuándo y cuánto retrasar.

at: una sola vez

$ at 18:30 # escribes las órdenes y terminas con Ctrl+D
at> /usr/local/bin/aviso.sh
$ at now + 2 hours # también: at 10:00 tomorrow · at 2026-12-24 20:00 · at noon · at teatime
$ echo "reboot" | at 03:00
$ atq # tareas pendientes (= at -l)
$ atrm 5 # borrar la tarea 5 (= at -r)
$ at -c 5 # ver qué hará la 5
$ batch # ejecutar cuando la carga del sistema baje

Necesita el demonio atd. Permisos con /etc/at.allow y /etc/at.deny, igual que cron.

Timers de systemd

Una alternativa a cron: un .timer que activa un .service del mismo nombre.

# /etc/systemd/system/copia.timer
[Timer]
OnCalendar=*-*-* 02:30:00        # o daily, weekly, Mon..Fri 09:00
Persistent=true                  # si estaba apagado, hacerlo al encender (como anacron)
# OnBootSec=10min  OnUnitActiveSec=1h  → relativo al arranque / a la última vez
[Install]
WantedBy=timers.target

systemctl enable --now copia.timer · systemctl list-timers · systemd-analyze calendar "Mon..Fri 9:00" (comprueba la expresión). Una sola vez, al estilo at: systemd-run --on-active=30m /usr/local/bin/aviso.sh.

Dos relojes

• Reloj del sistema: lo lleva el kernel mientras el equipo está encendido.
• Reloj hardware (RTC, de la placa, con su pila): sigue en marcha con el equipo apagado. Al arrancar, el sistema toma la hora de él.

Lo normal en Linux es que el reloj hardware vaya en UTC y cada usuario vea su hora local según la zona horaria.

date

$ date # fecha y hora local
$ date -u # en UTC
$ date +"%Y-%m-%d %H:%M:%S" # con formato → 2026-10-07 17:30:00
$ date +%F_%T # %F = %Y-%m-%d · %T = %H:%M:%S
$ date -d "next friday" +%A # calcular otras fechas (-d tomorrow, -d "3 days ago", -d @1700000000)
$ date +%s # segundos desde el 1-1-1970 (época Unix)
$ sudo date -s "2026-10-07 17:30" # cambiar la hora (solo el reloj del sistema)

Formatos: %Y año · %m mes · %d día · %H hora · %M minutos · %S segundos · %A día de la semana · %B mes en letras · %j día del año · %Z zona.

hwclock: el reloj hardware

hwclock (o hwclock -r) lo lee · hwclock -w (--systohc) copia la hora del sistema al hardware · hwclock -s (--hctosys) al revés · --utc / --localtime dicen en qué está el reloj hardware. (/etc/adjtime lo recuerda.)

timedatectl (systemd)

$ timedatectl # todo: hora local, UTC, RTC, zona, si NTP está activo
$ sudo timedatectl set-time "2026-10-07 17:30:00" # cambia sistema y hardware (falla si NTP está activo)
$ timedatectl list-timezones | grep Madrid
$ sudo timedatectl set-timezone Europe/Madrid
$ sudo timedatectl set-ntp true # activar la sincronización por red
$ sudo timedatectl set-local-rtc 0 # el reloj hardware en UTC

Zona horaria

• /etc/localtime es un enlace (o copia) a un archivo de /usr/share/zoneinfo/ (paquete tzdata): ln -sf /usr/share/zoneinfo/Europe/Madrid /etc/localtime.
• /etc/timezone (Debian) guarda el nombre: Europe/Madrid. tzselect ayuda a elegirla; dpkg-reconfigure tzdata en Debian.
• La variable TZ cambia la zona solo para una orden o un usuario: TZ=America/New_York date.

NTP: la hora por red

El protocolo NTP (puerto 123/UDP) sincroniza el reloj con servidores de hora (por ejemplo pool.ntp.org), organizados en estratos (stratum 0 relojes atómicos, 1 los servidores conectados a ellos…).

ntpdate servidor (antiguo) ajusta la hora de golpe una vez; chronyc makestep hace lo mismo con chrony.

Idioma y formatos: el «locale»

Un locale como es_ES.UTF-8 dice idioma_PAÍS.codificación. Afecta a los mensajes, las fechas, los números (coma o punto decimal), la moneda, el orden alfabético…

• Prioridad: LC_ALL > LC_* > LANG. LANG=C (o C.UTF-8, POSIX) da el comportamiento «de toda la vida» en inglés: muy útil en scripts para que la salida no cambie con el idioma.
• locale muestra las actuales · locale -a las instaladas · localectl (estado) · localectl set-locale LANG=es_ES.UTF-8 (para siempre, en /etc/locale.conf o /etc/default/locale) · localectl set-keymap es (teclado de consola, /etc/vconsole.conf) · localectl list-locales.
• Generar uno nuevo en Debian: descomentarlo en /etc/locale.gen y locale-gen (o dpkg-reconfigure locales).

Codificaciones

• ASCII: 7 bits, 128 caracteres (inglés, sin tildes). Los 32 primeros son de control (tabulador, salto de línea…). man ascii.
• ISO-8859-1 (Latin-1) / ISO-8859-15 (con €): 8 bits, 256 caracteres para Europa occidental. Hubo muchas variantes incompatibles.
• Unicode: un número para cada carácter de todos los idiomas. UTF-8 lo guarda con 1 a 4 bytes, y los 128 primeros coinciden con ASCII; es lo que usa hoy casi todo. UTF-16 usa 2 o 4 bytes.
• Convertir: iconv -f ISO-8859-1 -t UTF-8 viejo.txt > nuevo.txt (iconv -l lista las codificaciones). file -i texto.txt adivina la que tiene.

Lo que necesita un equipo para salir a la red

1. Dirección IP: identifica el equipo. IPv4 son 4 bytes (192.168.1.20); IPv6, 16 bytes en hexadecimal (2001:db8::1).
2. Máscara (o prefijo): qué parte de la IP es la red y cuál el equipo. /24 = 255.255.255.0.
3. Puerta de enlace (gateway, router): a quién enviar lo que va a otras redes.
4. Servidor DNS: quién traduce nombres (debian.org) a IPs.

Direcciones IPv4

Clases antiguas (ya solo como vocabulario): A 1-126.x.x.x (/8) · B 128-191 (/16) · C 192-223 (/24) · D 224-239 multicast · E experimental.

Subredes: el cálculo que cae

Con 192.168.10.77/26: la máscara tiene 26 bits a 1 → 255.255.255.192. Quedan 32-26 = 6 bits para equipos.

• Equipos por subred: 2⁶ - 2 = 62 (se restan la dirección de red y la de difusión).
• Saltos de 64 en el último byte (256 - 192): las subredes empiezan en .0, .64, .128, .192. El 77 cae en la de .64.
• Red: 192.168.10.64 · Primer equipo: .65 · Último: .126 · Difusión: 192.168.10.127.

IPv6: 128 bits en 8 grupos de 4 cifras hexadecimales; los ceros a la izquierda se omiten y una serie de grupos a cero se resume con :: (2001:0db8:0000:0000:0000:0000:0000:0001 = 2001:db8::1). ::1 es el loopback; fe80::/10 enlace local; fc00::/7 privadas (ULA). La red suele ser /64. No hay difusión (usa multicast).

Puertos y protocolos

TCP es fiable (conexión, orden, reenvíos); UDP, rápido y sin garantías (DNS, NTP, streaming). ICMP es el de ping. Puertos: 0-1023 de sistema (solo root puede escuchar en ellos), 1024-49151 registrados, el resto dinámicos. Lista en /etc/services.

Ver y cambiar la configuración: ip

Equivalentes antiguos (paquete net-tools) que aún caen: ifconfig · route -n · arp · netstat. ifup eth0 / ifdown eth0 activan según la configuración guardada. Nombres de interfaces: lo · eno1 (en placa) · ens1 (ranura) · enp2s0 (bus PCI) · wlp3s0 (wifi) · eth0 (estilo antiguo).

Configuración permanente

DHCP a mano: dhclient eth0 (-r suelta la IP). Nombre del equipo: /etc/hostname, hostnamectl set-hostname servidor1, hostname.

Resolución de nombres

• /etc/hosts: nombres fijos sin DNS (192.168.1.10 nas nas.casa).
• /etc/resolv.conf: nameserver 1.1.1.1, search casa.lan. Suele generarlo otro programa (NetworkManager, systemd-resolved, que lo enlaza a /run/systemd/resolve/…); resolvectl status enseña los DNS que se usan de verdad.
• /etc/nsswitch.conf: el orden en que se consulta: hosts: files dns = primero /etc/hosts, luego DNS.
• Preguntar: host debian.org · dig debian.org (dig @8.8.8.8 debian.org MX, dig -x 1.1.1.1 inversa, +short) · nslookup · getent hosts debian.org (usa nsswitch, como los programas) · whois (quién tiene el dominio).

Diagnóstico

Orden para encontrar un fallo: ¿interfaz con IP? (ip a) → ¿llego al router? (ping a la puerta de enlace) → ¿llego fuera por IP? (ping 1.1.1.1) → ¿resuelvo nombres? (dig, /etc/resolv.conf) → ¿el servicio escucha? (ss -tlnp).

CUPS: el sistema de impresión

CUPS (Common Unix Printing System) es el demonio que recibe los trabajos de impresión, los pone en cola, los convierte al lenguaje de la impresora (con filtros y archivos PPD que describen cada modelo) y los envía.

• Servicio: cups (systemctl status cups). Configuración: /etc/cups/cupsd.conf; impresoras: /etc/cups/printers.conf; trabajos en cola: /var/spool/cups/; registros: /var/log/cups/.
• Interfaz web: http://localhost:631 (puerto 631, protocolo IPP): añadir impresoras (/admin), ver colas (/printers) y trabajos (/jobs).
• Sin impresora a mano: el paquete cups-pdf crea una impresora virtual que «imprime» en PDF (en ~/PDF).

Órdenes (los nombres vienen de los sistemas antiguos, BSD y System V, y conviven):

La variable PRINTER también elige la impresora predeterminada del usuario.

El correo electrónico: quién hace qué

Cómo viaja un correo de ana@a.com a bob@b.com: el MUA de ana lo entrega al servidor SMTP de a.com → este pregunta al DNS el registro MX de b.com (qué servidor recibe su correo) → se lo pasa por SMTP → el MDA lo deja en el buzón de bob → bob lo lee con su MUA por IMAP o POP3.

• POP3 descarga los mensajes (normalmente los borra del servidor); IMAP los deja en el servidor y permite carpetas.
• Buzones: formato mbox (todos los mensajes en un archivo, /var/mail/usuario o /var/spool/mail/usuario) o Maildir (una carpeta, un archivo por mensaje: ~/Maildir).
• Puertos: SMTP 25 (entre servidores), 587 (envío de usuarios, con STARTTLS), 465 (SMTPS); POP3 110/995; IMAP 143/993.

Lo que pide el LPIC del correo en un equipo

• Todos los MTA (Postfix, Exim…) instalan una orden **sendmail** compatible, que es la que usan los programas para enviar.
• mail / mailx: enviar desde la terminal: echo "Copia hecha" | mail -s "Informe" root.
• mailq (= sendmail -bp) ver la cola de correo pendiente de salir; sendmail -q reintentar.
• Alias: /etc/aliases (root: ana, webmaster: ana, luis) y luego **newaliases** para que tenga efecto.
• Reenvío de un usuario: un archivo ~/.forward con la dirección de destino.

La idea de las claves

• Simétrica: la misma clave cifra y descifra (rápida, pero hay que compartirla en secreto). AES.
• Asimétrica: un par de claves. Lo que cifra la pública solo lo descifra la privada; lo que firma la privada lo comprueba cualquiera con la pública. RSA, ECDSA, Ed25519. - Para enviarle algo secreto a Bea: lo cifras con la pública de Bea. - Para demostrar que algo es tuyo: lo firmas con tu privada.
• TLS (HTTPS) y SSH cifran el canal; GPG cifra los datos (un archivo, un correo), que luego pueden viajar por donde sea.

SSH: conectarse a otro equipo

$ ssh ana@servidor # entrar (puerto 22); -p 2222 otro puerto; -l ana = ana@
$ ssh ana@servidor 'df -h' # ejecutar una orden y volver
$ scp informe.pdf ana@servidor:/tmp/ # copiar (-r carpetas, -P puerto ¡mayúscula!, -p conservar fechas)
$ sftp ana@servidor # como un FTP, pero por SSH
$ rsync -av carpeta/ ana@servidor:copia/ # sincronizar por SSH
$ ssh -X ana@servidor xclock # con las ventanas gráficas reenviadas (-Y: «de confianza»)
$ ssh -L 8080:localhost:80 ana@servidor # túnel: tu puerto 8080 llega al 80 del servidor
$ ssh -R 2222:localhost:22 ana@servidor # túnel inverso
$ sshfs ana@servidor:/datos /mnt/remoto # montar una carpeta remota (fusermount -u para desmontar)

La primera vez, ssh enseña la huella del servidor y la guarda en ~/.ssh/known_hosts. Si cambia, avisa a gritos (posible ataque, o servidor reinstalado: ssh-keygen -R servidor la olvida). Las claves del propio servidor están en /etc/ssh/ssh_host_*_key (privadas) y .pub.

Entrar con claves en vez de contraseña

$ ssh-keygen -t ed25519 # crea ~/.ssh/id_ed25519 (privada) y id_ed25519.pub (pública); -t rsa -b 4096
$ ssh-copy-id ana@servidor # añade tu pública a ~/.ssh/authorized_keys del servidor
$ ssh ana@servidor # ya no pide la contraseña del servidor (sí la frase de la clave, si le pusiste)

• La frase de paso (passphrase) protege la clave privada en tu disco. ssh-keygen -p la cambia.
• Permisos: ~/.ssh 700, authorized_keys y la clave privada 600. Si están más abiertos, sshd no acepta la clave.
• ssh-agent guarda las claves ya desbloqueadas durante la sesión: eval $(ssh-agent), ssh-add (añadir; -l listar; -D quitar todas; -t 3600 caducan). Los escritorios lo arrancan solos.

Configuración

Opciones del servidor que caen: Port 22 · PermitRootLogin no (o prohibit-password: root solo con clave) · PasswordAuthentication no · PubkeyAuthentication yes · AllowUsers ana luis@192.168.1.* / DenyUsers / AllowGroups · X11Forwarding yes · MaxAuthTries 3 · ListenAddress · AuthorizedKeysFile .ssh/authorized_keys. sshd -t comprueba la sintaxis. En el cliente: Host casa / HostName 192.168.1.10 / User ana / Port 2222 / IdentityFile ~/.ssh/id_casa → luego ssh casa.

GPG: cifrar y firmar archivos

$ gpg --full-generate-key # crear tu par de claves (gpg --gen-key: versión rápida)
$ gpg --list-keys   (gpg -k) # claves públicas de tu anillo; --list-secret-keys (-K) las privadas
$ gpg --export -a ana@mail.com > ana.asc # exportar tu pública (-a: en texto, «armadura» ASCII)
$ gpg --import bea.asc # importar la de otra persona
$ gpg -e -r bea@mail.com informe.pdf # cifrar PARA bea (con su pública) → informe.pdf.gpg
$ gpg -d informe.pdf.gpg > informe.pdf # descifrar (con tu privada)
$ gpg -c secreto.txt # cifrado SIMÉTRICO con una contraseña (sin claves)
$ gpg --sign doc.txt # firmar (doc.txt.gpg, binario); --clearsign: texto legible + firma
$ gpg --detach-sign -a doc.txt # firma aparte: doc.txt.asc
$ gpg --verify doc.txt.asc doc.txt # comprobar una firma
$ gpg --fingerprint bea@mail.com # la huella, para comprobarla con bea por otro medio
$ gpg --sign-key bea@mail.com # «doy fe» de que esa clave es de bea (red de confianza)
$ gpg --gen-revoke ana@mail.com > revocar.asc # certificado para anular tu clave si la pierdes (hazlo YA)
$ gpg --keyserver keys.openpgp.org --send-keys ID # publicar; --recv-keys ID para bajar

Todo se guarda en ~/.gnupg/ (configuración en ~/.gnupg/gpg.conf; el agente que recuerda la frase, gpg-agent).

Las capas

1. Servidor gráfico: habla con la tarjeta, la pantalla, el teclado y el ratón. X11 (implementación Xorg) o, hoy, Wayland.
2. Gestor de ventanas (window manager): pone bordes, botones y deja mover y redimensionar. Sin él, las ventanas no se pueden mover. Ejemplos: KWin, Mutter, Openbox, i3, twm.
3. Entorno de escritorio: gestor de ventanas + paneles + aplicaciones + configuración: GNOME (GTK), KDE Plasma (Qt), Xfce, LXDE/LXQt, Cinnamon, MATE.
4. Gestor de pantalla (display manager): la pantalla de inicio de sesión: GDM (GNOME), SDDM (KDE), LightDM, XDM.

X11

• X es cliente-servidor y transparente a la red: el servidor X está donde está la pantalla; los programas son clientes y pueden estar en otro equipo.
• La variable **DISPLAY** dice a qué pantalla mandar las ventanas: :0 (pantalla 0 de este equipo), servidor:0, :1… DISPLAY=:1 xeyes &.
• Permisos: xhost +192.168.1.20 deja a ese equipo dibujar en tu pantalla (xhost - cierra); xauth gestiona las «cookies» (~/.Xauthority). Lo cómodo y seguro es ssh -X equipo programa.
• Configuración: hoy se detecta sola. Si hace falta, /etc/X11/xorg.conf o archivos en /etc/X11/xorg.conf.d/, con secciones Section "Device" (tarjeta), "Monitor", "Screen", "InputDevice", "ServerLayout"… Xorg -configure genera uno de ejemplo.
• Registro: /var/log/Xorg.0.log (o ~/.local/share/xorg/). Arrancar a mano: startx (lee ~/.xinitrc). Otro servidor en una ventana: Xephyr :1.
• Herramientas: xrandr (resoluciones y monitores: xrandr --output HDMI-1 --mode 1920x1080), xdpyinfo (datos de la pantalla), xwininfo (de una ventana), xset (salvapantallas, teclado), xev (ver los eventos de teclas). Programas de prueba: xclock, xeyes, xterm, xkill.

Wayland

El sucesor de X: el compositor (KWin, Mutter, sway…) hace a la vez de servidor y de gestor de ventanas. Más sencillo y seguro (una aplicación no puede espiar a otra), pero no es transparente a la red. Las aplicaciones de X funcionan dentro gracias a XWayland. ¿Cuál usas?: echo $XDG_SESSION_TYPE (x11 o wayland); también WAYLAND_DISPLAY.

Escritorio remoto

Estándares de freedesktop.org (XDG)

Para que los escritorios se entiendan entre sí:

• **Archivos .desktop**: los lanzadores del menú. En /usr/share/applications/ (sistema) y ~/.local/share/applications/ (tuyos):

[Desktop Entry]
Type=Application
Name=Mi programa
Exec=/opt/miprograma/bin/miprograma %f
Icon=miprograma
Terminal=false
Categories=Utility;

• Arranque automático al iniciar sesión: .desktop en /etc/xdg/autostart/ o ~/.config/autostart/.
• Asociaciones de tipos de archivo (MIME): xdg-mime query filetype foto.jpg, xdg-mime default gimp.desktop image/jpeg, xdg-open archivo (lo abre con su programa).
• Carpetas: XDG_CONFIG_HOME (~/.config), XDG_DATA_HOME (~/.local/share), XDG_CACHE_HOME (~/.cache); las de usuario (Escritorio, Descargas…) en ~/.config/user-dirs.dirs.

Accesibilidad

Ayudas que hay que saber reconocer (en GNOME, «Accesibilidad»; en KDE, «Accesibilidad» de Preferencias del sistema):

AT-SPI es el sistema por el que las aplicaciones dan información a estas ayudas.