Docker Compose मध्ये PUID आणि PGID काय करतात?
PUID आणि PGID ही Docker settings नाहीत, तर linuxserver.io images मधील entrypoint convention आहे. bind mount मधील files 911:911 का होतात आणि ते कसे दुरुस्त करायचे ते जाणून घ्या.
PUID आणि PGID प्रत्यक्षात काय आहेत
PUID आणि PGID हे दोन environment variables आहेत, जे काही container images startup वेळी वाचतात. 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 चालवतो. त्या scripts पैकी एक application सुरू होण्यापूर्वी या user चे IDs बदलतो:
groupmod -o -g "${PGID}" abc
usermod -o -u "${PUID}" abc-o flag मुळे इतरत्र आधीच वापरात असलेला ID वापरता येतो. त्यानंतर init privileges कमी करते आणि application abc म्हणून चालवते. त्यामुळे Docker PUID=1000 इतर कोणत्याही environment variable प्रमाणे container मध्ये पाठवतो आणि त्यावर स्वतः कोणतीही प्रक्रिया करत नाही. Application सुरू होण्यापूर्वी हे variable container मधील user चे IDs बदलते. त्यामुळे user namespace remapping नसलेल्या standard rootful daemon मध्ये नव्याने तयार झालेल्या files तुमच्या disk वर साधारणपणे 1000 च्या मालकीच्या असतात. आधीपासून writable असलेली file लिहिल्याने तिचा owner बदलत नाही. Rootless Docker हा ID बदलतो; याचे स्पष्टीकरण पुढे दिले आहे. PUID unset ठेवल्यास abc 911 वरच राहतो. म्हणून configuration न केलेला bind mount 911:911 च्या मालकीच्या files ने भरतो.
id वापरून तुमचे दोन क्रमांक मिळवा
हे host वर, data directories चा मालक असलेल्या user म्हणून चालवा:
iduid=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 असतो; परंतु असे गृहीत धरू नका. उपलब्ध accounts आणि configuration नुसार allocation बदलते: पुन्हा तयार केलेला server 1000 पुन्हा allocate करू शकतो, तर नंतर तयार केलेल्या account ला जास्त उपलब्ध ID मिळतो. तुमच्या services तुमच्या login user ऐवजी dedicated service account अंतर्गत चालत असल्यास, id thatuser चालवा आणि त्यातून क्रमांक घ्या.
तुमच्या फाइल्स 911:911 म्हणून का दिसतात
ls -l ला त्या ID शी जुळणारे host account नसल्यास नावाऐवजी numeric ID दाखवला जातो. UID 911 शी जुळणारे कोणतेही host account नसल्यास दाखवण्यासाठी नाव उपलब्ध नसते. प्रत्येक वेळी संख्या पाहण्यासाठी ls -ln वापरा आणि ही संदिग्धता दूर करा:
ls -ln /srv/appdata/sonarrdrwxr-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 मधील अंगभूत default settings शी जुळते. मात्र, फक्त विद्यमान फाइल्सवरून application सध्या कोणत्या user म्हणून चालते हे सिद्ध होत नाही. त्या listing मधील config.xml ही authentication settings ठेवणारी फाइल देखील आहे. त्यामुळे web UI प्रथमच उघडताना Sonarr आणि Radarr कोणतेही default username किंवा password देऊन release होत नाहीत हे महत्त्वाचे ठरते. अंदाज न लावता container च्या आतून याची खात्री करा:
docker exec sonarr id abc
docker compose logs sonarr | head -n 25linuxserver init त्याचा result startup log मध्ये दोन ओळींमध्ये दाखवतो:
User UID: 911
User GID: 911Compose file मध्ये PUID=1000 सेट केल्यानंतर त्या ओळींमध्ये 911 दिसत असल्यास, चालू container तुम्ही सेट केलेली value वापरत नाही. नेहमीचे कारण असे असते की तुम्ही docker-compose.yml संपादित करून नंतर docker compose restart चालवले. यामुळे मूळ environment सह विद्यमान container पुन्हा वापरला जातो. Environment मधील बदलांसाठी docker compose up -d आवश्यक आहे. यामुळे container पुन्हा तयार केला जातो. दुसरे कारण जाणूनबुजून केलेले वर्तन असू शकते: image read-only किंवा non-root mode मध्ये चालत असल्यास, container मध्ये variable उपलब्ध असली तरी init renumbering पूर्णपणे वगळतो. Read-only mode मध्ये banner abc चा न बदललेला ID दाखवतो; non-root mode मध्ये तो /run च्या owner ची माहिती दाखवतो.
कंटेनरने लिहिलेली फाइल तुम्ही का हटवू शकत नाही
Kernel नावांची नाही, तर क्रमांकांची तुलना करतो. तुमचा shell UID 1000 म्हणून चालतो. ही फाइल UID 911 च्या मालकीची आहे. ती असलेली directory drwxr-xr-x आहे आणि तीदेखील 911 च्या मालकीची आहे. त्यामुळे group आणि other कडे read आणि execute permission आहेत, पण write permission नाही. फाइल हटवण्यासाठी फाइलवर नव्हे, तर तिच्या directory वर write permission आवश्यक असते. म्हणून फाइल स्वतः निरुपद्रवी दिसत असली तरी तुम्हाला हे दिसते:
rm: cannot remove '/srv/appdata/sonarr/config.xml': Permission deniedलिहिणाऱ्या कंटेनरलाही उलट बाजूने हीच अडचण येते. Host directory तुमच्या user च्या मालकीची आणि mode 755 वर असल्यास, application 911 म्हणून चालत असेल तर तिचे पहिले write operation Permission denied मुळे अयशस्वी होते. Application हे कारण स्वतःच्या संदेशात दाखवते. Sonarr किंवा Radarr सारख्या .NET application मध्ये ते UnauthorizedAccessException: Access to the path '/data/downloads' is denied म्हणून दिसते. फाइलच्या सुरुवातीला असलेली permission string तुम्हाला तीन permission sets पैकी कोणत्या संचाच्या आधारे तपासले जात आहे ते सांगते. drwxr-xr-x योग्य प्रकारे वाचणे या error चे कारण गूढ न ठेवता स्पष्ट करते.
ही विशेषतः bind mount ची समस्या आहे. Docker एखादे empty named volume तयार करून ते image मधील आधीपासून अस्तित्वात असलेल्या path वर mount करते, तेव्हा त्या path मधील contents volume मध्ये copy केले जातात. त्यात ownership आणि permission bits देखील समाविष्ट असतात. त्यामुळे application ला आधीपासून आपल्या मालकीची directory मिळते. Bind mount ला अशी कोणतीही प्रक्रिया लागू होत नाही. Docker तुमची host directory जशी आहे तशीच mount करतो. bind mount named volume पेक्षा कधी चांगला ठरतो आणि कधी नाही हे समजून घेण्याचे हे एक व्यावहारिक कारण आहे.
आधीच चुकीच्या मालकीचा असलेला directory दुरुस्त करणे
PUID आणि PGID सेट केल्याने application यापुढे कसे कार्य करेल ते बदलते. डिस्कवर आधीपासून असलेल्या प्रत्येक file ची मालकी ते पूर्वलक्षी पद्धतीने दुरुस्त करत नाही. मात्र, खाली वर्णन केलेल्या विशिष्ट paths वरील ownership init दुरुस्त करते. Stack थांबवा, ownership स्वतः दुरुस्त करा आणि नंतर तो पुन्हा सुरू करा:
docker compose down
sudo chown -R 1000:1000 /srv/appdata/sonarr
docker compose up -dतुम्हाला numbers टाइप करायचे नसतील, तर sudo chown -R "$(id -u):$(id -g)" /srv/appdata/sonarr वापरा. Container थांबवलेला असतानाच हे करा. कारण recursive chown सुरू असताना application file लिहित असेल, तर directory tree अंशतः दुरुस्त होऊ शकतो आणि errors ची दुसरी, गोंधळात टाकणारी फेरी निर्माण होऊ शकते.
PUID आणि PGID काय दुरुस्त करत नाहीत
सर्व काही योग्यरीत्या केल्यानंतरही काही वापरकर्त्यांच्या लक्षात न येणारा हा भाग आहे. linuxserver base image ची user setup script सुरू होताना तीन paths वर chown करते: /app, /config आणि /defaults. तुमचे media mounts या यादीत नाहीत. /data, /downloads आणि /tv application कडे कोणताही बदल न करता दिले जातात. त्यामुळे या mounts च्या host बाजूची ownership container user ला लिहिण्याची परवानगी देत नसेल, तर container व्यवस्थित सुरू होतो, त्याच्या banner मध्ये योग्य UID दाखवतो आणि त्यानंतर पहिल्याच import वेळी अपयशी ठरतो.
हेच योग्य वर्तन आहे. प्रत्येक container सुरू होताना बारा terabyte media library वर recursive chown चालवणे आपत्तीजनक ठरेल. याचा अर्थ media directories ची जबाबदारी तुमची आहे. Permissions प्रत्यक्षात चुकीच्या ठरणारे mounts हेच आहेत. अशा प्रकारचे अपयश container निरोगी दिसल्यानंतर अनेक तासांनी application log मध्ये शांतपणे दिसू शकते. त्यामुळे तुमच्या स्वतःच्या VPS वरील ntfy, जे तुमच्या फोनवर alerts पाठवते यामध्ये periodic write test जोडणे हा ते कळण्याचा स्वस्त मार्ग आहे. Missing episodes चा प्रश्न आठवडाभर साचल्यानंतर लक्षात येण्यापूर्वीच तुम्हाला त्याची माहिती मिळते.
वापरकर्त्याचे नियंत्रण करण्याचे तीन मार्ग आणि प्रत्येक कधी वापरावा
PUID आणि PGID environment variables
हे केवळ अशा images वर कार्य करते ज्यांचा entrypoint हे variables वाचतो. ही पद्धत लोकप्रिय आहे, कारण container सुरुवातीला root म्हणून सुरू होतो, स्वतःची setup प्रक्रिया पूर्ण करतो, /config दुरुस्त करतो आणि त्यानंतरच privileges कमी करतो. Docker Mods आणि custom init scripts कार्यरत राहतात. मात्र, यासाठी platform feature ऐवजी एका प्रचलित पद्धतीवर विश्वास ठेवावा लागतो. तसेच variable names वेगवेगळ्या projects मध्ये 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 मिळतो. मात्र, entrypoint मधील root privileges आवश्यक असलेली कोणतीही गोष्ट कार्य करणार नाही. linuxserver images वर project हे reasonable endeavours basis वर आणि केवळ त्याने तपासलेल्या images साठी support करते. यातील अटी स्पष्ट आहेत: 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 मध्ये matching 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 arithmetic पूर्णपणे बदलते. Container UID 0 हा rootless Docker चालवणाऱ्या user च्या host UID शी map होतो. तसेच n 1 किंवा त्याहून अधिक असलेल्या कोणत्याही n साठी container UID subuid + (n - 1) असा map होतो, जिथे subuid हा /etc/subuid मध्ये तुम्हाला दिलेल्या range चा base आहे. Group IDs साठीही /etc/subgid वापरून हाच नियम लागू होतो. Docker ला तेथे किमान 65,536 subordinate IDs अपेक्षित असतात.
ते mapping पुन्हा वाचा, कारण त्यामुळे नेहमीचा सल्ला उलट लागू होतो. Rootless Docker अंतर्गत container ने root म्हणून file तयार केली, तर ती सामान्यतः तुमच्या नावावर तयार होते. Container ने UID 1000 म्हणून file तयार केली, तर ती सामान्यतः subordinate ID च्या मालकीची होते. उदाहरणार्थ, range 100000 पासून सुरू होत असल्यास ती 100999 असू शकते. तुमच्या shell चा access permissions आणि ACLs वर अवलंबून असतो. File 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 वापरणे हा व्यावहारिक पर्याय आहे, कारण images याच पद्धतीसाठी तयार आणि documented असतात. Image README मध्ये त्या image साठी user: तपासलेले असल्याचे नमूद असल्यास किंवा PUID support नसलेली official upstream image वापरत असल्यास user: वापरा. एका VPS वरील self-hosted AFFiNE instance या शेवटच्या प्रकारात येते, कारण त्यातील कोणतेही container PUID वाचत नाही. त्याच्या database directory आणि uploaded files ची ownership environment block मधील कोणत्याही setting मुळे नव्हे, तर runtime मुळे निश्चित होते. self-hosted Chatwoot support desk साठीही हेच लागू होते. Rails container आणि त्याचा Sidekiq worker दोघेही एका uploads directory मध्ये लिहितात आणि त्यांपैकी कोणीही PUID वाचत नाही. त्यामुळे ती directory image आधीपासून ज्या user म्हणून चालते त्याच्याशी जुळली पाहिजे. नवीन stack साठीही हे बदलत नाही. म्हणून team मधील प्रत्येक व्यक्तीसाठी स्वतंत्र sandboxed OneCLI agent देणे यामध्ये प्रत्येक व्यक्तीच्या workspace directories आणि Postgres data directory ची ownership प्रत्येक 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 स्वतः व्यवस्थापित करतो.
कंटेनरमध्ये सामायिक केलेला group: media stack चे उदाहरण
Sonarr, Radarr आणि download client असलेला arr media stack ही अशी परिस्थिती आहे जिथे हा विषय केवळ सिद्धांत राहत नाही. download client पूर्ण झालेली फाइल /data/downloads मध्ये लिहितो. त्यानंतर Sonarr ती फाइल /data/media मध्ये hardlink करतो किंवा हलवतो. hardlink कार्य करण्यासाठी दोन्ही कंटेनरना त्याच tree वर write access आवश्यक असतो. download client 1000 म्हणून, तर Sonarr 1001 म्हणून चालत असेल आणि shared group write permissions नसतील, तर त्यांपैकी एकाच्या मालकीच्या फाइल्स दुसरा कंटेनर फक्त वाचू शकतो.
यासाठी stack मधील प्रत्येक कंटेनरने 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 वर याचा अर्थ असा होतो की त्यात तयार होणारी प्रत्येक नवीन फाइल आणि subdirectory तयार करणाऱ्या वापरकर्त्याच्या primary group ऐवजी media हा group वारसा म्हणून घेते. त्यामुळे प्रत्येक नवीन download नंतर chown पुन्हा चालवण्याची गरज राहत नाही. स्वतःचा access तपासण्यापूर्वी logout करून पुन्हा login करा किंवा newgrp media चालवा. usermod -aG ने जोडलेला group आधीपासून उघडलेल्या shell session मध्ये दिसत नाही.
कंटेनरमध्ये groupmod -o -g 13000 abc हे abc group ला 13000 क्रमांक देते. त्यामुळे abc तुमच्या host वरील media group सारख्याच GID ने लिहितो. या tree ला access करणारा प्रत्येक linuxserver container स्वतःचा PUID ठेवतो आणि तोच PGID सामायिक करतो. पूर्ण झालेली library फक्त वाचणाऱ्या पुढील chain मधील कंटेनरनाही हे लागू होते, जसे Jellyfin. ही library 90s video store प्रमाणे browse करता येईल अशा स्वरूपात पुरवणारा Halcyon सारखा front end HALCYON_JELLYFIN_URL वापरून HTTP द्वारे Jellyfin शी जोडतो. त्याच्या standard deployment साठी shared media PGID किंवा media-directory mount यापैकी कशाचीही गरज नसते.
यानंतर stack मधील प्रत्येक linuxserver container वर UMASK=002 सेट करा. हा टप्पा अनेकदा चुकतो. तो सेट न केल्यास, अन्य कोणताही बदल होईपर्यंत application ला inherited umask वापरावा लागतो. Image README मध्ये दाखवलेले उदाहरणमूल्य UMASK=022 आहे. Effective umask 022 असल्यास आणि default ACL नसल्यास, नवीन फाइलीसाठी application ने 0666 मागितल्यावर तिला 0644 मिळते. त्यामुळे group मधील इतर सदस्य ती फाइल वाचू शकतात, पण बदलू शकत नाहीत. यामुळे तुम्ही नुकतीच केलेली sharing configuration बहुतांश निष्फळ ठरते. 002 आणि default ACL नसताना, files साठी नेहमीचा 0666 आणि directories साठी 0777 मागणाऱ्या application ला अनुक्रमे 0664 files आणि setgid tree मध्ये 2775 directories मिळतात. त्यामुळे group ला write access मिळतो. umask फक्त permission 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ही दोन्ही मूल्ये Compose file च्या शेजारी असलेल्या .env file मध्ये ठेवा. त्यामुळे संपूर्ण stack एकच definition वापरतो:
PUID=1000
PGID=13000Compose ${PUID} प्रकारच्या substitution साठी ही file आपोआप वाचतो. Credentials साठी वापरली जाणारी हीच यंत्रणा आहे. मूल्ये docker-compose.yml मध्ये न ठेवता .env file मध्ये ठेवण्याची पद्धत येथेही लागू होते. फरक इतकाच की ही दोन्ही संख्या secret नाहीत.
Configuration वर केवळ अवलंबून न राहता end-to-end पडताळणी करा. Application user म्हणून configured umask लागू करून नवीन फाइल लिहा आणि ती host वरून वाचा. आधीपासून अस्तित्वात नसलेले test filename वापरा:
docker exec --user abc sonarr sh -c 'umask "$UMASK" && touch /data/downloads/permtest'
ls -ln /srv/media/downloads/permtestयोग्य निकालात तुमचा PUID owner, 13000 group आणि -rw-rw-r-- mode म्हणून दिसतो. Group 1000 असा दिसत असल्यास ls -ldn /srv/media/downloads चालवा. याचा अर्थ त्या directory मधून setgid bit, म्हणजे drwxrwsr-x मधील s, गहाळ आहे किंवा directory स्वतः 1000 या group ची आहे, media ची नाही. वर दिलेले chown आणि chmod 2775 commands दोन्ही समस्या दूर करतात. Mode -rw-r--r-- असा दिसत असल्यास कंटेनरचे UMASK मूल्य आणि directory चे default ACL तपासा. Environment जुने असल्यास कंटेनर पुन्हा तयार करा. ही चाचणी configured mask सह abc म्हणून file तयार करण्याची प्रक्रिया तपासते. Application चा स्वतःचा creation mode आणि effective umask यांवर तिच्या फाइल्सचे permissions अजूनही अवलंबून असतात. काम पूर्ण झाल्यावर rm /srv/media/downloads/permtest वापरून test file काढून टाका.
कोणती प्रतिमा कोणता चल वापरतात
linuxserver.io प्रतिमा PUID, PGID आणि UMASK वापरतात. Paperless-ngx याच संकल्पनेसाठी वेगळी नावे वापरते: USERMAP_UID आणि USERMAP_GID. या दोन्हींचे default मूल्य 1000 असते. त्यांची कागदपत्रे ही मूल्ये id -u आणि id -g मधून वाचण्यास सांगतात. फोटो सर्व्हरमध्येही अशीच विविधता दिसते: PhotoPrism ची स्वतःची PHOTOPRISM_UID आणि PHOTOPRISM_GID ही जोडी आहे, तर Immich मध्ये याचा समतुल्य पर्याय नाही. तो container user साठी Docker मधील user: key वर अवलंबून असतो. त्यामुळे PhotoPrism आणि Immich पैकी निवडणे म्हणजे सर्व्हरवरील सर्वात मोठ्या library साठी यापैकी कोणती पद्धत तुम्ही व्यवस्थापित करणार हेही ठरवणे होय.
अनेक अधिकृत upstream प्रतिमा, त्यात सामान्य database आणि web server प्रतिमांचाही समावेश आहे, fixed built-in user सह येतात. त्या तुम्ही user: वापरावे किंवा तो बदलू नये अशी अपेक्षा करतात. छोट्या single-app deployment मध्येही हाच प्रश्न लागू होतो. त्यामुळे self-hosted openGym workout tracker उभारताना त्याचा container प्रत्यक्षात कोणत्या user म्हणून चालतो हे bind mount जोडण्यापूर्वी तपासा. त्याच्या database च्या directory ची ownership तुम्ही PUID सेट केला नसला तरी या user वर अवलंबून असते.
Remote access relay देखील याच प्रकारात येतो. त्यामुळे स्वतःचा RustDesk relay server चालवताना hbbs पहिल्यांदा सुरू झाल्यावर लिहित असलेली Ed25519 key pair तुमच्या bind mount मध्ये त्या image ने शेवटी वापरलेल्या user च्या ownership सह तयार होते. त्यानंतर host वरील chown वापरून ती ownership दुरुस्त करता येते. किंवा user: key वापरून सुरुवातीपासून identity निवडता येते. या image मध्ये स्वतःचा user सेट केलेला नसतो. मात्र mounted directory तुम्ही निवडलेल्या ID साठी writable असणे आवश्यक आहे.
नंतर जोडलेल्या infrastructure साठीही हेच लागू होते. त्यामुळे एकाच login साठी तुमच्या अॅप्ससमोर Authentik ठेवताना अधिकृत authentik आणि Postgres प्रतिमा चालवाव्या लागतात. या प्रतिमा PUID अजिबात वाचत नाहीत. त्यांच्या volume ची ownership त्यांच्या process ज्या user म्हणून चालतात आणि त्यांच्या entrypoint कडून होणाऱ्या setup वर अवलंबून असते. Authentik ने release 2025.10 मध्ये Redis dependency काढून टाकली.
म्हणून projects मध्ये environment block copy करण्यापूर्वी प्रत्येक image चा README तपासा. तुम्ही सेट केलेला कोणताही environment variable Docker प्रत्येक container मध्ये पाठवतो, त्याच्या आतला कोणताही घटक तो वाचत असो वा नसो. काहीही वापरत नसलेला PUID कोणतीही error, warning किंवा परिणाम निर्माण करत नाही. Container Docker च्या user: setting किंवा Dockerfile ने निवडलेल्या user म्हणून सुरू होतो. त्यानंतर त्याचा entrypoint application सुरू करण्यापूर्वी privileges कमी करू शकतो.
Box मध्ये नवीन काहीही जोडण्यापूर्वी ही माहिती तपासा. यात self-hosted open-kritt security scanning stack चाही समावेश आहे. त्या stack ची Compose file प्रतिमा PUID स्वीकारतात की mounted directories ची ownership प्रतिमांनीच निश्चित केलेली आहे हे स्पष्ट करते.
FAQ
माझ्या Docker फाइल्स 911:911 मालकीच्या का आहेत?
911 हा linuxserver.io images मध्ये अंगभूत असलेल्या abc user चा UID आणि GID आहे. हे अंगभूत defaults शी जुळते. मात्र container चे PUID आणि PGID बदलल्यानंतरही फाइल्स तीच मालकी राखू शकतात. तुमच्या host वरील कोणतेही account या IDs शी जुळत नसल्यास ls -l कच्चे numbers दाखवते; म्हणून display करण्यासाठी नाव उपलब्ध नसते. id च्या output प्रमाणे PUID आणि PGID सेट करा. त्यानंतर docker compose up -d वापरून container पुन्हा तयार करा आणि प्रभावित directory मधील विद्यमान फाइल्सची मालकी sudo chown -R 1000:1000 ने दुरुस्त करा.
PUID आणि PGID प्रत्येक Docker image वर कार्य करतात का?
नाही. ते Docker चे feature नाहीत आणि Docker ते कधीही वाचत नाही. ज्या images चा स्वतःचा entrypoint हे variables वाचतो आणि application सुरू करण्यापूर्वी usermod आणि groupmod चालवतो, त्यांच्यावरच ते कार्य करतात. यामध्ये linuxserver.io family आणि ही पद्धत स्वीकारलेले काही projects येतात. इतर projects इतर names वापरतात. उदाहरणार्थ, paperless-ngx मध्ये USERMAP_UID आणि USERMAP_GID वापरले जातात. एखादी image यापैकी कोणतेही variable वाचत नसल्यास ते variables स्वीकारले जातात आणि कोणतीही warning न देता दुर्लक्षित केले जातात.
Docker Compose मध्ये PUID आणि PGID वापरावे की user: key वापरावी?
Image त्यांना support करत असल्यास PUID आणि PGID वापरा. यामुळे entrypoint root म्हणून पुरेसा वेळ चालू राहतो, त्यामुळे /config दुरुस्त करून स्वतःच्या services योग्य प्रकारे सुरू करता येतात. Image ने निवडलेल्या user साठी support documented केले असल्यास user: वापरा. केवळ PUID support नसल्यामुळे entrypoint root शिवाय कार्य करेलच असे नाही. linuxserver image वर user: सेट केल्यास PUID आणि PGID निष्क्रिय होतात, Docker Mods आणि custom services चालणे थांबते आणि प्रत्येक mounted volume च्या permissions ची जबाबदारी तुमची राहते.
Sonarr कडे योग्य PUID असूनही फाइल्स हलवता येत नाहीत. समस्या काय आहे?
क्रमाने तीन गोष्टी तपासा. प्रथम, media mount तपासा. Base image ची user setup script /app, /config आणि /defaults वर chown करते. त्यामुळे /data किंवा /downloads ला host वरील विद्यमान मालकी कायम राहते. दुसरे, shared group तपासा. Media tree ला access करणाऱ्या containers ना समान PGID आणि group write permissions द्या. तिसरे, umask तपासा. Application ने 0666 ची विनंती केली आणि default ACL लागू नसल्यास, 022 च्या effective mask मुळे 0644 files तयार होतात. त्यामुळे group मधील इतर containers त्या फाइल्स वाचू शकतात, पण बदलू शकत नाहीत. UMASK unset ठेवल्याने विशिष्ट mask किंवा file mode मिळेलच याची हमी नसते. UMASK=002 सेट करा आणि directories वर setgid bit chmod 2775 ने सेट करा, जेणेकरून नवीन files ना group inherit होईल. Application ने 0600 ची विनंती केल्यास private files तयार होतात. Default ACL मुळे creation permissions कशा assign केल्या जातात ते बदलते.