Lección 31 de 31 · Proyecto final: el informe del log✦ WebMCP implementado
Fase 5 · El informe completo y cómo usarlo en tu servidor
10 min de lectura2 retos
Tu informe ya calcula todo lo que tiene que calcular. Le falta presentarlo: títulos, porcentajes, tamaños que se lean y de qué horas a qué horas habla. En esta última fase lo dejas terminado, lo ves entero y aprendes a usarlo donde de verdad hace falta: en tu servidor.
¿De dónde vienen los nombres?
zcat = z (de gzip) + cat
El cat de los ficheros comprimidos: escribe su contenido descomprimido sin tocar el fichero. Sirve para leer los logs antiguos, que el servidor guarda en .gz.
cron = del griego chrónos (tiempo)
El programa de Linux que ejecuta comandos a una hora fija: cada noche, cada lunes. Es lo que usarías para lanzar un script de PHP programado.
KB, MB = kilobyte, megabyte
1 KB son 1024 bytes y 1 MB son 1024 KB (1.048.576 bytes). El log guarda siempre bytes; las personas leen mejor megas.
GoAccess = inglés go + access (por access log)
Un programa libre que analiza logs de acceso y los enseña en un panel. Es lo que hace tu informe, hecho por gente que lleva años en ello.
En 4 ideas
1/4
Tres ayudantes de formato: titulo() subraya, porcentaje() hace la regla de tres y tamano() pasa bytes a KB o MB con sprintf. En PHP serían tres funciones de un helper de vistas.
porcentaje() comprueba que el total no sea cero antes de dividir. En awk dividir entre cero para el programa en seco, igual que el DivisionByZeroError de PHP.
En el servidor el informe se ejecuta con gawk -f informe.awk y el log como argumento; los logs antiguos, comprimidos, entran por una tubería desde zcat. Es tu php informe.php de la terminal.
awk es para preguntar al log en el momento. Si necesitas guardar datos, cruzarlos con la base de datos o enseñarlos en una web, toca volver a PHP o usar GoAccess.
1 · Lo que le falta a tu informe
Ejecuta mentalmente el informe de la fase 4 y ponte en el lugar de quien lo recibe. Dice «Bytes servidos 1166236». ¿Eso es mucho? Dice «Peticiones de bots 9». ¿De cuántas? Y no dice de qué día es. Los números están bien; lo que falla es que hay que pensar para entenderlos.
Un buen informe es como el marcador de un partido: se entiende de un vistazo. Estos son los cambios de la fase 5, todos de presentación:
Una cabecera con el periodo: la fecha de la primera línea válida y la de la última.
Un título subrayado en cada sección, con una línea en blanco delante.
Porcentajes al lado de los números: 9 robots son el 45,0 % de las peticiones.
Los bytes, en la unidad que toque: 1.1 MB en vez de 1166236.
Una sección nueva, NAVEGADORES, que por fin usa la función navegador() de la fase 1.
Para el periodo hace falta un dato más de la línea, así que la fase 1 gana una función: momento(), que devuelve la fecha y la hora sin el corchete. El programa guarda el primero que ve y va pisando el último:
awkprograma.awk
# En PHP: return substr($this->campos[3], 1);functionmomento() {
returnsubstr($4, 2)
}
{
# En PHP: $desde ??= $linea->momento();if (desde == "") {
desde = momento()
}
hasta = momento()
}
No hace falta convertir fechas ni comparar nada: el log está escrito en orden, así que la primera línea es la más antigua y la última la más reciente. desde solo se asigna cuando está vacía; hasta se asigna siempre, y al acabar se queda con la última.
2 · Tres ayudantes: titulo(), porcentaje() y tamano()
Las tres cosas se repiten por todo el informe, así que van en funciones. Las dos primeras se prueban sin fichero, con números puestos a mano en un BEGIN:
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-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.
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.
titulo() hace la raya a la medida del texto: copia el título y cambia cada carácter por un guion con gsub(/./, "-", raya). Recuerda del módulo 06 que gsub cambia la variable que le das: por eso trabaja sobre una copia local.
porcentaje() es la regla de tres de siempre: parte * 100 / total. Devuelve un número con sus decimales; quien lo imprime decide cuántos enseña (%6.1f, uno).
En el formato de printf, %% es la forma de escribir un signo de porcentaje, igual que en PHP.
¿Por qué? · En PHP no existe
¿Por qué porcentaje() mira si el total es cero?
Porque un día tu informe leerá un log vacío. Pasa más de lo que parece: justo después de que el servidor rote los logs a medianoche, access.log tiene cero líneas. Sin esa comprobación, esto es lo que ocurre al dividir:
$ gawk -f informe.awk access.log
gawk: informe.awk:2: fatal: division by zero attempted
fatal significa que awk se para ahí mismo: no imprime ni lo que ya tenía calculado. En PHP 8 es igual de serio: dividir entre cero lanza un DivisionByZeroError.
La diferencia es que en PHP lo arreglarías con un try/catch y en awk no existe. Lo único que puedes hacer es no llegar a la división: preguntar antes y devolver 0. Un informe de un log vacío tiene que decir «0 visitas», no romperse.
tamano() elige la unidad según lo grande que sea el número. Devuelve un texto ya montado con sprintf, que es el printf que no imprime (módulo 04):
# En PHP: function tamano(int $cantidad): stringfunctiontamano(cantidad) {
if (cantidad >= 1048576) {
returnsprintf("%.1f MB", cantidad / 1048576)
}
if (cantidad >= 1024) {
returnsprintf("%.1f KB", cantidad / 1024)
}
returnsprintf("%d B", cantidad)
}
BEGIN {
print512, "->", tamano(512)
print1536, "->", tamano(1536)
print1166236, "->", tamano(1166236)
}
$ awk -f programa.awk
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-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.
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.
awk no tiene match ni los guiones bajos de 1_048_576, así que son if en fila y el número escrito de un tirón. El orden importa otra vez, como en navegador(): primero se pregunta por lo más grande.
3 · El informe completo
Este es informe.awk terminado. Arriba, las funciones por fases, con los mismos nombres que les diste al escribirlas. En medio, las secciones, que ahora llaman a titulo(), porcentaje() y tamano(). Abajo, el programa: el embudo de siempre y un END que es el índice del informe.
awkprograma.awk
# informe.awk: el informe de un dia de tu web (necesita gawk)# Uso: gawk -v top=3 -v umbral=3 -f informe.awk ips-bloqueadas.txt access.log# ---------- Fase 1: sacar los datos de la linea ----------functionip() {
return$1
}
functionmomento() {
returnsubstr($4, 2)
}
functionhora() {
returnsubstr($4, 14, 2)
}
functionmetodo() {
returnsubstr($6, 2)
}
functionurl( ruta) {
ruta = $7sub(/\?.*/, "", ruta)
return ruta
}
functionestado() {
return$9
}
functionbytes() {
return$10 + 0
}
functionagente( trozos) {
split($0, trozos, "\"")
return trozos[6]
}
functionnavegador( texto) {
texto = agente()
if (texto ~ /Firefox\//) {
return"Firefox"
}
if (texto ~ /Chrome\//) {
return"Chrome"
}
if (texto ~ /Safari\//) {
return"Safari"
}
return"otro"
}
functionlinea_valida() {
returnNF >= 12 && estado() ~ /^[0-9][0-9][0-9]$/
}
# ---------- Fase 2: filtrar y contar ----------functiones_bot() {
returntolower(agente()) ~ /bot|spider|crawl|curl|wget|python-requests/
}
functiones_estatico() {
returntolower(url()) ~ /\.(css|js|png|jpg|jpeg|gif|svg|ico|woff2)$/
}
# ---------- Fase 3: ordenar y dibujar ----------functionpor_valor_y_clave(clave1, valor1, clave2, valor2) {
if (valor1 != valor2) {
return valor2 - valor1
}
if (clave1 < clave2) {
return -1
}
return clave1 > clave2
}
functionbarra(valor, maximo, largo, texto, i) {
largo = int(valor * 20 / maximo)
for (i = 1; i <= largo; i++) {
texto = texto "#"
}
return texto
}
# ---------- Fase 4: ataques ----------functiones_escaneo() {
returnestado() == 404 && tolower(url()) ~ /wp-login|wp-admin|phpmyadmin|\.env|\.git|\/admin|backup/
}
functiones_login_fallido() {
returnestado() == 401 && url() == "/login"
}
functionetiqueta_bloqueo(ip_sospechosa) {
if (ip_sospechosa in bloqueada) {
return"YA BLOQUEADA (" bloqueada[ip_sospechosa] ")"
}
return"SIN BLOQUEAR"
}
# ---------- Fase 5: dar formato ----------functiontitulo(texto, raya) {
raya = texto
gsub(/./, "-", raya)
print""print texto
print raya
}
functionporcentaje(parte, total) {
if (total == 0) {
return0
}
return parte * 100 / total
}
functiontamano(cantidad) {
if (cantidad >= 1048576) {
returnsprintf("%.1f MB", cantidad / 1048576)
}
if (cantidad >= 1024) {
returnsprintf("%.1f KB", cantidad / 1024)
}
returnsprintf("%d B", cantidad)
}
# ---------- Las secciones del informe ----------functionimprimir_resumen( validas) {
validas = leidas - rotas
titulo("RESUMEN")
printf"%-20s %7d\n", "Lineas leidas", leidas
printf"%-20s %7d\n", "Lineas rotas", rotas
printf"%-20s %7d %6.1f%%\n", "Peticiones de bots", de_bots, porcentaje(de_bots, validas)
printf"%-20s %7d %6.1f%%\n", "Ficheros estaticos", estaticos, porcentaje(estaticos, validas)
printf"%-20s %7d %6.1f%%\n", "Visitas reales", visitas, porcentaje(visitas, validas)
printf"%-20s %7s\n", "Bytes servidos", tamano(total_bytes)
}
functionimprimir_estados( codigo) {
titulo("ESTADOS")
PROCINFO["sorted_in"] = "@ind_str_asc"for (codigo in por_estado) {
printf"%-20s %7d %6.1f%%\n", codigo, por_estado[codigo], porcentaje(por_estado[codigo], leidas - rotas)
}
}
functionimprimir_top(texto, cuenta, cuantos, clave, puesto) {
titulo(texto)
PROCINFO["sorted_in"] = "por_valor_y_clave"for (clave in cuenta) {
puesto++
if (puesto > cuantos) {
break
}
printf"%d. %-25s %4d %6.1f%%\n", puesto, clave, cuenta[clave], porcentaje(cuenta[clave], visitas)
}
if (puesto == 0) {
print"(sin datos)"
}
}
functionimprimir_horas( franja, maximo) {
titulo("VISITAS POR HORA")
for (franja in por_hora) {
if (por_hora[franja] > maximo) {
maximo = por_hora[franja]
}
}
PROCINFO["sorted_in"] = "@ind_str_asc"for (franja in por_hora) {
printf"%sh %-20s %4d\n", franja, barra(por_hora[franja], maximo), por_hora[franja]
}
}
functionimprimir_sospechosas(texto, cuenta, minimo, clave, cuantas) {
print texto
PROCINFO["sorted_in"] = "por_valor_y_clave"for (clave in cuenta) {
if (cuenta[clave] < minimo) {
break
}
cuantas++
printf" %-15s %4d %s\n", clave, cuenta[clave], etiqueta_bloqueo(clave)
}
if (cuantas == 0) {
print" (ninguna)"
}
}
functionimprimir_ataques() {
titulo("ATAQUES")
imprimir_sospechosas("Escaneos (404 a rutas trampa):", escaneos, 1)
imprimir_sospechosas("Fuerza bruta (" umbral " o mas 401 en /login):", fallos_login, umbral)
}
# ---------- El programa ----------BEGIN {
if (top == "") {
top = 3
}
if (umbral == "") {
umbral = 3
}
}
FILENAME ~ /bloqueadas/ {
bloqueada[$1] = $2next
}
{
leidas++
}
!linea_valida() {
rotas++
next
}
{
if (desde == "") {
desde = momento()
}
hasta = momento()
total_bytes += bytes()
por_estado[estado()]++
}
es_escaneo() {
escaneos[ip()]++
}
es_login_fallido() {
fallos_login[ip()]++
}
es_bot() {
de_bots++
next
}
es_estatico() {
estaticos++
next
}
{
visitas++
paginas[url()]++
visitas_ip[ip()]++
por_hora[hora()]++
navegadores[navegador()]++
}
END {
print"INFORME DE ACCESOS"print"=================="print"Desde: " desde
print"Hasta: " hasta
imprimir_resumen()
imprimir_estados()
imprimir_top("TOP " top " PAGINAS", paginas, top)
imprimir_top("TOP " top " IP", visitas_ip, top)
imprimir_top("NAVEGADORES", navegadores, 10)
imprimir_horas()
imprimir_ataques()
}
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-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.
ips-bloqueadas.txtaccess.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 qué ha cambiado y qué no respecto a la fase 4:
Las reglas del programa son las mismas. Solo hay dos líneas nuevas en el embudo: las de desde y hasta, y navegadores[navegador()]++ al fondo.
La sección de navegadores no ha necesitado ninguna función nueva: es otra llamada a imprimir_top() con otro array. Eso es lo que se gana al escribir una función que recibe el array.
Los print "" que separaban secciones en el END han desaparecido: ahora la línea en blanco la pone titulo().
4 · En tu servidor
Hasta aquí todo ha corrido en tu navegador. Lo que sigue es de solo lectura: son comandos para la terminal de tu servidor, donde sí hay tuberías y otros programas. Guarda el informe como informe.awk, súbelo y entra por SSH.
El log de hoy. El fichero suele ser de root, así que hace falta sudo. Las dos variables son opcionales:
Los logs antiguos. Cada noche el servidor aparta el log del día y empieza uno nuevo (se llama rotar). Los antiguos se quedan comprimidos: access.log.2.gz, access.log.3.gz… awk no sabe leer un .gz, pero zcat sí: lo descomprime y se lo pasa por una tubería. Sin fichero en la línea de comando, awk lee lo que le llega por ella:
$ zcat access.log.2.gz | gawk -f informe.awk | head -4
INFORME DE ACCESOS
==================
Desde: 19/Nov/2026:10:15:32
Hasta: 19/Nov/2026:12:14:50
Si además quieres cruzar con la lista, un guion (-) le dice a awk en qué momento leer la tubería: zcat access.log.2.gz | gawk -f informe.awk ips-bloqueadas.txt -.
Todas las mañanas, solo. Con cron el informe de ayer te espera cada día en un fichero. Esta línea, añadida con crontab -e, lo genera a las 7:00 con el log que se rotó por la noche:
tail -f access.log enseña las líneas nuevas según llegan, y no termina nunca. Es tentador enchufarle el informe: tail -f access.log | gawk -f informe.awk. Lo haces y la pantalla se queda en blanco.
Todo lo que imprime tu informe está en el END, y el END se ejecuta cuando se acaba la entrada. Con tail -f la entrada no se acaba. Y si cortas con Ctrl+C, mueren los dos programas a la vez y el END tampoco llega.
En PHP te pasaría lo mismo con un while (true) que acumula en un array y un echo puesto después del bucle. Para vigilar en directo hace falta otro tipo de programa: uno que imprima en la regla, línea a línea. Puedes reutilizar tus funciones:
awkprograma.awkSolo lectura: se usa con tail -f access.log | gawk -f vigilar.awk
fflush() obliga a awk a escribir ya, sin esperar a llenar su memoria intermedia. Sin él, los avisos saldrían a golpes y con retraso.
5 · Cuándo dejar awk
Has escrito un analizador de logs en menos de 300 líneas, sin instalar nada y sin base de datos. Para saber qué ha pasado hoy en tu web, es difícil hacerlo con menos. Pero awk es un pelapatatas, como dijimos en la primera lección, y hay trabajos que piden otra herramienta:
Necesitas…
Usa…
Por qué
Una respuesta rápida mirando el log
awk
Ya está en el servidor y la pregunta cabe en una línea
Un resumen diario como el de este módulo
awk (tu informe)
Un fichero, sin dependencias, lo lanza cron
Un panel con gráficos, países y tiempo real
GoAccess
Ya lo hace, y reconoce miles de navegadores y robots
Guardar el histórico y compararlo mes a mes
PHP + base de datos
awk no recuerda nada de una ejecución a otra
Cruzar con tus usuarios, pedidos o sesiones
PHP
Esos datos están en MySQL, no en un fichero de texto
Enseñárselo a alguien en una página web
PHP
awk imprime texto en una terminal y nada más
Bloquear a los atacantes
fail2ban
Hay que tocar el cortafuegos, y eso no se improvisa
La regla para decidir es sencilla: mientras la pregunta sea «¿qué hay en este fichero?», awk. En cuanto sea «¿y qué hago con ello?», PHP. Y los dos se llevan bien: un script de PHP puede ejecutar tu informe cada noche y guardar sus números en una tabla.
La pregunta que te vas a hacer
¿Y ahora qué? ¿Por dónde sigo?
Lo mejor que puedes hacer es ejecutar tu informe sobre el log de tu propia web y mirar qué sale. Verás rutas trampa que no están en la lista, robots que no conocías y páginas con más visitas de las que creías. Cada sorpresa es una mejora: una palabra más en una regex, una sección nueva.
GoAccess: pruébalo con el mismo log y compara sus números con los tuyos. Si no coinciden, averiguar por qué enseña mucho.
Manual de GNU awk: la referencia completa. Con lo que sabes ya puedes leer cualquier capítulo.
crontab.guru: escribe los cinco campos de una línea de cron y te dice en cristiano cuándo se ejecuta.
logrotate: el programa que rota y comprime los logs; su manual explica de dónde salen access.log.1 y los .gz.
Hora de practicar
Retos · 0/2 resueltos
Reto 1 de 2 · ✓ Resuelto
tamano(): bytes que se leen
tamano() lo devuelve todo en bytes. Hazla elegir la unidad: desde 1048576, megas con un decimal (1.0 MB); desde 1024, kilos con un decimal (1.5 KB); por debajo, bytes sin decimales (512 B). Al comprobar se prueban siete cantidades (1023 sigue siendo 1023 B y 1024 ya es 1.0 KB) y después tu informe imprime cuánto se ha llevado cada IP, como 192.0.2.140 1.0 MB. En PHP: un match (true) con tres sprintf().
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?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-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.
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.
Pista. Dos if antes del return que ya hay, del más grande al más pequeño: if (cantidad >= 1048576) { return sprintf("%.1f MB", cantidad / 1048576) } y lo mismo con 1024 y KB.
Reto 2 de 2 · ✓ Resuelto
La sección NAVEGADORES, con porcentajes
Este trozo del informe cuenta las visitas reales por navegador, pero solo imprime el título y el total. Dos tareas. Primera: porcentaje(parte, total) devuelve siempre 0; haz que devuelva parte * 100 / total, y 0 si el total es 0 (la prueba la llama con 0, 0: no puede romperse). Segunda: en el END, imprime una línea por navegador, de más a menos visitas (usa por_valor_y_clave), con el formato %-10s %4d %6.1f%%, y deja la línea de Visitas al final con su 100.0%. Con el log del curso la primera es Firefox 4 44.4%. En PHP: $total === 0 ? 0.0 : $parte * 100 / $total.
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?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-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.
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.
Pista. En porcentaje(), un if (total == 0) { return 0 } antes de dividir. En el END, pon PROCINFO["sorted_in"] = "por_valor_y_clave" justo antes de un for (clave in navegadores), y dentro un printf con clave, navegadores[clave] y porcentaje(navegadores[clave], visitas). No olvides añadir el porcentaje a la línea de Visitas.
Resumen
Lo que te llevas de esta lección
titulo(), porcentaje() y tamano() separan calcular de presentar. En PHP serían funciones de un helper de vistas.
Antes de dividir, se mira que el divisor no sea cero: en awk es un fatal que para el programa y no hay try/catch. En PHP, un DivisionByZeroError.
sprintf monta un texto sin imprimirlo: tamano() devuelve "1.1 MB" y quien llama lo coloca con %7s.
En el servidor: gawk -f informe.awk lista log; los .gz, con zcat … | gawk -f informe.awk; cada mañana, con cron.
Un programa que imprime en el END no sirve con tail -f: la entrada no termina. Para vigilar en directo se imprime en la regla y se llama a fflush().
awk contesta «¿qué hay en este fichero?». Para guardar, cruzar con la base de datos o publicar en una web, vuelve a PHP; para un panel, GoAccess.
Para recordarlo: Las cinco fases: «Para Filtrar Tanto Ataque, Formato»
PParsear url(), estado()…
FFiltrar es_bot(), es_estatico()
TTop imprimir_top(), barra()
AAtaques es_escaneo(), umbral
FFormato titulo(), tamano()
Es el orden en que has construido el informe, y el orden en que se lee el fichero de arriba abajo. Si un día tienes que arreglar algo, la inicial te dice en qué bloque de funciones mirar.