Linux Intermedio: 200 Comandos y Técnicas

Ya navegas, editas e instalas paquetes. Estos 200 elementos son el punto de inflexión: combinar comandos, automatizar con scripts, administrar servicios con systemd, programar tareas, dominar SSH y diagnosticar disco, red y logs.

Es el conjunto que separa a quien usa la terminal de quien administra el servidor.

La filosofía Unix en una frase: cada comando hace una cosa bien hecha, y la tubería (|) lo une todo. La mayor parte de este post trata de eso.

Índice

• 1–20 · Tuberías, redirección y expansión
• 21–50 · grep, sed y awk
• 51–85 · Scripts de shell
• 86–105 · systemd y servicios
• 106–117 · Cron y programación de tareas
• 118–135 · SSH
• 136–155 · Red intermedia
• 156–175 · Discos, particiones y sistemas de archivos
• 176–190 · Logs
• 191–200 · Seguridad y automatización del acceso

Tuberías, redirección y expansión

Lo que convierte comandos aislados en una sola herramienta.

1. Tubería (|)

Manda la salida de un comando a la entrada del siguiente.

ps aux | grep nginx | wc -l

2. Redirigir la salida

> sobrescribe el archivo; >> añade al final.

comando > saida.txt
comando >> log.txt

3. Separar el error de la salida

1 es la salida estándar, 2 es el error.

comando > saida.txt 2> erros.txt

4. Juntar el error con la salida

El orden importa: redirige primero el archivo y después une el 2 al 1.

comando > tudo.txt 2>&1
comando &> tudo.txt        # atajo de bash

5. Descartar la salida

/dev/null es el desagüe del sistema.

comando 2>/dev/null
comando >/dev/null 2>&1

6. Entrada desde un archivo

< alimenta el comando con el contenido del archivo.

sort < nomes.txt
while read linha; do echo "$linha"; done < lista.txt

7. Here-document

Un bloque de texto directamente en el comando. Muy usado para configuración y SQL.

cat <<EOF > config.yml
servidor: producao
porta: 8080
EOF

8. Here-string

Manda una cadena directamente a la entrada.

grep "erro" <<< "$conteudo"

9. tee — grabar y mostrar

Guarda en un archivo y continúa la tubería. Esencial con sudo.

comando | tee saida.txt
echo "linha" | sudo tee -a /etc/hosts

10. xargs — convertir la entrada en argumentos

Algunos comandos no leen de la tubería; xargs lo resuelve.

find . -name "*.log" | xargs rm
cat urls.txt | xargs -n1 curl -sI

11. xargs en paralelo

-P procesa varios a la vez. Una ganancia enorme en una tarea repetitiva.

cat urls.txt | xargs -P 8 -n 1 curl -sO

12. Sustitución de comandos

$(...) inserta la salida de un comando dentro de otro.

echo "Hoje é $(date +%F)"
kill $(pgrep -f meu-script)

13. Sustitución de procesos

<(...) convierte la salida de un comando en un archivo temporal.

diff <(ls pasta1) <(ls pasta2)
comm -13 <(sort a.txt) <(sort b.txt)

14. Expansión de llaves

Genera listas y secuencias sin bucle.

mkdir -p projeto/{src,test,docs}
touch arquivo{1..5}.txt
cp config.yml{,.bak}

15. Expansión aritmética

Hace cuentas en el propio shell.

echo $((2 + 3 * 4))
total=$((total + 1))

16. Comillas simples vs dobles

Las comillas dobles expanden variables; las simples no expanden nada.

nome="Jhonatan"
echo "Olá $nome"    # Olá Jhonatan
echo 'Olá $nome'    # Olá $nome

17. Entrecomilla siempre las variables

Sin comillas, un espacio en el valor se convierte en dos argumentos — el origen de la mitad de los bugs en los scripts.

arquivo="meu arquivo.txt"
rm "$arquivo"     # correcto
rm $arquivo       # intenta borrar "meu" y "arquivo.txt"

18. Código de salida

$? guarda el resultado del último comando: 0 es éxito.

comando
if [ $? -ne 0 ]; then echo "falhou"; fi

19. pipefail

Sin esto, una tubería solo falla si falla el último comando.

set -o pipefail
falso | true; echo $?   # ahora sí reporta el fallo

20. Encadenamiento condicional

Se ejecuta según el éxito del comando anterior.

make build && make deploy
comando || echo "falhou" >&2

grep, sed y awk

El trío que procesa texto en cualquier servidor, sin instalar nada.

21. grep con regex

Patrones en lugar de texto fijo.

grep -E "^[0-9]{3}-[0-9]{4}$" telefones.txt

22. grep -o — solo lo que casó

Extrae el fragmento, no la línea entera.

grep -oE "[0-9]{1,3}(\.[0-9]{1,3}){3}" access.log | sort | uniq -c | sort -nr

23. grep -P — regex de Perl

Habilita lookahead, \d, \s y similares.

grep -P "(?<=usuario=)\w+" app.log

24. grep en binarios y comprimidos

Busca dentro de un log rotado sin descomprimirlo.

zgrep "erro" /var/log/syslog.2.gz
grep -a "texto" arquivo.bin

25. grep excluyendo directorios

Evita recorrer node_modules y .git.

grep -r "TODO" . --exclude-dir={node_modules,.git,dist}

26. sed — sustituir

La operación más usada: cambiar texto.

sed 's/antigo/novo/' arquivo.txt        # la primera aparición de la línea
sed 's/antigo/novo/g' arquivo.txt       # todas

27. sed editando el archivo

-i graba en el propio archivo. Haz siempre una copia con -i.bak.

sed -i.bak 's/porta=8080/porta=9090/' config.ini

28. sed con otro delimitador

Evita escapar barras al trabajar con rutas.

sed 's|/var/www|/srv/www|g' config.conf

29. sed en una línea concreta

Restringe la sustitución a una línea o a un rango.

sed '3s/erro/ok/' arquivo.txt
sed '10,20s/dev/prod/g' arquivo.txt

30. sed borrando líneas

Elimina por número, por patrón o las vacías.

sed '5d' arquivo.txt
sed '/^#/d' config.conf        # comentarios
sed '/^$/d' arquivo.txt        # líneas en blanco

31. sed insertando líneas

Antes (i), después (a) o en su lugar (c).

sed '1i #!/bin/bash' script.sh
sed '/\[servidor\]/a porta=8080' config.ini

32. sed imprimiendo un rango

-n calla la salida por defecto; p imprime lo que interesa.

sed -n '10,20p' arquivo.txt
sed -n '/INICIO/,/FIM/p' log.txt

33. sed con grupos

Captura partes y las reordena.

echo "2026-08-10" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'

34. sed en varios archivos

Sustitución por lotes, combinada con find.

find . -name "*.md" -exec sed -i 's/http:/https:/g' {} +

35. awk — imprimir columnas

Divide la línea en campos automáticamente.

awk '{print $1, $3}' arquivo.txt
ps aux | awk '{print $2, $11}'

36. awk con delimitador

-F define el separador de campos.

awk -F: '{print $1}' /etc/passwd
awk -F, '{print $2}' dados.csv

37. awk con filtro

Solo procesa las líneas que cumplen la condición.

awk '$3 > 100 {print $1, $3}' vendas.txt
awk '/erro/ {print}' app.log

38. awk sumando

Acumula valores y los imprime al final.

awk '{soma += $2} END {print "Total:", soma}' vendas.txt

39. awk con media

Contador y suma en la misma pasada.

awk '{soma += $1; n++} END {print "Média:", soma/n}' numeros.txt

40. awk agrupando

Array asociativo: el "GROUP BY" de la terminal.

awk '{contagem[$1]++} END {for (chave in contagem) print chave, contagem[chave]}' acessos.log

41. awk con cabecera

NR es el número de línea; NF, la cantidad de campos.

awk 'NR > 1 {print $1}' dados.csv       # se salta la cabecera
awk '{print NF}' arquivo.txt            # campos por línea

42. awk formateando

printf da control total del formato.

awk '{printf "%-20s %8.2f\n", $1, $2}' precos.txt

43. awk con múltiples condiciones

Combina filtros como en SQL.

awk -F, '$3 == "SP" && $4 > 1000 {print $1}' clientes.csv

44. awk cambiando el separador de salida

OFS define cómo salen los campos.

awk -F: 'BEGIN {OFS=","} {print $1, $3}' /etc/passwd

45. Analizar un log de acceso

La receta clásica: las 10 IPs con más accesos.

awk '{print $1}' access.log | sort | uniq -c | sort -nr | head -10

46. Las URLs con más errores 500

awk combinado con un filtro de estado.

awk '$9 == 500 {print $7}' access.log | sort | uniq -c | sort -nr | head

47. Tiempo de respuesta medio

Extrae la métrica directamente del log.

awk '{soma += $NF; n++} END {printf "média: %.3fs\n", soma/n}' tempos.log

48. cut vs awk

cut es más rápido para columnas fijas; awk maneja el espaciado variable.

cut -d, -f1,3 dados.csv        # simple y rápido
awk '{print $1, $3}' saida.txt # espaciado irregular

49. paste y join

Une archivos por columna o por clave, como un JOIN.

paste nomes.txt idades.txt
join -t, -1 1 -2 1 clientes.csv pedidos.csv

50. column — alinear la salida

Deja legible una salida desordenada.

mount | column -t
cat /etc/passwd | column -t -s:

Scripts de shell

Automatizar lo que repites — con el mínimo de trampas.

51. Shebang

Primera línea: dice qué intérprete ejecuta el archivo.

#!/usr/bin/env bash

52. Hacerlo ejecutable

Sin permiso de ejecución, el script no corre.

chmod +x script.sh
./script.sh

53. Modo estricto

Las tres líneas que evitan la mayoría de los bugs: sale ante el error, protesta por una variable indefinida y propaga el fallo de la tubería.

set -euo pipefail

54. Variables

Sin espacios alrededor del =. Comillas al usarlas.

nome="Jhonatan"
echo "Olá, $nome"

55. Variable local en una función

Sin local, todo es global — y un nombre repetido se convierte en un bug silencioso.

minha_funcao() {
  local contador=0
  contador=$((contador + 1))
}

56. Argumentos del script

$1, $2... y $@ para todos.

echo "primeiro: $1"
echo "todos: $@"
echo "quantidade: $#"

57. Valor por defecto de una variable

Usa el valor por defecto cuando la variable está vacía.

porta="${PORTA:-8080}"
destino="${1:?informe o destino}"   # aborta con un mensaje

58. if sencillo

Condicional con corchetes dobles (una función de bash, más segura).

if [[ -f config.yml ]]; then
  echo "config encontrado"
fi

59. if / elif / else

La cadena completa.

if [[ $1 == "prod" ]]; then
  echo "produção"
elif [[ $1 == "hml" ]]; then
  echo "homologação"
else
  echo "ambiente desconhecido" >&2
  exit 1
fi

60. Pruebas de archivo

Existe, es un directorio, es legible, tiene contenido.

[[ -e caminho ]]   # existe
[[ -f arquivo ]]   # es un archivo
[[ -d pasta ]]     # es un directorio
[[ -r arquivo ]]   # legible
[[ -s arquivo ]]   # no está vacío

61. Pruebas de cadena

Vacía, igual, distinta, casa con un patrón.

[[ -z "$var" ]]          # vacía
[[ -n "$var" ]]          # no vacía
[[ "$a" == "$b" ]]
[[ "$arquivo" == *.log ]]

62. Pruebas numéricas

La comparación de números usa sus propios operadores.

[[ $n -eq 10 ]]   # igual
[[ $n -ne 10 ]]   # distinto
[[ $n -gt 10 ]]   # mayor
[[ $n -lt 10 ]]   # menor

63. case

Más legible que una pila de elif.

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

64. for sobre una lista

Itera sobre valores literales.

for ambiente in dev hml prod; do
  echo "implantando em $ambiente"
done

65. for sobre archivos

Usa el glob directamente — nunca la salida de ls.

for arquivo in *.log; do
  gzip "$arquivo"
done

66. for numérico

Un rango de números con secuencia o al estilo C.

for i in {1..10}; do echo "$i"; done
for ((i = 0; i < 10; i++)); do echo "$i"; done

67. while

Repite mientras la condición sea verdadera.

contador=0
while [[ $contador -lt 5 ]]; do
  echo "$contador"
  contador=$((contador + 1))
done

68. while read — leer línea a línea

La forma correcta de procesar un archivo: IFS= y -r preservan los espacios y las barras.

while IFS= read -r linha; do
  echo "Linha: $linha"
done < arquivo.txt

69. until

Lo inverso del while: repite hasta que la condición se vuelva verdadera.

until curl -sf http://localhost:8080/health; do
  echo "aguardando o serviço..."
  sleep 2
done

70. break y continue

Sale del bucle o salta a la siguiente iteración.

for i in {1..10}; do
  [[ $i -eq 5 ]] && continue
  [[ $i -eq 8 ]] && break
  echo "$i"
done

71. Funciones

Agrupan lógica y reciben argumentos como el script.

saudacao() {
  local nome="$1"
  echo "Olá, $nome"
}
saudacao "Jhonatan"

72. Retorno de una función

return devuelve un código de salida; para devolver texto, usa echo y captúralo.

soma() { echo $(( $1 + $2 )); }
resultado=$(soma 2 3)

73. Arrays

Una lista indexada, con todos los elementos en [@].

servidores=("web1" "web2" "db1")
echo "${servidores[0]}"
echo "${#servidores[@]}"      # cantidad
for s in "${servidores[@]}"; do echo "$s"; done

74. Array asociativo

Un mapa clave-valor en bash 4+.

declare -A porta
porta[web]=80
porta[api]=3000
for servico in "${!porta[@]}"; do echo "$servico: ${porta[$servico]}"; done

75. Manipular cadenas

Longitud, porción y eliminación de prefijo/sufijo, sin llamar a un comando externo.

s="arquivo.tar.gz"
echo "${#s}"          # longitud
echo "${s%.gz}"       # quita el sufijo
echo "${s#*.}"        # quita hasta el primer punto
echo "${s/tar/zip}"   # sustituye

76. trap — limpieza al salir

Garantiza que el temporal se borre aunque el script muera.

temporario=$(mktemp)
trap 'rm -f "$temporario"' EXIT
# ... usa el archivo

77. Archivo y directorio temporales

mktemp los crea con un nombre único y permisos seguros.

arquivo=$(mktemp)
pasta=$(mktemp -d)

78. Leer la entrada del usuario

-p muestra el prompt; -s oculta lo que se escribe.

read -p "Nome: " nome
read -s -p "Senha: " senha; echo

79. Confirmación antes de actuar

La protección mínima en un script destructivo.

read -p "Apagar tudo? (s/N) " resposta
[[ "$resposta" == "s" ]] || exit 0

80. Opciones con getopts

Parseo de flags al estilo Unix.

while getopts "a:p:v" opcao; do
  case $opcao in
    a) ambiente="$OPTARG" ;;
    p) porta="$OPTARG" ;;
    v) verboso=1 ;;
    *) exit 1 ;;
  esac
done

81. Log con fecha

Una función de log sencilla que salva la depuración más adelante.

log() { echo "[$(date +'%F %T')] $*"; }
log "iniciando implantação"

82. Escribir en stderr

Un mensaje de error no debe ensuciar la salida del script.

echo "erro: arquivo não encontrado" >&2

83. Garantizar una única ejecución

flock impide dos instancias simultáneas — esencial en cron.

flock -n /tmp/meu-script.lock ./meu-script.sh || echo "já está rodando"

84. Depurar un script

-x imprime cada comando ejecutado.

bash -x script.sh
set -x   # lo activa a mitad del script
set +x   # lo desactiva

85. shellcheck — el linter

Señala los errores clásicos antes de que los sufras. Úsalo siempre.

shellcheck script.sh

systemd y servicios

Cómo un servicio arranca en el boot, se reinicia solo y registra lo que hizo.

86. Estado de un servicio

Estado actual, PID y las últimas líneas del log.

systemctl status nginx

87. Arrancar, parar, reiniciar

El trío del día a día.

sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx

88. Recargar sin tumbar

Relee la configuración manteniendo las conexiones abiertas.

sudo systemctl reload nginx
sudo systemctl reload-or-restart nginx

89. Habilitar en el arranque

enable solo lo configura; --now además lo inicia ahora.

sudo systemctl enable nginx
sudo systemctl enable --now nginx

90. Deshabilitar

Impide que arranque en el siguiente boot.

sudo systemctl disable --now nginx

91. Comprobar si está activo

Devuelve un código de salida — perfecto para un script.

systemctl is-active nginx
systemctl is-enabled nginx

92. Listar servicios

Todo lo que existe, o solo lo que está corriendo.

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

93. Servicios que fallaron

La primera consulta al entrar en un servidor con problemas.

systemctl --failed

94. Crear un servicio

Un archivo unit mínimo para ejecutar tu aplicación.

# /etc/systemd/system/minha-api.service
[Unit]
Description=Minha API
After=network.target

[Service]
Type=simple
User=app
WorkingDirectory=/opt/minha-api
ExecStart=/usr/bin/node server.js
Restart=on-failure
RestartSec=5
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target

95. Recargar las units

Obligatorio después de crear o editar cualquier archivo de servicio.

sudo systemctl daemon-reload

96. Editar una unit con seguridad

Crea un override en lugar de alterar el archivo del paquete.

sudo systemctl edit nginx
sudo systemctl cat nginx     # muestra la unit efectiva

97. Variables de entorno del servicio

Un archivo aparte, fuera de git, con las credenciales.

# en la unit:
EnvironmentFile=/etc/minha-api/env
# en el archivo:
DATABASE_URL=postgres://...

98. Dependencias entre servicios

After los ordena; Requires obliga a que el otro esté activo.

[Unit]
After=postgresql.service
Requires=postgresql.service

99. Limitar los recursos del servicio

systemd aplica cgroups sin que tengas que configurarlos a mano.

[Service]
MemoryMax=512M
CPUQuota=50%

100. Endurecer el servicio

Opciones que reducen mucho el destrozo en caso de intrusión.

[Service]
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/lib/minha-api

101. Enmascarar un servicio

Impide que arranque de ninguna forma, ni por dependencia.

sudo systemctl mask apache2
sudo systemctl unmask apache2

102. Targets (runlevels)

Modo gráfico, multiusuario o rescate.

systemctl get-default
sudo systemctl set-default multi-user.target
sudo systemctl isolate rescue.target

103. Tiempo de arranque

Muestra quién está retrasando el inicio.

systemd-analyze
systemd-analyze blame | head -20

104. Árbol de dependencias

Entiende por qué un servicio arranca antes que otro.

systemctl list-dependencies nginx

105. Timers de systemd

La alternativa moderna al cron, con log integrado y control de dependencias.

# /etc/systemd/system/backup.timer
[Unit]
Description=Backup diário

[Timer]
OnCalendar=*-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target

# sudo systemctl enable --now backup.timer
# systemctl list-timers

Cron y programación de tareas

Tareas que se ejecutan solas — y los detalles que hacen que fallen en silencio.

106. Editar el crontab

Abre la programación de tu usuario.

crontab -e
sudo crontab -e -u www-data   # la de otro usuario

107. Listar y eliminar

Ver lo que está programado; -r lo borra todo (cuidado).

crontab -l
crontab -r

108. El formato de los cinco campos

Minuto, hora, día del mes, mes, día de la semana.

# * * * * * comando
# │ │ │ │ └── día de la semana (0-7, 0 y 7 = domingo)
# │ │ │ └──── mes (1-12)
# │ │ └────── día del mes (1-31)
# │ └──────── hora (0-23)
# └────────── minuto (0-59)

109. Ejemplos comunes

Las programaciones que cubren casi todo.

0 3 * * *      /opt/backup.sh          # todos los días a las 3
*/15 * * * *   /opt/checa-saude.sh      # cada 15 minutos
0 9 * * 1      /opt/relatorio.sh        # los lunes a las 9
0 0 1 * *      /opt/fechamento.sh       # el primer día del mes

110. Atajos especiales

Más legibles que los cinco campos.

@daily   /opt/backup.sh
@hourly  /opt/sync.sh
@reboot  /opt/inicia.sh

111. El PATH en cron

Cron se ejecuta con un entorno mínimo. Usa siempre la ruta absoluta.

# Fallo silencioso:
0 3 * * * backup.sh
# Correcto:
0 3 * * * /usr/local/bin/backup.sh

112. Guardar la salida

Sin redirigirla, la salida va al correo local — que nadie lee.

0 3 * * * /opt/backup.sh >> /var/log/backup.log 2>&1

113. Definir variables en el crontab

Declaradas al principio del archivo, valen para todas las líneas.

SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin
MAILTO=""

114. Los directorios del cron del sistema

Basta con dejar un script ejecutable en esas carpetas.

ls /etc/cron.daily/
ls /etc/cron.d/
cat /etc/crontab

115. Evitar el solapamiento

Una tarea lenta puede empezar de nuevo antes de terminar. flock lo resuelve.

*/5 * * * * flock -n /tmp/sync.lock /opt/sync.sh

116. at — programar una sola vez

Se ejecuta una única vez en un momento futuro.

echo "/opt/manutencao.sh" | at 02:00
atq        # lista
atrm 3     # elimina

117. Probar el comando antes

Ejecútalo con el mismo entorno del cron para detectar problemas de PATH.

env -i /bin/bash --noprofile --norc -c "/opt/backup.sh"

SSH

El acceso remoto — y cómo usarlo sin contraseña y sin riesgo.

118. Conectar

Usuario, host y puerto.

ssh usuario@servidor
ssh -p 2222 usuario@servidor

119. Generar una clave

Ed25519 es el estándar actual: más pequeña y más segura que RSA.

ssh-keygen -t ed25519 -C "voce@email.com"

120. Copiar la clave al servidor

Habilita el login sin contraseña.

ssh-copy-id usuario@servidor
ssh-copy-id -i ~/.ssh/id_ed25519.pub usuario@servidor

121. Permisos de ~/.ssh

SSH rechaza la clave si los permisos están flojos.

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub
chmod 600 ~/.ssh/authorized_keys

122. El archivo de configuración

Alias que evitan memorizar IP, puerto y usuario.

# ~/.ssh/config
Host prod
  HostName 203.0.113.10
  User deploy
  Port 2222
  IdentityFile ~/.ssh/id_ed25519

# ahora: ssh prod

123. El agente de claves

Guarda la clave desbloqueada durante la sesión.

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
ssh-add -l

124. Ejecutar un comando remoto

Se ejecuta y vuelve, sin abrir una sesión interactiva.

ssh prod "df -h && uptime"

125. Túnel local

Trae un puerto remoto a tu máquina — la forma segura de acceder a una base de datos.

ssh -L 5432:localhost:5432 prod
# ahora localhost:5432 es el Postgres del servidor

126. Túnel inverso

Expone un puerto tuyo en el servidor remoto.

ssh -R 8080:localhost:3000 prod

127. Proxy SOCKS

Navega como si estuvieras en la red del servidor.

ssh -D 1080 prod

128. Saltar por un bastion

Accede a la máquina interna pasando por el host de borde.

ssh -J bastion usuario@servidor-interno

129. Mantener viva la conexión

Evita la caída por inactividad.

# ~/.ssh/config
Host *
  ServerAliveInterval 60
  ServerAliveCountMax 3

130. Reutilizar la conexión

Multiplexing: la segunda conexión al mismo host es instantánea.

Host *
  ControlMaster auto
  ControlPath ~/.ssh/cm-%r@%h:%p
  ControlPersist 10m

131. Endurecer el servidor SSH

Los tres cambios que más reducen los ataques.

# /etc/ssh/sshd_config
PermitRootLogin no
PasswordAuthentication no
Port 2222

sudo systemctl reload sshd

132. Probar la configuración

Valídala antes de recargar — un error aquí te deja fuera.

sudo sshd -t

133. Diagnosticar la conexión

-v muestra cada paso de la autenticación.

ssh -vvv usuario@servidor

134. known_hosts

¿Cambió la clave del servidor? Quita la entrada antigua (y confirma que no sea un ataque).

ssh-keygen -R servidor

135. Copiar un archivo por la sesión

scp y rsync usan la misma configuración de ~/.ssh/config.

scp arquivo.txt prod:/tmp/
rsync -avz ./site/ prod:/var/www/site/

Red intermedia

Diagnosticar de verdad la conectividad, los puertos y el tráfico.

136. Configurar una IP temporal

Vale hasta el siguiente reinicio — útil en mantenimiento.

sudo ip addr add 192.168.1.50/24 dev eth0
sudo ip link set eth0 up

137. Ruta por defecto

Añade o cambia la puerta de enlace.

sudo ip route add default via 192.168.1.1
ip route get 8.8.8.8   # por dónde sale el tráfico

138. Netplan (Ubuntu)

Configuración persistente moderna.

# /etc/netplan/01-config.yaml
network:
  version: 2
  ethernets:
    eth0:
      addresses: [192.168.1.50/24]
      routes:
        - to: default
          via: 192.168.1.1
      nameservers:
        addresses: [1.1.1.1, 8.8.8.8]

# sudo netplan apply

139. NetworkManager desde la CLI

Habitual en RHEL y en escritorios.

nmcli device status
nmcli connection show
sudo nmcli connection modify eth0 ipv4.addresses 192.168.1.50/24

140. Conexiones establecidas

Quién está conectado a qué, ahora mismo.

ss -tan state established
ss -tp   # con el proceso

141. Contar conexiones por IP

Detecta a un cliente abusando o un ataque simple.

ss -tan | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -nr | head

142. tcpdump — capturar tráfico

Ve el paquete de verdad. Insustituible cuando el log no lo explica.

sudo tcpdump -i eth0 port 80 -n
sudo tcpdump -i any host 192.168.1.10 -w captura.pcap

143. tcpdump legible

-A muestra el contenido ASCII — bueno para HTTP.

sudo tcpdump -i eth0 -A -s0 'tcp port 80 and host api.exemplo.com'

144. nmap — escanear puertos

Descubre lo que está abierto. Escanea solo lo que es tuyo.

nmap -sT localhost
nmap -p 1-1000 192.168.1.10
nmap -sV 192.168.1.10   # detecta el servicio y la versión

145. netcat — la navaja de red

Prueba un puerto, transfiere un archivo y levanta un servidor improvisado.

nc -zv servidor 443
nc -l 9000              # escucha en el puerto
nc servidor 9000 < arquivo.txt

146. curl con detalles de tiempo

Muestra dónde se gasta el tiempo: DNS, conexión, TLS, respuesta.

curl -w "dns:%{time_namelookup} conn:%{time_connect} tls:%{time_appconnect} total:%{time_total}\n" -o /dev/null -s https://exemplo.com

147. Probar un certificado TLS

Validez, cadena y emisor.

openssl s_client -connect exemplo.com:443 -servername exemplo.com < /dev/null 2>/dev/null | openssl x509 -noout -dates -subject -issuer

148. Cortafuegos con ufw

Una capa sencilla sobre iptables, habitual en Ubuntu.

sudo ufw status verbose
sudo ufw allow 22/tcp
sudo ufw allow from 192.168.1.0/24 to any port 5432
sudo ufw enable

149. Cortafuegos con firewalld

El estándar en RHEL y Fedora.

sudo firewall-cmd --list-all
sudo firewall-cmd --add-service=https --permanent
sudo firewall-cmd --reload

150. Ver las reglas de iptables

Lo que está realmente aplicado en el kernel.

sudo iptables -L -n -v
sudo nft list ruleset   # nftables, el sucesor

151. DNS: qué servidor está en uso

En sistemas con systemd-resolved, el /etc/resolv.conf engaña.

resolvectl status
cat /etc/resolv.conf

152. Vaciar la caché de DNS

Después de cambiar un registro, la caché local estorba la prueba.

sudo resolvectl flush-caches

153. Medir el ancho de banda entre máquinas

iperf3 mide el caudal real del enlace.

# en el servidor
iperf3 -s
# en el cliente
iperf3 -c 192.168.1.10 -t 30

154. Monitorizar el ancho de banda por proceso

Descubre quién está consumiendo la red.

sudo nethogs
sudo iftop -i eth0

155. Wake-on-LAN y MAC

La dirección física y encender una máquina de forma remota.

ip link show eth0 | grep ether
wakeonlan 00:11:22:33:44:55

Discos, particiones y sistemas de archivos

Del disco en crudo al punto de montaje que sobrevive al reinicio.

156. Listar discos

Vista de dispositivos, particiones y puntos de montaje.

lsblk -f
sudo fdisk -l

157. Particionar con fdisk

Interactivo, para tablas MBR y GPT sencillas.

sudo fdisk /dev/sdb
# n (nueva) · p (primaria) · w (graba)

158. Particionar con parted

Mejor para un disco mayor de 2 TB (GPT).

sudo parted /dev/sdb mklabel gpt
sudo parted -a opt /dev/sdb mkpart primary ext4 0% 100%

159. Formatear

Crea el sistema de archivos en la partición.

sudo mkfs.ext4 /dev/sdb1
sudo mkfs.xfs /dev/sdb1

160. Etiqueta y UUID

Usa el UUID en fstab: el nombre del dispositivo puede cambiar entre arranques.

sudo e2label /dev/sdb1 dados
blkid /dev/sdb1

161. Montar permanentemente

Una entrada en fstab con el UUID y las opciones.

# /etc/fstab
UUID=abcd-1234  /mnt/dados  ext4  defaults,noatime  0  2

sudo mount -a   # prueba sin reiniciar

162. Opciones de montaje útiles

noatime reduce la escritura; ro protege; nosuid/nodev/noexec endurecen.

sudo mount -o noatime,nodev,nosuid /dev/sdb1 /mnt/dados

163. Verificar el sistema de archivos

Solo con la partición desmontada.

sudo umount /dev/sdb1
sudo fsck -f /dev/sdb1

164. Redimensionar

Amplía el filesystem después de hacer crecer la partición.

sudo resize2fs /dev/sdb1        # ext4
sudo xfs_growfs /mnt/dados      # xfs (en caliente)

165. Swap

Crea y activa el área de intercambio.

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
swapon --show

166. Swappiness

Cuánto prefiere el kernel usar la swap. En un servidor de base de datos, valores bajos.

cat /proc/sys/vm/swappiness
sudo sysctl vm.swappiness=10

167. LVM: visión general

Un volumen lógico permite hacer crecer el disco sin reparticionar.

sudo pvs   # volúmenes físicos
sudo vgs   # grupos
sudo lvs   # volúmenes lógicos

168. Crear la estructura LVM

Del disco en crudo al volumen montable.

sudo pvcreate /dev/sdb
sudo vgcreate dados-vg /dev/sdb
sudo lvcreate -L 50G -n dados-lv dados-vg
sudo mkfs.ext4 /dev/dados-vg/dados-lv

169. Ampliar un volumen LVM

La gran ventaja: crecer sin downtime.

sudo lvextend -L +20G /dev/dados-vg/dados-lv
sudo resize2fs /dev/dados-vg/dados-lv

170. Snapshot LVM

Una foto del volumen para un backup consistente.

sudo lvcreate -L 5G -s -n snap /dev/dados-vg/dados-lv

171. Montar una ISO o una imagen

Accede al contenido sin grabar el medio.

sudo mount -o loop imagem.iso /mnt/iso

172. Montar un recurso compartido de red

NFS y SMB/CIFS.

sudo mount -t nfs servidor:/export /mnt/nfs
sudo mount -t cifs //servidor/compartilhado /mnt/win -o username=user

173. Salud del disco (SMART)

Anticipa un fallo de hardware.

sudo smartctl -a /dev/sda
sudo smartctl -t short /dev/sda

174. E/S por proceso

Descubre quién está machacando el disco.

sudo iotop -o
pidstat -d 1

175. Estadísticas de E/S

Latencia y utilización por dispositivo. Un %util cerca de 100 es un cuello de botella.

iostat -xz 1

Logs

Donde el servidor cuenta lo que pasó.

176. journalctl

El log unificado de systemd.

journalctl
journalctl -n 100

177. El log de un servicio

Filtra por unit — el comando que más vas a usar.

journalctl -u nginx
journalctl -u nginx -f     # en vivo

178. Log por periodo

Recorta la ventana temporal del incidente.

journalctl --since "2026-08-10 14:00" --until "2026-08-10 15:00"
journalctl --since "1 hour ago"

179. Log por prioridad

Solo error y superiores.

journalctl -p err
journalctl -p warning..emerg

180. Log del arranque

El arranque actual o el anterior — esencial tras una caída.

journalctl -b
journalctl -b -1
journalctl --list-boots

181. Log del kernel

Mensajes del kernel, con timestamp legible.

dmesg -T | tail -50
journalctl -k

182. Buscar el OOM killer

Confirma si el kernel mató tu proceso por falta de memoria.

dmesg -T | grep -i "out of memory"
journalctl -k | grep -i oom

183. Exportar el log

Formato JSON para analizarlo en una herramienta externa.

journalctl -u nginx -o json > nginx.json
journalctl -u nginx --since today > nginx.txt

184. Tamaño del journal

Crece hasta el límite configurado — y llena el disco.

journalctl --disk-usage
sudo journalctl --vacuum-size=500M
sudo journalctl --vacuum-time=30d

185. Logs en /var/log

Donde escriben los servicios tradicionales.

ls -lh /var/log/
sudo tail -f /var/log/auth.log      # autenticación
sudo tail -f /var/log/syslog

186. logrotate

Rota, comprime y descarta el log antiguo — lo que impide que el disco se llene.

cat /etc/logrotate.conf
sudo logrotate -d /etc/logrotate.d/nginx   # simula
sudo logrotate -f /etc/logrotate.d/nginx   # fuerza

187. Configurar la rotación de tu app

Un archivo propio en /etc/logrotate.d/.

/var/log/minha-api/*.log {
  daily
  rotate 14
  compress
  missingok
  notifempty
  copytruncate
}

188. logger — escribir en syslog

Hace que tu script aparezca en el log del sistema.

logger -t meu-script "backup concluído"
logger -p user.err -t meu-script "falha ao conectar"

189. Encontrar el error en medio del log

grep combinado con contexto y una ventana horaria.

journalctl -u minha-api --since "30 min ago" | grep -i -C 5 "exception"

190. Intentos de intrusión

Fallos de autenticación SSH — la primera señal de un ataque.

sudo grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort | uniq -c | sort -nr | head

Seguridad y automatización del acceso

Endurecer lo básico y automatizar lo que se repite.

191. sudoers con seguridad

Edita siempre con visudo: valida antes de guardar y evita que bloquees el sudo.

sudo visudo
sudo visudo -f /etc/sudoers.d/deploy

192. sudo sin contraseña para un comando

Permite solo lo necesario, en lugar de un acceso irrestricto.

# /etc/sudoers.d/deploy
deploy ALL=(ALL) NOPASSWD: /bin/systemctl restart minha-api

193. fail2ban

Bloquea una IP tras varios intentos de login fallidos.

sudo apt install fail2ban
sudo fail2ban-client status sshd
sudo fail2ban-client set sshd unbanip 192.168.1.10

194. Actualizaciones de seguridad automáticas

Deja que el servidor aplique una corrección crítica por su cuenta.

sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

195. Puertos abiertos vs esperados

Una auditoría sencilla: ¿lo que está escuchando debería estar escuchando?

sudo ss -tulpn | grep LISTEN

196. Archivos modificados recientemente

Investigación posterior al incidente.

sudo find /etc -mtime -2 -type f
sudo find / -mmin -60 -type f -not -path "/proc/*" 2>/dev/null

197. Verificar la integridad de los paquetes

Detecta un binario del sistema modificado.

sudo debsums -c          # Debian/Ubuntu
sudo rpm -Va             # RHEL/Fedora

198. El historial de comandos de otro usuario

Auditoría — y el recordatorio de que el tuyo también queda registrado.

sudo cat /home/usuario/.bash_history

199. Cifrar un archivo

GPG para proteger un backup o un archivo sensible.

gpg -c segredo.txt              # cifra con contraseña
gpg -d segredo.txt.gpg > segredo.txt

200. Generar una contraseña fuerte

Sin depender de un sitio de terceros.

openssl rand -base64 32
head -c 32 /dev/urandom | base64