Tar 2026 : compresser et extraire sans erreur

tar reste un réflexe de base sur Linux. Même en 2026, dès qu’il faut regrouper des fichiers, préparer une sauvegarde, transférer un répertoire ou manipuler une archive système, c’est souvent l’outil le plus direct. Et contrairement à une idée répandue, tar ne sert pas seulement à “faire un .tar.gz” : il permet aussi de lister, tester, extraire proprement, exclure des fichiers, préserver les métadonnées et travailler avec plusieurs algorithmes de compression, dont gzip, xz et de plus en plus zstd.

Dans ce guide, on va aller à l’essentiel : les commandes utiles, les bons choix de compression et les erreurs fréquentes à éviter. L’objectif n’est pas de réciter toutes les options de tar, mais de vous donner une méthode fiable pour l’utiliser au quotidien sur Linux.

Pourquoi tar reste incontournable en 2026 sur Linux

Sur la plupart des distributions Linux, tar est installé par défaut ou disponible immédiatement via les paquets de base. C’est un point important : dans un script, sur un serveur minimal, dans un conteneur ou sur une machine de secours, vous avez de fortes chances de pouvoir compter dessus sans installer d’outil supplémentaire.

Il reste incontournable pour plusieurs raisons :

• Il regroupe une arborescence complète dans un seul flux ou un seul fichier.
• Il préserve les permissions, propriétaires, dates et liens, selon le contexte d’utilisation et les droits disponibles.
• Il s’intègre parfaitement aux outils Unix : redirections, pipes, SSH, scripts shell, cron, systemd timers.
• Il fonctionne avec plusieurs compresseurs sans changer de logique de travail.
• Il est omniprésent dans les sauvegardes, les exports et la distribution de code source.

Concrètement, on retrouve tar dans des cas très variés :

• archiver un projet avant transfert ;
• sauvegarder /etc ou un répertoire applicatif ;
• préparer un export pour un client ;
• restaurer une archive reçue ;
• envoyer une archive sur un autre serveur via ssh ;
• manipuler des sources distribuées en .tar.gz, .tar.xz ou .tar.zst.

Si vous utilisez déjà rsync pour les sauvegardes Linux, tar ne le remplace pas forcément. En revanche, il complète très bien rsync quand vous avez besoin d’un fichier d’archive unique, simple à déplacer, stocker ou versionner.

Comprendre la logique de tar avant de taper les commandes

Le point qui fait gagner du temps avec tar, c’est de bien distinguer l’archivage de la compression.

tar crée d’abord une archive : il rassemble des fichiers et dossiers dans un seul flux. Ensuite, ce flux peut être compressé avec un outil comme gzip, xz ou zstd.

C’est pour cela qu’on rencontre des extensions comme :

• .tar : archive non compressée ;
• .tar.gz ou .tgz : archive compressée avec gzip ;
• .tar.xz : archive compressée avec xz ;
• .tar.zst : archive compressée avec zstd.

Les options les plus utiles à retenir sont peu nombreuses :

• -c : créer une archive ;
• -x : extraire une archive ;
• -t : lister le contenu ;
• -f : indiquer le fichier archive ;
• -v : mode verbeux, pour voir ce qui se passe ;
• -C : changer de répertoire avant l’opération ;
• --exclude : exclure des fichiers ou dossiers ;
• --zstd, -z, -J

Sur les systèmes GNU/Linux, la page officielle de GNU tar reste la référence pour le détail des comportements : gnu.org/software/tar.

Conseil pratique : avec tar, le plus grand nombre d’erreurs ne vient pas de la compression, mais du mauvais répertoire de départ, du chemin d’extraction ou d’une exclusion mal formulée.

Créer une archive propre avec gzip

gzip reste le choix le plus universel. Il est rapide, très largement compatible et parfaitement adapté aux usages courants : export de projet, sauvegarde simple, envoi par SCP ou stockage temporaire.

Pour archiver un dossier projet dans un fichier projet.tar.gz :

tar -czf projet.tar.gz projet/

Décomposition :

• -c crée l’archive ;
• -z active gzip ;
• -f précise le nom du fichier de sortie.

Si vous voulez voir les fichiers ajoutés pendant l’opération :

tar -cvzf projet.tar.gz projet/

En pratique, le mode verbeux est utile pour un test manuel, mais pas toujours souhaitable dans un script, où il peut produire beaucoup de bruit inutile.

Créer une archive depuis le bon répertoire

Un bon réflexe consiste à utiliser -C pour éviter les chemins trop longs dans l’archive.

Exemple :

tar -czf sauvegarde-site.tar.gz -C /var/www monsite

Ici, l’archive contiendra monsite/ et non tout le chemin /var/www/monsite. C’est souvent préférable pour une restauration propre sur une autre machine.

Autre exemple concret, pour sauvegarder la configuration système :

tar -czf etc-serveur.tar.gz /etc

Cette commande fonctionne, mais elle stocke un chemin absolu en entrée. Selon le contexte, beaucoup d’administrateurs préfèrent :

tar -czf etc-serveur.tar.gz -C / etc

Le résultat est plus portable et plus prévisible à l’extraction.

Quand choisir gzip

Choisissez gzip si vous privilégiez :

• la compatibilité ;
• la vitesse de compression et décompression ;
• un usage simple sur des machines hétérogènes ;
• des scripts qui doivent fonctionner presque partout sans surprise.

Pour beaucoup de cas quotidiens, gzip reste le meilleur compromis.

Créer une archive avec xz ou zstd selon le besoin

Si votre priorité est la taille finale de l’archive, xz reste une option courante. Si vous cherchez un meilleur compromis entre vitesse et compression, zstd est de plus en plus pertinent sur Linux.

Utiliser xz

Pour créer une archive compressée avec xz :

tar -cJf projet.tar.xz projet/

L’option -J active xz. Ce format est souvent utilisé pour des archives où la taille compte plus que la vitesse. En contrepartie, la compression peut être sensiblement plus lente que gzip.

Cas typique :

• archive destinée à être stockée longtemps ;
• distribution de code source ;
• transfert sur un lien limité en bande passante.

Utiliser zstd

Pour créer une archive compressée avec zstd :

tar --zstd -cf projet.tar.zst projet/

Sur les systèmes où l’intégration est disponible, c’est une option très intéressante. zstd, développé par Meta et publié en open source, est adopté dans de nombreux outils et distributions pour son bon équilibre entre rapidité et taux de compression. Le projet officiel est disponible ici : facebook.github.io/zstd.

En pratique, zstd est souvent un excellent choix pour les sauvegardes et archives fréquentes, notamment quand on veut éviter la lenteur de xz tout en gagnant en efficacité par rapport à gzip.

Quel format choisir en pratique

• gzip : le plus universel, simple et rapide.
• xz : intéressant si la taille finale est la priorité.
• zstd : très bon compromis moderne pour de nombreux usages Linux.

Si vous gérez plusieurs serveurs ou scripts, le bon choix dépend surtout de la disponibilité du compresseur sur toutes les machines concernées. Le meilleur format théorique n’est pas le meilleur choix si la restauration devient compliquée sur le serveur cible.

Exclure les fichiers inutiles pour produire une archive propre

Une archive utile n’est pas une archive qui contient tout. Le plus souvent, il faut exclure les caches, fichiers temporaires, dépendances reconstruites ou répertoires de versionnement.

Exemple simple :

tar -czf projet.tar.gz projet/ --exclude='projet/.git' --exclude='projet/node_modules' --exclude='projet/tmp'

Cette approche fonctionne, mais elle devient vite lourde. Une méthode plus propre consiste à partir du bon dossier avec -C :

tar -czf projet.tar.gz -C /srv projet --exclude='projet/.git' --exclude='projet/node_modules' --exclude='projet/tmp'

Autre option utile : stocker les exclusions dans un fichier texte, une entrée par ligne, puis les réutiliser dans vos scripts. Selon votre environnement, vous pouvez aussi vous appuyer sur des fichiers d’exclusion dédiés pour garder une logique stable entre sauvegardes.

Exemples concrets d’exclusions fréquentes

• .git
• node_modules
• vendor si les dépendances peuvent être régénérées
• __pycache__
• *.log
• tmp, cache, .cache

Attention toutefois : on n’exclut pas par habitude. Sur un serveur de production, un dossier vendor ou certains fichiers générés peuvent être nécessaires à une restauration rapide. L’exclusion doit correspondre à votre objectif réel : export de code, sauvegarde de production, duplication d’environnement ou archivage long terme.

Extraire une archive sans mauvaise surprise

L’extraction paraît simple, mais c’est là qu’on voit le plus d’erreurs : fichiers extraits au mauvais endroit, écrasement inattendu, confusion entre archive relative et absolue.

Pour extraire une archive .tar.gz dans le répertoire courant :

tar -xzf projet.tar.gz

Pour une archive .tar.xz :

tar -xJf projet.tar.xz

Pour une archive .tar.zst :

tar --zstd -xf projet.tar.zst

Extraire dans un répertoire précis

Le bon réflexe consiste souvent à créer un dossier cible explicite :

mkdir -p /tmp/restauration

tar -xzf projet.tar.gz -C /tmp/restauration

Ainsi, vous évitez d’extraire par erreur dans le répertoire courant, ce qui peut vite devenir pénible sur un serveur ou dans un répertoire déjà chargé.

Voir ce qui va être extrait

Avant une extraction, surtout si l’archive vient d’un tiers ou d’une ancienne sauvegarde, listez son contenu :

tar -tf projet.tar.gz

Avec affichage détaillé :

tar -tvf projet.tar.gz

Cette étape permet de vérifier :

• la structure des chemins ;
• le nom du dossier racine ;
• la présence éventuelle de fichiers inattendus ;
• la cohérence globale de l’archive.

C’est une habitude simple qui évite beaucoup d’erreurs, surtout dans les procédures de restauration.

Lister et vérifier une archive avant de l’utiliser

Une archive n’est utile que si vous savez ce qu’elle contient et si vous pouvez l’exploiter sans improviser. Avant toute restauration importante, il est raisonnable de faire au minimum deux choses :

• lister le contenu ;
• tester la lecture de l’archive si l’outil de compression le permet.

Pour lister rapidement :

tar -tf sauvegarde.tar.gz | head

Ou pour rechercher un fichier précis :

tar -tf sauvegarde.tar.gz | grep 'config.php'

Si vous voulez aller plus vite sur les recherches dans la liste, les bases de grep restent très utiles : voir ce guide pratique sur grep.

Dans certains contextes, vous pouvez aussi tester le fichier compressé avec l’outil adapté, par exemple gzip -t pour une archive compressée en gzip. Cela ne remplace pas une restauration réelle, mais permet de détecter certains fichiers corrompus.

Exemple :

gzip -t sauvegarde.tar.gz

Pour une sauvegarde critique, la seule vraie vérification reste néanmoins un test de restauration dans un répertoire ou un environnement séparé.

Une archive “créée sans erreur” n’est pas forcément une archive “restaurable comme prévu”. Testez au moins une extraction complète sur un emplacement de contrôle.

Les erreurs fréquentes avec tar et comment les éviter

Voici les pièges les plus courants rencontrés en production ou dans les scripts shell.

1. Confondre archive et compression

Beaucoup d’utilisateurs pensent que tar “compresse” par défaut. Non : tar archive, puis peut appeler un compresseur. Une archive .tar seule n’est pas compressée.

Conséquence pratique : si la taille du fichier vous semble anormalement élevée, vérifiez que vous avez bien utilisé l’option adaptée, par exemple -z, -J ou --zstd.

2. Oublier l’option -f ou mal placer le nom de l’archive

Le nom du fichier archive doit suivre -f. Par exemple :

tar -czf archive.tar.gz dossier/

Si vous inversez des arguments ou oubliez -f, le comportement peut devenir déroutant. Dans un script, gardez toujours un ordre stable et lisible.

3. Archiver avec de mauvais chemins

Créer une archive depuis le mauvais dossier produit souvent des chemins inutiles ou une structure difficile à restaurer. Utilisez -C aussi souvent que nécessaire.

Préférez :

tar -czf app.tar.gz -C /srv app

plutôt que :

tar -czf app.tar.gz /srv/app

Le premier résultat est généralement plus propre.

4. Extraire au mauvais endroit

Un simple tar -xzf archive.tar.gz lancé dans le mauvais répertoire peut semer des fichiers partout. Sur un serveur, c’est un classique.

Solution :

• vérifier avec pwd ;
• lister avant extraction avec tar -tf ;
• utiliser -C vers un dossier cible explicite.

5. Mal formuler les exclusions

Les motifs d’exclusion peuvent prêter à confusion selon le chemin réellement stocké dans l’archive. Si une exclusion “ne marche pas”, le problème vient souvent d’un mauvais point de départ ou d’un motif qui ne correspond pas au chemin réel.

La méthode la plus fiable consiste à :

• définir clairement le répertoire de départ ;
• tester avec une petite archive ;
• lister le résultat avec tar -tf.

6. Oublier les fichiers modifiés pendant l’archivage

Sur des répertoires actifs, notamment journaux, bases exportées en cours d’écriture ou fichiers applicatifs modifiés à chaud, le contenu peut changer pendant la création de l’archive. Cela peut produire des avertissements ou une archive incohérente pour certains usages.

Dans ce cas, il vaut mieux :

• travailler sur un snapshot si votre infrastructure le permet ;
• geler temporairement l’écriture ;
• ou exporter les données applicatives avec l’outil adapté avant archivage.

tar est excellent pour les fichiers, mais ce n’est pas un mécanisme magique de cohérence applicative.

Les options à connaître pour travailler plus proprement

Sans chercher l’exhaustivité, certaines options reviennent souvent dans un usage sérieux de tar.

Utiliser -C pour maîtriser les chemins

C’est probablement l’option la plus utile après -c, -x et -f. Elle permet de produire des archives plus propres et des scripts plus lisibles.

Exemple :

tar -czf logs.tar.gz -C /var/log nginx

Utiliser -v avec discernement

-v aide au diagnostic, mais dans les gros volumes il peut noyer l’information utile. Réservez-le :

• aux tests manuels ;
• au débogage ;
• aux procédures où la traçabilité détaillée est réellement nécessaire.

Utiliser --exclude pour garder des archives utiles

Une archive bien pensée est plus rapide à créer, plus légère à transférer et plus simple à restaurer. Les exclusions ne sont pas un détail : elles font partie de la qualité de la commande.

Combiner tar avec SSH

Dans un environnement Unix, tar se combine très bien avec ssh pour transférer une arborescence sans créer d’archive intermédiaire sur disque local.

Exemple classique :

tar -czf - dossier/ | ssh user@serveur 'cat > dossier.tar.gz'

Ou, pour une extraction distante :

tar -cf - dossier/ | ssh user@serveur 'tar -xf - -C /destination'

Ce type de commande est très pratique, mais demande de la rigueur sur les chemins et les droits. Si vous manipulez souvent des fichiers en ligne de commande, vous pouvez aussi compléter votre boîte à outils avec des commandes comme find pour préparer précisément le périmètre à archiver.

Exemples prêts à réutiliser au quotidien

Voici un mini pense-bête utilisable tel quel.

Archiver un dossier avec gzip

tar -czf site.tar.gz site/

Archiver un dossier avec xz

tar -cJf site.tar.xz site/

Archiver un dossier avec zstd

tar --zstd -cf site.tar.zst site/

Archiver depuis un répertoire précis

tar -czf sauvegarde.tar.gz -C /var/www monsite

Exclure Git et les caches

tar -czf projet.tar.gz projet/ --exclude='projet/.git' --exclude='projet/.cache'

Lister le contenu d’une archive

tar -tf projet.tar.gz

Extraire dans un dossier cible

tar -xzf projet.tar.gz -C /tmp/restauration

Tester rapidement une archive gzip

gzip -t projet.tar.gz

Conclusion

tar reste un outil central sur Linux parce qu’il fait très bien une chose essentielle : regrouper et transporter proprement des fichiers et des arborescences, avec une logique simple et robuste. En 2026, le socle ne change pas vraiment, mais le choix du bon compresseur devient plus intéressant, notamment avec la place prise par zstd dans de nombreux environnements.

Si vous devez retenir l’essentiel, gardez ces réflexes :

• utiliser -C pour maîtriser les chemins ;
• choisir gzip, xz ou zstd selon le besoin réel ;
• lister l’archive avant extraction ;
• tester vos restaurations au lieu de supposer qu’elles fonctionneront.

Et si vous voulez rendre vos manipulations shell plus fiables au quotidien, parcourez les autres guides de Prompt Bash : vous y trouverez des méthodes concrètes, sans folklore, pour gagner du temps sur Linux.