À quoi sert awk sous Linux

AWK est un langage de traitement de texte orienté lignes et champs. En pratique, tu l’utilises quand tu veux extraire une colonne, reformater une sortie, filtrer des lignes, compter, sommer ou produire un petit rapport sans écrire un script Python complet.

Sa force, c’est le rapport puissance / simplicité. Là où cut devient vite limité et où sed cible surtout des substitutions, awk te donne à la fois l’accès aux colonnes, aux conditions, aux boucles et aux variables internes. Pour de l’administration système, c’est souvent l’outil le plus rapide pour aller du besoin au résultat.

Syntaxe de base

La forme la plus courante d’une commande AWK est la suivante :

awk 'pattern { action }' fichier

Tu peux aussi lui passer un flux via un pipe :

commande | awk '{ print $1 }'

Dans cette logique :

• pattern décide quelles lignes sont concernées
• action décrit ce qu’il faut faire
• $1, $2, $3 représentent les champs de la ligne
• $0 représente la ligne complète
• NF représente le nombre de champs
• NR représente le numéro de ligne

Exemple simple pour afficher uniquement le propriétaire et le nom de fichier dans un ls -l :

ls -l | awk '{ print $3, $9 }'

Travailler avec les champs et séparateurs

Par défaut, AWK découpe sur les espaces et tabulations successifs. C’est un point important : le séparateur par défaut n’est pas uniquement la tabulation. C’est pour ça qu’il fonctionne bien avec beaucoup de sorties shell.

Si tu veux définir un séparateur précis, utilise -F. Exemple avec /etc/passwd :

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

Cette commande affiche le login et l’UID de chaque entrée. C’est plus propre que de bricoler plusieurs cut chaînés.

Tu peux aussi reformater complètement l’affichage :

awk -F: '{ print "username:" $1 " uid:" $3 }' /etc/passwd

Résultat : une sortie lisible, facilement exploitable dans un diagnostic ou un mini-report.

Variables utiles à connaître

• $0 : ligne complète
• $1 : premier champ
• $2 : deuxième champ
• NF : nombre de champs
• NR : numéro de la ligne courante
• FS : séparateur d’entrée
• OFS : séparateur de sortie

Filtrer des lignes avec des conditions

AWK devient vraiment intéressant quand tu ajoutes des conditions. Tu peux filtrer sur l’égalité, les expressions régulières, des comparaisons numériques ou des combinaisons logiques.

Afficher uniquement la ligne de l’utilisateur postgres dans /etc/passwd :

awk -F: '$1 == "postgres" { print "username:" $1 " uid:" $3 }' /etc/passwd

Afficher plusieurs comptes ciblés :

awk -F: '$1 == "postgres" || $1 == "mysql" { print "username:" $1 " uid:" $3 }' /etc/passwd

Filtrer avec une regex :

awk -F: '$1 ~ /oo/ { print "username:" $1 " uid:" $3 }' /etc/passwd

Afficher les comptes dont le shell se termine par /bin/false :

awk -F: '$7 ~ /\/bin\/false$/ { print $1, $7 }' /etc/passwd

Le symbole ~ sert à tester une expression régulière. Le $ dans la regex signifie “fin de chaîne”.

Transformer l’affichage et les données

Tu n’es pas obligé d’afficher les données telles quelles. AWK est très pratique pour enrichir, nettoyer ou réécrire une sortie.

Exemple de substitution avec gsub :

ls -l | awk '{ gsub("babidi", "BOSS", $0); print $0 }'

Ici, toutes les occurrences de babidi dans la ligne sont remplacées par BOSS. Tu peux faire la même chose sur un champ spécifique au lieu de toute la ligne.

Tu peux aussi changer le séparateur de sortie :

awk -F: 'BEGIN { OFS=";" } { print $1, $3, $7 }' /etc/passwd

Pratique pour produire un export intermédiaire facilement réutilisable ailleurs.

Faire des calculs et statistiques

AWK sait accumuler des valeurs très simplement. C’est parfait pour totaliser, compter ou produire une statistique rapide sur un fichier plat.

Sommer la première colonne d’un fichier :

awk '{ somme += $1 } END { print somme }' fichier.txt

Numéroter les lignes :

ls -l | awk '{ print "ligne", NR, $0 }'

Afficher le nombre de champs de chaque ligne :

ls -l | awk '{ print "nombre de champs", NF, $0 }'

Afficher chaque champ sur sa propre ligne :

awk '{ for (i=1; i<=NF; i++) print $i }' fichier.txt

Cette logique de boucle est très utile pour inspecter un format irrégulier avant d’écrire un traitement plus sérieux.

Utiliser BEGIN et END

Les blocs BEGIN et END rendent tes commandes AWK bien plus propres. BEGIN sert à initialiser des variables ou un séparateur de sortie. END sert à afficher un total, une moyenne ou un bilan final.

awk -F: 'BEGIN { OFS=";" } $3 >= 1000 { total++; print $1, $3 } END { print "comptes:", total }' /etc/passwd

Ici, on filtre les comptes avec un UID supérieur ou égal à 1000, on les affiche proprement, puis on imprime un total final. Pour de petits audits d’inventaire, ce pattern est redoutablement efficace.

Cas d’usage concrets

La théorie aide, mais AWK devient vraiment rentable quand tu l’intègres dans des tâches d’admin réelles.

Exemple concret sur des logs Nginx pour afficher l’IP et le code retour :

awk '{ print $1, $9 }' /var/log/nginx/access.log

Exemple pour compter le nombre de réponses HTTP 500 :

awk '$9 == 500 { total++ } END { print total }' /var/log/nginx/access.log

Exemple pour trier les utilisateurs par UID :

awk -F: '{ print $1, $3 }' /etc/passwd | sort -n -k2

Exemple concret pour repérer les erreurs 5xx dans un log Nginx et obtenir un top rapide :

awk '$9 ~ /^5/ { print $1, $7, $9 }' /var/log/nginx/access.log | sort | uniq -c | sort -nr | head

Exemple pour extraire des services en échec depuis un export texte ou une sortie préparée :

systemctl --failed --no-legend | awk '{ print $1, $2 }'

Exemple d’inventaire disque sur une sortie df -h :

df -h | awk 'NR > 1 { print $1, $5, $6 }'

Si tu travailles souvent sur les logs, tu peux compléter avec notre guide sur journalctl pour le debug systemd. Pour les filtres texte, regarde aussi grep regex Linux et grep vs ripgrep. Si tu automatises ces vérifications, tu peux aussi t’appuyer sur une structure de playbook Ansible en production et Ansible Vault pour industrialiser proprement.

Bonnes pratiques avant de l’utiliser en prod

AWK est rapide, mais une commande mal pensée peut produire un mauvais diagnostic, surtout sur des données imparfaites. Quelques réflexes évitent les erreurs classiques.

Erreurs fréquentes

AWK vs autres outils

AWK n’est pas toujours le bon outil unique. Voici une règle simple :

• cut : bien pour extraire brutalement une colonne simple
• sed : bien pour remplacer ou éditer du texte
• grep : bien pour chercher des motifs
• awk : bien pour combiner extraction, conditions, formatage et calculs

Si tu dois seulement chercher des lignes, grep est souvent plus lisible. Si tu dois combiner sélection + colonnes + logique, AWK reprend l’avantage.

En pratique, beaucoup de pipelines shell efficaces reposent sur le trio grep + awk + sort. Le bon réflexe consiste à garder AWK pour ce qu’il fait le mieux : la logique de champs et de transformation.

FAQ

Conclusion

La commande AWK reste un incontournable sous Linux dès qu’il faut exploiter rapidement du texte structuré. Elle te permet d’extraire des champs, filtrer, transformer, compter et produire des sorties propres sans alourdir ton outillage. Pour du diagnostic système, des scripts shell, de l’analyse de logs ou des fichiers délimités simples, c’est un excellent réflexe.

Si tu veux progresser vite, commence par trois bases : $1 / $0, -F pour les séparateurs, et les conditions avec regex. Avec ça, tu couvres déjà une grosse partie des besoins terrain.

Pour aller plus loin, le bon cap n’est pas d’écrire des one-liners de plus en plus opaques, mais de construire des pipelines lisibles, testables et documentés. C’est là qu’AWK devient vraiment rentable dans une pratique sysadmin ou DevOps sérieuse.

Aller plus loin :

• grep regex Linux : guide pratique
• grep vs ripgrep : comparatif
• journalctl pour debug systemd
• structure de playbook Ansible en production