lsns, nsenter și systemd-cgls: inspectezi un proces din container fără shell

Un proces dintr-un container consumă resurse sau pare blocat, dar politica de incident response nu permite deschiderea unei sesiuni interactive în container. În laboratorul de mai jos pornim un serviciu telemetry-worker într-un container systemd-nspawn, îi găsim PID-ul văzut de gazdă și îl inspectăm cu systemd-cgls, lsns și nsenter.

La final vei putea identifica relația dintre unitatea containerului, cgroup-ul serviciului și namespace-urile procesului. nsenter va executa numai comenzi de citire — hostname, cat, ps și ip — direct în namespace-urile țintei, fără machinectl shell, docker exec, podman exec sau un shell interactiv în container.

Laboratorul trebuie rulat numai pe o mașină proprie de test. Accesul nsenter ca root traversează limitele de izolare ale containerului; nu îl delega utilizatorilor neprivilegiați și nu îl folosi pentru a modifica un container în timpul colectării inițiale de date.

Fixăm gazda Ubuntu și rezultatul măsurabil

Varianta de referință folosește Ubuntu Server 24.04 LTS pe gazdă și un sistem Debian 12 minimal în container. Uneltele lsns și nsenter provin din util-linux, iar systemd-cgls, systemd-nspawn și machinectl fac parte din familia systemd.

Sunt necesare minimum 2 GB RAM, aproximativ 2 GB liberi sub /var/lib/machines, acces la internet pentru descărcarea sistemului Debian și privilegii sudo. Timpul obișnuit de lucru este de 30–45 de minute, în principal din cauza descărcării containerului.

Verifică gazda înainte să continui:

cat /etc/os-release
uname -r
lsns --version
nsenter --version
systemd-cgls --version
systemd-nspawn --version
stat -fc '%T' /sys/fs/cgroup
free -h
df -h /var/lib/machines

Pe Ubuntu 24.04 LTS, primele linii relevante trebuie să semene cu exemplul următor. Versiunea exactă a kernelului și reviziile pachetelor pot diferi după actualizările instalate:

PRETTY_NAME="Ubuntu 24.04.x LTS"
lsns from util-linux 2.39.3
nsenter from util-linux 2.39.3
systemd 255 (...)
cgroup2fs
Mem:           1.9Gi ...
Filesystem      Size  Used Avail Use% Mounted on
...

Valoarea decisivă este cgroup2fs: laboratorul folosește ierarhia unificată cgroups v2 pentru a găsi procesul serviciului. Pentru o verificare mai generală a memoriei și proceselor gazdei, poți consulta și ghidul despre spațiu, memorie și procese active în Linux.

Punct de control: dacă stat nu afișează cgroup2fs, nu continua cu scriptul final; căile cgroup construite în acest tutorial nu corespund unei gazde cgroups v1.

Instalăm nspawn și pregătim harta laboratorului

Instalarea este scurtă. util-linux și systemd sunt deja componente de bază ale Ubuntu, dar le numim explicit pentru ca toate cele trei comenzi investigate să fie prezente.

sudo apt update
sudo apt install -y util-linux systemd systemd-container debootstrap

systemd-container furnizează systemd-nspawn și instrumentele necesare administrării containerului. debootstrap construiește sistemul Debian direct într-un director, fără imagine descărcată de pe un site terț.

Exemplul de rezultat conține linii similare cu:

Setting up debootstrap (...)
Setting up systemd-container (...)
Processing triggers for man-db (...)

Numerele versiunilor pot diferi după actualizările depozitelor Ubuntu.

Laboratorul va avea această structură:

/var/lib/machines/inspect-lab/                 sistemul de fișiere al containerului Debian
/var/lib/machines/inspect-lab/etc/systemd/system/telemetry-worker.service
                                               serviciul urmărit în container
/usr/local/sbin/inspect-container              scriptul de inspecție rulat pe gazdă
/var/tmp/inspect-lab-report.txt                raportul produs de script

Nu stocăm parole, tokenuri sau chei în aceste fișiere. Containerul nu primește o parolă de root și nu expune niciun port.

Punct de control: command -v systemd-nspawn lsns nsenter systemd-cgls debootstrap trebuie să afișeze câte o cale pentru fiecare comandă.

Pasul 1 — Construim sistemul Debian fără autentificare interactivă

systemd-nspawn are nevoie de un arbore de sistem de operare. debootstrap instalează Debian 12 „bookworm” sub /var/lib/machines/inspect-lab, locul în care systemd caută în mod normal containerele locale.

Comanda modifică /var/lib/machines și descarcă pachete. Verifică înainte că numele inspect-lab nu aparține unui container pe care vrei să-l păstrezi:

sudo machinectl list-images --no-pager
sudo install -d -m 0755 /var/lib/machines
sudo debootstrap 
  --variant=minbase 
  --include=systemd-sysv,dbus,procps,iproute2 
  bookworm 
  /var/lib/machines/inspect-lab 
  https://deb.debian.org/debian
printf '%sn' 'inspect-lab' | sudo tee /var/lib/machines/inspect-lab/etc/hostname

--variant=minbase păstrează sistemul redus. Lista --include adaugă systemd ca init, D-Bus pentru administrarea serviciilor, ps din procps și comanda ip din iproute2. Argumentul bookworm fixează distribuția Debian 12, iar ultimul argument este oglinda oficială Debian folosită pentru pachete.

La final, debootstrap trebuie să confirme instalarea:

I: Base system installed successfully.
inspect-lab

Mesajele intermediare și versiunile pachetelor vor varia.

Punct de control: rulează test -x /var/lib/machines/inspect-lab/lib/systemd/systemd && echo OK; dacă nu apare OK, citește ultimele mesaje debootstrap înainte să încerci pornirea.

Pasul 2 — Pornim un worker identificabil în propriul container

Serviciul demonstrativ rulează sleep infinity. Nu deschide porturi și nu scrie date; scopul lui este să ofere un proces stabil, cu numele și cgroup-ul ușor de recunoscut.

Fișier nou: /var/lib/machines/inspect-lab/etc/systemd/system/telemetry-worker.service

[Unit]
Description=Telemetry worker used for namespace inspection
After=local-fs.target

[Service]
Type=simple
ExecStart=/usr/bin/sleep infinity
Restart=on-failure
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes

[Install]
WantedBy=multi-user.target

Creează fișierul complet și legătura de activare fără să pornești un shell în container:

sudo tee /var/lib/machines/inspect-lab/etc/systemd/system/telemetry-worker.service >/dev/null <<'EOF'
[Unit]
Description=Telemetry worker used for namespace inspection
After=local-fs.target

[Service]
Type=simple
ExecStart=/usr/bin/sleep infinity
Restart=on-failure
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes

[Install]
WantedBy=multi-user.target
EOF

sudo install -d -m 0755 
  /var/lib/machines/inspect-lab/etc/systemd/system/multi-user.target.wants

sudo ln -s 
  ../telemetry-worker.service 
  /var/lib/machines/inspect-lab/etc/systemd/system/multi-user.target.wants/telemetry-worker.service

sudo systemctl start systemd-nspawn@inspect-lab.service
sudo systemctl is-active systemd-nspawn@inspect-lab.service
sudo machinectl show inspect-lab --property=Name --property=State --property=Leader

Restart=on-failure repornește workerul numai după o ieșire nereușită. NoNewPrivileges=yes împiedică procesul și descendenții să dobândească privilegii noi. ProtectSystem=strict face sistemul de fișiere disponibil serviciului în mod read-only, iar PrivateTmp=yes îi oferă directoare temporare private.

Rezultatul trebuie să indice un container activ și un PID lider nenul:

active
Name=inspect-lab
State=running
Leader=12345

PID-ul este doar un exemplu și diferă la fiecare pornire.

Punct de control: dacă starea nu este running, folosește sudo journalctl -u systemd-nspawn@inspect-lab.service -b --no-pager pe gazdă; nu încerca să „repari” situația printr-un login interactiv în container.

Pasul 3 — Legăm unitatea systemd de arborele proceselor cu systemd-cgls

systemd-cgls afișează recursiv procesele din cgroup-ul unei unități. Este primul instrument folosit deoarece răspunde la întrebarea „ce procese aparțin containerului?”, înainte să traversăm vreun namespace.

sudo systemd-cgls --unit systemd-nspawn@inspect-lab.service
sudo systemctl show 
  systemd-nspawn@inspect-lab.service 
  --property=ControlGroup 
  --value

--unit limitează arborele la unitatea containerului. Proprietatea ControlGroup oferă calea stabilită de systemd în ierarhia cgroups; nu trebuie reconstruită manual după PID.

Un fragment de ieșire va semăna cu:

Unit systemd-nspawn@inspect-lab.service (/system.slice/systemd-nspawn@inspect-lab.service):
├─12345 /lib/systemd/systemd
└─...
  └─telemetry-worker.service
    └─12390 /usr/bin/sleep infinity

/system.slice/systemd-nspawn@inspect-lab.service

PID-urile și procesele auxiliare pot diferi. Elementul relevant este telemetry-worker.service, aflat sub cgroup-ul containerului.

systemd-cgls arată apartenența administrativă, nu consumul de resurse. Dacă ai nevoie de o vedere separată asupra proceselor și memoriei, folosește comenzile din ghidul de verificare a resurselor Linux, fără să confunzi PID-ul containerului cu PID-ul văzut de gazdă.

Punct de control: dacă arborele nu conține telemetry-worker.service, verifică unitatea creată și jurnalul containerului cu sudo journalctl -M inspect-lab -u telemetry-worker.service --no-pager.

Pasul 4 — Identificăm namespace-urile workerului cu lsns

PID-ul afișat de managerul systemd din container poate fi raportat în propriul PID namespace. Pentru nsenter avem nevoie de PID-ul gazdei. Îl extragem din cgroup.procs, fișierul cgroups v2 care enumeră procesele membre ale cgroup-ului serviciului.

UNIT_CGROUP="$(
  sudo systemctl show 
    systemd-nspawn@inspect-lab.service 
    --property=ControlGroup 
    --value
)"

SERVICE_CGROUP="$(
  sudo find "/sys/fs/cgroup${UNIT_CGROUP}" 
    -type d 
    -name telemetry-worker.service 
    -print 
    -quit
)"

TARGET_PID="$(sudo sed -n '1p' "${SERVICE_CGROUP}/cgroup.procs")"

printf 'Cgroup serviciu: %snPID pe gazdă: %sn' 
  "$SERVICE_CGROUP" 
  "$TARGET_PID"

sudo lsns 
  --task "$TARGET_PID" 
  --output NS,TYPE,NPROCS,PID,COMMAND

find rămâne în subarborele containerului și caută cgroup-ul cu numele exact al serviciului. sed -n '1p' citește primul PID; serviciul nostru are un singur proces. lsns --task limitează rezultatul la namespace-urile deținute de țintă, iar --output fixează explicit coloanele, deoarece documentația lsns avertizează că formatul implicit se poate schimba.

Exemplul va conține mai multe tipuri de namespace:

        NS TYPE   NPROCS   PID COMMAND
4026532... mnt         ... ... /lib/systemd/systemd
4026532... uts         ... ... /lib/systemd/systemd
4026532... ipc         ... ... /lib/systemd/systemd
4026532... pid         ... ... /lib/systemd/systemd
4026532... net         ... ... /lib/systemd/systemd
4026532... cgroup      ... ... /lib/systemd/systemd

Identificatorii namespace, PID-urile și numărul de procese sunt exemple. Tipurile mnt, uts, ipc, pid, net și cgroup sunt cele pe care le vom selecta în pasul următor.

Punct de control: confirmă imediat că /proc/$TARGET_PID există; un restart al serviciului schimbă PID-ul și impune repetarea extragerii din cgroup.procs.

Pasul 5 — Rulăm comenzi de diagnostic direct în namespace-uri

nsenter pornește un program cu namespace-urile unui proces existent. Nu creează o autentificare și nu are nevoie ca în container să ruleze SSH. În acest laborator executăm fiecare utilitar direct, fără /bin/bash sau /bin/sh.

sudo nsenter 
  --target "$TARGET_PID" 
  --mount --uts --ipc --net --pid --cgroup 
  --root --wd 
  -- /usr/bin/hostname

sudo nsenter 
  --target "$TARGET_PID" 
  --mount --uts --ipc --net --pid --cgroup 
  --root --wd 
  -- /bin/cat /etc/os-release

sudo nsenter 
  --target "$TARGET_PID" 
  --mount --uts --ipc --net --pid --cgroup 
  --root --wd 
  -- /usr/bin/ps -eo pid,ppid,user,comm,args

sudo nsenter 
  --target "$TARGET_PID" 
  --mount --uts --ipc --net --pid --cgroup 
  --root --wd 
  -- /usr/sbin/ip -brief address

--target indică procesul de referință. Opțiunile --mount, --uts, --ipc, --net, --pid și --cgroup selectează namespace-urile traversate. --root și --wd folosesc rădăcina și directorul de lucru ale țintei, astfel încât căile executabilelor și fișierelor sunt rezolvate în sistemul containerului. Separatorul -- marchează începutul programului executat.

Ieșirea trebuie să confirme că observi containerul, nu gazda:

inspect-lab
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
NAME="Debian GNU/Linux"
VERSION_ID="12"
...
    PID    PPID USER     COMMAND         COMMAND
      1       0 root     systemd         /lib/systemd/systemd
...
      ...     1 root     sleep           /usr/bin/sleep infinity
lo               UNKNOWN        127.0.0.1/8 ::1/128
host0            UP             ...

Interfața poate avea alt nume și alte adrese. Nu include într-un raport public adresele, numele interne sau întreaga linie de comandă a aplicațiilor reale, deoarece acestea pot dezvălui topologia și secrete transmise greșit ca argumente.

Punct de control: dacă hostname afișează numele gazdei, nu presupune că ai intrat în namespace-ul corect; recitește PID-ul din cgroup-ul serviciului și repetă lsns --task.

Automatizăm raportul fără comenzi interactive în container

Scriptul următor repetă verificările, oprește execuția când containerul sau procesul nu mai există și produce date exclusiv prin comenzi de citire.

Fișier nou: /usr/local/sbin/inspect-container

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

readonly MACHINE="inspect-lab"
readonly UNIT="systemd-nspawn@${MACHINE}.service"
readonly SERVICE_CGROUP_NAME="telemetry-worker.service"

fail() {
    printf 'Eroare: %sn' "$1" >&2
    exit 1
}

[[ "${EUID}" -eq 0 ]] || fail "rulează scriptul ca root."

systemctl is-active --quiet "${UNIT}" ||
    fail "containerul ${MACHINE} nu este pornit."

unit_cgroup="$(
    systemctl show "${UNIT}" --property=ControlGroup --value
)"
[[ -n "${unit_cgroup}" ]] ||
    fail "unitatea ${UNIT} nu are un ControlGroup."

service_cgroup="$(
    find "/sys/fs/cgroup${unit_cgroup}" 
        -type d 
        -name "${SERVICE_CGROUP_NAME}" 
        -print 
        -quit
)"
[[ -n "${service_cgroup}" ]] ||
    fail "cgroup-ul ${SERVICE_CGROUP_NAME} nu a fost găsit."

read -r target_pid < "${service_cgroup}/cgroup.procs"
[[ "${target_pid}" =~ ^[0-9]+$ ]] ||
    fail "PID-ul serviciului nu este numeric: ${target_pid}."
[[ -d "/proc/${target_pid}" ]] ||
    fail "procesul ${target_pid} a dispărut înainte de inspecție."

printf '=== CONTAINER ȘI CGROUP ===n'
printf 'Mașină: %snPID țintă pe gazdă: %sn' 
    "${MACHINE}" "${target_pid}"
systemd-cgls --unit "${UNIT}"

printf 'n=== NAMESPACE-URI ===n'
lsns 
    --task "${target_pid}" 
    --output NS,TYPE,NPROCS,PID,COMMAND

printf 'n=== IDENTITATEA SISTEMULUI ===n'
nsenter 
    --target "${target_pid}" 
    --mount --uts --ipc --net --pid --cgroup 
    --root --wd 
    -- /usr/bin/hostname

nsenter 
    --target "${target_pid}" 
    --mount --uts --ipc --net --pid --cgroup 
    --root --wd 
    -- /bin/cat /etc/os-release

printf 'n=== PROCESE VĂZUTE DIN CONTAINER ===n'
nsenter 
    --target "${target_pid}" 
    --mount --uts --ipc --net --pid --cgroup 
    --root --wd 
    -- /usr/bin/ps -eo pid,ppid,user,comm,args

Instalează-l cu permisiuni care permit modificarea numai de către root, apoi salvează raportul:

sudo tee /usr/local/sbin/inspect-container >/dev/null <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

readonly MACHINE="inspect-lab"
readonly UNIT="systemd-nspawn@${MACHINE}.service"
readonly SERVICE_CGROUP_NAME="telemetry-worker.service"

fail() {
    printf 'Eroare: %sn' "$1" >&2
    exit 1
}

[[ "${EUID}" -eq 0 ]] || fail "rulează scriptul ca root."

systemctl is-active --quiet "${UNIT}" ||
    fail "containerul ${MACHINE} nu este pornit."

unit_cgroup="$(systemctl show "${UNIT}" --property=ControlGroup --value)"
[[ -n "${unit_cgroup}" ]] ||
    fail "unitatea ${UNIT} nu are un ControlGroup."

service_cgroup="$(find "/sys/fs/cgroup${unit_cgroup}" -type d -name "${SERVICE_CGROUP_NAME}" -print -quit)"
[[ -n "${service_cgroup}" ]] ||
    fail "cgroup-ul ${SERVICE_CGROUP_NAME} nu a fost găsit."

read -r target_pid < "${service_cgroup}/cgroup.procs"
[[ "${target_pid}" =~ ^[0-9]+$ ]] ||
    fail "PID-ul serviciului nu este numeric: ${target_pid}."
[[ -d "/proc/${target_pid}" ]] ||
    fail "procesul ${target_pid} a dispărut înainte de inspecție."

printf '=== CONTAINER ȘI CGROUP ===n'
printf 'Mașină: %snPID țintă pe gazdă: %sn' "${MACHINE}" "${target_pid}"
systemd-cgls --unit "${UNIT}"

printf 'n=== NAMESPACE-URI ===n'
lsns --task "${target_pid}" --output NS,TYPE,NPROCS,PID,COMMAND

printf 'n=== IDENTITATEA SISTEMULUI ===n'
nsenter --target "${target_pid}" --mount --uts --ipc --net --pid --cgroup --root --wd -- /usr/bin/hostname
nsenter --target "${target_pid}" --mount --uts --ipc --net --pid --cgroup --root --wd -- /bin/cat /etc/os-release

printf 'n=== PROCESE VĂZUTE DIN CONTAINER ===n'
nsenter --target "${target_pid}" --mount --uts --ipc --net --pid --cgroup --root --wd -- /usr/bin/ps -eo pid,ppid,user,comm,args
EOF

sudo chmod 0750 /usr/local/sbin/inspect-container
sudo /usr/local/sbin/inspect-container |
  sudo tee /var/tmp/inspect-lab-report.txt

set -euo pipefail oprește scriptul la o comandă nereușită, la o variabilă nedefinită sau la o eroare ascunsă într-un pipeline. Permisiunea 0750 limitează execuția la root și grupul fișierului. Dacă adaptezi ulterior raportul pentru fluxuri mai complexe, ghidul despre file descriptors, redirecționări și named pipes explică efectul redirecționărilor asupra datelor textuale și binare.

Punct de control: sudo test -s /var/tmp/inspect-lab-report.txt && echo RAPORT_OK trebuie să afișeze RAPORT_OK.

Testul de capăt confirmă cele trei perspective

Rulează următoarea verificare după generarea raportului:

sudo grep -E 
  'telemetry-worker.service|TYPE|inspect-lab|Debian GNU/Linux|sleep infinity' 
  /var/tmp/inspect-lab-report.txt

Rezultatul așteptat este un fragment asemănător cu:

└─telemetry-worker.service
TYPE
inspect-lab
PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
... sleep ... /usr/bin/sleep infinity

Această verificare confirmă simultan cgroup-ul serviciului, tabelul namespace-urilor, identitatea UTS și sistemul de fișiere Debian, plus procesul văzut din PID namespace-ul containerului. Ordinea și PID-urile pot varia, dar toate cele cinci indicii trebuie să existe.

Mesajele care localizează o defecțiune a laboratorului

Eroare: containerul inspect-lab nu este pornit. Scriptul a găsit unitatea inactivă. Pornește-o și verifică starea:

sudo systemctl start systemd-nspawn@inspect-lab.service
sudo systemctl status systemd-nspawn@inspect-lab.service --no-pager

Eroare: cgroup-ul telemetry-worker.service nu a fost găsit. Containerul rulează, dar serviciul nu a pornit sau legătura din multi-user.target.wants lipsește. Verifică jurnalul:

sudo journalctl -M inspect-lab -u telemetry-worker.service --no-pager

Eroare: procesul PID a dispărut înainte de inspecție. Workerul s-a restartat între citirea cgroup.procs și accesarea /proc. Rulează din nou scriptul; acesta va prelua PID-ul actual.

nsenter: cannot open /proc/PID/ns/mnt: No such file or directory Procesul țintă s-a încheiat după validare. Confirmă serviciul cu systemd-cgls, apoi regenerează PID-ul din cgroup, nu dintr-o notiță veche.

Unit telemetry-worker.service could not be found. Fișierul unității nu se află în arborele containerului sau numele său diferă. Verifică direct de pe gazdă:

sudo test -f 
  /var/lib/machines/inspect-lab/etc/systemd/system/telemetry-worker.service &&
  echo UNITATE_OK

Eroare: rulează scriptul ca root. Inspecția namespace-urilor și citirea completă a cgroup-ului necesită privilegii. Folosește exact sudo /usr/local/sbin/inspect-container; nu relaxa permisiunile asupra /proc, /sys/fs/cgroup sau scriptului.

Oprim containerul și eliminăm toate urmele laboratorului

Avertisment: comenzile următoare șterg definitiv sistemul Debian din /var/lib/machines/inspect-lab și raportul generat. Nu le rula dacă ai reutilizat acel nume pentru alt container.

sudo systemctl stop systemd-nspawn@inspect-lab.service
sudo systemctl reset-failed systemd-nspawn@inspect-lab.service
sudo rm -f /usr/local/sbin/inspect-container
sudo rm -f /var/tmp/inspect-lab-report.txt
sudo rm -rf /var/lib/machines/inspect-lab
sudo systemctl daemon-reload

sudo test ! -e /var/lib/machines/inspect-lab &&
  test ! -e /usr/local/sbin/inspect-container &&
  echo CURATENIE_OK

Nu eliminăm pachetele systemd, util-linux sau dependențele de bază. Dacă systemd-container și debootstrap au fost instalate exclusiv pentru laborator, le poți scoate separat:

sudo apt remove -y systemd-container debootstrap
sudo apt autoremove

Rezultatul final trebuie să fie:

CURATENIE_OK

Lista de acceptanță pentru inspecția din gazdă

• ☐ Gazda folosește cgroups v2 și stat afișează cgroup2fs.
• ☐ Containerul inspect-lab apare cu starea running.
• ☐ systemd-cgls plasează telemetry-worker.service sub unitatea nspawn.
• ☐ PID-ul țintă provine din cgroup.procs, nu dintr-o valoare copiată anterior.
• ☐ lsns --task afișează namespace-urile procesului selectat.
• ☐ nsenter execută direct utilitarele, fără shell interactiv în container.
• ☐ hostname afișează inspect-lab.
• ☐ /etc/os-release văzut prin nsenter identifică Debian 12.
• ☐ Raportul nu conține tokenuri, parole sau date interne care vor fi publicate.
• ☐ Curățenia afișează CURATENIE_OK dacă laboratorul este eliminat.

Trei extinderi utile după laborator

Pentru un serviciu real, înlocuiește SERVICE_CGROUP_NAME cu numele unității investigate și păstrează descoperirea PID-ului prin cgroups v2. Adaugă journalctl -M NUME -u UNITATE pentru a corela arborele de procese cu evenimentele serviciului, fără autentificare interactivă.

Pentru monitorizare repetată, rulează scriptul printr-un timer systemd de pe gazdă și scrie raportul într-un director accesibil numai administratorilor. Pentru un incident, copiază raportul înainte de alte intervenții și calculează-i separat un hash, astfel încât versiunea analizată să poată fi identificată ulterior.

Întrebări frecvente

Acest laborator deschide un shell în container?

Nu. nsenter lansează direct hostname, cat, ps și ip, fără machinectl shell, SSH, /bin/bash sau /bin/sh în container.

De ce nu folosim PID-ul afișat în interiorul containerului?

Un PID din namespace-ul containerului poate desemna altceva pe gazdă. Tutorialul citește cgroup.procs din cgroup-ul serviciului pentru a obține PID-ul recunoscut de /proc pe gazdă.

Pot rula scriptul pe o gazdă cu cgroups v1?

Nu în forma prezentată. Scriptul construiește căile în ierarhia unificată cgroups v2, verificată prin rezultatul cgroup2fs.

nsenter modifică procesul inspectat?

Comenzile din laborator sunt de citire, dar nsenter rulează cu privilegii ridicate și poate traversa izolarea containerului. De aceea scriptul este limitat la root, iar comenzile executate sunt enumerate explicit.

Surse

• lsns(8) — Linux manual page, util-linux
• nsenter(1) — Linux manual page, util-linux
• systemd-cgls — documentația oficială systemd
• systemd-nspawn — documentația oficială systemd
• machinectl — documentația oficială systemd
• debootstrap(8) — Debian Manpages