Cum să editezi fișierul Hosts în Linux: Ghid tehnic complet

Fișierul `/etc/hosts` în Linux este un tabel de căutare static care mapează numele de gazdă la adrese IP, procesat de sistemul de operare *înainte* de a fi trimisă orice interogare DNS. Prin adăugarea sau modificarea intrărilor din acest fișier, puteți suprascrie rezoluția DNS pentru domenii specifice pe bază per-mașină — fără a modifica serverul DNS, routerul sau setările registrarului.

Acest mecanism este controlat de Name Service Switch (NSS), configurat în `/etc/nsswitch.conf`. Linia implicită `hosts:` citește de obicei `files dns`, ceea ce înseamnă că sistemul consultă mai întâi `/etc/hosts`, apoi recurge la rezolvoarele DNS definite în `/etc/resolv.conf`. Înțelegerea acestei ordini este esențială: dacă un nume de gazdă există în `/etc/hosts`, interogarea DNS nu părăsește niciodată mașina.

Ce este fișierul Hosts și cum funcționează

Fișierul `/etc/hosts` precede în întregime sistemul DNS modern. În era timpurie ARPANET, un singur fișier `HOSTS.TXT` întreținut de Stanford Research Institute era distribuit fiecărei mașini conectate la rețea. `/etc/hosts` de astăzi este un descendent direct al acelui concept — un strat de suprascriere local și autoritar pe care orice sistem de operare conform POSIX îl respectă în continuare.

Fiecare linie care nu este comentariu din fișier urmează această sintaxă:

“`

IP_address canonical_hostname [alias1] [alias2] …

“`

• Liniile care încep cu `#` sunt comentarii și sunt ignorate.
• Spațiile albe (spații sau taburi) separă câmpurile.
• O singură adresă IP poate fi mapată la mai multe nume de gazdă pe aceeași linie.
• Intrările IPv4 și IPv6 coexistă în același fișier.

Un fișier `/etc/hosts` implicit minimal pe o instalare Linux proaspătă arată astfel:

“`

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

“`

Intrarea `127.0.1.1` este specifică Debian/Ubuntu și mapează FQDN-ul mașinii la o adresă de loopback când nu este atribuită o adresă IP statică. Eliminarea acesteia poate defecta instrumente precum `sudo` care se bazează pe rezoluția numelui de gazdă.

De ce ați edita fișierul Hosts

Cazurile de utilizare variază de la simpla comoditate pentru dezvoltatori până la sarcini de infrastructură critice pentru securitate:

Medii locale de dezvoltare și staging

Direcționați un domeniu de producție (ex., `myapp.com`) către `127.0.0.1` sau un IP LAN în timp ce construiți sau testați, fără a modifica înregistrările DNS live. Acesta este cel mai frecvent caz de utilizare pentru dezvoltatorii care rulează un mediu de VPS Hosting local sau pe un server la distanță.

Testarea aplicațiilor multi-server

La migrarea unui site pe un server nou, direcționați domeniul către IP-ul noului server doar pe mașina dvs. locală. Puteți verifica că noul mediu este complet funcțional înainte de a actualiza înregistrarea DNS publică — eliminând riscul de întrerupere a serviciului.

Blocarea domeniilor malițioase sau nedorite

Redirecționarea unui domeniu către `0.0.0.0` (preferată față de `127.0.0.1` pentru blocare) face ca conexiunea să eșueze imediat fără a aștepta o conexiune refuzată pe localhost. Proiecte precum `StevenBlack/hosts` agregă milioane de domenii de reclame, trackere și malware într-o singură listă de blocare în format hosts.

Rețele de containere și microservicii

În mediile Docker sau LXC fără un rezolvator DNS personalizat, intrările `/etc/hosts` din interiorul containerelor (sau pe gazdă) oferă descoperire ușoară a serviciilor. Flag-ul `–add-host` al Docker injectează intrări direct în `/etc/hosts` unui container la runtime.

Suprascrierea DNS split-horizon

În rețelele corporative unde DNS-ul intern și cel extern returnează înregistrări diferite pentru același nume de gazdă, o intrare în fișierul hosts vă oferă control determinist pe o mașină specifică.

Testarea validării certificatelor SSL

La testarea unui deployment nou de Certificate SSL pe un server de staging, direcționarea domeniului către IP-ul de staging în `/etc/hosts` vă permite să verificați handshake-ul TLS complet, lanțul de certificate și comportamentul redirecționării HTTPS înainte de lansare.

Pas cu pas: Cum să editați fișierul Hosts în Linux

Pasul 1: Deschideți un Terminal

Accesați un emulator de terminal. Pe distribuțiile desktop, comanda rapidă `Ctrl + Alt + T` funcționează pe GNOME, KDE și XFCE. Pe un server fără interfață grafică, vă aflați deja într-o sesiune shell prin SSH.

Confirmați utilizatorul curent și nivelul de privilegii:

“`bash

whoami

id

“`

Pasul 2: Faceți o copie de rezervă a fișierului Hosts curent

Creați întotdeauna o copie de rezervă cu marcaj de timp înainte de a modifica orice fișier de sistem. Un `hosts.backup` generic poate fi suprascris accidental; un marcaj de timp este neambiguu:

“`bash

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

“`

Verificați că copia de rezervă a fost creată:

“`bash

ls -lh /etc/hosts*

“`

Pasul 3: Verificați permisiunile și proprietatea fișierului

Înainte de editare, confirmați proprietatea și permisiunile curente ale fișierului:

“`bash

ls -la /etc/hosts

“`

Rezultat așteptat:

“`

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

“`

Fișierul ar trebui să fie deținut de `root:root` cu permisiunile `644`. Dacă permisiunile diferă, investigați înainte de a continua — un `/etc/hosts` cu scriere pentru toți este o vulnerabilitate de securitate.

Pasul 4: Deschideți fișierul Hosts cu un editor de text

Folosind nano (recomandat pentru majoritatea utilizatorilor):

“`bash

sudo nano /etc/hosts

“`

Folosind vim:

“`bash

sudo vim /etc/hosts

“`

Folosind gedit (GUI, desktop GNOME):

“`bash

sudo gedit /etc/hosts

“`

Folosind tee pentru adăugări neinteractive/scriptate (nu este necesar un editor):

“`bash

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

“`

Flag-ul `-a` adaugă la fișier în loc să îl suprascrie. Aceasta este cea mai sigură metodă pentru scripturile de automatizare și playbook-urile Ansible.

Pasul 5: Adăugați, modificați sau eliminați intrări

Navigați la sfârșitul fișierului și adăugați intrările dvs. Respectați strict aceste reguli de formatare:

• O intrare pe linie.
• Adresa IP mai întâi, apoi unul sau mai multe nume de gazdă separate prin spații albe.
• Folosiți `#` inline pentru a adnota intrările pentru referință viitoare.

Redirecționați un domeniu către un server local de dezvoltare:

“`

127.0.0.1 myproject.local # Local dev – remove before production

“`

Direcționați un domeniu către un server de staging la distanță:

“`

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

“`

Blocați un domeniu (metodă preferată folosind 0.0.0.0):

“`

0.0.0.0 ads.example.com

0.0.0.0 tracker.analytics-provider.com

“`

Adăugați o intrare IPv6:

“`

::1 ipv6-service.local

“`

Mapați mai multe aliasuri la un singur IP (util pentru gazde virtuale):

“`

127.0.0.1 app.local api.local static.local

“`

Pasul 6: Salvați și ieșiți din editor

În nano:

• Salvați: `Ctrl + O`, apoi `Enter` pentru a confirma numele fișierului.
• Ieșiți: `Ctrl + X`.

În vim:

• Reveniți la modul normal: `Esc`
• Salvați și ieșiți: `:wq` apoi `Enter`
• Ieșiți fără a salva: `:q!` apoi `Enter`

Pasul 7: Verificați conținutul fișierului

Confirmați că intrările dvs. au fost scrise corect:

“`bash

cat /etc/hosts

“`

Pentru fișiere hosts mari, folosiți `grep` pentru a găsi intrări specifice:

“`bash

grep "myproject.local" /etc/hosts

“`

Verificați erorile de sintaxă — o intrare cu un IP lipsă sau o adresă malformată va fi ignorată silențios de rezolvator:

“`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}')

"

“`

Pasul 8: Goliți cache-ul DNS

Modificările aduse fișierului `/etc/hosts` intră în vigoare imediat pentru conexiunile noi pe majoritatea sistemelor. Cu toate acestea, dacă sistemul dvs. rulează un daemon local de cache DNS, trebuie să goliți cache-ul acestuia pentru a vedea modificările.

systemd-resolved (Ubuntu 18.04+, majoritatea distribuțiilor moderne):

“`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 cu plugin-ul dnsmasq:

“`bash

sudo systemctl restart NetworkManager

“`

Browserele își mențin propriul cache DNS independent. Chrome și Firefox stochează înregistrările DNS timp de până la 60 de secunde. Pentru a șterge cache-ul DNS intern al Chrome, navigați la `chrome://net-internals/#dns` și faceți clic pe „Clear host cache.”

Pasul 9: Testați rezoluția

Folosiți `getent` în loc de `ping` pentru un test mai fiabil al lanțului de rezoluție NSS:

“`bash

getent hosts myproject.local

“`

`getent` interogează direct Name Service Switch al sistemului, respectând `/etc/nsswitch.conf`, și vă va arăta exact ce rezolvă sistemul de operare — nu ce returnează un server DNS. Acesta este testul definitiv.

Suplimentar:

“`bash

ping -c 3 myproject.local

“`

“`bash

curl -v http://myproject.local

“`

Dacă `getent` returnează IP-ul corect, dar `ping` nu, problema se află în stiva de rețea sau firewall, nu în fișierul hosts.

Fișierul Hosts vs. DNS: Când să folosiți fiecare

Pentru echipele care gestionează mai multe servere — cum ar fi o flotă de Servere Dedicate — gestionarea centralizată a DNS este întotdeauna superioară distribuirii manuale a modificărilor fișierului hosts. Fișierul hosts este un instrument per-mașină, nu un instrument de infrastructură.

Tehnici avansate și cazuri limită

Utilizarea fișierului Hosts cu gazde virtuale în Apache și Nginx

Când rulați mai multe site-uri web pe un singur server folosind găzduire virtuală, fișierul hosts de pe *mașina client* trebuie să direcționeze domeniul către IP-ul serverului. Serverul web folosește apoi antetul HTTP `Host:` pentru a direcționa cererea către gazda virtuală corectă. Intrarea din fișierul hosts și configurația gazdei virtuale a serverului trebuie să folosească același nume de gazdă.

De exemplu, dacă aveți o gazdă virtuală Apache configurată pentru `myapp.local` pe un VPS cu cPanel, adăugați IP-ul serverului în fișierul hosts local:

“`

198.51.100.10 myapp.local

“`

Apoi accesați `http://myapp.local` în browserul dvs. Apache citește antetul `Host: myapp.local` și servește site-ul corect.

Protejarea fișierului Hosts împotriva modificărilor neautorizate

Programele malware vizează frecvent `/etc/hosts` pentru a redirecționa domenii legitime (ex., site-uri bancare) către servere de phishing. Folosiți `chattr` pentru a face fișierul imutabil:

“`bash

sudo chattr +i /etc/hosts

“`

Aceasta previne modificarea chiar și de către root până când flag-ul imutabil este eliminat explicit:

“`bash

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

“`

Verificați atributul:

“`bash

lsattr /etc/hosts

“`

Controlul versiunilor fișierului Hosts

Pentru echipe sau medii de dezvoltare complexe, urmăriți modificările `/etc/hosts` cu Git:

“`bash

sudo cp /etc/hosts ~/dotfiles/hosts

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

“`

Instrumente precum etckeeper versionează automat întregul director `/etc` folosind Git sau alte backend-uri VCS, oferind o urmă completă de audit a modificărilor fișierelor de sistem.

Fișierul Hosts în Docker și Kubernetes

În Docker, puteți injecta intrări din fișierul hosts la pornirea containerului fără a modifica sistemul gazdă:

“`bash

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

“`

În Kubernetes, `hostAliases` în specificația unui Pod obține același rezultat:

“`yaml

spec:

hostAliases:

• ip: "192.168.1.100"

hostnames:

• "myservice.local"

“`

Aceste abordări sunt preferabile modificării `/etc/hosts` gazdei atunci când lucrați în medii containerizate.

Dezbaterea blocării `0.0.0.0` vs. `127.0.0.1`

Ambele adrese sunt folosite pentru a bloca domenii, dar se comportă diferit:

• `127.0.0.1`: Direcționează conexiunea către interfața de loopback locală. Dacă nimic nu ascultă pe portul 80/443 local, conexiunea este refuzată — dar sistemul de operare încearcă totuși să o stabilească, cauzând o scurtă întârziere.
• `0.0.0.0`: Reprezintă o destinație invalidă pe majoritatea sistemelor. Conexiunea eșuează imediat fără a încerca un handshake TCP, rezultând în încărcări mai rapide ale paginilor la blocarea unui număr mare de domenii de reclame/trackere.

Pentru cazurile de utilizare cu liste de blocare, `0.0.0.0` este alegerea tehnic superioară.

Erori frecvente și depanare

Modificările nu intră în vigoare după editare:

• Confirmați că intrarea este corectă sintactic (IP mai întâi, apoi numele de gazdă).
• Goliți cache-ul DNS local (consultați Pasul 8).
• Verificați `/etc/nsswitch.conf` — dacă `dns` apare înaintea `files` în linia `hosts:`, DNS-ul este interogat primul și fișierul hosts este ocolit pentru intrările din cache.

Eroare `sudo: unable to resolve host` după editare:

• Probabil ați eliminat sau corupt linia care mapează numele de gazdă al mașinii dvs. la `127.0.1.1` sau `127.0.0.1`. Restaurați imediat copia de rezervă: `sudo cp /etc/hosts.bak.TIMESTAMP /etc/hosts`.

Intrarea este ignorată pentru o aplicație specifică:

• Unele aplicații (în special cele care folosesc `getaddrinfo` cu configurații NSS personalizate, sau cele cu rezolvoare legate static) ocolesc complet `/etc/nsswitch.conf` și interogează DNS direct. Acest lucru este frecvent în binarele Go compilate cu CGO dezactivat. Verificați cu `strace -e trace=network yourapp`.

Fișierul hosts funcționează local, dar nu într-un container Docker:

• Rețeaua containerului este izolată. Containerul are propriul `/etc/hosts`. Folosiți `–add-host` sau `hostAliases` după cum s-a descris mai sus.

Concluzii tehnice cheie: Listă de verificare pentru decizii

Înainte de a edita `/etc/hosts`, parcurgeți această listă de verificare:

• Verificarea domeniului de aplicare: Este această modificare necesară doar pe o singură mașină? Dacă mai multe mașini au nevoie de ea, folosiți DNS sau un instrument precum Ansible pentru a distribui modificarea.
• Copie de rezervă mai întâi: Creați întotdeauna o copie de rezervă cu marcaj de timp (`hosts.bak.YYYYMMDD_HHMMSS`) înainte de orice editare.
• Folosiți `0.0.0.0` pentru blocare: Eșec mai rapid, fără overhead de loopback.
• Goliți cache-ul potrivit: Identificați dacă sistemul dvs. folosește `systemd-resolved`, `nscd` sau `dnsmasq` înainte de a reporni serviciul greșit.
• Testați cu `getent`: Mai fiabil decât `ping` pentru confirmarea rezoluției NSS.
• Protejați fișierul: Folosiți `chattr +i` pe sistemele de producție sau sensibile la securitate.
• Documentați intrările dvs.: Adăugați comentarii inline (`# reason – added YYYY-MM-DD`) la fiecare intrare non-implicită.
• Eliminați intrările temporare: Intrările dev/test lăsate în fișierele hosts de producție sunt o sursă frecventă de erori de rutare greu de diagnosticat.

Dacă gestionați un flux de lucru de dezvoltare în mai multe medii, luați în considerare combinarea gestionării locale a fișierului hosts cu o configurare Panouri de Control VPS corect configurată pentru a centraliza gestionarea gazdelor virtuale și a reduce deriva de configurare per-mașină.

Pentru proiectele care implică Înregistrare Domenii și lansări etapizate, fișierul hosts rămâne cel mai fiabil mod de a efectua un test complet end-to-end al unei noi configurații de server înainte ca propagarea DNS să se finalizeze — oferindu-vă o fereastră de validare fără risc înainte ca publicul să vadă orice modificare.

Întrebări frecvente

Editarea fișierului `/etc/hosts` necesită o repornire a sistemului?

Nu. Modificările aduse fișierului `/etc/hosts` intră în vigoare imediat pentru conexiunile noi. Dacă aveți un daemon local de cache DNS (`systemd-resolved`, `nscd` sau `dnsmasq`), trebuie să goliți cache-ul acestuia. Browserele mențin, de asemenea, cache-uri DNS independente care poate fi necesar să fie șterse manual.

De ce intrarea din fișierul hosts funcționează în terminal, dar nu în browserul meu?

Browserele stochează înregistrările DNS independent de rezolvorul sistemului de operare. Chrome stochează înregistrările timp de până la 60 de secunde. Navigați la `chrome://net-internals/#dns` și ștergeți cache-ul gazdei, sau așteptați expirarea TTL-ului.

Pot folosi wildcarduri în `/etc/hosts`?

Nu. Fișierul `/etc/hosts` nu suportă intrări cu wildcarduri. Fiecare nume de gazdă trebuie listat explicit. Dacă aveți nevoie de rezoluție cu wildcarduri (ex., `*.local`), folosiți un rezolvator DNS local precum `dnsmasq` sau `unbound`.

Care este numărul maxim de intrări în `/etc/hosts`?

Nu există o limită codificată impusă de kernel sau glibc. Cu toate acestea, performanța se degradează cu fișiere foarte mari deoarece fișierul este analizat liniar pentru fiecare căutare. Fișierele cu zeci de mii de intrări (frecvente cu listele de blocare a reclamelor) pot adăuga latență măsurabilă la rezoluția numelor de gazdă. Pentru liste de blocare mari, un DNS sinkhole dedicat precum Pi-hole este mai eficient.

Este sigur să ștergeți intrările implicite din `/etc/hosts`?

Nu. Intrările implicite (`127.0.0.1 localhost`, `::1 localhost` și maparea numelui de gazdă al propriei mașini) sunt necesare pentru funcționarea corectă a sistemului. Eliminarea lor poate defecta `sudo`, conexiunile locale prin socket și aplicațiile care se bazează pe rezoluția loopback. Doar adăugați sau modificați intrări; nu eliminați niciodată valorile implicite fără un motiv specific, bine înțeles.