0Pricing
DevOps Bootcamp · Leçon

Motifs, plages et blocs BEGIN/END

Filtrez les enregistrements avec des motifs conditionnels et produisez des en-têtes et des totaux à l’aide des blocs BEGIN et END.

Motifs, plages et blocs BEGIN/END est une leçon DevOps Bootcamp gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage DevOps Bootcamp, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours DevOps Bootcamp comprend 4 leçons au total.

Que sont les motifs awk ?

Dans awk, un motif est une condition qui détermine si un bloc d’action s’exécute pour une ligne d’entrée donnée. La forme générale est la suivante :

awk 'pattern { action }' file

Si le motif correspond à l’enregistrement actuel, l’action est exécutée. Si aucune action n’est indiquée, awk affiche la ligne entière par défaut. Les motifs peuvent être :

  • Expressions régulières — /regex/
  • Expressions relationnelles — $3 > 100
  • Expressions composées — $1 == "ERROR" && $4 > 500
  • Motifs d’intervalle — /start/,/end/
  • Motifs spéciaux — BEGIN et END

Comprendre les motifs est la porte d’entrée vers l’utilisation de awk comme puissant filtre de données, plutôt que comme simple afficheur de colonnes.

Motifs d’expressions régulières pour filtrer les lignes

Le type de motif le plus courant est une expression régulière entourée de barres obliques. awk compare chaque ligne à l’expression régulière et n’exécute l’action qu’en cas de correspondance.

Ci-dessous, nous filtrons un fichier de type /var/log/syslog afin d’afficher uniquement les lignes contenant le mot 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 }'

Motifs inversés et composés

Préfixez un motif d’expression régulière avec ! pour l’inverser : les lignes qui ne contiennent pas le motif sont alors sélectionnées. Combinez plusieurs conditions avec && (AND) ou || (OR) pour obtenir un contrôle précis.

  • !/DEBUG/ — ignorer les lignes de débogage
  • $3 > 500 && $5 == "POST" — requêtes POST volumineuses
  • /WARN/ || /ERROR/ — l’un ou l’autre niveau de gravité

L’exemple ci-dessous analyse un journal d’accès simplifié et affiche uniquement les requêtes POST dont la taille de réponse dépasse 1000 octets :

#!/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 }'

Motifs d’intervalle : /start/,/end/

Un motif d’intervalle sélectionne un bloc contigu d’enregistrements : de la ligne correspondant à /start/ jusqu’à celle correspondant à /end/, bornes incluses. La syntaxe est la suivante :

awk '/start/,/end/ { action }' file

Comportements essentiels à connaître :

  • L’intervalle s’active sur la première ligne correspondant à /start/ et se désactive après la première ligne suivante correspondant à /end/.
  • Si /end/ ne correspond jamais, l’intervalle reste actif jusqu’à EOF.
  • Plusieurs intervalles disjoints dans un même fichier sont chacun traités indépendamment.

Les motifs d’intervalle sont donc idéaux pour extraire des sections marquées de fichiers de configuration, des journaux comportant des en-têtes délimiteurs ou des rapports composés de plusieurs blocs.

Extraire des sections avec des motifs d’intervalle

Considérez une configuration de serveur contenant plusieurs sections nommées, délimitées par des en-têtes [section]. Nous voulons uniquement les lignes situées dans [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'

Le bloc BEGIN

Le bloc BEGIN s’exécute une seule fois, avant la lecture de toute entrée. Il est idéal pour :

  • Afficher l’en-tête d’un rapport
  • Initialiser les variables et les compteurs
  • Définir le séparateur de champs (FS) ou d’autres variables intégrées
  • Exécuter des programmes awk autonomes qui ne nécessitent aucune entrée

Syntaxe :

awk 'BEGIN { setup } pattern { action }' file

Définir FS dans BEGIN est une alternative claire à l’option -F, particulièrement utile lors de l’écriture de programmes comportant plusieurs règles, lorsque la logique de séparation se trouve dans le 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 "--------------------------------------------"
}'

Le bloc END

Le bloc END s’exécute une seule fois, après le traitement du dernier enregistrement. C’est l’endroit naturel pour :

  • Afficher les totaux, les moyennes et les récapitulatifs calculés pendant le traitement
  • Vider ou fermer les fichiers de sortie
  • Afficher les lignes de pied de page des rapports mis en forme

Les variables définies dans les règles principales restent accessibles dans END : c’est ainsi que fonctionnent les totaux cumulés. L’exemple ci-dessous additionne les salaires d’un CSV et affiche le total dans le pied de page :

#!/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 }
'

Combiner BEGIN, les règles et END

La véritable puissance apparaît lorsque vous combinez les trois blocs en un seul programme awk autonome qui affiche un en-tête, traite chaque enregistrement et affiche un récapitulatif. Ce schéma constitue la base des pipelines de génération de rapports fondés sur le shell.

Voici un générateur de rapports complet qui lit un CSV de requêtes web, affiche les détails de chaque ligne, puis compte les requêtes ayant dépassé une seconde :

#!/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
}
'

Utiliser BEGIN pour définir OFS et ORS

Deux variables de sortie souvent négligées peuvent être définies proprement dans BEGIN :

  • OFS (séparateur de champs de sortie) — inséré entre les champs lorsque vous reconstruisez un enregistrement avec $1=$1 ou utilisez print $1, $2
  • ORS (séparateur d’enregistrements de sortie) — ajouté après chaque appel à print (la valeur par défaut est \n)

Définir OFS="," vous permet de reformater un TSV en CSV en un seul passage, sans concaténation de chaînes. Remplacer ORS par "\n---\n" ajoute automatiquement des séparateurs entre les enregistrements.

#!/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 }'

Motif d’intervalle pratique : fenêtres d’incident dans les journaux

Les motifs d’intervalle sont particulièrement utiles pour l’analyse opérationnelle des journaux. Une tâche courante consiste à extraire toutes les lignes du journal comprises entre le début et la fin d’un incident, identifiés par des messages sentinelles tels que INCIDENT START et INCIDENT END.

Dans l’exemple ci-dessous, awk extrait uniquement les lignes comprises dans la fenêtre de l’incident et compte les événements ERROR qui s’y produisent, en combinant un motif d’intervalle avec un accumulateur et un récapitulatif 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 }
'

Ignorer les lignes délimitrices d’un intervalle

Par défaut, les motifs d’intervalle incluent les lignes qui correspondent elles-mêmes à /start/ et /end/. Pour ignorer ces lignes délimitrices et ne conserver que le contenu intermédiaire, conditionnez l’action à une négation ou utilisez une variable indicatrice :

  • Approche par négation : /start/,/end/ { if (!/start/ && !/end/) print }
  • Approche par indicateur : définissez manuellement une variable à 1 pour /start/ et à 0 pour /end/

L’approche par indicateur est plus robuste lorsque le texte délimiteur peut également apparaître dans le contenu :

#!/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 }
'

Vérification des connaissances : comportement du bloc BEGIN

Vérifiez votre compréhension de l’interaction entre les blocs BEGIN et END et le traitement des entrées dans awk.

Récapitulatif de la leçon : motifs, intervalles et BEGIN/END

Dans cette leçon, vous avez maîtrisé les trois fonctionnalités structurelles les plus puissantes des programmes awk :

  • Motifs — expressions régulières (/ERROR/), relationnelles ($3 > 1000), inversées (!/DEBUG/) et composées (&&, ||) : ils déterminent quels enregistrements déclenchent une action, sans nécessiter d’instructions if explicites.
  • Motifs d’intervalle (/start/,/end/) — ils sélectionnent des blocs contigus d’enregistrements, parfaits pour extraire des fenêtres d’incident dans les journaux, des sections de configuration et des segments de rapports. Utilisez une variable indicatrice (next + booléen) lorsque vous devez exclure les lignes délimitrices elles-mêmes.
  • Bloc BEGIN — il s’exécute une fois avant toute entrée ; il est idéal pour définir FS, OFS et ORS, initialiser les compteurs et afficher les en-têtes de rapports.
  • Bloc END — il s’exécute une fois après toutes les entrées ; c’est l’endroit approprié pour afficher les totaux, les moyennes et les pieds de page à l’aide des variables cumulées dans les règles principales.

Ensemble, ces fonctionnalités vous permettent d’écrire des programmes awk complets et auto-documentés, qui ingèrent du texte brut et produisent des rapports structurés et lisibles par l’être humain, le tout dans une seule étape du pipeline, sans fichiers temporaires ni outils externes.

Questions Fréquemment Posées

La leçon « Motifs, plages et blocs BEGIN/END » est-elle gratuite ?

Oui — le texte complet de « Motifs, plages et blocs BEGIN/END » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours DevOps Bootcamp, passe à CoddyKit PRO. Le cours DevOps Bootcamp comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Motifs, plages et blocs BEGIN/END » ?

Filtrez les enregistrements avec des motifs conditionnels et produisez des en-têtes et des totaux à l’aide des blocs BEGIN et END. Tu pratiques DevOps Bootcamp avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer DevOps Bootcamp ?

Aucune expérience préalable n'est requise. DevOps Bootcamp sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Motifs, plages et blocs BEGIN/END » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon DevOps Bootcamp ?

Oui. Chaque leçon DevOps Bootcamp inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Enregistrements, champs et séparateurs personnalisés dans awk
  2. Motifs, plages et blocs BEGIN/END
  3. Agrégation avec les tableaux et le regroupement dans awk
  4. Fonctions awk, mise en forme avec printf et génération de rapports
← Retour à DevOps Bootcamp