# tar - Archive erstellen und Software installieren

Der `tar`-Befehl (tape archive) erstellt und entpackt Archive. Oft in Kombination mit Kompression (gzip, bzip2, xz).

## Grundsyntax

```bash
tar [OPTIONEN] [ARCHIV] [DATEIEN...]
```

## Archive erstellen

### Einfaches Archiv (unkomprimiert)

```bash
tar -cf archiv.tar verzeichnis/
```

- `-c` = create (erstellen)
- `-f` = file (Dateiname)

### Mit gzip-Kompression (.tar.gz)

```bash
tar -czf archiv.tar.gz verzeichnis/
```

- `-z` = gzip

### Mit bzip2-Kompression (.tar.bz2)

```bash
tar -cjf archiv.tar.bz2 verzeichnis/
```

- `-j` = bzip2

### Mit xz-Kompression (.tar.xz)

```bash
tar -cJf archiv.tar.xz verzeichnis/
```

- `-J` = xz (beste Kompression)

### Mit Fortschrittsanzeige

```bash
tar -czf archiv.tar.gz verzeichnis/ -v
```

- `-v` = verbose (Details anzeigen)

## Archive entpacken

### Automatische Kompressionserkennung

```bash
tar -xf archiv.tar.gz
```

- `-x` = extract (entpacken)

### In bestimmtes Verzeichnis

```bash
tar -xf archiv.tar.gz -C /ziel/verzeichnis
```

### Mit Fortschrittsanzeige

```bash
tar -xvf archiv.tar.gz
```

## Archiv-Inhalt anzeigen

```bash
tar -tf archiv.tar.gz
```

- `-t` = list (auflisten)

Mit Details:

```bash
tar -tvf archiv.tar.gz
```

## Praktische Beispiele

### Backup erstellen

```bash
tar -czf backup-$(date +%Y%m%d).tar.gz /home/user/dokumente
```

### Bestimmte Dateien ausschließen

```bash
tar -czf archiv.tar.gz --exclude='*.tmp' --exclude='.git' verzeichnis/
```

### Nur bestimmte Dateien hinzufügen

```bash
tar -czf logs.tar.gz /var/log/*.log
```

### Zu bestehendem Archiv hinzufügen

```bash
tar -rf archiv.tar neue_datei.txt
```

**Hinweis:** Funktioniert nur bei unkomprimierten Archiven!

### Einzelne Datei aus Archiv extrahieren

```bash
tar -xzf archiv.tar.gz pfad/zur/datei.txt
```

### Archiv auf andere Maschine übertragen

```bash
tar -czf - verzeichnis/ | ssh user@server "cd /ziel && tar -xzf -"
```

## Dateirechte bewahren

```bash
tar -czpf archiv.tar.gz verzeichnis/
```

- `-p` = preserve permissions

Als Root entpacken und Eigentümer bewahren:

```bash
sudo tar -xpf archiv.tar.gz
```

## Inkrementelles Backup

```bash
tar -czf backup-full.tar.gz -g snapshot.file verzeichnis/
tar -czf backup-incr.tar.gz -g snapshot.file verzeichnis/
```

- `-g` = incremental (inkrementell)

## Geschwindigkeit vs. Kompression

| Format | Geschwindigkeit | Kompression | Empfehlung |
|--------|----------------|-------------|------------|
| `.tar` | Sehr schnell | Keine | Lokale Kopien |
| `.tar.gz` | Schnell | Gut | Standard |
| `.tar.bz2` | Mittel | Besser | Archivierung |
| `.tar.xz` | Langsam | Beste | Langzeit-Archiv |

## Fehler vermeiden

### Führenden Slash entfernen

```bash
tar -czf archiv.tar.gz --absolute-names /home/user/dokumente  # Mit /
tar -czf archiv.tar.gz -C /home/user dokumente                # Ohne /
```

Zweite Variante ist sicherer beim Entpacken.

### Große Archive

Prüfe Speicherplatz vorher:

```bash
du -sh verzeichnis/
df -h .
```

### Testen vor Löschen

```bash
tar -czf backup.tar.gz daten/
tar -tzf backup.tar.gz | head  # Inhalt prüfen
# Erst dann löschen:
rm -rf daten/
```

## Mit Verschlüsselung

```bash
# Erstellen und verschlüsseln
tar -czf - verzeichnis/ | gpg -c > archiv.tar.gz.gpg

# Entschlüsseln und entpacken
gpg -d archiv.tar.gz.gpg | tar -xzf -
```

## Software aus tar.gz installieren

Eine `.tar.gz`-Datei kann verschiedene Inhalte haben:

1. **Quellcode** → muss kompiliert werden
2. **Kompilierte Binaries** → nur entpacken und ausführen
3. **Paket für Distribution** → mit Paketmanager installieren

### Archiv entpacken und untersuchen

```bash
tar -xvzf paket.tar.gz
cd paket
ls -la
```

Prüfe immer `README`, `INSTALL` oder `INSTALL.txt`:

```bash
cat README
cat INSTALL
```

### Installation aus Quellcode

**Voraussetzungen installieren:**

Debian/Ubuntu:
```bash
sudo apt install build-essential
```

Fedora:
```bash
sudo dnf groupinstall "Development Tools"
```

**Standard-Kompilierung (autotools):**
```bash
./configure
make
sudo make install
```

**CMake-basierte Projekte:**
```bash
mkdir build
cd build
cmake ..
make
sudo make install
```

### Installation von fertigen Binaries

Wenn das Archiv fertige Programme enthält:

```bash
chmod +x programmname
./programmname
```

Permanent installieren nach `/usr/local/bin`:

```bash
sudo cp programmname /usr/local/bin/
```

Oder nach `~/.local/bin` (ohne sudo):

```bash
mkdir -p ~/.local/bin
cp programmname ~/.local/bin/
```

Stelle sicher, dass `~/.local/bin` im PATH ist:

```bash
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
```

### Deinstallation

Bei selbst kompilierten Programmen:

```bash
cd paket/
sudo make uninstall
```

Falls `make uninstall` nicht verfügbar ist:

**Mit checkinstall (empfohlen):**
```bash
sudo apt install checkinstall  # Debian/Ubuntu

# Statt "sudo make install"
sudo checkinstall

# Später deinstallieren wie normales Paket
sudo apt remove paketname
```

**Manuell:**
```bash
# Liste der installierten Dateien erstellen
sudo make install > install.log 2>&1

# Zum Deinstallieren Dateien aus log löschen
```

### Beispiel-Workflow

```bash
# 1. Entpacken
tar -xzf programm-1.0.tar.gz
cd programm-1.0

# 2. Dokumentation lesen
cat README
cat INSTALL

# 3. Konfigurieren und kompilieren
./configure --prefix=/usr/local
make

# 4. Optional: Tests ausführen
make check

# 5. Installieren
sudo make install

# 6. Testen
which programmname
programmname --version
```

### Typische Verzeichnisse

Nach `make install` werden Dateien meist hier installiert:

- `/usr/local/bin/` - Programme
- `/usr/local/lib/` - Bibliotheken
- `/usr/local/share/` - Daten/Dokumentation
- `/usr/local/etc/` - Konfiguration

## Siehe auch

- [[IT-Know-How/Linux/BASH Basics/rsync]] - Alternative für Backups
- [[IT-Know-How/Linux/BASH Basics/find]] - Dateien für Archivierung finden
- [[IT-Know-How/Linux/BASH Basics/grep]] - Archiv-Inhalte durchsuchen
- [[IT-Know-How/Linux/BASH Basics/Dateiberechtigungen]] - Rechte in Archiven bewahren
- [[IT-Know-How/Linux/BASH Basics/ls]] - Archive anzeigen