SIN POSTUREOCatamos y probamos a fondo antes de recomendarte nada
Ilustración de una hoja de papel continuo con cuatro columnas de marcas, una de ellas resaltada en ámbar y con una regla de madera encima

Comando awk en Linux: filtrar columnas y analizar logs

domin10 min de lectura

Para sacar dos columnas de un archivo y sumar una de ellas, no me hace falta abrir una hoja de cálculo. awk lee el texto, separa cada registro en campos y ejecuta las reglas que le pases.

  • Para extraer columnas: awk '{print $1, $3}' archivo.txt imprime la primera y la tercera.
  • Puedes filtrar filas y hacer cálculos en el mismo programa, sin encadenar un grep por cada condición.
  • Necesitas conocer el formato de entrada. Separar por comas no basta para interpretar cualquier CSV.

En Debian y Ubuntu el awk que viene instalado es mawk; en Arch y Fedora, gawk (GNU awk). Todo lo de abajo funciona en los dos, salvo --csv, que es solo de gawk.

Condiciones y acciones

La estructura habitual es una condición seguida de una acción:

Terminal
awk 'condición {acción}' archivo.txt

Con los separadores predeterminados, cada línea es un registro. awk comprueba la condición y ejecuta la acción si se cumple. Sin condición, la aplica a todas las líneas; sin acción, imprime el registro completo. Es el modelo definido en el manual de awk de POSIX.

El programa va entre comillas simples para que la shell no interprete los signos $. Dentro, las cadenas de texto usan comillas dobles.

Si no indicas un archivo, lee la entrada estándar. Así puedes probarlo sin preparar nada en disco:

Terminal
printf 'api 120 ok\n' | awk '{print $1}'

Imprime api. Lo que hay a la izquierda del pipe es la entrada; lo que hay entre comillas simples es el programa.

Extraer columnas y distinguir campos de registros

Para los siguientes ejemplos, supón que tiempos.txt contiene un servicio, su duración en milisegundos y el resultado:

api 120 ok
web 85 ok
worker 210 error
api 95 ok

Por defecto, los campos se separan por secuencias de espacios o tabulaciones. Varios espacios seguidos no crean columnas vacías, y los espacios de los extremos se ignoran al obtener los campos. Ese comportamiento especial está explicado en la documentación del separador predeterminado.

Las variables que más vas a usar:

ReferenciaQué contiene
$0El registro completo
$1, $2…El primer campo, el segundo…
NFCantidad de campos del registro actual
$NFEl último campo
NRRegistros leídos en total
FNRRegistros leídos del archivo actual
FSSeparador de campos de entrada
OFSSeparador de campos de salida
RSSeparador de registros de entrada; inicialmente, salto de línea

La diferencia entre NR y FNR aparece al leer varios archivos: NR sigue contando y FNR vuelve a empezar. El resumen de lectura de GNU awk recoge estas variables.

Para sacar el servicio y la duración:

Terminal
awk '{print $1, $2}' tiempos.txt

La salida es:

api 120
web 85
worker 210
api 95

La coma de print introduce el separador de salida, un espacio por defecto. En cambio, print $1 $2 concatena ambos valores sin separador: la primera fila saldría como api120.

Para obtener el último campo basta con awk '{print $NF}' tiempos.txt. Aquí devuelve los estados.

Filtrar por números, texto o expresiones regulares

Para mostrar las ejecuciones que superaron los 100 milisegundos:

Terminal
awk '$2 > 100 {print $1, $2}' tiempos.txt

Obtienes api 120 y worker 210, cada uno en su línea. La segunda columna tiene que contener números.

Las comparaciones de texto usan ==. Para buscar mediante una expresión regular se usa ~:

Terminal
# Solo el nombre del servicio que terminó con error
awk '$3 == "error" {print $1}' tiempos.txt
# Registros cuyo primer campo sea exactamente api
awk '$1 ~ /^api$/' tiempos.txt

El segundo comando imprime las dos filas de api. Los anclajes ^ y $ delimitan el campo completo; sin ellos también coincidiría api-interna.

Puedes combinar condiciones con && —ambas— y || —al menos una—. Para comprobar igualdad usa ==: un solo = asigna un valor, no compara.

Si el límite viene de una variable de shell, pásalo con -v:

Terminal
limite=100
awk -v limite="$limite" '$2 > limite {print $1, $2}' tiempos.txt

Así el dato entra como variable de awk, sin tener que insertarlo dentro del código. El manual de las opciones de GNU awk documenta -v, que también permite usar el valor desde BEGIN.

Separadores y archivos CSV

La opción -F cambia el separador de entrada. Un caso habitual es consultar los nombres y las shells de /etc/passwd, cuyos campos van separados por dos puntos:

Terminal
awk -F: '{print $1, $7}' /etc/passwd

El separador de salida se configura por separado. Aquí la entrada usa : y la salida, una barra entre espacios:

Terminal
printf 'api:120:ok\n' |
awk -F: 'BEGIN {OFS=" | "} {print $1, $2}'

Devuelve api | 120. BEGIN se ejecuta antes de leer los registros; por eso sirve para preparar los separadores.

Cambiar OFS no modifica por sí solo la línea original. Si imprimes $0 sin haber cambiado ningún campo, conserva sus separadores. Para construir la salida con el nuevo formato, imprime los campos separados por comas. El manual explica cuándo se reconstruye el registro.

Con CSV hay otra pega. Esta fila tiene dos campos:

"Pérez, Ana",30

-F, la partiría también por la coma del apellido. No interpreta las comillas que protegen ese campo, ni los saltos de línea que puede contener un CSV.

GNU awk incorpora lectura de CSV desde la versión 5.3. Con esa implementación puedes usar:

Terminal
printf '"Pérez, Ana",30\n' | gawk --csv '{print $1, $2}'

Sale Pérez, Ana 30. mawk no tiene esa opción. La incorporación figura en el historial de GNU awk.

Calcular una media sin dividir entre cero

Para sumar duraciones basta con acumular $2. La media necesita además contar cuántas filas válidas has aceptado:

Terminal
awk '
NF == 3 && $2 ~ /^[0-9]+$/ {total += $2; n++}
END {
if (n > 0) printf "Media: %.2f ms\n", total / n
else print "Sin duraciones válidas"
}
' tiempos.txt

Con los datos del ejemplo devuelve:

Media: 127.50 ms

END ejecuta el cálculo después de leer la entrada. La comprobación de n evita dividir entre cero si el archivo está vacío o ninguna fila pasa el filtro.

La expresión acepta duraciones enteras no negativas y exactamente tres campos. Descarta cabeceras, líneas vacías y valores como pendiente; si tus datos admiten decimales, tendrás que adaptar esa validación.

El divisor es n, no NR. NR incluye también los registros descartados, que falsearían la media. Y sumar un campo no demuestra que contenga un número válido: conviene comprobarlo antes.

Dar formato y cambiar texto

printf permite fijar anchos y decimales. Para alinear las columnas del ejemplo:

Terminal
awk '{printf "%-8s %4d ms %s\n", $1, $2, $3}' tiempos.txt

%-8s reserva un mínimo de ocho posiciones y alinea el texto a la izquierda. %4d reserva cuatro para el entero. Los valores más largos no se recortan por usar esos anchos.

A diferencia de print, printf no añade un salto de línea: tienes que incluir \n. Tampoco aplica OFS, como explica el manual de salida de GNU awk.

Para transformaciones pequeñas tienes funciones incorporadas:

ExpresiónResultado o efecto
toupper($1)Copia del primer campo en mayúsculas
tolower($1)Copia en minúsculas
substr($1, 1, 3)Los tres primeros caracteres
sub(/error/, "fallo", $3)Sustituye la primera coincidencia en $3
gsub(/error/, "fallo", $3)Sustituye todas las coincidencias en $3

Por ejemplo, para cambiar el estado y mostrar el registro:

Terminal
awk '{gsub(/error/, "fallo", $3); print}' tiempos.txt

Aquí sí modificas un campo, así que awk reconstruye $0. Las funciones de sustitución cambian el destino; toupper y tolower devuelven una copia. La referencia está en las funciones de texto de GNU awk.

Analizar un log después de comprobar su formato

Las posiciones de un log dependen de cómo esté configurado. Este ejemplo, llamado access.log, usa la estructura de Common Log Format, incluida la zona horaria:

192.0.2.10 - - [10/Nov/2026:10:15:30 +0000] "GET /index.html HTTP/1.1" 200 1234
192.0.2.20 - - [10/Nov/2026:10:15:31 +0000] "POST /api/login HTTP/1.1" 401 567
192.0.2.10 - - [10/Nov/2026:10:15:32 +0000] "POST /api/login HTTP/1.1" 503 234

Separando por espacios, la ruta cae en $7, el estado HTTP en $9 y los bytes en $10. Para mostrar respuestas 4xx y 5xx:

Terminal
awk '$9 ~ /^[45][0-9][0-9]$/ {print $1, $9, $7}' access.log

Sale esto:

192.0.2.20 401 /api/login
192.0.2.10 503 /api/login

Si solo buscas errores de /api/login, compara la ruta completa:

Terminal
awk '$7 == "/api/login" && $9 ~ /^[45][0-9][0-9]$/ {
print $1, $9
}' access.log

Un estado distinto de 200 no implica necesariamente un error: puede ser otro resultado satisfactorio o una redirección. Aquí filtramos expresamente las familias 4xx y 5xx.

Para contar peticiones por IP, un array asociativo guarda un contador bajo cada dirección:

Terminal
awk '
{peticiones[$1]++}
END {for (ip in peticiones) print ip, peticiones[ip]}
' access.log | sort -k2,2nr -k1,1

El recorrido del array no garantiza el orden; sort coloca primero el contador mayor. Con estos datos, 192.0.2.10 tiene dos peticiones y 192.0.2.20, una. El programa conserva un contador por IP distinta, así que su memoria crece con esa cantidad.

Para sumar bytes, descartando valores como -:

Terminal
awk '$10 ~ /^[0-9]+$/ {bytes += $10}
END {printf "%.4f MiB\n", bytes / 1048576}' access.log

Devuelve 0.0019 MiB. La unidad es MiB porque divides entre 1024², no entre un millón.

Comprueba siempre el formato del servidor. Nginx permite personalizarlo y también generar logs en JSON; su documentación de logs muestra la definición de combined. Estos comandos presuponen las posiciones del ejemplo.

Filtrar líneas completas y quitar duplicados

Estas recetas no necesitan conocer las columnas:

Terminal
# Quitar registros sin campos, con el separador predeterminado
awk 'NF' archivo.txt
# Quitar líneas repetidas conservando la primera aparición
awk '!vistas[$0]++' archivo.txt
# Mostrar de la quinta a la décima línea, ambas incluidas
awk 'NR >= 5 && NR <= 10' archivo.txt
# Numerar líneas
awk '{print NR, $0}' archivo.txt

En la receta de duplicados, el contador empieza en cero. La primera aparición pasa el filtro y las siguientes se descartan. Guarda las líneas distintas en memoria: con entradas grandes, ese coste puede importar.

Estos comandos escriben en la salida estándar. Si quieres guardar el resultado, usa otro archivo: redirigirlo al mismo archivo de entrada puede vaciarlo antes de que awk lo lea. Es un efecto de las redirecciones de la shell.

Un ejercicio: calcular solo la media de las ejecuciones correctas

Con tiempos.txt, calcula la media de las filas cuyo estado sea ok. El resultado debe ser 100.00 ms.

Ver solución
Terminal
awk '
$3 == "ok" {total += $2; n++}
END {
if (n) printf "%.2f ms\n", total / n
else print "Sin resultados"
}
' tiempos.txt

Esta solución presupone las duraciones válidas del ejemplo. Para una entrada sin controlar, añade la validación numérica de la sección de medias.

Lo demás está en man awk.

En calidad de Afiliado de Amazon, obtengo ingresos por las compras adscritas que cumplen los requisitos aplicables. Más detalles en el aviso de afiliados.

Compartir