Automount la scară cu autofs și systemd: NFS fără blocarea bootului

Un server de aplicații trebuie să vadă zeci de directoare de proiect și un depozit comun de proceduri, dar serverul NFS poate fi temporar indisponibil în timpul mentenanței. Dacă toate resursele sunt montate sincron la pornire, o problemă de rețea poate întârzia serviciile locale sau poate trimite sistemul în emergency mode.

Vom construi o configurație în care /mnt/projects/<nume> este administrat printr-o hartă wildcard autofs, iar /mnt/runbooks printr-o unitate nativă systemd.automount. Niciuna dintre resurse nu este contactată în timpul bootului: montarea NFS începe numai când un proces accesează calea. După 120 de secunde fără utilizare, montarea este eliberată automat.

Scenariul folosește două mașini proprii, într-un laborator administrativ:

• storage01, cu adresa exemplificativă 192.0.2.10, publică resursele NFS;
• app01, cu adresa exemplificativă 192.0.2.20, montează resursele la cerere;
• proiectele alpha și beta sunt accesibile sub /mnt/projects/;
• documentația operațională apare la /mnt/runbooks;
• un timer systemd verifică la fiecare cinci minute mecanismul de automount, fără să declanșeze montările NFS.

Adresele aparțin intervalului rezervat documentației. Într-o implementare reală, ele trebuie înlocuite consecvent cu adresele private ale celor două servere.

Fixăm laboratorul la Ubuntu Server 24.04 LTS și NFSv4

Configurația este destinată Ubuntu Server 24.04 LTS, cu autofs 5.1.9, nfs-utils 2.6.4 și systemd 255. Reviziile Ubuntu afișate de apt pot diferi după actualizările de securitate, dar versiunile majore și opțiunile folosite aici rămân cele din depozitele distribuției.

Resurse minime pentru laborator:

• două mașini virtuale cu Ubuntu Server 24.04 LTS;
• câte 1 GB RAM și 5 GB spațiu disponibil;
• conectivitate IP între cele două mașini;
• portul TCP 2049 permis de la app01 către storage01;
• acces administrativ prin sudo;
• aproximativ 45-60 de minute.

Pe ambele servere verificăm sistemul, systemd și rețeaua:

. /etc/os-release
printf 'Sistem: %s %sn' "$NAME" "$VERSION_ID"
systemctl --version | head -n 1
free -h
df -h /
ip -brief address

Exemplu de rezultat; memoria, discul și numele interfețelor vor diferi:

Sistem: Ubuntu 24.04
systemd 255 (255.4-1ubuntu8...)
               total        used        free
Mem:           1.9Gi       310Mi       1.2Gi
Filesystem      Size  Used Avail Use% Mounted on
/dev/vda2        20G  3.1G   16G  17% /
ens18            UP   192.0.2.10/24

Instalarea se face într-un singur bloc. Pe storage01 instalăm serverul NFS, iar pe app01 clientul NFS și autofs.

Pe storage01:

sudo apt update
sudo apt install --yes nfs-kernel-server
sudo exportfs --version

Pe app01:

sudo apt update
sudo apt install --yes autofs nfs-common
automount --version
mount.nfs --version
systemctl --version | head -n 1

Un rezultat compatibil arată astfel; sufixele pachetelor pot fi mai noi:

Linux automount version 5.1.9
mount.nfs: (linux nfs-utils 2.6.4)
systemd 255 (255.4-1ubuntu8...)

Punct de control: dacă distribuția sau versiunile majore sunt diferite, nu copia unitățile direct în producție; verifică mai întâi paginile locale man auto.master, man autofs, man systemd.automount și man systemd.mount.

Patru configurații separă exportul, harta dinamică și monitorizarea

Fișierele proiectului vor fi așezate astfel:

storage01
└── /etc/exports.d/automount-lab.exports
    └── publică proiectele și runbook-urile numai către app01

app01
├── /etc/auto.master.d/projects.autofs
│   └── înregistrează rădăcina /mnt/projects în autofs
├── /etc/auto.projects
│   └── transformă orice cheie într-o cale NFS cu aceeași denumire
├── /etc/systemd/system/mnt-runbooks.automount
│   └── creează declanșatorul systemd pentru /mnt/runbooks
├── /etc/systemd/system/mnt-runbooks.mount
│   └── descrie montarea NFS declanșată la primul acces
├── /usr/local/sbin/check-automount-control
│   └── verifică autofs și unitatea .automount fără a citi resursele NFS
├── /etc/systemd/system/automount-health.service
│   └── execută verificarea cu privilegii și izolare
└── /etc/systemd/system/automount-health.timer
    └── programează verificarea la fiecare cinci minute

Harta wildcard este potrivită pentru colecția de proiecte, deoarece aceeași regulă deservește multe nume. Unitatea systemd separată este potrivită pentru resursa fixă /mnt/runbooks, care are propriul ciclu de viață și poate fi urmărită individual cu systemctl.

Pasul 1 — Publicăm pe storage01 două resurse NFS numai pentru app01

De ce: serverul NFS trebuie să ofere o rădăcină pentru proiectele dinamice și o resursă separată, read-only, pentru procedurile operaționale. Folosim un grup cu GID fix, astfel încât permisiunile să aibă aceeași semnificație pe ambele mașini.

Pe storage01, creăm directoarele și datele de control:

set -euo pipefail

if ! getent group projectshare >/dev/null; then
    sudo groupadd --gid 2600 projectshare
fi

sudo install -d -o root -g projectshare -m 2750 
    /srv/nfs/projects 
    /srv/nfs/projects/alpha 
    /srv/nfs/projects/beta 
    /srv/nfs/runbooks

printf '%sn' 'alpha: resursă NFS disponibilă' |
    sudo tee /srv/nfs/projects/alpha/status.txt >/dev/null
printf '%sn' 'beta: resursă NFS disponibilă' |
    sudo tee /srv/nfs/projects/beta/status.txt >/dev/null
printf '%sn' 'Procedură: verifică starea serviciului înainte de intervenție.' |
    sudo tee /srv/nfs/runbooks/maintenance.txt >/dev/null

sudo chown root:projectshare 
    /srv/nfs/projects/alpha/status.txt 
    /srv/nfs/projects/beta/status.txt 
    /srv/nfs/runbooks/maintenance.txt
sudo chmod 0640 
    /srv/nfs/projects/alpha/status.txt 
    /srv/nfs/projects/beta/status.txt 
    /srv/nfs/runbooks/maintenance.txt

Fișierul nou /etc/exports.d/automount-lab.exports trebuie să conțină integral:

/srv/nfs/projects 192.0.2.20(ro,sync,no_subtree_check,root_squash)
/srv/nfs/runbooks 192.0.2.20(ro,sync,no_subtree_check,root_squash)

Îl instalăm și validăm configurația înainte de reîncărcare:

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/exports.d/automount-lab.exports <<'EOF'
/srv/nfs/projects 192.0.2.20(ro,sync,no_subtree_check,root_squash)
/srv/nfs/runbooks 192.0.2.20(ro,sync,no_subtree_check,root_squash)
EOF

sudo exportfs -rav
sudo exportfs -s
sudo systemctl enable --now nfs-kernel-server

ro nu permite modificări prin NFS, sync confirmă operațiile după scrierea lor stabilă, no_subtree_check evită verificarea de subarbore, iar root_squash nu acordă clientului privilegii root asupra exportului. Adresa 192.0.2.20 limitează exportul la clientul din laborator.

Exemplu de rezultat:

exporting 192.0.2.20:/srv/nfs/runbooks
exporting 192.0.2.20:/srv/nfs/projects
/srv/nfs/projects  192.0.2.20(sync,wdelay,hide,no_subtree_check,sec=sys,ro,secure,root_squash,no_all_squash)
/srv/nfs/runbooks   192.0.2.20(sync,wdelay,hide,no_subtree_check,sec=sys,ro,secure,root_squash,no_all_squash)

Ordinea opțiunilor poate diferi.

Punct de control: dacă exportfs -rav raportează o eroare, corectează fișierul din /etc/exports.d/ înainte de a continua; nu testa automount peste un export invalid.

Pasul 2 — Transformăm orice proiect într-o montare autofs la cerere

De ce: nu vrem câte o intrare separată pentru fiecare proiect. Harta wildcard preia cheia accesată, de exemplu alpha, și o reutilizează în calea NFS prin substituția &.

Pe app01, creăm același grup și un cont tehnic fără shell interactiv:

set -euo pipefail

if ! getent group projectshare >/dev/null; then
    sudo groupadd --gid 2600 projectshare
fi

if ! id automount-reader >/dev/null 2>&1; then
    sudo useradd 
        --system 
        --no-create-home 
        --gid projectshare 
        --shell /usr/sbin/nologin 
        automount-reader
fi

sudo install -d -o root -g root -m 0755 /mnt/projects /mnt/runbooks

Fișierul complet /etc/auto.master.d/projects.autofs:

/mnt/projects /etc/auto.projects --timeout=120

Fișierul complet /etc/auto.projects:

* -fstype=nfs4,ro,hard,timeo=600,retrans=2 192.0.2.10:/srv/nfs/projects/&

Le instalăm cu permisiuni administrative, verificăm sintaxa hărților și activăm serviciul:

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/auto.master.d/projects.autofs <<'EOF'
/mnt/projects /etc/auto.projects --timeout=120
EOF

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/auto.projects <<'EOF'
* -fstype=nfs4,ro,hard,timeo=600,retrans=2 192.0.2.10:/srv/nfs/projects/&
EOF

sudo automount --dumpmaps
sudo systemctl enable --now autofs
systemctl is-active autofs
findmnt -rn -t autofs -M /mnt/projects

* acceptă orice cheie din această hartă, iar & introduce cheia în calea de pe server. Pentru /mnt/projects/alpha, ținta devine 192.0.2.10:/srv/nfs/projects/alpha.

hard păstrează operațiile NFS în așteptare în cazul unei întreruperi, în loc să returneze prematur erori aplicației. timeo=600 reprezintă timeout-ul NFS în zecimi de secundă, iar retrans=2 controlează retransmisiile înainte ca mecanismul NFS să inițieze recuperarea. Timeout-ul autofs de 120 de secunde se referă la demontarea unei resurse inactive, nu la timeout-ul traficului NFS.

Exemplu de rezultat:

Mount point: /mnt/projects
source(s):
  instance type(s): file
  map: /etc/auto.projects

active
/etc/auto.master.d/projects.autofs /mnt/projects autofs rw,relatime,fd=...

Câmpurile din ultima linie și descriptorul fd pot diferi.

Punct de control: dacă /mnt/projects nu apare ca tip autofs, citește journalctl -u autofs -b --no-pager și verifică exact cele două fișiere înainte de primul acces NFS.

Pasul 3 — Legăm runbook-urile de o unitate systemd.automount

De ce: /mnt/runbooks este o resursă fixă, nu o colecție de chei. O pereche .automount/.mount îi oferă o unitate individuală, dependențe clare și stare vizibilă în systemd.

Numele unității trebuie să corespundă căii. Confirmăm numele generat:

systemd-escape --path --suffix=automount /mnt/runbooks
systemd-escape --path --suffix=mount /mnt/runbooks

Rezultatul trebuie să fie:

mnt-runbooks.automount
mnt-runbooks.mount

Fișierul complet /etc/systemd/system/mnt-runbooks.automount:

[Unit]
Description=Automount la cerere pentru runbook-urile NFS

[Automount]
Where=/mnt/runbooks
TimeoutIdleSec=120

[Install]
WantedBy=multi-user.target

Fișierul complet /etc/systemd/system/mnt-runbooks.mount:

[Unit]
Description=Montare NFS read-only pentru runbook-uri
Wants=network-online.target
After=network-online.target

[Mount]
What=192.0.2.10:/srv/nfs/runbooks
Where=/mnt/runbooks
Type=nfs4
Options=ro,hard,timeo=600,retrans=2

[Install]
WantedBy=multi-user.target

Instalăm fișierele, verificăm sintaxa și activăm numai unitatea .automount:

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/systemd/system/mnt-runbooks.automount <<'EOF'
[Unit]
Description=Automount la cerere pentru runbook-urile NFS

[Automount]
Where=/mnt/runbooks
TimeoutIdleSec=120

[Install]
WantedBy=multi-user.target
EOF

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/systemd/system/mnt-runbooks.mount <<'EOF'
[Unit]
Description=Montare NFS read-only pentru runbook-uri
Wants=network-online.target
After=network-online.target

[Mount]
What=192.0.2.10:/srv/nfs/runbooks
Where=/mnt/runbooks
Type=nfs4
Options=ro,hard,timeo=600,retrans=2

[Install]
WantedBy=multi-user.target
EOF

sudo systemd-analyze verify 
    /etc/systemd/system/mnt-runbooks.automount 
    /etc/systemd/system/mnt-runbooks.mount
sudo systemctl daemon-reload
sudo systemctl enable --now mnt-runbooks.automount
systemctl is-active mnt-runbooks.automount
systemctl is-active mnt-runbooks.mount || true

Where= trebuie să fie identic în ambele unități. TimeoutIdleSec=120 cere demontarea după două minute de inactivitate. Nu activăm direct mnt-runbooks.mount: aceasta va fi pornită de unitatea .automount la primul acces.

Exemplu înainte de acces:

active
inactive

Aceasta este starea dorită: declanșatorul local este activ, însă serverul NFS nu a fost contactat.

Pentru interpretarea stărilor active, inactive și failed, este util și ghidul despre pornirea și diagnosticarea serviciilor cu systemctl.

Punct de control: dacă systemd-analyze verify produce orice mesaj, nu activa unitățile până când numele fișierului, Where= și secțiunile declarate sunt corectate.

Pasul 4 — Verificăm mecanismul fără să montăm accidental toate resursele

De ce: un monitor care execută ls sau stat în directoarele urmărite ar declanșa chiar montările pe care încearcă să le observe. Scriptul va verifica doar serviciul autofs, pseudo-montarea locală și starea unității .automount.

Fișierul complet /usr/local/sbin/check-automount-control:

#!/usr/bin/env bash
set -euo pipefail

readonly STATUS_DIR='/run/automount-health'
readonly STATUS_FILE="${STATUS_DIR}/status"
readonly PROJECT_ROOT='/mnt/projects'
readonly RUNBOOK_UNIT='mnt-runbooks.automount'

install -d -o root -g root -m 0755 "${STATUS_DIR}"

fail() {
    local message="$1"
    printf 'CRITICAL: %sn' "${message}" | tee "${STATUS_FILE}"
    logger -t automount-health -- "CRITICAL: ${message}"
    exit 1
}

systemctl is-active --quiet autofs ||
    fail 'autofs.service nu este activ'

findmnt -rn -t autofs -M "${PROJECT_ROOT}" >/dev/null ||
    fail '/mnt/projects nu este înregistrat ca autofs'

systemctl is-active --quiet "${RUNBOOK_UNIT}" ||
    fail 'mnt-runbooks.automount nu este activ'

printf '%sn' 
    'OK: autofs și mnt-runbooks.automount acceptă acces la cerere' |
    tee "${STATUS_FILE}"
logger -t automount-health -- 
    'OK: mecanismele locale de automount sunt active'

Instalarea și prima probă:

sudo install -o root -g root -m 0755 
    /dev/stdin /usr/local/sbin/check-automount-control <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

readonly STATUS_DIR='/run/automount-health'
readonly STATUS_FILE="${STATUS_DIR}/status"
readonly PROJECT_ROOT='/mnt/projects'
readonly RUNBOOK_UNIT='mnt-runbooks.automount'

install -d -o root -g root -m 0755 "${STATUS_DIR}"

fail() {
    local message="$1"
    printf 'CRITICAL: %sn' "${message}" | tee "${STATUS_FILE}"
    logger -t automount-health -- "CRITICAL: ${message}"
    exit 1
}

systemctl is-active --quiet autofs ||
    fail 'autofs.service nu este activ'

findmnt -rn -t autofs -M "${PROJECT_ROOT}" >/dev/null ||
    fail '/mnt/projects nu este înregistrat ca autofs'

systemctl is-active --quiet "${RUNBOOK_UNIT}" ||
    fail 'mnt-runbooks.automount nu este activ'

printf '%sn' 
    'OK: autofs și mnt-runbooks.automount acceptă acces la cerere' |
    tee "${STATUS_FILE}"
logger -t automount-health -- 
    'OK: mecanismele locale de automount sunt active'
EOF

sudo /usr/local/sbin/check-automount-control
findmnt -rn -t nfs,nfs4 -M /mnt/runbooks || true

Exemplu:

OK: autofs și mnt-runbooks.automount acceptă acces la cerere

A doua comandă nu trebuie să afișeze nimic dacă /mnt/runbooks nu a fost accesat anterior. Scriptul nu verifică disponibilitatea conținutului de pe storage01; verifică deliberat doar că mecanismele locale pot primi o cerere fără să blocheze bootul.

Punct de control: dacă verificarea trece, dar apare deja o montare NFS, identifică procesul care a accesat calea cu journalctl și cu jurnalele aplicației; nu adăuga acces NFS în scriptul de sănătate.

Pasul 5 — Programăm controlul printr-un timer izolat

De ce: verificarea trebuie repetată și jurnalizată, dar nu are nevoie de rețea, shell interactiv sau acces la directoarele utilizatorilor.

Fișierul complet /etc/systemd/system/automount-health.service:

[Unit]
Description=Verifică mecanismele locale autofs și systemd automount
After=autofs.service mnt-runbooks.automount
Wants=autofs.service mnt-runbooks.automount

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/check-automount-control
User=root
Group=root
NoNewPrivileges=yes
PrivateTmp=yes
ProtectHome=yes
ProtectSystem=strict
ReadWritePaths=/run/automount-health

Fișierul complet /etc/systemd/system/automount-health.timer:

[Unit]
Description=Rulează periodic controlul mecanismelor automount

[Timer]
OnBootSec=2min
OnUnitActiveSec=5min
AccuracySec=30s
Persistent=true
Unit=automount-health.service

[Install]
WantedBy=timers.target

Le instalăm și testăm serviciul înainte de activarea timerului:

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/systemd/system/automount-health.service <<'EOF'
[Unit]
Description=Verifică mecanismele locale autofs și systemd automount
After=autofs.service mnt-runbooks.automount
Wants=autofs.service mnt-runbooks.automount

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/check-automount-control
User=root
Group=root
NoNewPrivileges=yes
PrivateTmp=yes
ProtectHome=yes
ProtectSystem=strict
ReadWritePaths=/run/automount-health
EOF

sudo install -o root -g root -m 0644 
    /dev/stdin /etc/systemd/system/automount-health.timer <<'EOF'
[Unit]
Description=Rulează periodic controlul mecanismelor automount

[Timer]
OnBootSec=2min
OnUnitActiveSec=5min
AccuracySec=30s
Persistent=true
Unit=automount-health.service

[Install]
WantedBy=timers.target
EOF

sudo systemd-analyze verify 
    /etc/systemd/system/automount-health.service 
    /etc/systemd/system/automount-health.timer
sudo systemctl daemon-reload
sudo systemctl start automount-health.service
sudo systemctl enable --now automount-health.timer
systemctl list-timers automount-health.timer --no-pager
sudo cat /run/automount-health/status

Type=oneshot execută scriptul și încheie serviciul. ProtectSystem=strict face sistemul de fișiere read-only pentru proces, iar ReadWritePaths= permite numai actualizarea stării din /run. Persistent=true recuperează o execuție ratată cât timp serverul a fost oprit.

Exemplu:

NEXT                        LEFT LAST PASSED UNIT
Sat 2026-09-26 10:15:00 EEST 4min Sat 2026-09-26 10:10:00 EEST  automount-health.timer

OK: autofs și mnt-runbooks.automount acceptă acces la cerere

Orele vor diferi.

Punct de control: dacă serviciul eșuează sub restricțiile systemd, citește journalctl -u automount-health.service -b; nu elimina toate opțiunile de izolare înainte de a identifica exact calea refuzată.

Pasul 6 — Declanșăm montările și demonstrăm eliberarea după inactivitate

De ce: testul de capăt trebuie să arate patru stări: resursele lipsesc din tabela NFS înainte de acces, apar după acces, livrează fișierele corecte și dispar după timeout.

Pe app01, verificăm mai întâi că nu există montări NFS active pentru cele două rădăcini:

findmnt -rn -t nfs,nfs4 -M /mnt/projects/alpha || true
findmnt -rn -t nfs,nfs4 -M /mnt/runbooks || true

Nu este așteptat niciun output. Declanșăm apoi montările folosind contul tehnic:

sudo -u automount-reader cat /mnt/projects/alpha/status.txt
sudo -u automount-reader cat /mnt/projects/beta/status.txt
sudo -u automount-reader cat /mnt/runbooks/maintenance.txt

findmnt -rn -t nfs,nfs4 -M /mnt/projects/alpha
findmnt -rn -t nfs,nfs4 -M /mnt/projects/beta
findmnt -rn -t nfs,nfs4 -M /mnt/runbooks
systemctl is-active mnt-runbooks.mount

Rezultatul de conținut trebuie să fie:

alpha: resursă NFS disponibilă
beta: resursă NFS disponibilă
Procedură: verifică starea serviciului înainte de intervenție.

Tabela montărilor va include sursele corespunzătoare:

192.0.2.10:/srv/nfs/projects/alpha /mnt/projects/alpha nfs4 ro,relatime,...
192.0.2.10:/srv/nfs/projects/beta /mnt/projects/beta nfs4 ro,relatime,...
192.0.2.10:/srv/nfs/runbooks /mnt/runbooks nfs4 ro,relatime,...
active

Opțiunile negociate și ordinea lor pot diferi. Pentru a confirma că montările sunt read-only:

if sudo -u automount-reader touch /mnt/projects/alpha/should-not-exist 2>/tmp/automount-write-error; then
    printf '%sn' 'EROARE: exportul permite scrierea'
    exit 1
else
    cat /tmp/automount-write-error
fi
rm -f /tmp/automount-write-error

Exemplu:

touch: cannot touch '/mnt/projects/alpha/should-not-exist': Read-only file system

Nu mai accesăm căile timp de cel puțin 150 de secunde, apoi verificăm:

sleep 150
findmnt -rn -t nfs,nfs4 -M /mnt/projects/alpha || true
findmnt -rn -t nfs,nfs4 -M /mnt/projects/beta || true
findmnt -rn -t nfs,nfs4 -M /mnt/runbooks || true
systemctl is-active mnt-runbooks.automount
systemctl is-active mnt-runbooks.mount || true

Rezultatul dorit este lipsa liniilor findmnt, urmată de:

active
inactive

Declanșatorul rămâne pregătit, dar montarea NFS este eliberată.

Punct de control: dacă o resursă rămâne montată, un proces o folosește sau rulează periodic o verificare care îi accesează conținutul. Consultă fuser -vm /mnt/runbooks și jurnalele aplicației înainte de a forța demontarea.

Proba fără server NFS confirmă că mecanismele locale pornesc independent

Acest test oprește temporar serviciul NFS și trebuie executat numai în laborator sau într-o fereastră aprobată. Nu accesa căile NFS cât timp serverul este oprit: o montare hard poate lăsa procesul apelant în așteptare.

Mai întâi confirmăm pe app01 că montările NFS au fost eliberate:

findmnt -rn -t nfs,nfs4 | grep -E '/mnt/(projects|runbooks)' && {
    printf '%sn' 'Există încă montări NFS active; testul se oprește.'
    exit 1
} || true

Pe storage01:

sudo systemctl stop nfs-kernel-server

Pe app01, repornim numai componentele locale și măsurăm rezultatul:

sudo systemctl restart autofs
sudo systemctl restart mnt-runbooks.automount
sudo systemctl start automount-health.service

systemctl is-active autofs
systemctl is-active mnt-runbooks.automount
sudo cat /run/automount-health/status
systemd-analyze critical-chain autofs.service mnt-runbooks.automount

Rezultatul verificabil este:

active
active
OK: autofs și mnt-runbooks.automount acceptă acces la cerere

critical-chain trebuie să arate activarea componentelor locale, fără ca mnt-runbooks.mount să fie pornită. Timpurile diferă între mașini.

Pe storage01, restabilim imediat serviciul:

sudo systemctl start nfs-kernel-server
sudo systemctl is-active nfs-kernel-server

Rezultatul trebuie să fie:

active

Acest test demonstrează că activarea autofs, a unității .automount și a monitorului nu depinde de răspunsul serverului NFS. Nu demonstrează că accesul la date va funcționa când serverul este indisponibil; acel acces trebuie să eșueze sau să aștepte conform semanticii NFS.

Dacă vrei să aprofundezi ordinea dependențelor și limitele resurselor unui serviciu, articolul despre migrarea unui serviciu legacy la cgroups v2 cu systemd explică relația dintre unități, procese și controlul systemd.

Mesajele care indică o hartă greșită, un export refuzat sau un nume invalid

mount.nfs4: access denied by server while mounting 192.0.2.10:/srv/nfs/projects/alpha

Serverul nu exportă acea cale către adresa clientului sau adresa din /etc/exports.d/automount-lab.exports nu corespunde clientului real.

Pe storage01:

sudo exportfs -rav
sudo exportfs -s
ip -brief address

Corectează adresa clientului în fișierul de export, apoi rulează din nou sudo exportfs -rav.

failed to mount /mnt/projects/alpha

Mesajul apare în jurnalul autofs când sursa NFS nu poate fi montată. Verifică mai întâi substituția wildcard și jurnalul complet:

sudo automount --dumpmaps
sudo journalctl -u autofs -b --no-pager
grep -n . /etc/auto.master.d/projects.autofs /etc/auto.projects

Pentru cheia alpha, sursa calculată trebuie să se termine în /srv/nfs/projects/alpha.

Where= setting doesn't match unit name. Refusing.

Numele unității nu corespunde căii din Where=. Pentru /mnt/runbooks, numele valid este mnt-runbooks.mount sau mnt-runbooks.automount.

systemd-escape --path --suffix=mount /mnt/runbooks
systemd-escape --path --suffix=automount /mnt/runbooks
sudo systemd-analyze verify /etc/systemd/system/mnt-runbooks.*

Redenumește fișierul corect și execută sudo systemctl daemon-reload.

Dependency failed for mnt-runbooks.mount

Unitatea .mount nu a putut satisface o dependență sau serverul nu a devenit accesibil. Starea exactă se vede în cele două unități și în jurnal:

systemctl status mnt-runbooks.automount mnt-runbooks.mount --no-pager
sudo journalctl -u mnt-runbooks.mount -b --no-pager

Nu adăuga nofail în unitatea explicită pentru a ascunde cauza; repară rețeaua, exportul sau calea What=.

automount-health.service: Failed with result 'exit-code'.

Scriptul a detectat că autofs, pseudo-montarea sau unitatea .automount nu este activă. Mesajul CRITICAL identifică verificarea care a eșuat:

sudo journalctl -u automount-health.service -b --no-pager
sudo cat /run/automount-health/status
systemctl is-active autofs mnt-runbooks.automount

După remediere, rulează controlul manual:

sudo systemctl start automount-health.service
sudo systemctl is-failed automount-health.service

Pentru un serviciu oneshot încheiat cu succes, ultima comandă trebuie să răspundă inactive, nu failed.

Eliminăm configurația fără să atingem alte exporturi sau montări

Avertisment: următoarele comenzi șterg numai fișierele create în acest laborator. Rulează-le pe mașina indicată și verifică numele înainte de confirmare.

Pe app01, oprim timerul și mecanismele de automount:

set -euo pipefail

sudo systemctl disable --now automount-health.timer
sudo systemctl stop automount-health.service || true
sudo systemctl disable --now mnt-runbooks.automount
sudo systemctl stop mnt-runbooks.mount || true
sudo systemctl disable --now autofs

sudo rm -f 
    /etc/systemd/system/automount-health.service 
    /etc/systemd/system/automount-health.timer 
    /etc/systemd/system/mnt-runbooks.automount 
    /etc/systemd/system/mnt-runbooks.mount 
    /usr/local/sbin/check-automount-control 
    /etc/auto.master.d/projects.autofs 
    /etc/auto.projects

sudo systemctl daemon-reload
sudo systemctl reset-failed
sudo rm -rf /run/automount-health
sudo rmdir /mnt/projects /mnt/runbooks 2>/dev/null || true
sudo userdel automount-reader 2>/dev/null || true
sudo groupdel projectshare 2>/dev/null || true

Pachetele pot fi eliminate dacă nu sunt folosite de alte configurații:

sudo apt remove --yes autofs nfs-common

Pe storage01:

set -euo pipefail

sudo rm -f /etc/exports.d/automount-lab.exports
sudo exportfs -rav
sudo rm -rf /srv/nfs/projects /srv/nfs/runbooks
sudo groupdel projectshare 2>/dev/null || true

Dacă serverul nu mai publică nicio resursă NFS:

sudo systemctl disable --now nfs-kernel-server
sudo apt remove --yes nfs-kernel-server

Bifele care confirmă un automount pregătit pentru exploatare

• ☐ storage01 exportă numai către adresa reală a lui app01.
• ☐ GID-ul 2600 identifică grupul projectshare pe ambele mașini.
• ☐ /mnt/projects apare în findmnt ca tip autofs.
• ☐ Harta wildcard transformă alpha în exportul /srv/nfs/projects/alpha.
• ☐ mnt-runbooks.automount este activă înainte ca mnt-runbooks.mount să pornească.
• ☐ Proiectele și runbook-urile sunt montate read-only numai după acces.
• ☐ Cele trei montări dispar după cel puțin 120 de secunde fără utilizare.
• ☐ Monitorul nu execută ls, stat sau find în resursele NFS.
• ☐ automount-health.timer rulează periodic și scrie rezultatul în jurnal.
• ☐ Mecanismele locale rămân active când serviciul NFS din laborator este oprit.

Următorul pas operațional este înlocuirea hărții locale cu o hartă centralizată LDAP, dacă organizația administrează multe sute de clienți autofs. Pentru resursele fixe suplimentare, generează mai întâi numele unității cu systemd-escape, apoi creează câte o pereche .automount/.mount. Integrează mesajele CRITICAL din automount-health.service în sistemul existent de monitorizare prin colectarea jurnalului systemd, fără sonde care citesc periodic conținutul NFS.

Întrebări frecvente

De ce nu punem toate resursele direct în /etc/fstab?

Configurația folosește autofs pentru colecția dinamică de proiecte și o unitate systemd.automount pentru resursa fixă. Ambele creează declanșatoare locale la boot și contactează serverul NFS numai când calea este accesată.

Ce se întâmplă dacă serverul NFS este indisponibil?

Autofs și unitatea .automount pot porni local fără server. Un proces care accesează efectiv resursa va aștepta sau va primi o eroare conform comportamentului NFS și opțiunilor de montare.

De ce monitorul nu citește un fișier de pe server?

Citirea ar declanșa montarea și ar menține resursa activă. Monitorul verifică numai serviciul autofs, pseudo-montarea locală și unitatea systemd de tip automount.

Pot reduce intervalul de 120 de secunde?

Da, aceeași valoare este configurată prin --timeout=120 pentru autofs și TimeoutIdleSec=120 pentru systemd. Un interval foarte mic poate provoca montări și demontări repetate pentru aplicațiile care accesează resursele intermitent.

Surse

• auto.master — Master Map for automounter
• autofs — Format of the automounter maps
• automount — Manage autofs mount points
• systemd.automount — Automount unit configuration
• systemd.mount — Mount unit configuration
• systemd.timer — Timer unit configuration