Introducción
Los comandos pequeños de Linux resultan mucho más útiles cuando el shell los coordina. Un comando informa de si se ejecutó correctamente o no mediante un estado de salida; los operadores de secuencia deciden qué se ejecuta a continuación; una tubería conecta la salida estándar de un comando con la entrada estándar de otro.
En este laboratorio desarrollará estas ideas paso a paso y después usará grep, cut, wc, sort y uniq para transformar un pequeño conjunto de datos de eventos de servicio. En laboratorios posteriores sobre procesamiento de texto profundizará en estos filtros; aquí nos centraremos en cómo pasan los datos y las decisiones de un comando a otro.
Observe el estado de salida de los comandos
En este paso, relacionará el comportamiento visible de un comando con el estado numérico que registra el shell.
Un estado de salida 0 indica que la operación se realizó correctamente; un valor distinto de cero indica que el comando no pudo completar la operación solicitada. Ejecute una prueba correcta de un archivo e imprima inmediatamente $?, que contiene el estado más reciente:
cd /home/labex/project/pipeline-lab
test -f events.csv
echo $?
La salida es 0. Ahora pruebe un archivo que no existe:
test -f missing.csv
echo $?
El estado es distinto de cero. Lea $? inmediatamente, porque cada comando posterior lo reemplaza.
Cree una observación estable mediante una instrucción if. Más adelante estudiará los scripts completos de shell; aquí, esta instrucción simplemente convierte el estado en texto:
if test -f events.csv; then echo "events.csv is ready"; else echo "events.csv is missing"; fi > status-result.txt
cat status-result.txt
Controle qué comando se ejecuta a continuación
En este paso, comparará los operadores de comandos incondicionales y condicionales.
El punto y coma ejecuta el comando siguiente independientemente del resultado anterior:
false; echo "semicolon continues"
&& ejecuta el comando de la derecha solo si el comando anterior se ejecutó correctamente:
test -f events.csv && echo "input found"
test -f missing.csv && echo "you should not see this"
|| ejecuta el comando de la derecha solo si el comando anterior falla:
test -f missing.csv || echo "input missing"
Estos operadores permiten expresar una pequeña decisión de éxito o error. Copie el conjunto de datos solo si existe; de lo contrario, muestre un error:
test -f events.csv && cp events.csv working.csv || echo "Copy failed"
Compruebe que la copia protegida coincide con el archivo de origen:
cmp events.csv working.csv && echo "guarded copy matches" > sequence-result.txt
cat sequence-result.txt
Para lógicas complejas, prefiera una instrucción if legible; las cadenas largas de &&/|| pueden resultar ambiguas.
Envíe la salida mediante una tubería
En este paso, conectará comandos con | y observará cómo cada etapa reduce el flujo de datos.
El comando de la izquierda escribe su salida estándar en la tubería; el comando de la derecha lee esos datos como entrada estándar. Seleccione únicamente los registros ERROR:
cd /home/labex/project/pipeline-lab
cat events.csv | grep ',ERROR,'
grep puede leer un archivo directamente, por lo que esta forma más corta produce el mismo resultado:
grep ',ERROR,' events.csv
Añada wc -l para contar las líneas coincidentes:
grep ',ERROR,' events.csv | wc -l
Guarde tanto el flujo filtrado como el recuento. tee duplica su entrada estándar: escribe una copia en error-events.csv y pasa la otra copia a través de su salida estándar. Por eso, el wc -l final cuenta exactamente las líneas que se guardaron:
grep ',ERROR,' events.csv | tee error-events.csv | wc -l > error-count.txt
cat error-events.csv
cat error-count.txt
Inspeccione ambos archivos después de ejecutar la tubería. error-events.csv contiene los registros coincidentes, mientras que error-count.txt contiene su recuento.
Extraiga campos con Cut
En este paso, tratará cada línea CSV como un conjunto de campos separados por un delimitador.
cut -d, -f1 usa la coma como delimitador e imprime el campo 1, que corresponde al nombre del servicio:
cd /home/labex/project/pipeline-lab
cut -d, -f1 events.csv
Imprima juntos los campos del servicio y de la gravedad:
cut -d, -f1,2 events.csv
Combine el filtrado y la extracción para enumerar únicamente los servicios que generaron advertencias:
grep ',WARN,' events.csv | cut -d, -f1
Guarde este resultado intermedio:
grep ',WARN,' events.csv | cut -d, -f1 > warning-services.txt
cat warning-services.txt
cut funciona bien con registros sencillos cuyo delimitador nunca aparece dentro de un campo. Los formatos más complejos pueden requerir awk o una herramienta compatible con el formato.
Ordene y cuente los valores repetidos
En este paso, creará una tubería completa de frecuencias y comprenderá por qué sort debe ejecutarse antes de uniq.
uniq combina únicamente las líneas iguales adyacentes. Primero extraiga los nombres de los servicios y, después, ordénelos para que los valores idénticos queden juntos:
cd /home/labex/project/pipeline-lab
cut -d, -f1 events.csv | sort
Añada uniq -c para contar cada grupo de nombres iguales:
cut -d, -f1 events.csv | sort | uniq -c
Ordene los recuentos numéricamente en orden descendente. sort -k1,1nr usa el primer campo como clave numérica en orden inverso:
cut -d, -f1 events.csv | sort | uniq -c | sort -k1,1nr
Guarde el informe final:
cut -d, -f1 events.csv | sort | uniq -c | sort -k1,1nr > service-frequency.txt
cat service-frequency.txt
Lea esta tubería de izquierda a derecha: extraer → ordenar → contar duplicados adyacentes → clasificar los recuentos.
Resumen
Usó el estado de salida como señal de éxito del shell, controló la ejecución con ;, && y ||, y creó tuberías con etapas claras. Después filtró registros, extrajo campos, contó líneas, ordenó valores y contó duplicados: exactamente el vocabulario necesario para el próximo Challenge sobre canalizaciones de datos.
