Wie man die Hosts-Datei in Linux bearbeitet: Vollständige technische Anleitung

Die `/etc/hosts` Datei in Linux ist eine statische Nachschlagetabelle, die Hostnamen IP-Adressen zuordnet und vom Betriebssystem *vor* jeder DNS-Abfrage verarbeitet wird. Durch das Hinzufügen oder Ändern von Einträgen in dieser Datei können Sie die DNS-Auflösung für bestimmte Domains auf einzelnen Maschinen überschreiben — ohne Ihren DNS-Server, Router oder Registrar-Einstellungen zu ändern.

Dieser Mechanismus wird durch den Name Service Switch (NSS) gesteuert, der in `/etc/nsswitch.conf` konfiguriert ist. Die Standard-`hosts:`-Zeile lautet typischerweise `files dns`, was bedeutet, dass das System zuerst `/etc/hosts` konsultiert und dann auf DNS-Resolver zurückgreift, die in `/etc/resolv.conf` definiert sind. Das Verständnis dieser Reihenfolge ist entscheidend: Wenn ein Hostname in `/etc/hosts` vorhanden ist, verlässt die DNS-Abfrage die Maschine nie.

Was die Hosts-Datei ist und wie sie funktioniert

Die `/etc/hosts`-Datei ist älter als das moderne DNS-System. In der frühen ARPANET-Ära wurde eine einzige `HOSTS.TXT`-Datei, die vom Stanford Research Institute gepflegt wurde, an jede vernetzte Maschine verteilt. Das heutige `/etc/hosts` ist ein direkter Nachkomme dieses Konzepts — eine lokale, autoritative Überschreibungsschicht, die jedes POSIX-konforme Betriebssystem noch immer berücksichtigt.

Jede Nicht-Kommentar-Zeile in der Datei folgt dieser Syntax:

“`

IP_address canonical_hostname [alias1] [alias2] …

“`

• Zeilen, die mit `#` beginnen, sind Kommentare und werden ignoriert.
• Leerzeichen (Leerzeichen oder Tabulatoren) trennen Felder.
• Eine einzelne IP-Adresse kann mehreren Hostnamen in derselben Zeile zugeordnet werden.
• IPv4- und IPv6-Einträge koexistieren in derselben Datei.

Eine minimale Standard-`/etc/hosts` bei einer frischen Linux-Installation sieht so aus:

“`

127.0.0.1 localhost

127.0.1.1 myhostname.local myhostname

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

“`

Der `127.0.1.1`-Eintrag ist Debian/Ubuntu-spezifisch und ordnet den FQDN der Maschine einer Loopback-Adresse zu, wenn keine statische IP zugewiesen ist. Das Entfernen kann Tools wie `sudo` beschädigen, die auf Hostnamen-Auflösung angewiesen sind.

Warum Sie die Hosts-Datei bearbeiten würden

Die Anwendungsfälle reichen von einfacher Entwicklerfreundlichkeit bis hin zu sicherheitskritischen Infrastrukturaufgaben:

Lokale Entwicklungs- und Staging-Umgebungen

Leiten Sie eine Produktionsdomain (z. B. `myapp.com`) zu `127.0.0.1` oder einer LAN-IP um, während Sie entwickeln oder testen, ohne Live-DNS-Einträge zu ändern. Dies ist der häufigste Anwendungsfall für Entwickler, die eine VPS Hosting-Umgebung lokal oder auf einem Remote-Server betreiben.

Multi-Server-Anwendungstests

Wenn Sie eine Website auf einen neuen Server migrieren, leiten Sie die Domain nur auf Ihrem lokalen Rechner auf die IP des neuen Servers um. Sie können überprüfen, ob die neue Umgebung vollständig funktionsfähig ist, bevor Sie den öffentlichen DNS-Eintrag aktualisieren — und so das Risiko von Ausfallzeiten eliminieren.

Blockieren von bösartigen oder unerwünschten Domains

Das Umleiten einer Domain zu `0.0.0.0` (gegenüber `127.0.0.1` zum Blockieren bevorzugt) führt dazu, dass die Verbindung sofort fehlschlägt, ohne auf eine abgelehnte Verbindung auf localhost zu warten. Projekte wie `StevenBlack/hosts` aggregieren Millionen von Werbe-, Tracker- und Malware-Domains in einer einzigen Blockliste im Hosts-Format.

Container- und Microservice-Netzwerke

In Docker- oder LXC-Umgebungen ohne benutzerdefinierten DNS-Resolver bieten `/etc/hosts`-Einträge innerhalb von Containern (oder auf dem Host) eine leichtgewichtige Service-Erkennung. Dockers `–add-host`-Flag injiziert Einträge direkt in die `/etc/hosts` eines Containers zur Laufzeit.

Überschreiben von Split-Horizon-DNS

In Unternehmensnetzwerken, in denen internes und externes DNS unterschiedliche Einträge für denselben Hostnamen zurückgeben, gibt Ihnen ein Hosts-Datei-Eintrag deterministische Kontrolle auf einer bestimmten Maschine.

Tests zur SSL-Zertifikatsvalidierung

Beim Testen einer neuen SSL Certificates-Bereitstellung auf einem Staging-Server können Sie durch das Zeigen der Domain auf die Staging-IP in `/etc/hosts` den vollständigen TLS-Handshake, die Zertifikatskette und das HTTPS-Umleitungsverhalten vor dem Go-Live überprüfen.

Schritt für Schritt: So bearbeiten Sie die Hosts-Datei in Linux

Schritt 1: Terminal öffnen

Öffnen Sie einen Terminal-Emulator. Bei Desktop-Distributionen funktioniert die Tastenkombination `Ctrl + Alt + T` unter GNOME, KDE und XFCE. Auf einem headless Server befinden Sie sich bereits in einer Shell-Sitzung über SSH.

Bestätigen Sie Ihren aktuellen Benutzer und Berechtigungsgrad:

“`bash

whoami

id

“`

Schritt 2: Aktuelle Hosts-Datei sichern

Erstellen Sie immer eine zeitgestempelte Sicherung, bevor Sie eine Systemdatei ändern. Eine generische `hosts.backup` kann versehentlich überschrieben werden; ein Zeitstempel ist eindeutig:

“`bash

sudo cp /etc/hosts /etc/hosts.bak.$(date +%Y%m%d_%H%M%S)

“`

Überprüfen Sie, ob die Sicherung erstellt wurde:

“`bash

ls -lh /etc/hosts*

“`

Schritt 3: Dateiberechtigungen und Eigentümerschaft prüfen

Bestätigen Sie vor der Bearbeitung die aktuelle Eigentümerschaft und Berechtigungen der Datei:

“`bash

ls -la /etc/hosts

“`

Erwartete Ausgabe:

“`

-rw-r–r– 1 root root 221 Jan 10 09:00 /etc/hosts

“`

Die Datei sollte `root:root` gehören mit Berechtigungen `644`. Wenn die Berechtigungen abweichen, untersuchen Sie dies, bevor Sie fortfahren — eine weltweit beschreibbare `/etc/hosts` ist eine Sicherheitslücke.

Schritt 4: Hosts-Datei mit einem Texteditor öffnen

Mit nano (für die meisten Benutzer empfohlen):

“`bash

sudo nano /etc/hosts

“`

Mit vim:

“`bash

sudo vim /etc/hosts

“`

Mit gedit (GUI, GNOME-Desktop):

“`bash

sudo gedit /etc/hosts

“`

Mit tee für nicht-interaktive/geskriptete Ergänzungen (kein Editor erforderlich):

“`bash

echo "192.168.1.50 staging.myapp.com" | sudo tee -a /etc/hosts

“`

Das `-a`-Flag hängt an die Datei an, anstatt sie zu überschreiben. Dies ist die sicherste Methode für Automatisierungsskripte und Ansible-Playbooks.

Schritt 5: Einträge hinzufügen, ändern oder entfernen

Navigieren Sie zum Ende der Datei und fügen Sie Ihre Einträge hinzu. Befolgen Sie diese Formatierungsregeln strikt:

• Ein Eintrag pro Zeile.
• IP-Adresse zuerst, dann ein oder mehrere Hostnamen, getrennt durch Leerzeichen.
• Verwenden Sie `#` inline, um Einträge für zukünftige Referenz zu kommentieren.

Domain auf einen lokalen Entwicklungsserver umleiten:

“`

127.0.0.1 myproject.local # Local dev – remove before production

“`

Domain auf einen Remote-Staging-Server zeigen:

“`

203.0.113.45 staging.myapp.com # Staging server – pre-DNS cutover

“`

Domain blockieren (bevorzugte Methode mit 0.0.0.0):

“`

0.0.0.0 ads.example.com

0.0.0.0 tracker.analytics-provider.com

“`

IPv6-Eintrag hinzufügen:

“`

::1 ipv6-service.local

“`

Mehrere Aliase einer IP zuordnen (nützlich für virtuelle Hosts):

“`

127.0.0.1 app.local api.local static.local

“`

Schritt 6: Editor speichern und beenden

In nano:

• Speichern: `Ctrl + O`, dann `Enter` zur Bestätigung des Dateinamens.
• Beenden: `Ctrl + X`.

In vim:

• Zum Normalmodus zurückkehren: `Esc`
• Speichern und beenden: `:wq` dann `Enter`
• Beenden ohne Speichern: `:q!` dann `Enter`

Schritt 7: Dateiinhalt überprüfen

Bestätigen Sie, dass Ihre Einträge korrekt geschrieben wurden:

“`bash

cat /etc/hosts

“`

Für große Hosts-Dateien verwenden Sie `grep`, um bestimmte Einträge zu finden:

“`bash

grep "myproject.local" /etc/hosts

“`

Prüfen Sie auf Syntaxfehler — ein Eintrag mit fehlender IP oder fehlerhafter Adresse wird vom Resolver stillschweigend ignoriert:

“`bash

sudo python3 -c "

with open('/etc/hosts') as f:

for i, line in enumerate(f, 1):

line = line.strip()

if line and not line.startswith('#'):

parts = line.split()

if len(parts) < 2:

print(f'Line {i} may be malformed: {line}')

"

“`

Schritt 8: DNS-Cache leeren

Änderungen an `/etc/hosts` werden auf den meisten Systemen sofort für neue Verbindungen wirksam. Wenn Ihr System jedoch einen lokalen DNS-Caching-Daemon ausführt, müssen Sie dessen Cache leeren, um die Änderungen zu sehen.

systemd-resolved (Ubuntu 18.04+, die meisten modernen Distributionen):

“`bash

sudo systemd-resolve –flush-caches

sudo systemd-resolve –statistics # Verify cache was cleared

“`

nscd (Name Service Cache Daemon):

“`bash

sudo systemctl restart nscd

“`

dnsmasq:

“`bash

sudo systemctl restart dnsmasq

“`

NetworkManager mit dnsmasq-Plugin:

“`bash

sudo systemctl restart NetworkManager

“`

Browser pflegen ihren eigenen DNS-Cache unabhängig. Chrome und Firefox cachen DNS-Einträge bis zu 60 Sekunden. Um Chromes internen DNS-Cache zu leeren, navigieren Sie zu `chrome://net-internals/#dns` und klicken Sie auf „Clear host cache”.

Schritt 9: Auflösung testen

Verwenden Sie `getent` anstelle von `ping` für einen zuverlässigeren Test der NSS-Auflösungskette:

“`bash

getent hosts myproject.local

“`

`getent` fragt den Name Service Switch des Systems direkt ab, berücksichtigt `/etc/nsswitch.conf` und zeigt Ihnen genau, was das Betriebssystem auflöst — nicht was ein DNS-Server zurückgibt. Dies ist der definitive Test.

Zusätzlich:

“`bash

ping -c 3 myproject.local

“`

“`bash

curl -v http://myproject.local

“`

Wenn `getent` die richtige IP zurückgibt, `ping` jedoch nicht, liegt das Problem im Netzwerk-Stack oder in der Firewall, nicht in der Hosts-Datei.

Hosts-Datei vs. DNS: Wann welches verwenden

Für Teams, die mehrere Server verwalten — wie eine Flotte von Dedicated Servers — ist zentralisiertes DNS-Management immer überlegen gegenüber der manuellen Verteilung von Hosts-Datei-Änderungen. Die Hosts-Datei ist ein Werkzeug pro Maschine, kein Infrastrukturwerkzeug.

Fortgeschrittene Techniken und Sonderfälle

Verwendung der Hosts-Datei mit virtuellen Hosts in Apache und Nginx

Wenn Sie mehrere Websites auf einem einzigen Server mit virtuellem Hosting betreiben, muss die Hosts-Datei auf Ihrer *Client-Maschine* die Domain auf die IP des Servers zeigen. Der Webserver verwendet dann den `Host:` HTTP-Header, um die Anfrage an den richtigen virtuellen Host weiterzuleiten. Der Hosts-Datei-Eintrag und die virtuelle Host-Konfiguration des Servers müssen denselben Hostnamen verwenden.

Wenn Sie beispielsweise einen Apache-Virtual-Host für `myapp.local` auf einem VPS mit cPanel konfiguriert haben, fügen Sie die IP des Servers zu Ihrer lokalen Hosts-Datei hinzu:

“`

198.51.100.10 myapp.local

“`

Greifen Sie dann in Ihrem Browser auf `http://myapp.local` zu. Apache liest den `Host: myapp.local`-Header und liefert die richtige Website.

Schutz der Hosts-Datei vor unbefugter Änderung

Malware zielt häufig auf `/etc/hosts` ab, um legitime Domains (z. B. Banking-Websites) auf Phishing-Server umzuleiten. Verwenden Sie `chattr`, um die Datei unveränderlich zu machen:

“`bash

sudo chattr +i /etc/hosts

“`

Dies verhindert Änderungen selbst durch root, bis das unveränderliche Flag explizit entfernt wird:

“`bash

sudo chattr -i /etc/hosts # Remove immutability to edit

“`

Attribut prüfen:

“`bash

lsattr /etc/hosts

“`

Versionskontrolle Ihrer Hosts-Datei

Für Teams oder komplexe Entwicklungsumgebungen verfolgen Sie `/etc/hosts`-Änderungen mit Git:

“`bash

sudo cp /etc/hosts ~/dotfiles/hosts

cd ~/dotfiles && git add hosts && git commit -m "Add staging.myapp.com entry"

“`

Tools wie etckeeper versionieren automatisch das gesamte `/etc`-Verzeichnis mit Git oder anderen VCS-Backends und bieten einen vollständigen Prüfpfad für Systemdateiänderungen.

Hosts-Datei in Docker und Kubernetes

In Docker können Sie Hosts-Datei-Einträge beim Container-Start injizieren, ohne das Host-System zu ändern:

“`bash

docker run –add-host=myservice.local:192.168.1.100 myimage

“`

In Kubernetes erreicht `hostAliases` in einer Pod-Spezifikation dasselbe Ergebnis:

“`yaml

spec:

hostAliases:

• ip: "192.168.1.100"

hostnames:

• "myservice.local"

“`

Diese Ansätze sind vorzuziehen gegenüber der Änderung der `/etc/hosts` des Hosts bei der Arbeit in containerisierten Umgebungen.

Die `0.0.0.0` vs. `127.0.0.1` Blockier-Debatte

Beide Adressen werden zum Blockieren von Domains verwendet, verhalten sich jedoch unterschiedlich:

• `127.0.0.1`: Leitet die Verbindung zur lokalen Loopback-Schnittstelle. Wenn lokal nichts auf Port 80/443 lauscht, wird die Verbindung abgelehnt — aber das Betriebssystem versucht dennoch, sie herzustellen, was zu einer kurzen Verzögerung führt.
• `0.0.0.0`: Stellt auf den meisten Systemen ein ungültiges Ziel dar. Die Verbindung schlägt sofort fehl, ohne einen TCP-Handshake zu versuchen, was zu schnelleren Seitenladezeiten beim Blockieren einer großen Anzahl von Werbe-/Tracker-Domains führt.

Für Blocklisten-Anwendungsfälle ist `0.0.0.0` die technisch überlegene Wahl.

Häufige Fehler und Fehlerbehebung

Änderungen treten nach der Bearbeitung nicht in Kraft:

• Bestätigen Sie, dass der Eintrag syntaktisch korrekt ist (IP zuerst, dann Hostname).
• Leeren Sie den lokalen DNS-Cache (siehe Schritt 8).
• Überprüfen Sie `/etc/nsswitch.conf` — wenn `dns` vor `files` in der `hosts:`-Zeile erscheint, wird DNS zuerst abgefragt und die Hosts-Datei für gecachte Einträge umgangen.

`sudo: unable to resolve host`-Fehler nach der Bearbeitung:

• Sie haben wahrscheinlich die Zeile entfernt oder beschädigt, die den Hostnamen Ihrer Maschine `127.0.1.1` oder `127.0.0.1` zuordnet. Stellen Sie die Sicherung sofort wieder her: `sudo cp /etc/hosts.bak.TIMESTAMP /etc/hosts`.

Eintrag wird für eine bestimmte Anwendung ignoriert:

• Einige Anwendungen (insbesondere solche, die `getaddrinfo` mit benutzerdefinierten NSS-Konfigurationen verwenden, oder solche mit statisch verlinkten Resolvern) umgehen `/etc/nsswitch.conf` vollständig und fragen DNS direkt ab. Dies ist häufig bei Go-Binärdateien, die mit deaktiviertem CGO kompiliert wurden. Überprüfen Sie mit `strace -e trace=network yourapp`.

Hosts-Datei funktioniert lokal, aber nicht in einem Docker-Container:

• Container-Netzwerke sind isoliert. Der Container hat seine eigene `/etc/hosts`. Verwenden Sie `–add-host` oder `hostAliases` wie oben beschrieben.

Wichtige technische Erkenntnisse: Entscheidungs-Checkliste

Bevor Sie `/etc/hosts` bearbeiten, gehen Sie diese Checkliste durch:

• Geltungsbereichsprüfung: Wird diese Änderung nur auf einer Maschine benötigt? Wenn mehrere Maschinen sie benötigen, verwenden Sie DNS oder ein Tool wie Ansible, um die Änderung zu verteilen.
• Zuerst sichern: Erstellen Sie immer eine zeitgestempelte Sicherung (`hosts.bak.YYYYMMDD_HHMMSS`) vor jeder Bearbeitung.
• Verwenden Sie `0.0.0.0` zum Blockieren: Schnellerer Fehler, kein Loopback-Overhead.
• Den richtigen Cache leeren: Identifizieren Sie, ob Ihr System `systemd-resolved`, `nscd` oder `dnsmasq` verwendet, bevor Sie den falschen Dienst neu starten.
• Mit `getent` testen: Zuverlässiger als `ping` zur Bestätigung der NSS-Auflösung.
• Datei schützen: Verwenden Sie `chattr +i` auf Produktions- oder sicherheitssensiblen Systemen.
• Einträge dokumentieren: Fügen Sie jedem Nicht-Standard-Eintrag Inline-Kommentare (`# reason – added YYYY-MM-DD`) hinzu.
• Temporäre Einträge entfernen: Entwicklungs-/Test-Einträge, die in Produktions-Hosts-Dateien verbleiben, sind eine häufige Quelle schwer zu diagnostizierender Routing-Fehler.

Wenn Sie einen Entwicklungs-Workflow über mehrere Umgebungen hinweg verwalten, erwägen Sie, das lokale Hosts-Datei-Management mit einem ordnungsgemäß konfigurierten VPS Control Panels-Setup zu kombinieren, um das virtuelle Host-Management zu zentralisieren und die Konfigurationsabweichung pro Maschine zu reduzieren.

Für Projekte, die Domain Registration und stufenweise Rollouts beinhalten, bleibt die Hosts-Datei die zuverlässigste Methode, um einen vollständigen End-to-End-Test einer neuen Serverkonfiguration durchzuführen, bevor die DNS-Propagierung abgeschlossen ist — und gibt Ihnen ein risikofreies Validierungsfenster, bevor die Öffentlichkeit eine Änderung sieht.

FAQ

Erfordert die Bearbeitung von `/etc/hosts` einen Systemneustart?

Nein. Änderungen an `/etc/hosts` werden sofort für neue Verbindungen wirksam. Wenn Sie einen lokalen DNS-Caching-Daemon haben (`systemd-resolved`, `nscd` oder `dnsmasq`), müssen Sie dessen Cache leeren. Browser pflegen auch unabhängige DNS-Caches, die möglicherweise manuell geleert werden müssen.

Warum funktioniert mein Hosts-Datei-Eintrag im Terminal, aber nicht in meinem Browser?

Browser cachen DNS-Einträge unabhängig vom OS-Resolver. Chrome cached Einträge bis zu 60 Sekunden. Navigieren Sie zu `chrome://net-internals/#dns` und leeren Sie den Host-Cache, oder warten Sie, bis die TTL abläuft.

Kann ich Wildcards in `/etc/hosts` verwenden?

Nein. Die `/etc/hosts`-Datei unterstützt keine Wildcard-Einträge. Jeder Hostname muss explizit aufgelistet werden. Wenn Sie Wildcard-Auflösung benötigen (z. B. `*.local`), verwenden Sie einen lokalen DNS-Resolver wie `dnsmasq` oder `unbound`.

Was ist die maximale Anzahl von Einträgen in `/etc/hosts`?

Es gibt kein fest codiertes Limit, das vom Kernel oder glibc erzwungen wird. Die Leistung verschlechtert sich jedoch bei sehr großen Dateien, da die Datei für jede Suche linear geparst wird. Dateien mit Zehntausenden von Einträgen (häufig bei Ad-Blocking-Listen) können messbare Latenz bei der Hostnamen-Auflösung hinzufügen. Für große Blocklisten ist ein dediziertes DNS-Sinkhole wie Pi-hole effizienter.

Ist es sicher, die Standardeinträge in `/etc/hosts` zu löschen?

Nein. Die Standardeinträge (`127.0.0.1 localhost`, `::1 localhost` und die Hostnamen-Zuordnung der eigenen Maschine) sind für den korrekten Systembetrieb erforderlich. Das Entfernen kann `sudo`, lokale Socket-Verbindungen und Anwendungen, die auf Loopback-Auflösung angewiesen sind, beschädigen. Fügen Sie nur Einträge hinzu oder ändern Sie sie; entfernen Sie niemals die Standardeinträge ohne einen spezifischen, gut verstandenen Grund.