# ln — Hard- und Symlinks erstellen > Praxis-Guide zu ln: harte Links und symbolische Links (Symlinks) zu Dateien und Verzeichnissen anlegen, verwalten und den Unterschied verstehen. Source: https://www.jpkc.com/db/cheatsheets/files-text/ln/ ln legt Verknüpfungen zwischen Dateien an – entweder einen symbolischen Link (Symlink), der wie eine Verknüpfung auf einen Pfad zeigt, oder einen harten Link, bei dem mehrere Namen denselben Inode und damit dieselben Daten referenzieren. Die wichtigste Stolperfalle ist die Argument-Reihenfolge: Sie lautet immer `ln -s `, also zuerst das Ziel, dann der Name des neuen Links – wer das vertauscht, legt den Link am falschen Ort an. Dieser Guide zeigt dir Symlinks und Hardlinks, den entscheidenden Unterschied zwischen beiden sowie typische Muster wie atomare Deployments und Dotfile-Verwaltung. ## Symbolische Links (Soft Links) `ln -s ` — Erstellt einen symbolischen Link, der auf das Ziel zeigt. ```bash ln -s /var/log/syslog ~/syslog ``` `ln -s ` — Erstellt im aktuellen Verzeichnis einen Symlink mit demselben Namen wie das Ziel. ```bash ln -s /etc/nginx/nginx.conf ``` `ln -sf ` — Erstellt oder überschreibt einen symbolischen Link (force). ```bash ln -sf /usr/bin/python3.12 /usr/bin/python3 ``` `ln -sn ` — Dereferenziert den Link nicht, falls er ein Symlink auf ein Verzeichnis ist. Nützlich, um Verzeichnis-Symlinks zu ersetzen. ```bash ln -sfn /var/www/release-2.0 /var/www/current ``` `ln -s ` — Erstellt mehrere Symlinks in einem Zielverzeichnis. ```bash ln -s /opt/bin/app1 /opt/bin/app2 /usr/local/bin/ ``` ## Harte Links `ln ` — Erstellt einen harten Link. Beide Namen zeigen auf denselben Inode und dieselben Daten. ```bash ln important.txt important-backup.txt ``` `ln ` — Erstellt im aktuellen Verzeichnis einen harten Link mit demselben Namen. ```bash ln /data/shared-config.txt ``` `ln ` — Erstellt harte Links zu mehreren Dateien in einem Zielverzeichnis. ```bash ln file1.txt file2.txt /backup/ ``` `ln -f ` — Erzwingt die Erstellung, indem die vorhandene Zieldatei entfernt wird. ```bash ln -f newdata.txt data.txt ``` ## Harte Links vs. symbolische Links `ln ` — Harter Link: gleicher Inode, nur im selben Dateisystem, übersteht Umbenennen/Verschieben des Ziels. ```bash ln original.txt hardlink.txt ``` `ln -s ` — Symbolischer Link: eigener Inode, über Dateisystemgrenzen hinweg, wird ungültig, wenn das Ziel entfernt wird. ```bash ln -s original.txt symlink.txt ``` `ls -li ` — Zeigt die Inode-Nummer. Harte Links teilen sich denselben Inode wie ihr Ziel. ```bash ls -li original.txt hardlink.txt ``` `stat ` — Zeigt ausführliche Datei-Infos inklusive Inode und Anzahl harter Links. ```bash stat original.txt ``` ## Optionen `ln -v ` — Ausführlicher Modus. Gibt jeden erstellten Link aus. ```bash ln -sv /opt/app/config.yml ~/config.yml ``` `ln -i ` — Interaktiver Modus. Fragt vor dem Überschreiben vorhandener Dateien nach. ```bash ln -si /new/target existing-link ``` `ln -b ` — Legt vor dem Überschreiben ein Backup der vorhandenen Zieldatei an. ```bash ln -sb /new/target existing-link ``` `ln -S ` — Setzt die Backup-Endung (Standard: ~) bei Verwendung von -b. ```bash ln -sb -S .bak /new/target existing-link ``` `ln -r -s ` — Erstellt einen relativen statt eines absoluten symbolischen Links. ```bash ln -rs /var/www/shared/assets /var/www/app/assets ``` `ln -t -s ` — Gibt das Link-Verzeichnis mit -t explizit an. ```bash ln -t /usr/local/bin -s /opt/app/bin/tool ``` ## Links verwalten `readlink ` — Gibt das Ziel eines symbolischen Links aus. ```bash readlink /usr/bin/python3 ``` `readlink -f ` — Gibt den vollständig aufgelösten absoluten Pfad aus (folgt allen Symlinks). ```bash readlink -f /usr/bin/python ``` `ls -l ` — Zeigt das Symlink-Ziel im ausführlichen Listing (-> ziel). ```bash ls -l /usr/bin/python3 ``` `file ` — Zeigt, ob ein Pfad ein Symlink ist und wohin er zeigt. ```bash file /usr/bin/python3 ``` `unlink ` — Entfernt einen symbolischen oder harten Link (lässt das Ziel unberührt). ```bash unlink ~/syslog ``` `rm ` — Entfernt einen Link. Bei einzelnen Dateien wie unlink. ```bash rm ~/syslog ``` `find . -type l` — Findet alle symbolischen Links im aktuellen Verzeichnisbaum. ```bash find /etc -type l ``` `find . -xtype l` — Findet defekte symbolische Links (Ziel existiert nicht). ```bash find /usr/local/bin -xtype l ``` ## Häufige Muster `ln -sfn ` — Atomares Deployment: schaltet einen Symlink auf ein neues Release-Verzeichnis um. ```bash ln -sfn /var/www/releases/v2.1 /var/www/current ``` `ln -s /path/to/dotfile ~/.dotfile` — Dotfile-Verwaltung: verlinkt Konfigurationsdateien aus einem zentralen Repo. ```bash ln -s ~/dotfiles/.vimrc ~/.vimrc ``` `ln -s $(which ) /usr/local/bin/` — Erstellt einen Befehls-Alias per Symlink. ```bash ln -s $(which python3) /usr/local/bin/python ``` `for f in /*; do ln -s "$f" .; done` — Erstellt Symlinks zu allen Dateien in einem Verzeichnis. ```bash for f in /opt/config/*; do ln -s "$f" .; done ``` `ln -s /dev/null ` — Unterdrückt eine Datei, indem sie auf /dev/null zeigt (z. B. unerwünschte Logs). ```bash ln -sf /dev/null ~/.bash_history ``` `find . -type l ! -exec test -e {} \; -print` — Findet und listet alle defekten Symlinks auf. ```bash find /usr/local -type l ! -exec test -e {} \; -print ``` `find . -maxdepth 1 -type l -delete` — Entfernt alle Symlinks im aktuellen Verzeichnis (nicht rekursiv). ```bash find . -maxdepth 1 -type l -delete ``` ## Fazit ln ist klein, aber wirkungsvoll – wichtig ist, die beiden Link-Arten auseinanderzuhalten: Ein Symlink (`-s`) ist nur ein Verweis auf einen Pfad, funktioniert über Dateisystemgrenzen hinweg, wird aber ungültig, wenn das Ziel verschwindet; ein harter Link ist ein gleichwertiger zweiter Name für dieselben Daten, bleibt auch nach Umbenennen des Ziels gültig, ist aber auf ein Dateisystem beschränkt und für Verzeichnisse nicht erlaubt. Merke dir die Argument-Reihenfolge `ln -s ` und nutze `-sfn` für das atomare Umschalten von Verzeichnis-Symlinks (klassischer Deployment-Trick). Prüfe mit `ls -li` und `stat` Inode und Link-Anzahl, wenn du unsicher bist, was wohin zeigt. ## Weiterführende Links - [ubuntuusers-Wiki: ln](https://wiki.ubuntuusers.de/ln/) – deutschsprachige Erklärung von harten und symbolischen Links - [GNU coreutils: ln invocation](https://www.gnu.org/software/coreutils/manual/html_node/ln-invocation.html) – offizielle Referenz aller Optionen (englisch) ## Verwandte Kommandos - [cp](https://www.jpkc.com/db/cheatsheets/files-text/cp/) – Dateien und Verzeichnisse kopieren - [ls](https://www.jpkc.com/db/cheatsheets/files-text/ls/) – Verzeichnisinhalte und Inodes anzeigen - [stat](https://www.jpkc.com/db/cheatsheets/files-text/stat/) – ausführliche Datei- und Inode-Informationen anzeigen