Patrones, rangos y bloques BEGIN/END
Filtre registros con patrones condicionales y genere encabezados y totales mediante bloques BEGIN y END.
Patrones, rangos y bloques BEGIN/END es una lección gratuita de DevOps Bootcamp en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de DevOps Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de DevOps Bootcamp incluye 4 lecciones en total.
¿Qué son los patrones de awk?
En awk, un patrón es una condición que controla si se ejecuta un bloque de acciones para una línea de entrada determinada. La forma general es:
awk 'pattern { action }' fileSi el patrón coincide con el registro actual, se ejecuta la acción. Si no se indica ninguna acción, awk imprime la línea completa de forma predeterminada. Los patrones pueden ser:
- Expresiones regulares —
/regex/ - Expresiones relacionales —
$3 > 100 - Expresiones compuestas —
$1 == "ERROR" && $4 > 500 - Patrones de rango —
/start/,/end/ - Patrones especiales —
BEGINyEND
Comprender los patrones es la puerta de entrada para usar awk como un potente filtro de datos, en lugar de limitarse a imprimir columnas.
Patrones de expresiones regulares para filtrar líneas
El tipo de patrón más común es una expresión regular encerrada entre barras diagonales. awk comprueba cada línea con la expresión regular y ejecuta la acción únicamente cuando hay coincidencia.
A continuación filtramos un archivo del estilo de /var/log/syslog para mostrar solo las líneas que contienen la palabra ERROR:
#!/usr/bin/env bash
# Simulate a log file and filter ERROR lines
log=$(cat <<'EOF'
2026-06-11 08:01:22 INFO service started
2026-06-11 08:02:05 ERROR disk quota exceeded on /dev/sda1
2026-06-11 08:02:44 WARN memory usage at 80%
2026-06-11 08:03:10 ERROR connection timeout to 10.0.0.5
2026-06-11 08:03:55 INFO backup completed
EOF
)
echo "=== ERROR lines only ==="
echo "$log" | awk '/ERROR/ { print NR": "$0 }'Patrones negados y compuestos
Anteponer ! a un patrón de expresión regular lo invierte: coincidirán las líneas que no contengan el patrón. Combine varias condiciones con && (AND) o || (OR) para obtener un control más preciso.
!/DEBUG/— omitir las líneas de depuración$3 > 500 && $5 == "POST"— solicitudes POST grandes/WARN/ || /ERROR/— cualquiera de los dos niveles de gravedad
El ejemplo siguiente analiza un registro de acceso simplificado e imprime únicamente las solicitudes POST cuyo tamaño de respuesta supera los 1000 bytes:
#!/usr/bin/env bash
access=$(cat <<'EOF'
10.0.0.1 GET /api/ping 200 48
10.0.0.2 POST /api/upload 201 2048
10.0.0.3 GET /api/users 200 512
10.0.0.4 POST /api/data 200 3500
10.0.0.5 POST /api/health 200 60
EOF
)
echo "Large POST requests (>1000 bytes):"
echo "$access" | awk '$2 == "POST" && $5 > 1000 { print $1, $3, "size="$5 }'Patrones de rango: /start/,/end/
Un patrón de rango selecciona un bloque contiguo de registros: desde la línea que coincide con /start/ hasta la línea que coincide con /end/, ambas inclusive. La sintaxis es:
awk '/start/,/end/ { action }' fileComportamientos clave que debe conocer:
- El rango se activa en la primera línea que coincide con
/start/y se desactiva después de la primera línea posterior que coincide con/end/. - Si
/end/nunca coincide, el rango permanece activo hasta el final del archivo. - Los distintos rangos no solapados de un mismo archivo se procesan de forma independiente.
Esto hace que los patrones de rango sean ideales para extraer secciones marcadas de archivos de configuración, registros con encabezados delimitadores o informes formados por varios bloques.
Extraer secciones con patrones de rango
Considere una configuración de servidor con varias secciones identificadas por nombres y delimitadas por encabezados [section]. Queremos únicamente las líneas de [database]:
#!/usr/bin/env bash
config=$(cat <<'EOF'
[server]
host = 0.0.0.0
port = 8080
[database]
host = 127.0.0.1
port = 5432
name = appdb
user = admin
[cache]
host = 127.0.0.1
port = 6379
EOF
)
echo "=== [database] section ==="
echo "$config" | awk '/\[database\]/,/^\[/' \
| awk 'NR > 1 && !/^\[/ && NF'El bloque BEGIN
El bloque BEGIN se ejecuta una vez, antes de leer cualquier entrada. Es ideal para:
- Imprimir el encabezado de un informe
- Inicializar variables y contadores
- Establecer el separador de campos (
FS) u otras variables integradas - Ejecutar programas independientes de
awkque no necesitan ninguna entrada
Sintaxis:
awk 'BEGIN { setup } pattern { action }' fileEstablecer FS en BEGIN es una alternativa más clara a la opción -F, especialmente útil al escribir programas con varias reglas cuya lógica de separación reside dentro del script.
#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)
echo "$csv" | awk 'BEGIN {
FS = ","
printf "%-10s %-15s %10s\n", "Name", "Department", "Salary"
print "--------------------------------------------"
}'El bloque END
El bloque END se ejecuta una vez, después de procesar el último registro. Es el lugar natural para:
- Imprimir totales, promedios y resúmenes acumulados durante el procesamiento
- Vaciar o cerrar archivos de salida
- Imprimir líneas de pie en informes con formato
Las variables establecidas durante las reglas principales siguen estando disponibles dentro de END; así es como funcionan los totales acumulados. El ejemplo siguiente suma los valores salariales de un CSV e imprime el total en el pie:
#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)
echo "$csv" | awk -F',' '
{ total += $3; count++ }
END { printf "Employees: %d Total payroll: $%d\n", count, total }
'Combinar BEGIN, reglas y END
La verdadera potencia aparece al combinar los tres bloques en un único programa de awk autónomo que imprime un encabezado, procesa cada registro e imprime un resumen. Este patrón es la base de las canalizaciones de generación de informes basadas en shell.
A continuación se muestra un generador de informes completo que lee un CSV de solicitudes web e imprime los detalles de cada línea, además del recuento final de las solicitudes que superaron 1 segundo:
#!/usr/bin/env bash
data=$(cat <<'EOF'
/api/ping,0.03
/api/users,1.45
/api/login,0.88
/api/upload,2.10
/api/health,0.02
/api/report,1.73
EOF
)
echo "$data" | awk -F',' '
BEGIN {
printf "%-20s %10s %s\n", "Endpoint", "Latency(s)", "Status"
print "--------------------------------------"
}
{
status = ($2 > 1.0) ? "SLOW" : "OK"
if (status == "SLOW") slow++
printf "%-20s %10s %s\n", $1, $2, status
}
END {
print "--------------------------------------"
printf "Slow requests: %d / %d\n", slow, NR
}
'Usar BEGIN para establecer OFS y ORS
En BEGIN se pueden establecer fácilmente dos variables de salida que a menudo se pasan por alto:
- OFS (Output Field Separator) — se inserta entre los campos al reconstruir un registro con
$1=$1o al usarprint $1, $2 - ORS (Output Record Separator) — se añade después de cada llamada a
print(el valor predeterminado es\n)
Establecer OFS="," permite reformatear un TSV como CSV en una sola pasada, sin concatenar cadenas. Cambiar ORS a "\n---\n" añade automáticamente separadores entre los registros.
#!/usr/bin/env bash
# Convert whitespace-delimited data to CSV with a header
data=$(cat <<'EOF'
alice engineering 95000
bob marketing 72000
carol engineering 105000
EOF
)
echo "$data" | awk 'BEGIN { OFS=","; print "name,dept,salary" }
{ $1=$1; print }'Patrón de rango práctico: intervalos de incidentes en registros
Los patrones de rango son especialmente útiles para analizar registros operativos. Una tarea habitual consiste en extraer todas las líneas del registro entre el inicio y el final de un incidente, identificados mediante mensajes centinela como INCIDENT START e INCIDENT END.
En el ejemplo siguiente, awk extrae únicamente las líneas del intervalo del incidente y cuenta los eventos ERROR que contiene, combinando un patrón de rango con un acumulador y un resumen en END:
#!/usr/bin/env bash
log=$(cat <<'EOF'
08:00:01 INFO Normal operation
08:01:00 INFO INCIDENT START: disk pressure detected
08:01:05 ERROR write failed on /dev/sda1
08:01:09 ERROR inode table corruption
08:01:14 WARN remounting read-only
08:01:22 INFO INCIDENT END: disk replaced
08:02:00 INFO Normal operation resumed
EOF
)
echo "$log" | awk '
/INCIDENT START/,/INCIDENT END/ {
print
if (/ERROR/) errors++
}
END { print "Errors during incident:", errors+0 }
'Omitir las líneas delimitadoras de un rango
De forma predeterminada, los patrones de rango incluyen las propias líneas que coinciden con /start/ y /end/. Para omitir esas líneas delimitadoras y conservar únicamente el contenido intermedio, proteja la acción con una negación o con una variable de estado:
- Enfoque mediante negación:
/start/,/end/ { if (!/start/ && !/end/) print } - Enfoque mediante indicador: establezca manualmente una variable en 1 al encontrar
/start/y en 0 al encontrar/end/
El enfoque mediante indicador es más robusto cuando el texto delimitador también puede aparecer en el contenido:
#!/usr/bin/env bash
doc=$(cat <<'EOF'
## preamble
some intro text
## BEGIN_REPORT
row1: alpha 100
row2: beta 200
row3: gamma 150
## END_REPORT
## appendix
EOF
)
echo "$doc" | awk '
/## BEGIN_REPORT/ { capture=1; next }
/## END_REPORT/ { capture=0 }
capture { print }
'Comprobación de conocimientos: comportamiento del bloque BEGIN
Compruebe su comprensión de cómo interactúan los bloques BEGIN y END con el procesamiento de la entrada en awk.
Resumen de la lección: patrones, rangos y BEGIN/END
En esta lección ha aprendido las tres características estructurales más potentes de los programas de awk:
- Patrones — las expresiones regulares (
/ERROR/), relacionales ($3 > 1000), negadas (!/DEBUG/) y compuestas (&&,||) controlan qué registros activan una acción, sin necesidad de usar sentenciasifexplícitas. - Patrones de rango (
/start/,/end/) — seleccionan bloques contiguos de registros, perfectos para extraer intervalos de incidentes de registros, secciones de configuración y segmentos de informes. Use una variable de estado (next+ boolean) cuando necesite excluir las propias líneas delimitadoras. - Bloque BEGIN — se ejecuta una vez antes de cualquier entrada; es ideal para establecer
FS,OFSyORS, inicializar contadores e imprimir encabezados de informes. - Bloque END — se ejecuta una vez después de toda la entrada; es el lugar adecuado para imprimir totales, promedios y pies utilizando las variables acumuladas en las reglas principales.
En conjunto, estas características permiten escribir programas de awk completos y autodocumentados que reciben texto sin procesar y generan informes estructurados y legibles para las personas, todo ello en una sola etapa de la canalización, sin archivos temporales ni herramientas externas.
Preguntas frecuentes
¿La lección «Patrones, rangos y bloques BEGIN/END» es gratis?
Sí — el texto completo de «Patrones, rangos y bloques BEGIN/END» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de DevOps Bootcamp, actualiza a CoddyKit PRO. El curso de DevOps Bootcamp incluye 4 lecciones en total.
¿Qué aprenderé en «Patrones, rangos y bloques BEGIN/END»?
Filtre registros con patrones condicionales y genere encabezados y totales mediante bloques BEGIN y END. Practicas DevOps Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar DevOps Bootcamp?
No se requiere experiencia previa. DevOps Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Patrones, rangos y bloques BEGIN/END»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de DevOps Bootcamp?
Sí. Cada lección de DevOps Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Registros, campos y separadores personalizados en awk
- Patrones, rangos y bloques BEGIN/END
- Agregación con arrays y agrupación en awk
- Funciones de awk, formato con printf y generación de informes