Ein Projekt für die Weitergabe bündeln, ältere Protokolle platzsparend aufbewahren oder eine Verzeichnisstruktur sichern: Dafür gehören Archivierung und Komprimierung zu den wichtigsten Werkzeugen unter Linux. Dabei erfüllen sie unterschiedliche Aufgaben: Ein Archiv fasst Dateien, Verzeichnisse und Informationen über deren Struktur zusammen. Die **Komprimierung** verkleinert dagegen die Darstellung der Daten. Häufig werden beide Verfahren kombiniert – beispielsweise zu einer Datei namens `projekt.tar.gz`. Archivieren und Komprimieren unterscheiden ------------------------------------------ Die wichtigsten Werkzeuge lassen sich in zwei Gruppen einteilen: | Aufgabe | Werkzeuge | Typische Endungen | |---|---|---| | Dateien und Verzeichnisse archivieren | `tar`, `cpio` | `.tar`, `.cpio` | | Daten komprimieren | `gzip`, `bzip2`, `xz` | `.gz`, `.bz2`, `.xz` | | Archivieren und anschließend komprimieren | Kombination beider Gruppen | `.tar.gz`, `.tar.bz2`, `.tar.xz` | Ein Kompressionsprogramm ersetzt kein Archivierungsprogramm: `gzip` kann beispielsweise mehrere Dateien einzeln komprimieren, bildet daraus aber keinen Verzeichnisbaum mit einzeln wiederherstellbaren Archiveinträgen. Dafür wird zunächst ein Archiv erstellt. Der entscheidende Unterschied: Ein Ordner organisiert einzelne Dateien im Dateisystem. Ein Archiv verpackt diese Dateien samt ihrer Struktur in **eine** Datei, beispielsweise `projekt.tar`.[](https://www.gnu.org/software/tar/manual/html_node/Definitions.html) ### Ein konkretes Beispiel Dein Projektordner enthält: ``` `projekt/├── notizen.txt├── bilder/│ ├── bild1.png│ └── bild2.png└── skripte/ └── start.sh` ``` Im Ordner bleiben das einzelne Dateien, die du direkt öffnen und bearbeiten kannst. Beim Archivieren werden deren Inhalte, Namen und Verzeichnisstruktur in `projekt.tar` gespeichert. Beim Entpacken lässt sich die Struktur wiederherstellen. Warum ist das praktisch? - Weitergeben: Du überträgst ein einziges Paket statt vieler einzelner Dateien. Genau so verteilt beispielsweise das GNU-Projekt Software als Tar-Archive.[](https://www.gnu.org/software/tar/manual/html_chapter/Introduction.html) - Einen Stand aufbewahren: Änderst du später die Arbeitsdateien im Ordner, bleibt das zuvor erstellte Archiv unverändert – solange du es nicht selbst ersetzt oder bearbeitest.[](https://www.gnu.org/software/tar/manual/html_node/Creating-the-archive.html) - Dateieigenschaften mitnehmen: Ein Tar-Archiv kann neben Inhalten auch Linux-Rechte, Eigentümerinformationen und weitere Metadaten speichern.[](https://www.gnu.org/software/tar/manual/html_node/Definitions.html) Wenn du nur lokal mit deinen Dateien arbeiten möchtest, brauchst du also kein Archiv: Ein Ordner reicht. Der Nutzen entsteht, wenn du den Inhalt als zusammenhängendes Paket weitergeben oder einen bestimmten Stand aufbewahren möchtest. Ein Archiv ist dabei nicht automatisch kleiner als der Ordnerinhalt. Dafür kommt zusätzlich die Komprimierung hinzu, etwa bei `projekt.tar.gz`.[](https://www.gnu.org/software/gzip/manual/gzip.html) Das Prinzip: ``` Dateien und Verzeichnisse ↓ tar projekt.tar ↓ gzip projekt.tar.gz ``` Die folgenden Beispiele beziehen sich auf die unter Linux verbreiteten GNU-Werkzeuge sowie `bzip2` und XZ Utils. Einzelne Optionen können bei anderen Implementierungen abweichen. Archive mit `tar` erstellen --------------------------- Mit `tar` fasst du Dateien und Verzeichnisse in einer Archivdatei zusammen: ``` tar -cf projekt.tar projekt/ ``` Die Optionen bedeuten: - `-c`: Ein neues Archiv erstellen. - `-f`: Die folgende Angabe als Archivdateinamen verwenden. Das Verzeichnis `projekt` wird einschließlich seiner Unterverzeichnisse archiviert. Die Quelldaten bleiben bestehen. Ohne Kompressionsoption entsteht ein unkomprimiertes Archiv. ### Mehrere Dateien und Verzeichnisse aufnehmen ``` tar -cf sammlung.tar notizen.txt aufgaben.txt projekt/ ``` Mit `-v` kannst du dir die aufgenommenen Namen anzeigen lassen: ``` tar -cvf sammlung.tar notizen.txt aufgaben.txt projekt/ ``` Achte auf den Archivnamen: Ein vorhandenes Archiv gleichen Namens kann beim Erstellen ersetzt werden. Lege die Archivdatei außerdem möglichst außerhalb des zu archivierenden Verzeichnisses ab. ### Saubere Pfade mit `-C` Mit `-C` wechselt `tar` vor der Verarbeitung der nachfolgenden Quellen in ein anderes Verzeichnis: ``` tar -cf projekt.tar -C ~/Projekte projekt ``` Das Archiv enthält damit Pfade wie: ``` projekt/ projekt/notizen.txt projekt/daten/ ``` Der vollständige Home-Pfad muss nicht Bestandteil des Archivs werden. Solche relativen Pfade erleichtern eine spätere Wiederherstellung an einem anderen Ort. Archivinhalt anzeigen und Dateien entpacken ------------------------------------------- ### Erst ansehen: `tar -t` ``` tar -tf projekt.tar ``` Mit ausführlichen Informationen: ``` tar -tvf projekt.tar ``` Die Inhaltsliste hilft dir zu erkennen, welche Pfade und Einträge das Archiv enthält, bevor du etwas wiederherstellst. ### Entpacken: `tar -x` ``` tar -xf projekt.tar ``` Ohne weitere Zielangabe wird relativ zum aktuellen Arbeitsverzeichnis entpackt. Übersichtlicher ist ein eigenes Zielverzeichnis: ``` mkdir -p wiederherstellung tar -xf projekt.tar -C wiederherstellung/ ``` Das Zielverzeichnis muss bereits existieren. Enthält das Archiv den obersten Ordner `projekt`, entsteht hier `wiederherstellung/projekt`. ### Vorhandene Dateien schützen Beim Entpacken kann `tar` vorhandene Dateien gleichen Namens ersetzen – normalerweise ohne Rückfrage. Mit `tar` kannst du das verhindern: ``` tar --keep-old-files -xf projekt.tar -C wiederherstellung/ ``` Existierende Dateien bleiben erhalten; die entsprechenden Konflikte werden als Fehler gemeldet. Die Alternative `--skip-old-files` überspringt vorhandene Dateien, ohne dies als Fehler zu behandeln. Archivieren und komprimieren in einem Aufruf -------------------------------------------- `tar` kann Kompressionsprogramme direkt einbinden: | Format | Erstellen | Inhalt auflisten | Entpacken | |---|---|---|---| | gzip | `tar -czf projekt.tar.gz projekt/` | `tar -tzf projekt.tar.gz` | `tar -xzf projekt.tar.gz` | | bzip2 | `tar -cjf projekt.tar.bz2 projekt/` | `tar -tjf projekt.tar.bz2` | `tar -xjf projekt.tar.bz2` | | xz | `tar -cJf projekt.tar.xz projekt/` | `tar -tJf projekt.tar.xz` | `tar -xJf projekt.tar.xz` | Die Kompressionsoptionen lauten also: - `-z`: gzip. - `-j`: bzip2. - `-J`: xz. Groß- und Kleinschreibung sind hier entscheidend. Ein vollständiges Beispiel: ``` tar -czf projekt.tar.gz projekt/ mkdir -p wiederherstellung tar -xzf projekt.tar.gz -C wiederherstellung/ ``` Dabei wird beim Entpacken sowohl die Kompression entfernt als auch die Archivstruktur wiederhergestellt. Einzelne Dateien mit `gzip`, `gunzip` und `zcat` verarbeiten ------------------------------------------------------------ ### Komprimieren ``` gzip protokoll.log ``` Standardmäßig ersetzt `gzip` die Eingabedatei nach erfolgreicher Verarbeitung durch: ``` protokoll.log.gz ``` Möchtest du das Original behalten, verwende `-k`: ``` gzip -k protokoll.log ``` Dann bleiben beide Dateien vorhanden. ### Dekomprimieren ``` gunzip protokoll.log.gz ``` Gleichbedeutend: ``` gzip -d protokoll.log.gz ``` Auch beim Dekomprimieren wird die Eingabedatei standardmäßig entfernt. Mit `-k` bleibt die komprimierte Fassung erhalten: ``` gunzip -k protokoll.log.gz ``` Falls die unkomprimierte Zieldatei bereits existiert, solltest du den Namenskonflikt bewusst lösen und nicht einfach das Überschreiben erzwingen. ### Inhalt mit `zcat` ausgeben ``` zcat protokoll.log.gz ``` `zcat` dekomprimiert in die Standardausgabe, ohne eine zusätzliche unkomprimierte Datei anzulegen. Die komprimierte Datei bleibt erhalten. Für längere Texte: ``` zcat protokoll.log.gz | less ``` Das eignet sich für komprimierte Textdateien. Bei einem komprimierten Tar-Archiv würdest du dagegen den Tar-Datenstrom ausgeben, keine übersichtliche Dateiliste. Dafür verwendest du `tar -tzf`. `bzip2`, `bunzip2` und `bzcat` ------------------------------ Die üblichen Befehlsnamen lauten `bzip2`, `bunzip2` und `bzcat`. Der Dekompressionsbefehl heißt also `bunzip2`, nicht `bunzip`. ### Komprimieren und Original behalten ``` bzip2 -k protokoll.log ``` Ergebnis: ``` protokoll.log protokoll.log.bz2 ``` Ohne `-k` wird die Eingabedatei nach erfolgreicher Verarbeitung standardmäßig entfernt. ### Dekomprimieren ``` bunzip2 protokoll.log.bz2 ``` Alternativ: ``` bzip2 -d protokoll.log.bz2 ``` Mit `-k` bleibt auch hier die komprimierte Eingabedatei bestehen: ``` bunzip2 -k protokoll.log.bz2 ``` ### Inhalt ausgeben ``` bzcat protokoll.log.bz2 ``` Oder seitenweise lesen: ``` bzcat protokoll.log.bz2 | less ``` `bzcat` entspricht funktional `bzip2 -dc`: dekomprimieren und das Ergebnis auf die Standardausgabe schreiben. `xz`, `unxz` und `xzcat` ------------------------ Die grundsätzliche Bedienung ähnelt den anderen Kompressionswerkzeugen. ### Komprimieren ``` xz -k protokoll.log ``` Es entsteht `protokoll.log.xz`, während das Original durch `-k` erhalten bleibt. ### Dekomprimieren ``` unxz protokoll.log.xz ``` Alternativ: ``` xz -d protokoll.log.xz ``` Die komprimierte Fassung behalten: ``` unxz -k protokoll.log.xz ``` ### Inhalt ausgeben ``` xzcat protokoll.log.xz | less ``` `unxz` entspricht `xz -d`, `xzcat` entspricht `xz -dc`. Ohne `-k` beziehungsweise Ausgabe über `-c` entfernt `xz` die Eingabedatei nach erfolgreicher Verarbeitung normalerweise. Komprimierte Dateien prüfen --------------------------- Alle drei Werkzeuge besitzen eine Testfunktion: ``` gzip -t protokoll.log.gz bzip2 -t protokoll.log.bz2 xz -t protokoll.log.xz ``` Die Prüfung dekomprimiert intern und kontrolliert die Integrität des komprimierten Datenstroms, ohne eine entpackte Datei abzulegen. Das prüft allerdings nicht, ob du ursprünglich alle gewünschten Dateien archiviert hast oder ob die Daten aus einer vertrauenswürdigen Quelle stammen. Bei einem komprimierten Tar-Archiv ergänzen sich daher zwei Kontrollen: ``` gzip -t projekt.tar.gz tar -tzf projekt.tar.gz ``` Die erste prüft den gzip-Datenstrom, die zweite liest die enthaltene Archivstruktur. Symbolische und harte Links archivieren --------------------------------------- ### Symbolische Links: Verweis statt Zielinhalt `tar` speichert symbolische Links standardmäßig als Links. Der gespeicherte Zielpfad wird beim Entpacken wiederhergestellt; die Zieldatei wird nicht allein deshalb aufgenommen, weil ein Link auf sie zeigt. Beispiel: ``` projekt/ ├── daten.txt └── daten-link -> daten.txt ``` Mit: ``` tar -cf projekt.tar projekt/ ``` werden sowohl `daten.txt` als auch der Link aufgenommen, weil beide innerhalb der ausgewählten Struktur liegen. Zeigt ein Link dagegen auf eine Datei außerhalb des Projekts, ist deren Inhalt nicht automatisch im Archiv enthalten. Absolute Links können nach der Wiederherstellung auf einem anderen System ins Leere zeigen; relative Links funktionieren nur, wenn ihre benötigten Pfadbeziehungen erhalten bleiben. Mit `--dereference` beziehungsweise `-h` lässt sich stattdessen den Linkzielen folgen: ``` tar --dereference -cf projekt-mit-linkzielen.tar projekt/ ``` Das kann unerwartet zusätzliche Daten außerhalb des Projektverzeichnisses aufnehmen. Verwende diese Option daher nur bewusst. ### Harte Links: Beziehungen innerhalb des Archivs erhalten Werden mehrere harte Links auf dieselbe Datei aufgenommen, kann `tar` deren Beziehung im Archiv abbilden. Beim passenden Wiederherstellen entstehen wieder mehrere Namen für dieselbe Datei, statt unabhängiger Inhaltskopien. Nicht mitarchivierte Namen außerhalb der Auswahl werden dadurch allerdings nicht mitgesichert. ### Zusätzliche Dateiattribute Für POSIX-ACLs und erweiterte Attribute bietet `tar` eigene Optionen: ``` tar --acls --xattrs -czf projekt.tar.gz projekt/ ``` Beim Wiederherstellen müssen diese Funktionen ebenfalls aktiviert werden: ``` tar --acls --xattrs -xzf projekt.tar.gz -C wiederherstellung/ ``` Welche Attribute tatsächlich wiederhergestellt werden können, hängt unter anderem von Berechtigungen, Dateisystem und Attribut-Namensraum ab. `--xattrs` stellt standardmäßig nicht pauschal jeden gespeicherten Namensraum wieder her. Archive mit `cpio` erstellen ---------------------------- Der Befehl `cpio` ----------------- `cpio` steht für „copy in, copy out“. Mit diesem Werkzeug kannst du Dateien in einem Archiv zusammenfassen und später wieder daraus extrahieren. Die aufzunehmenden Dateinamen erhält `cpio` über die **Standardeingabe**, beispielsweise aus der Ausgabe von `ls`. > `cpio` ist ein Archivierungswerkzeug, das vor allem in speziellen Systemabläufen relevant ist, etwa bei Initramfs-Archiven für den Linux-Start. Für das gewöhnliche Archivieren von Dateien und Verzeichnissen ist `tar` der einfachere Einstieg ### Ein Archiv erstellen Wechsle in das Verzeichnis mit den Dateien und führe folgenden Befehl aus: ``` ls | cpio -o > ../archive.cpio ``` Dabei passiert Folgendes: - `ls` listet die sichtbaren Einträge im aktuellen Verzeichnis auf. - `|` übergibt diese Liste an `cpio`. - `-o` (Output) weist `cpio` an, die angegebenen Dateien in ein Archiv zu schreiben. - `>` speichert die Archivausgabe in `../archive.cpio`. Das Archiv wird bewusst eine Ebene darüber gespeichert, damit es nicht selbst in der Dateiliste auftaucht. Dieses einfache Beispiel nimmt keine versteckten Dateien und nicht automatisch die Inhalte von Unterverzeichnissen auf. ### Ein Archiv entpacken Wechsle in ein leeres Zielverzeichnis und führe aus: ``` cpio -id < ../archive.cpio ``` Passe den Archivpfad bei Bedarf an. - `-i` (Input) extrahiert die Dateien aus dem Archiv. - `-d` erstellt dabei benötigte Verzeichnisse. - `<` liest die angegebene Archivdatei als Standardeingabe ein. Die Dateien werden relativ zum aktuellen Verzeichnis wiederhergestellt, sofern das Archiv wie im Beispiel relative Dateinamen enthält. ### Ein cpio-Archiv komprimieren ``` gzip -k archive.cpio ``` Zum Auflisten des komprimierten Archivs: ``` zcat archive.cpio.gz | cpio -itv ``` Auch hier bleiben Archivierung und Komprimierung getrennte Arbeitsschritte. `cpio` kann Links als solche speichern; die Option `-L` veranlasst stattdessen das Folgen symbolischer Linkziele. Archive sicher erstellen und wiederherstellen --------------------------------------------- Ein paar Gewohnheiten verhindern typische Probleme: - Archivdateien außerhalb der ausgewählten Quelldaten ablegen. - Vor dem Entpacken die enthaltenen Namen auflisten. - Fremde Archive ohne administrative Rechte in ein eigenes, leeres Verzeichnis entpacken. - Für mehrere fremde Archive getrennte Zielverzeichnisse verwenden. - Auf Fehlermeldungen achten und wichtige Wiederherstellungen praktisch testen. Ein Archiv kann sensible Daten und problematische Pfade oder Links enthalten. `tar` empfiehlt deshalb ausdrücklich ein leeres, gegen fremde Änderungen geschütztes Zielverzeichnis. Komprimierung ist außerdem keine Verschlüsselung: Die hier gezeigten Verfahren machen Daten kleiner, schützen ihren Inhalt aber nicht vor dem Lesen. Fazit: Erst bündeln, dann verkleinern ------------------------------------- `tar` und `cpio` bewahren Dateien in einer Archivstruktur auf. `gzip`, `bzip2` und `xz` komprimieren die daraus entstehenden Daten. Mit `gunzip`, `bunzip2` und `unxz` machst du die Kompression rückgängig; `zcat`, `bzcat` und `xzcat` geben den dekomprimierten Inhalt direkt aus. Für die Praxis zählt nicht nur, dass eine Archivdatei entsteht. Entscheidend ist, ob sie die gewünschten Daten und Linkbeziehungen enthält – und ob du sie an einem geeigneten Ort zuverlässig wiederherstellen kannst.