Redirecciones, pipes y ejecución segura: >, >>, 2>, |, &&, ||

(el 80% de la potencia real de Bash está aquí)

---

1. Objetivo del día

Aprender a controlar:

• la salida estándar
• la salida de error
• la redirección a archivos
• la combinación de comandos con pipes
• la ejecución segura con && y ||
• la captura de errores reales

Esto es lo que permite construir scripts eficientes, limpios y seguros.

Hoy sudamos… pero terminamos siendo profesionales de verdad 😄.

---

2. Requisitos

• Días 1–5 completos
• Especialmente funciones y bucles

---

3. Redirecciones: escribir y capturar salidas

3.1. Sobrescribir un archivo: >

echo "Hola" > salida.txt

Esto BORRA el contenido anterior del archivo.

---

3.2. Añadir al final: >>

echo "Línea adicional" >> salida.txt

No borra nada.

---

3.3. Redirigir errores: 2>

comando_que_falla 2> errores.log

• 1> es salida estándar (stdout)
• 2> es salida de error (stderr)

---

3.4. Guardar salida normal Y errores (muy real)

comando > salida.log 2> errores.log

O mezclarlas juntas:

comando > todo.log 2>&1

2>&1 = “redirige errores donde vaya stdout”.

---

4. Pipes (|): conectar comandos

Un pipe envía la salida de un comando a otro:

Ejemplo simple:

ls -l | grep ".txt"

Ejemplo real:

ps aux | grep ssh

Ejemplo ultra real en monitorización:

journalctl -p 3 -n 50 | grep "timeout"

Ejemplo para ver los 5 procesos con más CPU:

ps aux | sort -nrk 3 | head -5

---

5. Ejecución segura con operadores lógicos

5.1. Ejecutar un comando SOLO si el anterior fue bien: &&

ping -c1 google.com && echo "Conectado"

5.2. Ejecutar un comando SOLO si el anterior falla: ||

ping -c1 google.com || echo "Sin conexión"

5.3. Cadena de comandos segura

cp archivo.txt /backup/ && echo "Copia OK" || echo "Copia FALLÓ"

Muy útil en scripts de backup o despliegue.

---

6. Combinando pipes + redirecciones + seguridad

6.1. Buscar errores y guardarlos en un archivo

journalctl -p 3 -n 100 | grep "ERROR" > errores.txt

---

6.2. Guardar salida normal y errores SEMÁNTICAMENTE

curl http://localhost 1>ok.log 2>errores.log

---

6.3. Pipeline con “fallback”

ping -c1 "$host" > /dev/null 2>&1 \
    && echo "$host OK" \
    || echo "$host FAIL"

Esto es exactamente lo que se usa en scripts de health-check.

¿Qué significa “fallback” en este contexto?

Un fallback es una acción alternativa que se ejecuta si la acción principal falla.

En Bash, esto se hace usando los operadores lógicos:

• && → ejecuta el siguiente comando solo si el anterior tuvo éxito (exit code 0)
• || → ejecuta el siguiente comando solo si el anterior falló (exit code ≠ 0)

Por eso este pipeline:

ping -c1 "$host" > /dev/null 2>&1 \
    && echo "$host OK" \
    || echo "$host FAIL"

Significa:

1. Ejecuta ping
2. Si ping funciona → muestra "host OK"
3. Si ping falla → muestra "host FAIL" (esto es el fallback)

Es una forma muy compacta de escribir:

if ping -c1 "$host" > /dev/null 2>&1; then
    echo "$host OK"
else
    echo "$host FAIL"
fi

---

7. Capturar salida de un comando dentro del script

Muy usado para obtener valores.

fecha=$(date)
host=$(hostname)
usuarios=$(who | wc -l)

Usos reales:

ip=$(hostname -I | awk '{print $1}')
cpu=$(top -bn1 | grep "Cpu" | awk '{print $2}')

¿Qué es awk y por qué aparece aquí?

awk es una herramienta clásica de Unix para procesar texto línea a línea.
Se usa mucho en scripts para extraer columnas, filtrar campos o formatear salidas.

Ejemplo típico:

echo "192.168.1.10 servidor1" | awk '{print $1}'

Salida:

192.168.1.10

En este ejemplo:

• $1 → primera columna
• $2 → segunda columna
• {print $1} → imprime solo la primera columna

Separa por espacios automáticamente (a menos que digas lo contrario).

Es útil cuando:

• Lees un fichero con columnas
• Procesas salidas de comandos (ps, df, netstat, etc.)
• Necesitas quedarte solo con un dato concreto

Es una herramienta potente, pero aquí solo la usamos como extractor simple de columnas, sin complejidad.

---

8. Práctica guiada (20–30 minutos)

8.1. Crear archivo con errores (versión en script)

Script: errores.sh

#!/bin/bash

ls carpeta_inexistente > salida.txt 2> error.txt

echo "Salida y errores guardados."

Objetivo: practicar redirecciones (>, 2>).

---

8.2. Buscar procesos usando pipes (versión en script)

Script: buscar_proceso.sh

#!/bin/bash

proceso=$1

if [[ -z "$proceso" ]]; then
    echo "Uso: $0 <nombre_proceso>"
    exit 1
fi

ps aux | grep -i "$proceso"

Objetivo: pipes + argumentos.

---

8.3. Contar procesos ssh (en general, contar procesos)

Script: contar.sh

#!/bin/bash

proceso=$1

if [[ -z "$proceso" ]]; then
    echo "Uso: $0 <nombre_proceso>"
    exit 1
fi

cantidad=$(ps aux | grep -i "$proceso" | grep -v grep | wc -l)

echo "Procesos encontrados: $cantidad"

Objetivo: pipes + sustitución de comandos $( ).

---

8.4. Health-check seguro (versión script)

Script: healthcheck.sh

#!/bin/bash

host=$1

if [[ -z "$host" ]]; then
    echo "Uso: $0 <host>"
    exit 1
fi

if ping -c1 "$host" > /dev/null 2>&1; then
    echo "$host OK"
else
    echo "$host FAIL"
fi

Objetivo: usar lógica, if, redirecciones.

---

8.5. Guardar logs en un archivo (en script)

Script: logs_criticos.sh

#!/bin/bash

salida="errores.txt"

journalctl -p 3 -n 20 | tee "$salida"

echo "Guardado en $salida"

Objetivo: tee, redirecciones, variables.

¿Qué es tee?

tee es un comando que recibe datos por entrada estándar y:

1. Los muestra por pantalla
2. Los guarda en un archivo al mismo tiempo

Por eso se llama tee, porque actúa como una “T” que divide el flujo.

Ejemplo:

journalctl -p 3 -n 20 | tee errores.txt

Hace dos cosas a la vez:

• Muestra los logs críticos en pantalla
• Los guarda en errores.txt

Es útil cuando quieres ver la salida y guardar una copia al mismo tiempo.

---

9. Checklist del Día 6

• Usas > y >> correctamente
• Rediriges errores con 2>
• Combinas stdout y stderr
• Conectas comandos con pipes
• Usas && y || para ejecutar de forma segura
• Capturas salidas con $( )
• Puedes hacer health-checks seguros

Si está todo marcado → Día 6 superado.

---

10. Ejercicio sugerido

Crea un script:

analiza_log.sh

Que haga:

1. Reciba un archivo de log como argumento
2. Cuente cuántas veces aparece “error”
3. Cuente cuántas veces aparece “timeout”
4. Muestre las últimas 20 líneas
5. Guarde un informe en resultado.txt usando redirecciones

Ejemplo de salida:

Errores: 5
Timeouts: 2
Últimas líneas guardadas en resultado.txt

---

11. Día 6 completado

Hoy has aprendido lo que separa a un usuario de terminal de un verdadero script creator profesional.

Mañana llega EL GRAN FINAL:

👉 DÍA 7 — Proyecto final: Script de chequeo completo de un servidor

Será un script real, profesional y digno de producción, basado en:

• funciones
• bucles
• argumentos
• pipes
• redirecciones
• ejecución segura
• lectura de archivos