Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- daten_packen [2021-08-13 14:35:43] – manfred
+++ daten_packen [2023-12-12 18:29:04] (aktuell) – [Daten packen] manfred
@@ Zeile 1: / Zeile 1: @@
+====== Daten packen ======
+  * [[::tar]] - //Der Klassiker, faßt ganze Verzeichnisbäume zu einer einzigen Datei zusammen//
+  * [[https://linuxnightly.com/how-to-use-zstandard-compression-on-linux-with-commands/|Zstandard]] - //Der zur Zeit beste Packer//
+  * [[::XZ]] - //Der Neue, wird gelegentlich als TAR-Ersatz verwendet - Windows unterstützt diesen Packer auch und somit ist er für Kompatibilität zu bevorzugen//
+  > tar -caf archiv.txz verzeichnis
+  > tar -caf archiv.tar.zst verzeichnis
+===== Beispiel für ein mit Passwort geschütztes Archiv =====
+Aufgabenstellung:
+  Es soll das Verzeichnis "Daten" in einem möglichst sicher verschlüsseltem Archiv abgelegt werden.
+  Dabei sollen unter Linux nur "Board-Mittel" zum Einsatz kommen und der sicherste verfügbare Verschlüsselungsalgorithmus verwendet werden.
+beispielhafte Lösung:
+  > time tar cf - --exclude='/.cache/' Daten | gpg --no-options --no-symkey-cache --cipher-algo TWOFISH --digest-algo SHA512 -ac --batch --passphrase Geheim01 -o - | gzip -9 > daten.tar.gpg.gz
+  > zcat daten.tar.gpg.gz | gpg --no-options --no-symkey-cache -d --batch --passphrase Geheim01
+//In diesem Fall kann GZIP sehr effektiv packen, weil GPG hier nur Textdaten an GZIP übergibt.//
+  * __gegenüber OpenSSL hat GPG zwei Vorteile:__
+    - man muß beim entschlüsseln nicht wissen wie das Archiv genau verschlüsselt wurde
+    - in OpenSSL gibt es nur [[::verschluesselungsarten#Blowfish]], den Vorgängeralgorithmus von [[::verschluesselungsarten#Twofish]]
+  * __siehe auch:__
+    * [[::GPG-Verschlüsselung mit Passwort]]
+    * [[::einzelne Dateien mit GPG verschlüsseln]]
+    * [[::Verschlüsselung mit CryptSetup]]
+verschlüsseltes Archiv überprüfen:
+  > zcat daten.tar.gpg.gz | gpg --no-options --batch --passphrase geheim -do - | tar tf -
+verschlüsseltes Archiv ins Home-Verzeichnis entpacken:
+  > zcat daten.tar.gpg.gz | gpg --no-options --batch --passphrase geheim -do - | tar f - -C ~/
+verschlüsseltes Archiv in kleine Häppchen aufteilen, damit es auch auf dem USB-Stick mit FAT-Dateisystem untergebracht werden kann:
+  > split -b 2000m daten.tar.gpg.gz daten_tar_gpg_gz.
+  > ls daten_tar_gpg_gz.*
+  daten_tar_gpg_gz.aa
+  daten_tar_gpg_gz.ab
+  daten_tar_gpg_gz.ac
+alle Teile des verschlüsselten Archives ins Home-Verzeichnis entpacken:
+  > cat daten_tar_gpg_gz* > daten_tar_gpg.gz
+  > rm daten_tar_gpg_gz*
+  > zcat daten_tar_gpg.gz | gpg --no-options --batch --passphrase geheim -do - | tar f - -C ~/
+//Theoretisch sollte das auch so funktionieren: ''zcat daten_tar_gpg_gz* | gpg -do - | tar f - -C ~/'', aber leider nicht immer...//
+===== Archive =====
+Um ein Verzeichnis von Dateien zu packen benötigt man ein Archivierungsprogramm.
+Derartige Programme gibt es viele, allerdings ist hier das verbreitetste unser gutes altes //tar// und alle anderen Programme, die antraten um seine Nachfolge anzutreten, haben zu wenig Vorteile gehabt als das sie ihn vom Trohn stoßen könnten.
+Hat man jetzt ein Archiv, dann kann man es, um Platz zu sparen, noch packen.
+Dazu braucht man ein Packprogramm.
+Davon gibt es ebenfalls recht viele, wobei jedes dieser Programme auch in einem anderen Umfeld seine speziellen Vorteile hat.
+Das möchte ich hier nicht genauer beleuchte.
+Wir konzentrieren uns auf die zwei verbreitetsten, die auch immernoch State-of-the-Art sind: //gzip// und //bzip2//.
+//gzip// schreibt für jede gepackte Datei nur einen Header, das hat seine Vor- und Nachteile!
+Da //Gzip// nur einmal den Inhalt am Anfang der Datei analysiert und an Hand dieser Analyse einen vernünftigen Algorithmus auswählt, sollte man //gzip// nur für Dateien mit homogenem Inhalt (Textdateien, Logdateien) verwenden. Ein großer Pluspunkt von //gzip// ist auch, das es deutlich weniger Rechenzeit der CPU beim packen verbraucht als //bzip2// zum Beispiel! //Gzip//-Dateien können (ohne sie auszupacken) mit //zcat// direckt angesehen werden.
+Sollen dagegen Dateien mit inhomogenem Inhalt (MySQL-Bin-Logs, TAR-Archive von Verzeichnissen mit Binärdateien **und** Textdateien) gepackt werden, dann ist //bzip2// die deutlich bessere Wahl. Es verbraucht zwar deutlich mehr Rechenzeit der CPU, aber das Ergebnis ist bis zu 12-mal kleiner als mit //gzip//. Das liegt daran, dass //bzip2// die zu packende Datei, Blockweise packt. Für jeden Block wählt //bzip2// jeweils den optimalen Pack-Algotithmus aus, dadurch wird bei gemischtem Inhalt der gesammten Datei trotzdem jede Datanart in der selbigen optimal gapackt. Allerdings schreibt //bzip2// auch **für jeden Block** einen eigenen Header und das kostet Platz. Deshalb kann //bzip2// z.B. Logdateien nicht so gut packen wie //gzip// zum Beispiel.
+===== Einschränkungen =====
+==== cpio (archivierer) ====
+kann nicht komprimieren;
+kann nur ASCII und max. 8GB-Archive,
+standardmäßig wird ein überflüssiges Binärformat verwendet
+"-H crc":   portable SVR4-Format mit einer Schecksumme je Datei
+"-H ustar": POSIX.1-Format
+Wegen seiner Dateigrößenbeschränkungen wird cpio nicht mehr von
+der POSIX geführt, Nachfolger sollte afio werden;
+Die POSIX führt pax als Nachfolger von cpio und tar ein.
+und so trat pax die Nachfolge von cpio, tar und afio im POSIX-Standard an...
+==== tar (archivierer) ====
+  - kann nur ASCII und max. 8GB-Archive,
+  - kann mit Hardlinks und Sparse-Dateien nicht richtig umgehen, was beim
+  - Wiedereinspielen eines Archivs zu Problemen führen kann;
+  - mit star und bsdtar versucht man die Schwächen von tar/GNU-tar
+  - zu vermeiden;
+  - mehr als 8GB gehen
+    - mit "-H ustar" (POSIX 1003.1-1988)
+    - und "-H posix" (POSIX 1003.1-2001)
+  - Solaris: mehr als 8GB gehen mit "-E" (ustar)
+  - Linux  : benutzt standardmäßig "-H ustar" (POSIX 1003.1-1988) / (GNU-tar ist kein echtes POSIX-Format, nur ähnlich)
+Die POSIX führte //pax// als Nachfolger von //cpio// und //tar// ein;
+==== afio  (archivierer + packer) ====
+Nachfolger von cpio sollte afio werden, allerdings
+stammt der Quellcode von afio aus einer zur LPGL (aktuelle Lizenz)
+nicht kompatiblen Lizenz, aus diesem Grund hat die FSF afio aus ihrem
+Software-Verzeichnis genommen;
+==== star (archivierer) ====
+  - es kann //xz// nicht direckt einbinden
+==== pax (archivierer + packer) ====
+  - POSIX-Nachfolger von cpio;
+  - benutzt standardmäßig "-x ustar" (POSIX 1003.1-1988)
+  - mit "-x cpio" ist es "IEEE 1003.2 / POSIX.2"-konform
+==== rar (archivierer + packer) ====
+  - steht unter Lizenzschutz / ist kommerziell
+==== XZ (packer) ====
+XZ kann zwei Formate:
+  -  ''XZ''  packt nur ca. halb so gut wie LZMA
+  - ''LZMA'' kann keine beschädigten Archive entpacken (im Gegensatz zu XZ)
+==== p7zip/7za (archivierer + packer) ====
+Der Unterschied zwischen ''7z'' und ''7za'' liegt darin, dass ''7z'' dynamisch gelinkt wurde und ''7za'' statisch gelinkt wurde.
+''7z'' kann keine beschädigten Archive entpacken (im Gegensatz zu ''rar'' und ''tar'')
+  * owner/group wird nicht gespeichert
+deshalb wird noch ein archivierer (z.B. //tar// oder //star//) gebraucht.
+Verwendet man //p7zip// mit //star//, dann legt //star// sein TAR-Archiv erst im ///tmp-Verzeichnis ab
+bevor das TAR-Archiv dann mit //p7zip// zum endgültigen komprimierten Archiv gemacht wird.
+Man muss also im ///tmp-Verzeichnis genügend Platz vorhalten...
+===== Vorteile =====
+==== cpio (archivierer) ====
+gibt es auf allen Unix-Systemen;
+==== tar (archivierer) ====
+ist das verbreitetste Unix-Archivierungsprogramm;
+==== afio  (archivierer + packer) ====
+afio komprimiert Dateiweise und verwendet blockweise komprimierende Algorithmen,
+so das ein beschädigter Bereich nicht das gesamte Archiv zerstört, wie es
+bei tar passieren kann;
+==== star (archivierer) ====
+  - hat nicht die beschränkungen von //tar//
+  - verwendet die gleichen Prozeduren wie restore/dump;
+  - das Standard-Format ''xstar'' ist so POSIX-konform wie möglich (POSIX.1-1988), dadurch können mit anderen //tar//-Implementationen nur 100+130 Zeichen des Dateinamens gelesen werden
+  - mit "H=pax" ist //star// "POSIX-1003.1-2001"-konform, es ist //strikt// deshalb sind die "POSIX.1-2001"-Erweiterungen nicht enthalten
+  - wird //star// mit dem Namen ''tar'' aufgerufen, dann ist ''xustar'' das Standard-Format, dieses Format enthält auch die "POSIX.1-2001"-Erweiterungen
+  - mit "H=exustar" verwendet //star// den "POSIX.1-2001"-Erweiterten Header zwingend und kann dann auch (als einzige //tar//-Implementation unter Linux) ALC's (-acl) speichern
+  - mit "H=exustar -dump" speichert //star// mehr Metadaten als üblich, das ist der "beste" Archivierungs-Mode (wenn man "-dump" gesetzt hat, braucht man "H=exustar" nicht mehr angeben, diese Funktionalität ist inklusive)
+  - ein, durch verbesserte Pufferung, schneller Archivierer
+  - beherscht UNICODE UTF-8
+  - versteht ''find''-Ausdrücke (star -find), auch beim lesen von Archiven
+  - sollte ein Dateisystem beschädigt worden sein, kann //star// nach einem "fsck -y" alle fehlenden Dateien wieder entpacken (star -diff) ohne die vorhandenen unnötiger weise auch auspacken zu müssen
+==== pax (archivierer + packer) ====
+(Nachfolger für cpio und tar, einziger POSIX.2-Archivierer)
+kann alle cpio- und tar-Archive lesen und schreiben;
+kann POSIX.2;
+==== zip (archivierer + packer) ====
+ist das verbreitetste Windoofs-Archivierungsprogramm, Passwortschutz,
+kann beschädigte Archive manchmal reparieren
+==== gzip (packer) ====
+sehr verbreitet, packt Dateien mit einheitlichen Dateninhalt am besten;
+verbraucht sehr wenig Rechenleistung, packt nicht ganz so gut wie zip;
+kann nur eine Datei komprimieren, braucht also noch einen Archivierer;
+Es gibt auch eine Implementierung von GZip, die parallel auf mehreren CPU-Kernen gleichzeitig packen kann, sie heißt ''pigz''.
+''pigz'' steht für Parallel Implementation of GZip. Sie ist ein funktional
+vollständiger Ersatz für gzip, der bei der Datenkompression mehrere Prozessoren oder Prozessorkerne nutzt.
+Den besten Kompromiss zwischen Packungsdichte, Systemleistungsverbrauch und Packzeit, bietet ''gzip -1''.
+==== bzip2 (packer) ====
+  - sehr verbreitet, ist für Dateien mit gemischtem Dateninhalt optimiert;
+  - verbraucht deutlich mehr Rechenleitung als gzip;
+  - kann nur eine Datei komprimieren, braucht also noch einen Archivierer;
+==== rar (archivierer + packer) ====
+kann beschädigte Archive entpacken
+==== XZ (packer) ====
+Die [[http://tukaani.org/xz/|XZ-Utils]] stellen die gleiche LZMA-Kompression wie 7-Zip bereit, aber in einem anderen Format, das laut den Entwicklern immer populärer wird und besser zu POSIX-Systemen passt.
+  - ca. 30% besser als //gzip//
+  - ca. 15% besser als //bzip2//
+  - legt crc64-Checksummen an und kann deshalb auch defekte Archive entpacken
+  - POSIX-konformer als //7zip//
+  - im LZMA-Format wird etwa doppelt so gut gepackt wie //bzip2// allerdings ohne Checksummen
+==== p7zip/7za (packer) ====
+Komprimiert teilweise besser als bzip2 und zip;
+beherscht UNICODE, verschlüssellung,
+Passwortschutz, Selbstentpacker und
+kann Archive mit beschädigten Dateien entpacken.
+=== Archivierungsprogramme, die 7z unterstützen ===
+Der Unterschied zwischen ''7z'' und ''7za'' liegt darin, dass ''7z'' dynamisch gelinkt wurde und ''7za'' statisch gelinkt wurde.
+  - p7zip/7za (portabeles Kommandozeilenprogramm)
+  - star (einzige //tar//-Implementation, die unter Linux ACL's speichern kann)
+  - ark (KDE-FrontEnd für verschiedene Kommandozeilenarchivierer)
+  - File Roller (GNOME-Archivierungstool)
+  - PeaZip (in Free Pascal geschrieben)
+===== Beispiele =====
+  # find [Verzeichnis/Datei] | cpio -oH ustar --sparse > [Archiv.tar]
+  # tar cjf [Archiv.tar.bz2] [Verzeichnis/Datei]
+  # tar cJf [Archiv.tar.xz] [Verzeichnis/Datei]
+  # tar cf - [Verzeichnis/Datei] | 7za a -si [Archiv.tar.7z]
+  # pax -wf [Archiv.tar] [Verzeichnis/Datei]
+  # pax -wjf [Archiv.tar.bz2] [Verzeichnis/Datei]
+  # 7za a [Archiv.7z] [Verzeichnis/Datei]
+  # 7za a -sfx [Archiv.exe] [Verzeichnis/Datei]           # Archiv MUSS auch in Unix/Linux auf ".exe" enden!]
+  # 7za a -sfx -mx=9 [Archiv.exe] [Verzeichnis/Datei]     # Archiv mit max. Kompressionsrate
+  # 7za a -v1g [Archiv.7z] [Verzeichnis/Datei]            # 1GB-Archive
+  # pax -w [Verzeichnis/Datei] | xz -z > [Archiv.tar.xz]
+  # cat datei.img    | xz -z > datei.img.xz               # mit xz per Pipe packen
+  # xz -t datei.img.xz                                    # mit xz testen
+  # cat datei.img.xz | xz -d > datei.img                  # mit xz per Pipe entpacken
+  ### mit star ein einfaches tar-Archiv (POSIX.1-1988) erstellen
+  # star cf [Archiv.tar] [Verzeichnis/Datei]
+  ### mit star ein modernes tar-Archiv (POSIX.1-2001 + Erweiterungen) erstellen
+  # star c H=exustar -f [Archiv.tar] [Verzeichnis/Datei]
+  ### mit star können auch ACL's gesichert werden
+  # star c H=exustar -acl -f [Archiv.tar] [Verzeichnis/Datei]
+  ### star User-Daten, ACL's und Attribute sichern
+  # star c H=exustar -pax-p e -f [Archiv.tar] [Verzeichnis/Datei]
+  ### star soll alle Meta-Daten sichern, die es sichern kann
+  # star c -dump -f [Archiv.tar] [Verzeichnis/Datei]
+  ### mit star ein gepacktes tar-Archiv mit allen Meta-Daten erstellen
+  # star c -7z -dump -f [Archiv.tar.7z] [Verzeichnis/Datei]
+  ### eine Datei verschlüsselt mit maximaler Kompression verpaken
+  # zip -9 -e [Archiv.tar.zip] [Datei]
+  # zip -9 -r -e [Archiv.tar.zip] [Verzeichnis/]
+=== Inhalt zeigen ===
+  # cpio --list < [Archiv.tar]
+  # cpio --list < [Archiv.newc]
+  # pax [Archiv.tar]
+  # 7za l [Archiv.7z]
+=== testen ===
+  # tar tJf [Archiv.tar.xz]
+  # xz -t [Archiv.tar.xz]
+  # xz -dc [Archiv.tar.xz] | pax
+  # 7za t [Archiv.7z]
+  # star t -7z -f [Archiv.tar.7z]
+=== entpacken ===
+  # tar xJf [Archiv.tar.xz]
+  # pax -rf [Archiv]
+  # pax -rjf [Archiv.tar.bz2]
+  # xz -dc [Archiv.tar.xz] | pax -r
+  # 7za e [Archiv.7z]                               # mit relativem Pfad
+  # 7za x [Archiv.7z]                               # mit absolutem Pfad
+  # 7za e -so [Archiv.tar.7z] | tar xf -            # owner/group mit entpacken (relativer Pfad)
+  # 7za x -so [Archiv.tar.7z] | tar xf -            # owner/group mit entpacken (absoluter Pfad)
+  # star x -7z -f [Archiv.tar.7z]
+=== kopieren ===
+  # pax -rwp e [Quelle] [Ziel]
+  # mkdir -p [Ziel] ; star -copy -p [Quelle] [Ziel]
+  # star -copy [Quell-Datei] [Ziel-Verzeichnis]
+  # star -copy [Datei1] [Datei2] [Datei3] [Ziel-Verzeichnis]
+  # star -copy -C [Quell-Verzeichnis] . [Ziel-Verzeichnis]
+  # star c -dump -f - [Quell-Verzeichnis/-datei] | ssh root@192.168.0.1 'star xf -'
+  # ssh root@192.168.0.1 'star c -dump -f - [Quell-Verzeichnis/-datei]' | star xf -
+  # star c H=exustar -f - [Quell-Verzeichnis/-datei] | ssh root@192.168.0.1 'tar xf -'
+  # tar cf - [Quell-Verzeichnis/-datei] | ssh root@192.168.0.1 'tar xf -'
+  # ssh root@192.168.0.1 'tar cf - [Quell-Verzeichnis/-datei]' | tar xf -
+=== mit Passwort verschlüsseln ===
+  # 7za a -mhe=on -p[geheim] [Archiv.7z] [Verzeichnis/Datei]
+==== TAR - der bekannteste Vertreter ====
+ein unkomprimiertes Archiv anlegen
+  > tar cf Archiv.tar Datei_1.txt Datei_2.txt Datei_3.txt
+zum unkomprimierten Archiv einige Dateien hinzufühgen
+  > tar rf Archiv.tar Datei_4.txt Datei_5.txt Datei_6.txt
+den Inhalt des unkomprimierten Archives anzeigen bzw. das entpacken testen (Sicherheitsüberprüfung)
+  > tar tf Archiv.tar
+den Inhalt des unkomprimierten Archives entpacken
+  > tar xf Archiv.tar
+das komplette Home-Verzeichnis, ohne Cache-Daten, packen
+  > tar cf - --exclude='.cache' ~/
+__Die Option ''-****-exclude='' erwartet Pattern im glob-Format.__
+das komplette Home-Verzeichnis, ohne das Cache-Verzeichnis, packen
+  > tar cf - --exclude='*/.cache/*' ~/
+===== Fazit =====
+Das beste Archivierungsprogramm ist //star//, da kein anderer Archivierer im Moment diese Geschwindigkeit bietet und dabei noch alle Meta-Daten, inklusive ACL's, speichern kann.
+Und das beste Packprogramm ist //xz//, da es in meinem Praxistest sogar noch etwas besser gepackt hat als //7z// und darüber hinaus eine
+bessere POSIX-konformität bietet als //7z//. Leider kann von beiden aber nur //7z// seine Archive mit Passwort schützen.
+Leider lassen sich die beiden besten nur etwas umständlich kombinieren, einfacher geht es mit dem zweitbesten Packprogramm //7z//.
+Die Kombination //star// und //7z// ist schnell, packt gut und ist einfach zu handhaben.
+Damit ist das mein persönlicher Favorit (bis //star// auch noch mit //xz// umgehen kann).
+  # star c -7z -dump -f [Archiv.tar.7z] [Verzeichnis/Datei]