Mis apuntes · Aprende awk desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 27 de 31 · Proyecto final: el informe del log ✦ WebMCP implementado

Fase 1 · Parsear cada línea con funciones

10 min de lectura 3 retos

Empieza el proyecto final: un informe de tu web hecho con awk, que resume un día de access.log en una pantalla. Lo construyes en cinco fases, y cada una parte del programa de la anterior. En esta primera fase no cuentas nada todavía: enseñas a tu informe a leer bien una línea, con una función por cada dato.

¿De dónde vienen los nombres?

parsear = inglés to parse, del latín pars (parte)
Analizar un texto separándolo en sus partes y dándole nombre a cada una. Es lo que haces en PHP cuando conviertes una línea de texto en un objeto con propiedades.
informe.awk = informe + la extensión .awk
El nombre que le damos al programa del proyecto. En esta página las cajas lo llaman programa.awk (no se puede cambiar): cuando leas «tu informe», es ese fichero.
user agent = inglés user agent (agente del usuario)
El programa que hace la petición en nombre de la persona: su navegador. En el log es el último texto entre comillas, y en PHP lo lees en $_SERVER["HTTP_USER_AGENT"].
En 4 ideas
1/4

En PHP convertirías cada línea en un objeto LineaLog con sus métodos. En awk no hay objetos: escribes una función por dato (ip(), url(), estado()…) que lee los campos de la línea actual.

1 · El plan: qué vas a construir

Llevas siete módulos sacando cosas sueltas del log: las 404, las IP, los bytes. Ahora lo juntas todo en un solo programa. Cuando acabes la fase 5, tu informe imprimirá esto con el access.log del curso:

$ gawk -f informe.awk ips-bloqueadas.txt access.log
INFORME DE ACCESOS
==================
Desde: 19/Nov/2026:10:15:32
Hasta: 19/Nov/2026:12:14:50

RESUMEN
-------
Lineas leidas             20
Lineas rotas               0
Peticiones de bots         9   45.0%
Ficheros estaticos         2   10.0%
Visitas reales             9   45.0%
Bytes servidos        1.1 MB

ESTADOS
-------
200                       10   50.0%
302                        1    5.0%
304                        1    5.0%
401                        3   15.0%
403                        1    5.0%
404                        3   15.0%
500                        1    5.0%

TOP 3 PAGINAS
-------------
1. /                            1   11.1%
2. /api/ventas                  1   11.1%
3. /blog/tutorial-logs          1   11.1%

TOP 3 IP
--------
1. 203.0.113.7                  4   44.4%
2. 192.0.2.55                   3   33.3%
3. 192.0.2.140                  2   22.2%

NAVEGADORES
-----------
1. Firefox                      4   44.4%
2. Chrome                       3   33.3%
3. Safari                       2   22.2%

VISITAS POR HORA
----------------
10h ####################    4
11h ###############         3
12h ##########              2

ATAQUES
-------
Escaneos (404 a rutas trampa):
  198.51.100.4       3  YA BLOQUEADA (escaner)
Fuerza bruta (3 o mas 401 en /login):
  198.51.100.4       3  YA BLOQUEADA (escaner)

Es mucho para escribirlo de golpe. Por eso va por fases, como se monta un mueble: primero las patas, luego el tablero. Cada lección parte del programa de la anterior, añade una pieza y al final te lo enseña entero.

FaseQué añadeQué usas de lo que ya sabes
1 · ParsearUna función por dato y el control de líneas rotasCampos, substr, split, funciones propias
2 · Filtrar y contarQuitar bots y ficheros estáticos; el resumen y los estadosRegex, next, arrays, printf
3 · Top y horasLas páginas y las IP con más visitas; un gráfico de barrasOrdenar arrays, bucles for
4 · AtaquesEscaneos y fuerza bruta; cruce con las IP bloqueadas-v, varios ficheros, in
5 · Informe finalTítulos, porcentajes, tamaños y cómo usarlo en tu servidorsprintf, gsub, la terminal

2 · Una función por dato

Hasta ahora escribías $7 para la página y $9 para el estado. En un programa de dos líneas va bien. En uno de doscientas, dentro de un mes no te acordarás de qué era $9. Y si un día nginx añade una columna al log, tendrás que buscar y cambiar cada número.

En PHP lo resolverías con una clase: la línea entra por el constructor y tú preguntas $linea->url(). En awk no hay clases, pero sí funciones. Escribes una por dato, y que cada una sepa en qué campo está lo suyo:

PHP 8.5LineaLog.php
<?php
final readonly class LineaLog
{
    /** @param list<string> $campos */
    public function __construct(private array $campos) {}

    public function ip(): string
    {
        return $this->campos[0];
    }

    public function url(): string
    {
        return $this->campos[6];
    }

    public function estado(): int
    {
        return (int) $this->campos[8];
    }
}

foreach (file("access.log", FILE_IGNORE_NEW_LINES) as $texto) {
    $linea = new LineaLog(preg_split('/\s+/', trim($texto)));
    if ($linea->estado() === 404) {
        echo $linea->ip(), " ", $linea->url(), PHP_EOL;
    }
}
awkprograma.awk
# En PHP: public function ip(): string { return $this->campos[0]; }
function ip() {
    return $1
}

# En PHP: public function url(): string { return $this->campos[6]; }
function url() {
    return $7
}

# En PHP: public function estado(): int { return (int) $this->campos[8]; }
function estado() {
    return $9
}

# En PHP: if ($linea->estado() === 404) { echo $linea->ip(), " ", $linea->url(), PHP_EOL; }
estado() == 404 {
    print ip(), url()
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Medido en el servidor del curso con access.log multiplicado hasta 1.000.000 líneas: PHP 8.5: 1,63 s · gawk: 620 ms · mawk: 570 ms. awk tarda 2,9 veces menos que PHP.

Mira la última regla: estado() == 404 { print ip(), url() }. Se lee casi como una frase. Los números de campo han desaparecido del programa: solo los conocen las tres funciones de arriba.

¿Por qué? · En PHP no existe

¿Por qué url() no recibe la línea como parámetro?

En PHP una función no ve las variables de fuera: si quieres que trabaje con la línea, se la pasas (url($linea)) o la guardas en $this. Es una pared que te protege.

En awk esa pared no existe. Lo viste en la lección de funciones propias: todo es global salvo los parámetros. Y los campos ($0, $1, $7, NF) son lo más global que hay: son la línea que awk está leyendo ahora mismo. Cualquier función puede mirarlos.

Así que url() no necesita que le pases nada. Piensa en la línea actual como en el plato que hay ahora en la mesa: cualquiera que se siente puede servirse. La contrapartida es que estas funciones solo tienen sentido mientras se lee una línea. En el bloque END ya no hay plato: se usan los contadores que hayas guardado.

3 · Devolver el dato ya limpio

Algunos campos vienen con «cáscara». El método trae una comilla pegada ("GET), la fecha trae un corchete y la hora metida dentro ([19/Nov/2026:10:15:32). Si cada parte del informe tuviera que pelarlos, repetirías el mismo substr diez veces. Se pela una vez, dentro de la función:

awkprograma.awk
# En PHP: return substr($this->campos[3], 13, 2);
function hora() {
    return substr($4, 14, 2)
}

# En PHP: return substr($this->campos[5], 1);
function metodo() {
    return substr($6, 2)
}

# En PHP: return (int) $this->campos[9];
function bytes() {
    return $10 + 0
}

NR <= 4 {
    print "crudo:  " $4, $6, $10
    print "limpio: " hora(), metodo(), bytes()
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

  • hora() usa lo que viste en el módulo 06: la hora empieza en el carácter 14 de $4 y ocupa 2. Recuerda que substr de awk cuenta desde 1 y el de PHP desde 0.
  • metodo() se salta el primer carácter, que es la comilla.
  • bytes() suma cero. Así devuelve siempre un número: si algún día el servidor escribe un guion en vez del tamaño (Apache lo hace), "-" + 0 vale 0 y tus sumas no se estropean.

La página también tiene cáscara, aunque en el log del curso no se vea. Una visita real suele llegar así: /blog/tutorial-logs?utm_source=boletin. Lo que va tras el ? es la query string, tu $_GET de PHP. Para el informe, esa visita es de /blog/tutorial-logs y punto. Si no lo quitas, la misma página saldrá cien veces con cien colas distintas.

awkprograma.awk
# En PHP: return explode("?", $this->campos[6])[0];
function url(    ruta) {
    ruta = $7
    sub(/\?.*/, "", ruta)
    return ruta
}

¿Por qué? · En PHP no existe

¿Por qué copiar $7 a ruta antes de limpiarlo?

En PHP, preg_replace() te devuelve el texto nuevo y deja el original como estaba. En awk, sub() hace lo contrario: cambia la variable que le das. Si escribieras sub(/\?.*/, "", $7) estarías modificando el campo 7 de la línea.

Y cambiar un campo tiene premio: awk reconstruye $0 entero (lo viste en nr-nf-y-ofs) y los espacios y las comillas de la línea dejan de estar donde estaban. Una función que solo debía mirar la línea la habría roto para todas las que vienen detrás.

Por eso se trabaja sobre una copia. Y esa copia, ruta, va en los paréntesis tras cuatro espacios: es el truco del módulo 06 para tener una variable local. Sin él, ruta sería global y cualquier otra parte del informe que usara ese nombre se la encontraría cambiada.

4 · El navegador: el orden importa

El user agent es el dato más pesado de la línea: tiene espacios, así que con el separador normal queda repartido en un montón de campos. En el módulo 02 lo sacabas ejecutando awk con -F '"'. Aquí no puedes: el resto del informe cuenta con los campos partidos por espacios.

La solución es partir la línea por las comillas solo dentro de una función, con split. El user agent es el sexto trozo:

awkprograma.awk
# En PHP: return explode('"', $texto)[5];
function agente(    trozos) {
    split($0, trozos, "\"")
    return trozos[6]
}

function navegador(    texto) {
    texto = agente()
    # En PHP: if (str_contains($texto, "Firefox/")) { return "Firefox"; }
    if (texto ~ /Firefox\//) {
        return "Firefox"
    }
    if (texto ~ /Chrome\//) {
        return "Chrome"
    }
    if (texto ~ /Safari\//) {
        return "Safari"
    }
    return "otro"
}

NR == 1 || NR == 3 || NR == 4 || NR == 16 {
    print navegador() " <- " agente()
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Fíjate en la tercera línea de la salida, la de Chrome. Su user agent termina en Chrome/130.0.0.0 Safari/537.36: lleva escritas las dos palabras. Chrome se presenta así desde que nació, para que las webs que solo aceptaban Safari le dejaran pasar.

Lo que no reconoce (curl, Googlebot…) se queda en otro. No pasa nada: en la fase 2 esas visitas se apartan por ser de robots.

5 · Líneas rotas: el control de la puerta

Un log de verdad no es tan limpio como el del curso. A tu servidor llegan programas que ni siquiera hablan HTTP y mandan basura. nginx la apunta tal cual, y sale una línea con la petición rota y menos campos de la cuenta. Una línea normal tiene 12 o más (el user agent añade los suyos).

Tu informe necesita un portero que mire cada línea antes de dejarla pasar. Dos comprobaciones bastan: que haya al menos 12 campos y que el estado sean tres cifras.

El log del curso no trae ninguna línea rota, así que para probar al portero hay que fabricarlas. En un bloque BEGIN puedes asignar un texto a $0: awk lo trocea igual que si lo hubiera leído del fichero, y tus funciones no notan la diferencia. Esta caja no lee ningún fichero:

awkprograma.awk
function estado() {
    return $9
}

# En PHP: return count($campos) >= 12 && preg_match('/^[0-9]{3}$/', $campos[8]) === 1;
function linea_valida() {
    return NF >= 12 && estado() ~ /^[0-9][0-9][0-9]$/
}

BEGIN {
    $0 = "203.0.113.7 - - [19/Nov/2026:10:15:32 +0100] \"GET / HTTP/1.1\" 200 5123 \"-\" \"Mozilla/5.0 (X11; Linux x86_64; rv:131.0) Gecko/20100101 Firefox/131.0\""
    print "linea normal:", linea_valida(), "(" NF " campos, estado " estado() ")"

    $0 = "198.51.100.4 - - [19/Nov/2026:10:16:07 +0100] \"\\x16\\x03\\x01\" 400 157 \"-\" \"-\""
    print "peticion basura:", linea_valida(), "(" NF " campos, estado " estado() ")"

    $0 = "198.51.100.4 - - [19/Nov/2026:10:16:08 +0100] \"-\" 400 0 \"-\" \"Mozilla/5.0 (X11; Linux x86_64)\""
    print "sin peticion:", linea_valida(), "(" NF " campos, estado " estado() ")"
}
$ awk -f programa.awk
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. Sin fichero de datos: este programa solo tiene BEGIN, así que no lee nada.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

1 es verdadero y 0 es falso: awk no tiene true ni false. Mira la tercera prueba: tiene 13 campos, así que pasaría el primer control. Pero como la petición es un guion en vez de tres palabras, todo se ha corrido dos sitios a la izquierda y en el campo del estado hay un "-". La segunda comprobación la caza.

¿Por qué? · En PHP no existe

¿Por qué hay que validar a mano? En PHP me habría avisado

En PHP, pedir $campos[8] en una línea con 5 trozos lanza un aviso de Undefined array key. Molesta, pero te enteras de que algo va mal.

En awk, un campo que no existe vale texto vacío y nadie dice nada. Viene muy bien para programas de una línea. Para un informe es un peligro: la línea rota se contaría como una visita a la página «» con el estado «», y tus totales estarían mal sin que lo supieras.

awk te da silencio a cambio de comodidad. El precio es que el control lo pones tú. La buena noticia es que se pone una sola vez, arriba del todo, y lo que pasa de ahí ya es de fiar.

6 · Tu informe al acabar la fase 1

Juntas las funciones y debajo pones el programa, que por ahora son tres reglas y un END:

  1. Cuenta la línea como leída.
  2. Si no es válida, la cuenta como rota y pasa a la siguiente con next.
  3. Si ha llegado hasta aquí, imprime sus datos ya limpios. Es una salida de control: sirve para comprobar a ojo que las funciones aciertan, y en la fase 2 la cambiarás por contadores.
awkprograma.awk
# informe.awk · fase 1 (necesita gawk a partir de la fase 2)
# ---------- Fase 1: sacar los datos de la linea ----------
# En PHP: public function ip(): string { return $this->campos[0]; }
function ip() {
    return $1
}

function hora() {
    return substr($4, 14, 2)
}

function metodo() {
    return substr($6, 2)
}

function url(    ruta) {
    ruta = $7
    sub(/\?.*/, "", ruta)
    return ruta
}

function estado() {
    return $9
}

function bytes() {
    return $10 + 0
}

function agente(    trozos) {
    split($0, trozos, "\"")
    return trozos[6]
}

function navegador(    texto) {
    texto = agente()
    if (texto ~ /Firefox\//) {
        return "Firefox"
    }
    if (texto ~ /Chrome\//) {
        return "Chrome"
    }
    if (texto ~ /Safari\//) {
        return "Safari"
    }
    return "otro"
}

function linea_valida() {
    return NF >= 12 && estado() ~ /^[0-9][0-9][0-9]$/
}

# ---------- El programa ----------
{
    leidas++
}

!linea_valida() {
    rotas++
    next
}

{
    print hora() "h", ip(), metodo(), estado(), bytes(), navegador(), url()
}

END {
    printf "Lineas leidas: %d\n", leidas
    printf "Lineas rotas: %d\n", rotas
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

En el END se usa printf con %d y no print. Tiene truco: como no hay líneas rotas, la variable rotas no se ha tocado nunca y vale vacío. print imprimiría un hueco; %d la convierte en 0, igual que un (int) de PHP.

La pregunta que te vas a hacer

¿Y si el log de mi servidor tiene otro formato?

El formato de este curso es el combined, el que traen nginx y Apache si no tocas nada. Si tu nginx usa un log_format propio (por ejemplo con el tiempo de respuesta al final), los datos estarán en otros campos.

Ahí se nota la ventaja de esta fase: abres informe.awk, cambias el número dentro de estado() o de bytes() y todo lo demás sigue funcionando. Para ver qué formato tienes, busca log_format y access_log en la configuración de tu nginx.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

metodo() y hora(), sin cáscara

Tu informe imprime por cada línea la hora, el método, el estado y la página. Pero hora() devuelve el campo entero ([19/Nov/2026:10:15:32) y metodo() trae la comilla ("GET). Arregla las dos funciones para que la primera línea del log salga así: 10h GET 200 /. Al comprobar se añade un BEGIN que fabrica una línea de prueba y las llama; debe imprimir prueba: 07h DELETE. En PHP serían substr($campos[3], 13, 2) y substr($campos[5], 1).

Al pulsar Comprobar, tu programa se ejecuta en tu navegador con el fichero que ves y con otro distinto que no ves: tiene que acertar con los dos.

awkprograma.awk · editable
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Resumen

Lo que te llevas de esta lección

  1. Una función por dato: ip(), hora(), metodo(), url(), estado(), bytes(), navegador(). Son los métodos de tu clase LineaLog de PHP, sin clase.
  2. Los $número viven solo dentro de esas funciones. Si cambia el formato del log, tocas un sitio. En PHP es tener las propiedades en private.
  3. La función devuelve el dato limpio: sin comilla, sin corchete, sin query string y, si es un número, con + 0. Es el trim() y el (int) del constructor.
  4. sub() cambia la variable que le das (al revés que preg_replace): se limpia una copia local, nunca el campo.
  5. En navegador() el orden de los if importa: Chrome antes que Safari, porque Chrome lleva las dos palabras.
  6. awk no avisa de un campo que falta: linea_valida() (NF >= 12 y estado de tres cifras) es el portero. Se prueba fabricando líneas con $0 = "…" en un BEGIN.

Para recordarlo: «El número de campo, en un solo sitio»

SSaca
$7, $9…
LLimpia
substr, sub, + 0
DDevuelve
return

Si en tu informe ves un $7 fuera de una función, algo sobra. Y para acordarte de qué hace cada función con su dato: lo Saca, lo Limpia y lo Devuelve.

Los programas se ejecutan con GNU awk 5.4.1 compilado a WebAssembly, software libre con licencia GPL-3.0. Código fuente: gawk en ftp.gnu.org · receta de compilación.