SSD Nodes Learn Hosting plans →

Docker Compose లో PUID మరియు PGID అంటే ఏమిటి?

PUID మరియు PGID అనేవి Docker సెట్టింగ్స్ కావు, ఇవి linuxserver.io ఇమేజ్‌ల కోసం మాత్రమే. మీ ఫైల్స్ ఎందుకు 911:911 పర్మిషన్లతో వస్తున్నాయో మరియు వీటిని ఎలా సరిచేయాలో ఇక్కడ తెలుసుకోండి.

PUID మరియు PGID వాస్తవంగా ఏమిటి

PUID మరియు PGID అనేవి కొన్ని container images startup సమయంలో చదివే రెండు environment variables. Docker స్వయంగా వీటిని పరిశీలించదు. ఇవి linuxserver.io images మరియు మరికొన్ని images ఉపయోగించే ఒక convention మాత్రమే. వాటిని చదవడానికి రాయబడని image వీటిని మౌనంగా విస్మరిస్తుంది.

linuxserver.io image లో abc అనే user ఉంటుంది. ఇది build సమయంలో UID (user ID) 911 మరియు GID (group ID) 911 తో సృష్టించబడుతుంది. Container root గా ప్రారంభమై, తన init scripts ను అమలు చేస్తుంది. Application ప్రారంభమయ్యే ముందు ఆ scripts లో ఒకటి ఈ user కు సంబంధించిన numbers ను మార్చుతుంది:

groupmod -o -g "${PGID}" abc
usermod -o -u "${PUID}" abc

ఇప్పటికే మరెక్కడైనా ఉపయోగంలో ఉన్న ID ను అనుమతించడానికి -o flag ఉపయోగపడుతుంది. ఆ తరువాత init privileges ను తగ్గించి, application ను abc గా అమలు చేస్తుంది. అందువల్ల Docker PUID=1000 ను ఇతర environment variable లాగానే container లోకి పంపుతుంది; దానిపై Docker ఎలాంటి చర్య తీసుకోదు. Application ప్రారంభమయ్యే ముందు container లోని user కు సంబంధించిన number ను ఈ variable మార్చుతుంది. అంటే user namespace remapping లేని సాధారణ rootful daemon లో, కొత్తగా సృష్టించే files సాధారణంగా మీ disk పై 1000 కు చెందినవిగా నిల్వ అవుతాయి. ఇప్పటికే ఉన్న writable file ను రాయడం వల్ల దాని owner మారదు. Rootless Docker ఆ number ను మార్చుతుంది; దీనిని కింద మరింత వివరించాం. PUID ను unset గా ఉంచితే abc విలువ 911 గానే ఉంటుంది. అందుకే configuration చేయని bind mount లో 911:911 కు చెందిన files నిండిపోతాయి.

id తో మీ రెండు సంఖ్యలను పొందండి

డేటా డైరెక్టరీలను కలిగి ఉన్న userగా hostపై దీన్ని అమలు చేయండి:

id
uid=1000(deploy) gid=1000(deploy) groups=1000(deploy),27(sudo),988(docker)

uid మీ PUID, gid మీ PGID. Scriptలో కేవలం సంఖ్యలను ముద్రించడానికి id -u మరియు id -g ఉపయోగించండి. కొత్తగా సిద్ధం చేసిన చాలా VPS imagesలో మొదటి human accountకు 1000:1000 ఉంటాయి, కానీ దీనిని ఊహించవద్దు. Allocation ప్రస్తుతం ఉన్న accounts మరియు configurationపై ఆధారపడి ఉంటుంది: మళ్లీ నిర్మించిన serverకు 1000 మళ్లీ కేటాయించవచ్చు, అయితే తరువాత సృష్టించిన accountకు అందుబాటులో ఉన్న అధిక ID కేటాయించవచ్చు. మీ services మీ login userకు బదులుగా ప్రత్యేక service account కింద నడిస్తే, id thatuser అమలు చేసి అక్కడి నుంచి ఆ సంఖ్యలను తీసుకోండి.

మీ ఫైళ్లు 911:911గా ఎందుకు కనిపిస్తున్నాయి

ls -l కు ఆ ID సరిపోలే host account లేకపోతే, పేరు బదులుగా numeric ID ను చూపిస్తుంది. UID 911 కు సరిపోలే host account లేకపోతే, చూపించడానికి పేరు ఉండదు. ప్రతిసారీ సంఖ్యలను చూపించి ఈ అస్పష్టతను తొలగించడానికి ls -ln ఉపయోగించండి:

ls -ln /srv/appdata/sonarr
drwxr-xr-x 2 911 911 4096 Aug  7 09:12 Backups
-rw-r--r-- 1 911 911  512 Aug  7 09:12 config.xml

ఆ output container లోని built-in defaults కు సరిపోతుంది. అయితే ప్రస్తుతానికి application ఏ user గా నడుస్తుందో existing files మాత్రమే నిరూపించవు. ఆ listing లోని config.xml authentication settings ను కలిగి ఉన్న file కూడా. మీరు మొదటిసారి web UI తెరిచినప్పుడు ఇది ముఖ్యమైనది, ఎందుకంటే Sonarr మరియు Radarr ఎలాంటి default username లేదా password లేకుండానే విడుదలవుతాయి. ఊహించకుండా container లోపల నుంచే నిర్ధారించండి:

docker exec sonarr id abc
docker compose logs sonarr | head -n 25

linuxserver init తన ఫలితాన్ని startup log లో రెండు lines గా చూపిస్తుంది:

User UID:    911
User GID:    911

మీ Compose file లో PUID=1000 సెట్ చేసిన తర్వాత కూడా ఆ lines లో 911 కనిపిస్తే, నడుస్తున్న container మీరు సెట్ చేసిన విలువను ఉపయోగించడం లేదు. సాధారణ కారణం: మీరు docker-compose.yml ను సవరించి, తరువాత docker compose restart నడిపారు. ఇది ఇప్పటికే ఉన్న container ను దాని అసలు environment తోనే మళ్లీ ఉపయోగిస్తుంది. Environment మార్పులకు docker compose up -d అవసరం. ఇది container ను మళ్లీ సృష్టిస్తుంది. మరో కారణం ఉద్దేశపూర్వక ప్రవర్తనే: image read-only లేదా non-root mode లో నడిస్తే, container లో variable ఉన్నప్పటికీ init renumbering ను పూర్తిగా skip చేస్తుంది. Read-only mode లో banner, మార్చని abc యొక్క ID ను చూపిస్తుంది; non-root mode లో అది /run యొక్క owner ను చూపిస్తుంది.

కంటైనర్ సృష్టించిన ఫైల్‌ను మీరు ఎందుకు తొలగించలేరు

కర్నల్ పేర్లను కాకుండా సంఖ్యలను మాత్రమే పోల్చి చూస్తుంది. మీ షెల్ UID 1000గా రన్ అవుతుంది. ఆ ఫైల్ UID 911కి చెందినది. దానిని కలిగి ఉన్న డైరెక్టరీ drwxr-xr-x, ఇది కూడా 911కే చెందినది, కాబట్టి గ్రూప్ మరియు ఇతరులకు చదవడానికి (read) మరియు అమలు చేయడానికి (execute) అనుమతి ఉంటుంది కానీ రాయడానికి (write) ఉండదు. ఒక ఫైల్‌ను తొలగించాలంటే ఆ ఫైల్‌పై కాదు, దాని డైరెక్టరీపై రైట్ పర్మిషన్ ఉండాలి, అందుకే ఫైల్ చూడటానికి సాధారణంగా ఉన్నా మీకు ఈ ఎర్రర్ వస్తుంది:

rm: cannot remove '/srv/appdata/sonarr/config.xml': Permission denied

రైట్ చేస్తున్న కంటైనర్ కూడా ఇదే సమస్యను ఎదుర్కొంటుంది. హోస్ట్ డైరెక్టరీ మీ యూజర్‌కు చెందినదై, మోడ్ 755లో ఉండి, అప్లికేషన్ 911గా రన్ అవుతుంటే, దాని మొదటి రైట్ ఆపరేషన్ Permission deniedతో విఫలమవుతుంది మరియు అప్లికేషన్ దాని స్వంత భాషలో ఆ విషయాన్ని తెలియజేస్తుంది. Sonarr లేదా Radarr వంటి .NET అప్లికేషన్లలో ఇది UnauthorizedAccessException: Access to the path '/data/downloads' is deniedగా కనిపిస్తుంది. ఫైల్ ముందు ఉండే పర్మిషన్ స్ట్రింగ్, మీరు ఏ మూడు పర్మిషన్ సెట్‌ల ద్వారా అంచనా వేయబడుతున్నారో తెలియజేస్తుంది, మరియు drwxr-xr-x ను సరిగ్గా చదవడం నేర్చుకుంటే, ఈ ఎర్రర్ ఎందుకు వస్తుందో స్పష్టంగా అర్థమవుతుంది.

ఇది ప్రత్యేకంగా bind mount సమస్య. Docker ఒక empty named volumeను సృష్టించి, ఇమేజ్‌లో ఉన్న పాత్‌పై మౌంట్ చేసినప్పుడు, అది ఆ పాత్‌లోని కంటెంట్‌ను వాల్యూమ్‌లోకి కాపీ చేస్తుంది (ownership మరియు permission bits తో సహా), తద్వారా అప్లికేషన్‌కు అది ఇప్పటికే ఓన్ చేసుకున్న డైరెక్టరీ కనిపిస్తుంది. Bind mount కు ఆ వెసులుబాటు ఉండదు: Docker మీ హోస్ట్ డైరెక్టరీని ఉన్నది ఉన్నట్లుగానే మౌంట్ చేస్తుంది. ఈ తేడా వల్లే bind mount ఎప్పుడు వాడాలి, named volume ఎప్పుడు వాడాలి అన్నది తెలుసుకోవడం చాలా ముఖ్యం.

ఇప్పటికే తప్పుగా ఉన్న directory ను సరిచేయడం

PUID మరియు PGID సెట్ చేయడం వల్ల ఇకపై application పనిచేసే విధానం మారుతుంది. Disk పై ఇప్పటికే ఉన్న ప్రతి file ను ఇది వెనుకకు వెళ్లి సరిచేయదు. అయితే క్రింద వివరించిన నిర్దిష్ట paths లో ownership ను init సరిచేస్తుంది. Stack ను ఆపి, ownership ను మీరే సరిచేసి, తరువాత దాన్ని మళ్లీ ప్రారంభించండి:

docker compose down
sudo chown -R 1000:1000 /srv/appdata/sonarr
docker compose up -d

సంఖ్యలను స్వయంగా టైప్ చేయకూడదనుకుంటే sudo chown -R "$(id -u):$(id -g)" /srv/appdata/sonarr ఉపయోగించండి. Container ఆపి ఉన్నప్పుడు మాత్రమే దీన్ని చేయండి. Recursive chown జరుగుతున్న సమయంలో application file కు write చేస్తుంటే, directory tree లో కొంత భాగం మాత్రమే సరిచేయబడవచ్చు. దాంతో రెండో దశలో గందరగోళపరిచే errors ఏర్పడవచ్చు.

PUID మరియు PGID ఏ సమస్యలను పరిష్కరించవు

అన్నీ సరిగ్గా చేసిన వారికి కూడా ఎదురయ్యే ముఖ్యమైన విషయం ఇది. linuxserver base image యొక్క user setup script startup సమయంలో మూడు paths పై chown చేస్తుంది: /app, /config మరియు /defaults. మీ media mounts ఆ జాబితాలో ఉండవు. /data, /downloads మరియు /tv ను application కు ఎలాంటి మార్పు లేకుండా అందిస్తారు. అందువల్ల ఆ mounts కు host వైపు ఉన్న ownership ను container user మార్చలేకపోతే, container సరిగ్గా ప్రారంభమవుతుంది, తన banner లో సరైన UID ను చూపిస్తుంది, కానీ మొదటి import సమయంలోనే విఫలమవుతుంది.

అది సరైన ప్రవర్తనే. ప్రతి container start సమయంలో పన్నెండు terabyte media library పై recursive chown అమలు చేయడం తీవ్రమైన సమస్యలకు దారితీస్తుంది. దీనివల్ల media directories నిర్వహణ మీ బాధ్యత అవుతుంది. Permissions వాస్తవంగా తప్పు అయ్యే mounts కూడా అవే. ఇలాంటి వైఫల్యం container ఆరోగ్యంగా కనిపించిన కొన్ని గంటల తర్వాత application log లో నిశ్శబ్దంగా కనిపించవచ్చు. అందువల్ల మీ స్వంత VPS లో ntfyను ఏర్పాటు చేసి, మీ phone కు alerts పంపడం ద్వారా periodic write test ను అమలు చేయడం తక్కువ ఖర్చుతో కూడిన పద్ధతి. ఒక వారం episodes కనిపించకపోయిన తర్వాత విషయం బయటపడేలోపు సమస్యను తెలుసుకోవచ్చు.

వినియోగదారును నియంత్రించడానికి మూడు మార్గాలు, ప్రతి మార్గాన్ని ఎప్పుడు ఉపయోగించాలి

PUID మరియు PGID environment variables

ఇవి entrypoint వాటిని చదివే imagesలో మాత్రమే పనిచేస్తాయి. Container మొదట rootగా ప్రారంభమై, స్వయంగా setup చేసి, /config ను సరిచేసిన తర్వాత మాత్రమే privileges తగ్గిస్తుంది కాబట్టి ఇది ప్రజాదరణ పొందింది. Docker Mods మరియు custom init scripts పనిచేస్తూనే ఉంటాయి. అయితే platform feature బదులుగా ఒక conventionపై ఆధారపడాల్సి రావడం దీని ప్రతికూలత. అదనంగా, projects మధ్య variable names standardగా ఉండవు.

Composeలోని user: key

ఇది నిజమైన Docker feature. ప్రతి imageలో పనిచేస్తుంది, ఎందుకంటే imageలోని code అమలుకాకముందే container runtime దీన్ని వర్తింపజేస్తుంది:

services:
  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    user: "1000:1000"

Process rootగా ఎప్పుడూ అమలు కాదు, క్షణం పాటు కూడా కాదు. ఇది నిజమైన security gain. అయితే root అవసరమైన entrypoint చర్యలు పనిచేయవు. linuxserver imagesలో project దీన్ని సహేతుకమైన ప్రయత్నాల ప్రాతిపదికన, తాను పరీక్షించిన imagesకు మాత్రమే support చేస్తుంది. దీనికి సంబంధించిన caveats నిర్దిష్టంగా ఉంటాయి: PUID మరియు PGIDకు ఇక ఎలాంటి ప్రభావం ఉండదు, Docker Mods అమలు కావు, custom services అమలు కావు, mounted volumeలన్నింటి permissionsకు మీరు బాధ్యత వహించాలి. వారి documented pattern ఈ flagను writable /run తో జత చేస్తుంది:

user: 1000:1000
tmpfs:
  - /run:uid=1000,gid=1000,exec
security_opt:
  - no-new-privileges=true

ఒక చిన్న cosmetic side effect కొంతమందిని ఆశ్చర్యపరుస్తుంది. Containerలోని /etc/passwd లో సరిపోలే entry లేని numeric user: ఉంటే, లోపలి tools whoami: cannot find name for user ID 1000 అని చూపిస్తాయి. ID చెల్లుబాటు అవుతుంది, file access సాధారణంగానే పనిచేస్తుంది. Name lookup మాత్రమే విఫలమవుతుంది.

Rootless Docker

Rootless Docker daemonను మీ unprivileged userగానే అమలు చేస్తుంది. అందువల్ల daemon మరియు containers host root privileges లేకుండా నడుస్తాయి. ఇది ownership లెక్కింపును పూర్తిగా మారుస్తుంది. Container UID 0, rootless Docker నడుపుతున్న user యొక్క host UIDకు map అవుతుంది. Container UID n, 1 లేదా అంతకంటే ఎక్కువ ఉన్న ఏదైనా n కోసం, subuid + (n - 1) కు map అవుతుంది. ఇక్కడ subuid అనేది /etc/subuid లో మీకు కేటాయించిన range యొక్క base. Group IDs కూడా /etc/subgid ఉపయోగించి ఇదే నియమాన్ని అనుసరిస్తాయి. Docker అక్కడ కనీసం 65,536 subordinate IDsను ఆశిస్తుంది.

ఆ mappingను మరోసారి చదవండి. ఇది సాధారణ సలహాకు విరుద్ధంగా ఉంటుంది. Rootless Docker కింద container rootగా file సృష్టిస్తే, సాధారణంగా ఆ file మీకు చెందినదిగా కనిపిస్తుంది. Container UID 1000గా file సృష్టిస్తే, range 100000 నుంచి ప్రారంభమైతే 100999 వంటి subordinate IDకు file చెందుతుంది. మీ shellకు access permissions మరియు ACLsపై ఆధారపడి ఉంటుంది. Deletion సాధారణంగా containing directoryపై ఆధారపడి ఉంటుంది. కాబట్టి మీరు నియంత్రించే directory నుంచి ఆ fileను delete చేయవచ్చు. అందువల్ల rootful daemonలో సరైన PUID value ఇక్కడ తప్పు కావచ్చు. ఈ రెండు mechanisms వేర్వేరు layersలో ownershipను మారుస్తాయి. తనిఖీ చేయకుండా రెండింటినీ కలిపితే mounted dataకు write చేయలేని పరిస్థితి ఏర్పడవచ్చు. Rootlessకు మారితే, libraryని migrate చేయడానికి ముందు మీ serverలో ఒక వ్రాయబడిన file ownershipను పరీక్షించండి.

ఒకే VPSలో నడిచే చాలా self-hosted stacksకు rootful daemonపై PUID మరియు PGID ఉపయోగించడం practical choice. ఎందుకంటే images వాటి కోసం రూపొందించబడి, documentationలో కూడా అదే విధంగా సూచించబడతాయి. Image README ఆ imageను పరీక్షించిందని చెప్పినప్పుడు లేదా PUID support లేని official upstream imageను నడుపుతున్నప్పుడు user: ను ఉపయోగించండి. ఒకే VPSలో self-hosted AFFiNE instance వంటి document workspace చివరి పరిస్థితికి చెందుతుంది. దాని containers ఏవీ PUIDను చదవవు. అందువల్ల database directory మరియు uploaded files ownership environment blockలోని దేనివల్ల కాదు, runtime నిర్ణయిస్తుంది. self-hosted Chatwoot support desk విషయంలో కూడా ఇదే వర్తిస్తుంది. Rails container మరియు దాని Sidekiq worker రెండూ ఒకే uploads directoryలో వ్రాస్తాయి. వాటిలో ఏదీ PUIDను చదవదు. కాబట్టి ఆ directory image ఇప్పటికే అమలు చేస్తున్న userకు సరిపోవాలి. Newer stackలో కూడా ఇది మారదు. అందువల్ల బృందంలోని ప్రతి వ్యక్తికి sandboxed OneCLI agentను అందించడం వలన ప్రతి వ్యక్తి workspace directories మరియు Postgres data directory, ప్రతి image ఇప్పటికే అమలు చేస్తున్న userకు చెందినవిగానే ఉంటాయి. ఇది user: మరియు chown సమస్య, PUID సమస్య కాదు. Codex, Claude Code మరియు Hermes ముందు ఒకే self-hosted APIని ఉంచడం ద్వారా దాని entrypoint అనేక identitiesను నిర్వహిస్తుంది: container rootగా ప్రారంభం కావాలి, console మరియు gateway unprivileged userగా నడవాలి, ప్రతి agent session తన స్వంత userగా నడవాలి. ఆ deploymentకు user: ను జోడించవద్దు. దాని entrypoint data volume ownershipను స్వయంగా నిర్వహిస్తుంది.

మీడియా stack ఉదాహరణ: containers అన్నింటికీ ఒకే shared group

ఒక Sonarr, Radarr మరియు download client కలిగిన arr media stackలో ఇది కేవలం సిద్ధాంతం కాదు. Download client పూర్తయిన file ను /data/downloadsలో రాస్తుంది. తరువాత Sonarr ఆ file కు hardlink సృష్టిస్తుంది లేదా దాన్ని /data/mediaలోకి move చేస్తుంది. Hardlink పనిచేయాలంటే రెండు containers కు ఒకే tree పై write access ఉండాలి. Download client 1000గా, Sonarr 1001గా నడుస్తూ shared group write permissions లేకపోతే, వాటిలో ఒకటి సృష్టించిన files ను మరొకటి read మాత్రమే చేయగలదు.

దీనికి పరిష్కారం stackలోని ప్రతి container తన PGIDగా ఉపయోగించే shared group:

sudo groupadd -g 13000 media
sudo usermod -aG media deploy
sudo chown -R deploy:media /srv/media
sudo find /srv/media -type d -exec chmod 2775 {} +
sudo find /srv/media -type f -exec chmod 0664 {} +

2775లో ప్రారంభంలోని 2 setgid bit. Directoryపై ఇది అంటే, దాని లోపల సృష్టించే ప్రతి కొత్త file మరియు subdirectory, సృష్టించిన user యొక్క primary group బదులుగా media group ను inherit చేసుకుంటాయి. అందువల్ల ప్రతి కొత్త download తర్వాత మీరు మళ్లీ chown అమలు చేయాల్సిన అవసరం ఉండదు. మీ స్వంత access ను తనిఖీ చేసే ముందు log out చేసి మళ్లీ log in అవ్వండి లేదా newgrp media అమలు చేయండి. usermod -aGతో జోడించిన group ఇప్పటికే తెరిచి ఉన్న shell sessionలో కనిపించదు.

Containerలో groupmod -o -g 13000 abc, abc group ను 13000గా renumber చేస్తుంది. అందువల్ల abc మీ hostలోని media groupకు సమానమైన GIDతో files రాస్తుంది. ఈ treeను access చేసే ప్రతి linuxserver container తన స్వంత PUIDను ఉంచుకుని, అదే PGIDను share చేస్తుంది. పూర్తయిన libraryని మాత్రమే read చేసే chainలోని తరువాతి containers కూడా ఇందులో ఉంటాయి. Jellyfin కూడా అందులో భాగమే. ఆ libraryని నడిచి చూడగలిగే 90s video storeగా అందించే Halcyon వంటి front end, HALCYON_JELLYFIN_URL ఉపయోగించి HTTP ద్వారా Jellyfinకు connect అవుతుంది. దాని standard deploymentకు shared media PGID లేదా media-directory mount అవసరం లేదు.

తరువాత stackలోని ప్రతి linuxserver containerపై UMASK=002 set చేయండి. చాలామంది మర్చిపోయే దశ ఇదే. ఇది set చేయకపోతే, మరేదైనా మార్చే వరకు application తన inherited umaskనే ఉపయోగిస్తుంది. Image READMEsలో చూపించే example value UMASK=022. Effective umask 022గా ఉన్నప్పుడు, కొత్త file కోసం application 0666 కోరితే, default ACL లేనప్పుడు 0644 లభిస్తుంది. Groupలోని ఇతర సభ్యులు ఆ fileను read చేయగలరు, కానీ మార్చలేరు. మీరు ఇప్పుడే చేసిన sharing configurationలో ఇది ఎక్కువ భాగాన్ని నిర్వీర్యం చేస్తుంది. 002 మరియు default ACL లేకుండా, application files కోసం సాధారణ 0666, directories కోసం 0777 కోరితే, 0664 files మరియు setgid tree లో 2775 directories లభిస్తాయి. అప్పుడు group write చేయగలదు. Umask bitsను తొలగిస్తుంది మాత్రమే. కాబట్టి application 0600 కోరితే 0600 ఇప్పటికీ లభిస్తుంది. Default ACL కలిగిన directory అయితే umaskను పూర్తిగా పట్టించుకోదు. PUID మరియు PGID పక్కన ఈ variableను జోడించండి:

services:
  sonarr:
    image: lscr.io/linuxserver/sonarr:latest
    container_name: sonarr
    environment:
      - PUID=${PUID}
      - PGID=${PGID}
      - UMASK=002
      - TZ=Etc/UTC
    volumes:
      - /srv/appdata/sonarr:/config
      - /srv/media:/data
    restart: unless-stopped

ఈ రెండు values Compose file పక్కన ఉన్న .env fileలో ఉండాలి. అప్పుడు మొత్తం stack ఒకే definitionను చదువుతుంది:

PUID=1000
PGID=13000

${PUID} తరహా substitution కోసం Compose ఆ fileను స్వయంచాలకంగా చదువుతుంది. Credentials కోసం మీరు ఉపయోగించే mechanism ఇదే. valuesను docker-compose.ymlలో ఉంచకుండా .env fileలో ఉంచే విధానం ఇక్కడ కూడా వర్తిస్తుంది. అయితే ఈ రెండు numbers secret కావు.

Configurationను నమ్మకుండా end to endగా verify చేయండి. Application userగా కొత్త fileను రాయండి. Configured umaskను వర్తింపజేసి, ఆ fileను host నుంచి read చేయండి. ఇప్పటికే లేని test filenameను ఉపయోగించండి:

docker exec --user abc sonarr sh -c 'umask "$UMASK" && touch /data/downloads/permtest'
ls -ln /srv/media/downloads/permtest

సరైన ఫలితంలో ownerగా మీ PUID, groupగా 13000, modeగా -rw-rw-r-- కనిపిస్తాయి. Groupలో 1000 కనిపిస్తే ls -ldn /srv/media/downloads అమలు చేయండి. ఆ directoryలో setgid bit, అంటే drwxrwsr-xలోని s, లేకపోవచ్చు. లేదా directory ఇప్పటికీ mediaకు బదులుగా group 1000కు చెందినదై ఉండవచ్చు. పై chown మరియు chmod 2775 commands ఈ రెండు సమస్యలను పరిష్కరిస్తాయి. Mode -rw-r--r--గా కనిపిస్తే containerలోని UMASK value మరియు directory default ACLను తనిఖీ చేయండి. Environment పాతదిగా ఉంటే containerను recreate చేయండి. ఈ test configured maskతో abcగా file creationను తనిఖీ చేస్తుంది. Application ఉపయోగించే creation mode మరియు effective umask దాని filesను ఇంకా నిర్ణయిస్తాయి. పని పూర్తైన తర్వాత rm /srv/media/downloads/permtestతో test fileను తొలగించండి.

ఏ images ఏ variableలను ఉపయోగిస్తాయి

linuxserver.io images PUID, PGID మరియు UMASK ను ఉపయోగిస్తాయి. Paperless-ngx ఇదే భావనకు వేర్వేరు పేర్లను ఉపయోగిస్తుంది: USERMAP_UID మరియు USERMAP_GID. ఈ రెండింటి default విలువ 1000. వాటిని id -u మరియు id -g నుంచి చదవాలని దాని documentation చెబుతుంది. Photo serverలలో కూడా ఇదే విధమైన తేడా కనిపిస్తుంది: PhotoPrism కు స్వంత PHOTOPRISM_UID మరియు PHOTOPRISM_GID జత ఉన్నాయి. Immich కు దీనికి సమానమైన setting లేదు. బదులుగా container user కోసం Docker యొక్క user: key పై ఆధారపడుతుంది. అందువల్ల PhotoPrism మరియు Immich మధ్య ఎంపిక చేయడం అంటే, ఆ serverలోని అతిపెద్ద library కోసం మీరు ఏ విధానాన్ని నిర్వహించాలో కూడా నిర్ణయించడమే. సాధారణ database మరియు web server images సహా అనేక official upstream images, built-in user ను స్థిరంగా కలిగి ఉంటాయి. వాటిలో user: ను ఉపయోగించాలని లేదా దానిని మార్చకుండా వదిలేయాలని ఆశిస్తాయి. చిన్న single-app deployments లో కూడా ఇదే ప్రశ్న వస్తుంది. కాబట్టి self-hosted openGym workout tracker ను ఏర్పాటు చేసేటప్పుడు bind mount ను దానికి అనుసంధానించే ముందు, దాని container వాస్తవంగా ఏ user గా నడుస్తుందో పరిశీలించాలి. మీరు PUID సెట్ చేయకపోయినా, దాని database ఉన్న directory ownership ఆ user ఆధారంగానే ఉంటుంది. Remote access relay కూడా ఇదే వర్గంలోకి వస్తుంది. కాబట్టి మీ స్వంత RustDesk relay server ను నడిపేటప్పుడు, మొదటి start సమయంలో hbbs రాసే Ed25519 key pair, ఆ image చివరికి ఏ user గా నడిచిందో ఆ user ownershipతో మీ bind mount లోకి వస్తుంది. తరువాత host side chown తో ownership ను సరిచేయవచ్చు. లేదా user: key తో ముందుగానే identity ను ఎంచుకోవచ్చు. ఈ image స్వయంగా ఏ user ను set చేయదు. అయితే మీరు ఎంచుకున్న ID కు mounted directory పై write permission ఉండాలి. తరువాత జోడించే infrastructure కు కూడా ఇదే వర్తిస్తుంది. అందువల్ల మీ apps ముందు ఒకే login కోసం Authentik ను ఉంచేటప్పుడు, PUID ను అసలు చదవని official authentik మరియు Postgres images ను నడుపుతారు. వాటి volume ownership, processes ఏ users గా నడుస్తున్నాయో మరియు వారి entrypoints చేసే setup పై ఆధారపడి ఉంటుంది. Authentik తన Redis dependency ను release 2025.10 లో తొలగించింది.

కాబట్టి projects మధ్య environment block ను copy చేసే ముందు ప్రతి image యొక్క README ను పరిశీలించండి. మీరు set చేసిన ఏ environment variable అయినా Docker ప్రతి container లోకి పంపుతుంది. Container లోని ఏదీ దాన్ని చదవకపోయినా ఇది జరుగుతుంది. ఏదీ ఉపయోగించని PUID ఎటువంటి error, warning లేదా ప్రభావాన్ని కలిగించదు. Container, Docker యొక్క user: setting లేదా Dockerfile ఎంచుకున్న user గా ప్రారంభమవుతుంది. తరువాత application ను ప్రారంభించే ముందు దాని entrypoint privileges ను తగ్గించవచ్చు. Box కు ఏదైనా కొత్తది జోడించే ముందు ఈ విషయాన్ని పరిశీలించండి. ఇందులో self-hosted open-kritt security scanning stack కూడా ఉంటుంది. దాని Compose file images PUID ను support చేస్తాయా లేదా మీరు mount చేసే directories ownership ను images స్వయంగా నిర్ణయిస్తాయా అన్నది చూపిస్తుంది.

FAQ

నా Docker files 911:911 కు చెందినవిగా ఎందుకు కనిపిస్తున్నాయి?

911 అనేది linuxserver.io images లో built-in గా ఉన్న abc user యొక్క UID మరియు GID. ఇది built-in defaults కు సరిపోతుంది. అయితే container యొక్క PUID మరియు PGID మార్చిన తర్వాత కూడా files ఆ ownership ను కొనసాగించవచ్చు. మీ host లో ఆ IDs కు సరిపోయే account లేకపోతే, ls -l raw numbers ను చూపిస్తుంది; అందువల్ల చూపించడానికి పేరు ఉండదు. PUID మరియు PGID ను id output కు సెట్ చేయండి. తరువాత docker compose up -d తో container ను recreate చేయండి. ప్రభావిత directory లోని ఇప్పటికే ఉన్న files ను sudo chown -R 1000:1000 తో సరిచేయండి.

ప్రతి Docker image లో PUID మరియు PGID పనిచేస్తాయా?

లేదు. అవి Docker feature కావు. Docker వాటిని ఎప్పుడూ చదవదు. Image యొక్క స్వంత entrypoint వాటిని చదివి, application ప్రారంభించే ముందు usermod మరియు groupmod ను అమలు చేసినప్పుడు మాత్రమే అవి పనిచేస్తాయి. linuxserver.io family మరియు ఈ విధానాన్ని అనుసరించిన కొన్ని projects లో ఇది ఉంటుంది. ఇతర projects వేరే పేర్లను ఉపయోగిస్తాయి. ఉదాహరణకు paperless-ngx లో USERMAP_UID మరియు USERMAP_GID ఉపయోగిస్తారు. ఈ రెండింటినీ చదవని image లో variables ఎటువంటి హెచ్చరిక లేకుండా స్వీకరించబడతాయి మరియు విస్మరించబడతాయి.

Docker Compose లో PUID మరియు PGID లేదా user: key ను ఉపయోగించాలా?

Image వాటికి support ఇస్తే PUID మరియు PGID ను ఉపయోగించండి. అప్పుడు entrypoint కొంతకాలం root గా నడుస్తూ /config ను సరిచేసి, తన services ను సరిగ్గా ప్రారంభించగలదు. ఎంచుకున్న user కు image support ఉందని documentation లో పేర్కొంటే user: ను ఉపయోగించండి. PUID support లేకపోవడం ఒక్కటే entrypoint root లేకుండా పనిచేస్తుందని అర్థం కాదు. linuxserver image లో user: సెట్ చేస్తే PUID మరియు PGID ప్రభావం లేకుండా పోతాయి. Docker Mods మరియు custom services అమలు కావు. ప్రతి mounted volume permissions మీ బాధ్యత అవుతాయి.

Sonarr కు సరైన PUID ఉన్నా files ను move చేయలేకపోతోంది. సమస్య ఏమిటి?

మూడు విషయాలను ఈ క్రమంలో పరిశీలించండి. మొదట media mount ను పరిశీలించండి. Base image యొక్క user setup script /app, /config మరియు /defaults పై chown చేస్తుంది. అందువల్ల /data లేదా /downloads host లో ఉన్న ownership ను అలాగే ఉంచుతుంది. రెండవది shared group ను పరిశీలించండి. Media tree ను access చేసే containers కు ఒకే PGID మరియు group write permissions ఇవ్వండి. మూడవది umask ను పరిశీలించండి. Application 0666 ను అభ్యర్థించినప్పుడు, default ACL వర్తించకపోతే effective mask 022 ఉంటే 0644 files ఉత్పత్తి అవుతాయి. అప్పుడు group లోని ఇతర containers వాటిని చదవగలవు, కానీ మార్చలేవు. UMASK ను unset గా ఉంచడం ద్వారా నిర్దిష్ట mask లేదా file mode ఖచ్చితంగా వస్తుందని హామీ లేదు. UMASK=002 ను సెట్ చేయండి. కొత్త files group ను inherit చేసుకునేలా directories పై setgid bit ను chmod 2775 తో సెట్ చేయండి. Application 0600 ను అభ్యర్థిస్తే private files సృష్టిస్తుంది. Default ACL ఉంటే creation permissions కేటాయించే విధానం మారుతుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?