ഡോക്കർ മൗണ്ട് പിശകുകൾ

Daniel Marino

2024, നവംബർ 9, ശനിയാഴ്‌ച 5:07:58 AM

എന്തുകൊണ്ടാണ് ഡോക്കറിന് എൻ്റെ മൗണ്ട് പാത്തിലേക്ക് എഴുതാൻ കഴിയാത്തത്? GitLab റണ്ണർ അനുമതികൾ ട്രബിൾഷൂട്ട് ചെയ്യുന്നു

ഡോക്കറിൽ ഒരു GitLab റണ്ണർ പ്രവർത്തിപ്പിക്കുന്നത് പലപ്പോഴും സുഗമമായി നടക്കുന്നു - മൌണ്ട് അനുമതികൾ എന്നതിൽ നിങ്ങൾ ഒരു തടസ്സപ്പെടുത്തുന്ന പിശക് നേരിടുന്നതുവരെ. 🐳 അടുത്തിടെ, ഞാൻ ഒരു "റീഡ്-ഒൺലി ഫയൽ സിസ്റ്റം" പ്രശ്നം നേരിട്ടു, അത് പരിഹരിക്കാൻ നിരവധി ശ്രമങ്ങൾ നടത്തിയിട്ടും ഒരു മൗണ്ട് പാത്ത് ആക്‌സസ് ചെയ്യുന്നതിൽ നിന്ന് ഡോക്കറിനെ തടഞ്ഞു. GitLab റണ്ണറിനായുള്ള ഒരു ഡോക്കർ കണ്ടെയ്‌നറിൽ `/srv/gitlab-runner/config` ഡയറക്‌ടറി മൌണ്ട് ചെയ്യാൻ ശ്രമിച്ചപ്പോൾ ഈ പിശക് ഉയർന്നു.

തുടക്കത്തിൽ, ഇതൊരു ഡയറക്‌ടറി അനുമതികൾ പ്രശ്‌നമാകാമെന്ന് ഞാൻ അനുമാനിച്ചു, അതിനാൽ ഞാൻ ഉടമസ്ഥതയും അനുമതികളും ക്രമീകരിക്കാൻ ശ്രമിച്ചു. എന്നിരുന്നാലും, ഈ മാറ്റങ്ങൾക്ക് ശ്രമിച്ചതിന് ശേഷവും, പിശക് തുടർന്നു, കൂടുതൽ വ്യവസ്ഥാപിതമായ എന്തെങ്കിലും സൂചന നൽകി. സജ്ജീകരണം ശരിയാണെന്ന് തോന്നുന്നു, എന്നിട്ടും പാത സൃഷ്ടിക്കുന്നതിനോ ആക്സസ് ചെയ്യുന്നതിനോ ഉള്ള ഏതൊരു ശ്രമവും ഡോക്കർ നിരസിക്കുന്നത് തുടർന്നു.

അടുത്തതായി, മൗണ്ട് ഓപ്‌ഷനുകൾ ഡയറക്‌ടറി റീഡ്-ഒൺലി ആക്കുന്നതിന് കാരണമാകുന്നുണ്ടോ എന്ന് ഞാൻ പരിശോധിച്ചു. എന്നെ അത്ഭുതപ്പെടുത്തിക്കൊണ്ട്, `/srv` യഥാർത്ഥത്തിൽ `ro` (വായിക്കാൻ-മാത്രം) ആട്രിബ്യൂട്ടുകൾ ഉപയോഗിച്ച് മൌണ്ട് ചെയ്തതായി കാണപ്പെട്ടു, ഒരുപക്ഷേ എൻ്റെ സിസ്റ്റത്തിൻ്റെ അന്തർലീനമായ ഡെബിയൻ അല്ലെങ്കിൽ ഡോക്കർ കോൺഫിഗറേഷനുകൾ കാരണം.

ഈ ലേഖനത്തിൽ, ഓരോ ട്രബിൾഷൂട്ടിംഗ് ഘട്ടവും ഞാൻ തകർക്കുകയും ഡോക്കർ ചില ഡയറക്‌ടറികളെ റീഡ്-ഒൺലി ആയി കണക്കാക്കുന്നത് എന്തുകൊണ്ടെന്ന് വിശദീകരിക്കുകയും ചെയ്യും. നിർദ്ദിഷ്ട പരിഹാരങ്ങൾ പര്യവേക്ഷണം ചെയ്യുന്നതിലൂടെ, സമാനമായ മൌണ്ട് പെർമിഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കാനും നിങ്ങളുടെ GitLab റണ്ണർ കണ്ടെയ്നർ സുഗമമായി പ്രവർത്തിപ്പിക്കാനും നിങ്ങളെ സഹായിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു! 🚀

കമാൻഡ്	ഉപയോഗത്തിൻ്റെ ഉദാഹരണം
mount \| grep "/srv"	മൌണ്ട് ചെയ്ത എല്ലാ ഫയൽസിസ്റ്റങ്ങളും ലിസ്റ്റുചെയ്യുന്നു, `/srv` ഡയറക്‌ടറിക്കായി ഫിൽട്ടർ ചെയ്യുന്നു. അനുമതി പ്രശ്‌നങ്ങൾ കണ്ടെത്തുന്നതിന് നിർണ്ണായകമായ റീഡ്-ഓൺലി (ro) അല്ലെങ്കിൽ റീഡ്-റൈറ്റ് (rw) ആയി ഡയറക്ടറി മൌണ്ട് ചെയ്തിട്ടുണ്ടോ എന്ന് പരിശോധിക്കാൻ ഈ കമാൻഡ് സഹായിക്കുന്നു.
sudo mount -o remount,rw /srv	റീഡ്-റൈറ്റ് അനുമതികളോടെ `/srv` ഡയറക്‌ടറി റീമൗണ്ട് ചെയ്യാനുള്ള ശ്രമങ്ങൾ. ഒരു ഡയറക്‌ടറി അശ്രദ്ധമായി റീഡ്-ഓൺലി ആയി മൌണ്ട് ചെയ്‌തിരിക്കുന്ന സാഹചര്യങ്ങൾക്ക് ഈ കമാൻഡ് സവിശേഷമാണ്, കൂടാതെ ഡോക്കർ വോളിയം ബൈൻഡിംഗുകൾ പ്രവർത്തിക്കുന്നതിന് എഴുതാവുന്നതായിരിക്കണം.
sudo chown -R 1000:1000 /srv/gitlab-runner	`/srv/gitlab-runner` ഡയറക്‌ടറിയുടെ ഉടമസ്ഥാവകാശം ഒരു നിർദ്ദിഷ്‌ട ഉപയോക്താവിന് ആവർത്തിച്ച് മാറ്റുന്നു (UID 1000). ബൈൻഡ്-മൌണ്ട് ചെയ്ത വോള്യങ്ങൾ ആക്സസ് ചെയ്യുന്നതിന് ഡോക്കറിന് ഉപയോക്തൃ-നിർദ്ദിഷ്ട അനുമതികൾ ആവശ്യമുള്ള സന്ദർഭങ്ങളിൽ ഈ കമാൻഡ് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.
docker.from_env()	ഹോസ്റ്റ് മെഷീനിൽ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന ഡോക്കർ എൻവയോൺമെൻ്റുമായി ബന്ധിപ്പിക്കുന്ന ഒരു ഡോക്കർ ക്ലയൻ്റ് ആരംഭിക്കുന്നു. പൈത്തൺ സ്‌ക്രിപ്റ്റുകളിലെ കണ്ടെയ്‌നറുകൾ ആരംഭിക്കുക, നിർത്തുക, അല്ലെങ്കിൽ പരിശോധിക്കുക തുടങ്ങിയ ഡോക്കർ കണ്ടെയ്‌നറുകൾ പ്രോഗ്രമാറ്റിക്കായി കൈകാര്യം ചെയ്യുന്നതിന് ഇത് അത്യന്താപേക്ഷിതമാണ്.
client.containers.run()	പൈത്തണിനായി ഡോക്കർ SDK ഉപയോഗിച്ച് ഒരു ഡോക്കർ കണ്ടെയ്‌നർ പ്രവർത്തിപ്പിക്കുന്നു. കണ്ടെയ്‌നറിൻ്റെ കോൺഫിഗറേഷനിൽ കൃത്യമായ നിയന്ത്രണം ആവശ്യമായി വരുമ്പോൾ, വോളിയം ബൈൻഡിംഗുകൾ നിർവചിക്കുക, പ്രോഗ്രമാറ്റിക്കായി പ്രത്യേക ആക്‌സസ്സ് എന്നിവ ആവശ്യമായി വരുമ്പോൾ ഈ രീതി വളരെ ഉപയോഗപ്രദമാണ്.
unittest.TestCase	പൈത്തണിൻ്റെ യൂണിറ്റ്ടെസ്റ്റ് ചട്ടക്കൂടിൻ്റെ ഭാഗമായി, ഈ അടിസ്ഥാന ക്ലാസ്, സംഘടിതവും പുനരുപയോഗിക്കാവുന്നതുമായ ടെസ്റ്റ് കേസുകൾ സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നു, ഇത് ഓരോ ഫംഗ്ഷൻ്റെയും പെരുമാറ്റം, പ്രത്യേകിച്ച് ബഹു-പരിസ്ഥിതി സാഹചര്യങ്ങളിൽ സാധൂകരിക്കുന്നതിന് അത്യന്താപേക്ഷിതമാണ്.
assertNotIn("ro", mount_check)	ഡയറക്‌ടറി എഴുതാനാകുന്നതാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട്, `മൗണ്ട്` കമാൻഡ് ഔട്ട്‌പുട്ടിൽ റീഡ്-ഒൺലി (ro) ആട്രിബ്യൂട്ട് ഇല്ലെന്ന് പരിശോധിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു യൂണിറ്റ് ടെസ്റ്റ് അസെർഷൻ. ഫയൽ സിസ്റ്റം അനുമതികൾക്കായുള്ള ടാർഗെറ്റുചെയ്‌ത പരിശോധനയാണിത്.
restart_policy={"Name": "always"}	ഡോക്കർ കണ്ടെയ്‌നർ അപ്രതീക്ഷിതമായി നിലച്ചാൽ യാന്ത്രികമായി പുനരാരംഭിക്കുന്നതിന് കോൺഫിഗർ ചെയ്യുന്നു. റീബൂട്ടുകൾക്കോ പിശകുകൾക്കോ ശേഷവും ഇത് പ്രവർത്തനക്ഷമമാണെന്ന് ഉറപ്പാക്കാൻ GitLab Runner പോലുള്ള ദീർഘകാല സേവനങ്ങൾക്ക് ഈ ക്രമീകരണം പ്രധാനമാണ്.
container.status	ഒരു ഡോക്കർ കണ്ടെയ്‌നറിൻ്റെ നിലവിലെ നില വീണ്ടെടുക്കുന്നു (ഉദാ. "റണ്ണിംഗ്," "പുറത്തുപോയി"). കണ്ടെയ്‌നർ വിജയകരമായി ആരംഭിച്ചുവെന്നും പ്രവർത്തനക്ഷമമാണോ എന്നും പ്രോഗ്രമാറ്റിക്കായി പരിശോധിക്കുന്നതിന് ഈ കമാൻഡ് അത്യന്താപേക്ഷിതമാണ്.
ls -ld /srv/gitlab-runner	`/srv/gitlab-runner` എന്നതിനായുള്ള അനുമതികളും ഉടമസ്ഥാവകാശവും ഉൾപ്പെടെയുള്ള ഡയറക്ടറി വിശദാംശങ്ങൾ ലിസ്റ്റുചെയ്യുന്നു. ഡയറക്‌ടറിക്ക് ഡോക്കറിന് ആവശ്യമായ ശരിയായ അനുമതികളും ഉടമസ്ഥാവകാശ ക്രമീകരണങ്ങളും ഉണ്ടെന്ന് പരിശോധിക്കാൻ ഈ കമാൻഡ് സഹായിക്കുന്നു.

പരിഹാരങ്ങൾ മനസ്സിലാക്കുന്നു: ഡോക്കർ മൗണ്ട് അനുമതികളും റീമൗണ്ടിംഗും

അഭിസംബോധന ചെയ്യാൻ ഡോക്കർ മൗണ്ട് GitLab റണ്ണർ സജ്ജീകരണത്തിൽ നേരിട്ട പ്രശ്നം, ഷെൽ സ്ക്രിപ്റ്റുകൾ, ഡോക്കർ കമ്പോസ്, പൈത്തൺ എന്നിവ ഉപയോഗിച്ച് ഞാൻ മൂന്ന് വ്യത്യസ്തമായ പരിഹാരങ്ങൾ തയ്യാറാക്കി. ഫയൽ സിസ്റ്റം അനുമതികൾ നേരിട്ട് കൈകാര്യം ചെയ്യുന്നതിനുള്ള അടിസ്ഥാന ഷെൽ കമാൻഡുകളാണ് ആദ്യ പരിഹാരം ഉപയോഗിക്കുന്നത്. `/srv` ഡയറക്‌ടറി `മൗണ്ട് | ഉപയോഗിച്ച് വായിക്കാൻ മാത്രമാണോ എന്ന് പരിശോധിക്കുന്നതിലൂടെ grep "/srv"` കമാൻഡ്, ഡയറക്‌ടറി അനുമതികൾ ഡോക്കറിൻ്റെ ആക്‌സസ് പ്രശ്‌നത്തിന് കാരണമാകുന്നുണ്ടോ എന്ന് സ്‌ക്രിപ്റ്റ് തിരിച്ചറിയുന്നു. അങ്ങനെയാണെങ്കിൽ, സ്ക്രിപ്റ്റ് `/srv` റീഡ്-റൈറ്റായി `sudo mount -o remount,rw /srv` ഉപയോഗിച്ച് റീമൗണ്ട് ചെയ്യാൻ ശ്രമിക്കുന്നു. ഫയൽ സിസ്റ്റം നിയന്ത്രണങ്ങൾ കാരണം ഡോക്കറിന് ഡയറക്‌ടറികൾ സൃഷ്‌ടിക്കാൻ കഴിയാത്തപ്പോൾ, ഉടനടി റീമൗണ്ടിംഗ് ആവശ്യങ്ങൾക്കുള്ള വേഗത്തിലുള്ള പരിഹാരമാണിത്. ഉദാഹരണത്തിന്, ഡയറക്‌ടറികൾ അശ്രദ്ധമായി റീഡ്-ഓൺലി ഡിഫോൾട്ട് ചെയ്യുന്ന സിസ്റ്റങ്ങളിൽ, ഈ ദ്രുത ക്രമീകരണത്തിന് അനുമതി പ്രശ്നങ്ങൾ കാര്യക്ഷമമായി പരിഹരിക്കാൻ കഴിയും. 🛠️

ഷെൽ സ്‌ക്രിപ്റ്റ് `sudo chown -R 1000:1000 /srv/gitlab-runner` ഉപയോഗിച്ച് `/srv/gitlab-runner`-ൻ്റെ ഉടമസ്ഥാവകാശവും മാറ്റുന്നു, ഇത് ഡോക്കറിന് ഡയറക്‌ടറിയിലേക്ക് ആവശ്യമായ ആക്‌സസ് നൽകുന്നു. ഈ കമാൻഡ് അത്യന്താപേക്ഷിതമാണ്, കാരണം ശരിയായ ഉടമസ്ഥാവകാശമില്ലാതെ, ഡയറക്‌ടറികൾ ശരിയായി മൌണ്ട് ചെയ്യാൻ ഡോക്കർ പലപ്പോഴും പാടുപെടുന്നു. `ls -ld /srv/gitlab-runner` എന്ന കമാൻഡ് ഡയറക്‌ടറിയുടെ അനുമതികൾ പരിശോധിക്കുന്നു, ഡോക്കറിന് ആ സ്ഥലത്ത് വായിക്കാനും എഴുതാനും കഴിയുമെന്ന് സ്ഥിരീകരിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു. ഉടനടി ക്രമീകരണങ്ങൾ ആവശ്യമായി വരുമ്പോൾ ഈ ലളിതവും നേരിട്ടുള്ളതുമായ സമീപനം ഉപയോഗപ്രദമാണ്, കൂടാതെ ഡോക്കർ `/srv` പോലെയുള്ള സാധാരണ പാതകൾക്ക് പുറത്തുള്ള ഡയറക്ടറികൾ ആക്സസ് ചെയ്യണം. എന്നിരുന്നാലും, മോഡുലറും പുനരുപയോഗിക്കാവുന്നതുമായ കോൺഫിഗറേഷനുകൾക്ക് മുൻഗണന നൽകുന്ന പ്രൊഡക്ഷൻ എൻവയോൺമെൻ്റുകളിൽ ഈ സമീപനം നിലനിർത്താൻ സാധിക്കണമെന്നില്ല.

രണ്ടാമത്തെ പരിഹാരം മോഡുലാരിറ്റി ഉപയോഗിച്ച് നിർമ്മിക്കുന്നു ഡോക്കർ രചന. ഒരു `docker-compose.yml` ഫയലിനുള്ളിൽ വോള്യങ്ങളും അനുമതികളും നിർവചിക്കുന്നതിലൂടെ, ഞങ്ങൾ വീണ്ടും ഉപയോഗിക്കാവുന്ന ഒരു കോൺഫിഗറേഷൻ സൃഷ്ടിക്കുന്നു. ഈ കമ്പോസ് ഫയൽ കണ്ടെയ്‌നറിനുള്ളിൽ `/srv/gitlab-runner/config` മുതൽ `/etc/gitlab-runner` വരെ മാപ്പ് ചെയ്യുന്നു, കൂടാതെ 'പ്രിവിലേജ്ഡ്: ട്രൂ' ഉപയോഗിച്ച് കണ്ടെയ്‌നറിന് പ്രത്യേക ആക്‌സസ് അനുവദിക്കുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, GitLab റണ്ണർ സേവനങ്ങൾക്ക് സ്ഥിരമായ സ്റ്റാർട്ടപ്പ് കോൺഫിഗറേഷനുകൾ ആവശ്യമുള്ള പരിതസ്ഥിതികളിൽ, മുഴുവൻ സജ്ജീകരണവും ഒരു സേവനമായി കൈകാര്യം ചെയ്യാൻ ഡോക്കർ കമ്പോസ് അനുവദിക്കുന്നു. `docker-compose.yml` ഫയൽ സംരക്ഷിച്ചുകഴിഞ്ഞാൽ, `docker-compose up -d` കണ്ടെയ്‌നർ കൊണ്ടുവരുന്നു. കമ്പോസ് രീതി ദീർഘകാല പരിപാലനം മെച്ചപ്പെടുത്തുന്നു, പ്രത്യേകിച്ചും വ്യത്യസ്ത മെഷീനുകളിൽ വിന്യസിക്കുമ്പോഴോ ടീം അംഗങ്ങളുമായി കോൺഫിഗറേഷനുകൾ പങ്കിടുമ്പോഴോ.

മൂന്നാമത്തെ പരിഹാരം പൈത്തണിനെയും ഡോക്കർ എസ്ഡികെയെയും സ്വാധീനിക്കുന്നു, ഇത് കൂടുതൽ വഴക്കം നൽകുകയും വിശദമായ പ്രോഗ്രാമാറ്റിക് നിയന്ത്രണം അനുവദിക്കുകയും ചെയ്യുന്നു. ഈ സമീപനം ആദ്യം `/srv` വായിക്കാൻ മാത്രമാണോ എന്ന് പരിശോധിക്കുന്നു, തുടർന്ന് ആവശ്യമെങ്കിൽ അത് റീമൗണ്ട് ചെയ്യുന്നു. `client.containers.run` ഉപയോഗിച്ച്, സ്‌ക്രിപ്റ്റ് പിന്നീട് ഒരു GitLab റണ്ണർ കണ്ടെയ്‌നർ പ്രവർത്തിപ്പിക്കുകയും നിർദ്ദിഷ്‌ട വോളിയം മാപ്പിംഗുകളും നയങ്ങൾ പുനരാരംഭിക്കുകയും ചെയ്യുന്നു, ഇത് തുടർച്ചയായ പ്രവർത്തനം ഉറപ്പാക്കുന്നു. സ്വമേധയാലുള്ള ക്രമീകരണങ്ങളേക്കാൾ പ്രോഗ്രമാറ്റിക് സജ്ജീകരണത്തിന് മുൻഗണന നൽകുന്ന സങ്കീർണ്ണമായ സിസ്റ്റങ്ങളിൽ ഈ പരിഹാരം പ്രത്യേകിച്ചും ഫലപ്രദമാണ്. ഈ ഡോക്കർ കോൺഫിഗറേഷനുകൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിലൂടെ, മൾട്ടി-യൂസർ എൻവയോൺമെൻ്റുകളിൽ ഡോക്കറിൻ്റെ പെരുമാറ്റത്തിൽ പിശക് കൈകാര്യം ചെയ്യലും നിയന്ത്രണവും ഞങ്ങൾ നേടുന്നു. കൂടാതെ, ഈ സമീപനം വലിയ ഓട്ടോമേഷൻ പൈപ്പ്ലൈനുകളിലേക്ക് സംയോജിപ്പിക്കാൻ കഴിയും, ഇത് ഉൽപ്പാദന പരിതസ്ഥിതികൾക്ക് അമൂല്യമാക്കുന്നു. 🚀

പരിഹാരം 1: ഷെൽ കമാൻഡുകൾ ഉപയോഗിച്ച് ഡോക്കർ വോളിയം അനുമതികൾ ക്രമീകരിക്കുന്നു

ഫയൽ സിസ്റ്റത്തിനും ഡോക്കർ പെർമിഷൻ മാനേജ്മെൻ്റിനുമുള്ള ഷെൽ സ്ക്രിപ്റ്റിംഗ്

# Step 1: Check if the /srv directory is mounted as read-only
mount | grep "/srv"
# If /srv is mounted as read-only, attempt remounting it as read-write
sudo mount -o remount,rw /srv

# Step 2: Change ownership of the target directory to avoid permission conflicts
sudo chown -R 1000:1000 /srv/gitlab-runner

# Step 3: Verify permissions (directory should now be writable by Docker)
ls -ld /srv/gitlab-runner

# Step 4: Run the Docker command again to see if the error persists
sudo docker run -d --privileged --name gitlab-runner --restart always \
-v /srv/gitlab-runner/config:/etc/gitlab-runner \
-v /var/run/docker.sock:/var/run/docker.sock \
gitlab/gitlab-runner:latest

പരിഹാരം 2: മെച്ചപ്പെട്ട മോഡുലാരിറ്റിക്കായി ഡോക്കർ കമ്പോസ് ഉപയോഗിച്ച് ഡോക്കർ കോൺഫിഗർ ചെയ്യുന്നു

വോളിയം അനുമതികളും കണ്ടെയ്‌നർ വിന്യാസവും നിയന്ത്രിക്കുന്നതിന് ഡോക്കർ കമ്പോസ് കോൺഫിഗറേഷൻ ഫയൽ

# Create a docker-compose.yml file to configure the GitLab Runner container
version: '3.8'

services:
  gitlab-runner:
    image: gitlab/gitlab-runner:latest
    container_name: gitlab-runner
    privileged: true
    restart: always
    volumes:
      - /srv/gitlab-runner/config:/etc/gitlab-runner
      - /var/run/docker.sock:/var/run/docker.sock

# Step 1: Run Docker Compose to start the GitLab Runner container
sudo docker-compose up -d

# Step 2: Verify if container is running with appropriate permissions
sudo docker-compose ps

പരിഹാരം 3: പൈത്തൺ, ഡോക്കർ SDK എന്നിവ ഉപയോഗിച്ച് റീമൗണ്ടിംഗും അനുമതി കൈകാര്യം ചെയ്യലും

വിപുലമായ റീമൗണ്ട് കൈകാര്യം ചെയ്യലിനും കണ്ടെയ്‌നർ വിന്യാസത്തിനുമായി ഡോക്കർ SDK ഉപയോഗിക്കുന്ന പൈത്തൺ സ്‌ക്രിപ്റ്റ്

import os
import docker
from subprocess import call

# Step 1: Check if /srv is mounted as read-only and attempt remount if necessary
mount_check = call(["mount", "|", "grep", "/srv"])
if 'ro' in mount_check:
    call(["sudo", "mount", "-o", "remount,rw", "/srv"])

# Step 2: Change ownership of the directory to allow Docker access
os.system("sudo chown -R 1000:1000 /srv/gitlab-runner")

# Step 3: Set up Docker client and run GitLab Runner container
client = docker.from_env()
container = client.containers.run("gitlab/gitlab-runner:latest",
    name="gitlab-runner",
    detach=True,
    privileged=True,
    restart_policy={"Name": "always"},
    volumes={'/srv/gitlab-runner/config': {'bind': '/etc/gitlab-runner', 'mode': 'rw'},
             '/var/run/docker.sock': {'bind': '/var/run/docker.sock', 'mode': 'rw'}}
)

print("Container started with ID:", container.id)

# Step 4: Validate the status of the container
print(client.containers.get("gitlab-runner").status)

സൊല്യൂഷനുകളിലുടനീളം മൂല്യനിർണ്ണയത്തിനുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾ

റീമൗണ്ടിംഗ്, ഡോക്കർ കണ്ടെയ്‌നർ അനുമതികൾ എന്നിവ പരിശോധിക്കുന്നതിനുള്ള പൈത്തൺ യൂണിറ്റ് ടെസ്റ്റ് ഫ്രെയിംവർക്ക്

import unittest
import os
from subprocess import call
import docker

class TestDockerGitLabRunner(unittest.TestCase):
    def test_mount_check(self):
        mount_check = call(["mount", "|", "grep", "/srv"])
        self.assertNotIn("ro", mount_check, "Directory is read-only")

    def test_directory_permissions(self):
        self.assertEqual(os.stat('/srv/gitlab-runner').st_uid, 1000, "Ownership mismatch")

    def test_container_start(self):
        client = docker.from_env()
        container = client.containers.get("gitlab-runner")
        self.assertEqual(container.status, "running", "Container failed to start")

if __name__ == "__main__":
    unittest.main()

ഡോക്കറിലെ റീഡ്-ഒൺലി ഫയൽസിസ്റ്റം പ്രശ്നങ്ങൾ മനസ്സിലാക്കുന്നു

ഡോക്കറുമായി പ്രവർത്തിക്കുന്നതിൻ്റെ അത്ര അറിയപ്പെടാത്ത ഒരു വശം അതിൻ്റെ അടിസ്ഥാനമാണ് ഫയൽസിസ്റ്റം കോൺഫിഗറേഷനുകൾ ഹോസ്റ്റിൽ കണ്ടെയ്‌നർ സ്വഭാവത്തെ സ്വാധീനിച്ചേക്കാം, പ്രത്യേകിച്ച് വോള്യങ്ങൾ മൗണ്ട് ചെയ്യുമ്പോൾ. ഡെബിയൻ അല്ലെങ്കിൽ ഉബുണ്ടു കോറിൻ്റെ ചില പതിപ്പുകൾ പോലെയുള്ള ചില സിസ്റ്റങ്ങളിൽ, ഡിഫോൾട്ടായി അല്ലെങ്കിൽ സിസ്റ്റം അപ്‌ഡേറ്റുകൾ കാരണം നിർദ്ദിഷ്ട ഡയറക്ടറികൾ റീഡ്-ഒൺലി ആയി സജ്ജീകരിച്ചേക്കാം, ഇത് ഡോക്കറിൻ്റെ മൗണ്ടിംഗ് കഴിവുകൾ പരാജയപ്പെടുന്നതിന് കാരണമാകുന്നു. നിങ്ങൾ GitLab റണ്ണറിനായി `/srv` പോലുള്ള പാഥുകൾ മൌണ്ട് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, "വായിക്കാൻ മാത്രം" പിശകുകൾ നേരിടേണ്ടിവരുമ്പോൾ ഇത് പലപ്പോഴും സംഭവിക്കാറുണ്ട്. ഇവ ഒഴിവാക്കാൻ, റീഡ്-ഒൺലി ഫയൽസിസ്റ്റമുകളുടെ, പ്രത്യേകിച്ച് സുരക്ഷിതമോ മാറ്റമില്ലാത്തതോ ആയ സജ്ജീകരണങ്ങളിൽ, കണ്ടെയ്‌നർ മൗണ്ടുകളെ സാരമായി ബാധിച്ചേക്കാവുന്ന മൂലകാരണങ്ങൾ മനസ്സിലാക്കുന്നത് സഹായകമാണ്.

ഈ പ്രശ്‌നങ്ങൾ പരിഹരിക്കുന്നതിന്, ഉപയോക്താക്കൾ പലപ്പോഴും `chown` ഉപയോഗിച്ച് അനുമതികൾ മാറ്റുകയോ `mount -o remount,rw /srv` ഉപയോഗിച്ച് ഡയറക്ടറികൾ റീമൗണ്ട് ചെയ്യുകയോ പോലുള്ള പൊതുവായ പരിഹാരങ്ങൾ പരീക്ഷിക്കുന്നു. എന്നിരുന്നാലും, റൂട്ട് ഫയൽസിസ്റ്റത്തിന് തന്നെ നിയന്ത്രണങ്ങൾ ഉണ്ടെങ്കിലോ ഡോക്കറിൻ്റെ സ്റ്റോറേജ് ഡ്രൈവർ ആണെങ്കിലോ ഈ സമീപനങ്ങൾ പ്രവർത്തിച്ചേക്കില്ല. ഓവർലേ2) നിർദ്ദിഷ്ട ഹോസ്റ്റ് കോൺഫിഗറേഷനുകളുമായി പൊരുത്തപ്പെടുന്നില്ല. അത്തരം സന്ദർഭങ്ങളിൽ, ഡെഡിക്കേറ്റഡ് ഡോക്കർ കമ്പോസ് കോൺഫിഗറേഷനുകൾ ഉപയോഗിച്ചോ ഡോക്കറിൻ്റെ റൂട്ട് ഡയറക്‌ടറി (`ഡോക്കർ റൂട്ട് ദിർ`) പുനഃക്രമീകരിക്കുകയോ ചെയ്യുന്നത് ചിലപ്പോൾ കൂടുതൽ ഫ്ലെക്സിബിൾ ഡയറക്‌ടറികളിലേക്ക് മൗണ്ടുകൾ നയിക്കുന്നതിലൂടെ ഒരു പരിഹാരമാർഗം നൽകാം. കൂടാതെ, Kubernetes പോലെയുള്ള കണ്ടെയ്നർ ഓർക്കസ്ട്രേഷൻ ടൂളുകൾ ഉപയോഗിക്കുന്നത് സ്ഥിരമായ സംഭരണത്തിനായി കൂടുതൽ ക്രമീകരിക്കാവുന്ന ഓപ്ഷനുകൾ വാഗ്ദാനം ചെയ്യുന്നു.

നിയന്ത്രിത ഫയൽ സിസ്റ്റങ്ങളിൽ ഡോക്കറിൽ പതിവായി പ്രവർത്തിക്കുന്ന ഡവലപ്പർമാർക്ക്, ഈ കോൺഫിഗറേഷനുകൾ മനസ്സിലാക്കുന്നത് ട്രബിൾഷൂട്ടിംഗ് സമയം ലാഭിക്കുന്നു. റീബൂട്ട് ചെയ്യുമ്പോൾ കൂടുതൽ ശാശ്വതമായ റീഡ്-റൈറ്റ് കോൺഫിഗറേഷൻ അനുവദിക്കുന്ന സിസ്റ്റം ഫയലുകൾ (`/etc/fstab` പോലുള്ളവ) എഡിറ്റ് ചെയ്യുന്നതും ചില സമീപനങ്ങളിൽ ഉൾപ്പെടുന്നു. ഈ രീതികൾ പര്യവേക്ഷണം ചെയ്യുന്നതിലൂടെ, ഡോക്കർ ഉപയോക്താക്കൾക്ക് പരിമിതമായ ഫയൽ സിസ്റ്റങ്ങളിൽ കണ്ടെയ്നറൈസ്ഡ് വർക്ക്ഫ്ലോകൾ നന്നായി കൈകാര്യം ചെയ്യാൻ കഴിയും, സുഗമമായ വിന്യാസങ്ങളും കുറച്ച് അനുമതികൾ അടിസ്ഥാനമാക്കിയുള്ള തലവേദനയും ഉറപ്പാക്കുന്നു! 🔧

ഡോക്കർ വോളിയം മൗണ്ട് പിശകുകളെക്കുറിച്ചുള്ള പതിവ് ചോദ്യങ്ങൾ

വോളിയം ഉപയോഗിക്കുമ്പോൾ ഡോക്കർ റീഡ്-ഒൺലി ഫയൽസിസ്റ്റം പിശക് എറിയുന്നത് എന്തുകൊണ്ട്?
നിങ്ങൾ മൗണ്ട് ചെയ്യാൻ ശ്രമിക്കുന്ന ഹോസ്റ്റ് ഡയറക്‌ടറി റീഡ്-ഒൺലി ആയി സജ്ജീകരിക്കുമ്പോൾ ഈ പിശക് സാധാരണയായി സംഭവിക്കുന്നു. ഇത് പരിശോധിക്കാൻ, കമാൻഡ് ഉപയോഗിക്കുക mount | grep "/srv" ഇത് റീഡ്-ഒൺലി ആയി ഘടിപ്പിച്ചിട്ടുണ്ടോ എന്ന് സ്ഥിരീകരിക്കാൻ.
chown ഉപയോഗിച്ച് അനുമതികൾ മാറ്റിക്കൊണ്ട് എനിക്ക് ഈ പിശക് പരിഹരിക്കാനാകുമോ?
ചിലപ്പോൾ. ഉപയോഗിച്ച് ഉടമസ്ഥാവകാശം മാറ്റുന്നു sudo chown -R 1000:1000 /srv/gitlab-runner ഇത് ഒരു ലളിതമായ അനുമതി പ്രശ്നമാണെങ്കിൽ സഹായിക്കാനാകും. ഫയൽസിസ്റ്റം തലത്തിൽ ഡയറക്‌ടറി റീഡ്-ഓൺലി ആയി മൌണ്ട് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, കൂടുതൽ കോൺഫിഗറേഷൻ ആവശ്യമാണ്.
റീഡ്-റൈറ്റായി റീമൗണ്ട് ചെയ്യുന്നത് എന്താണ് അർത്ഥമാക്കുന്നത്?
ഉപയോഗിച്ച് റീമൗണ്ട് ചെയ്യുന്നു sudo mount -o remount,rw /srv ഡയറക്‌ടറിയെ എഴുതാവുന്നതാക്കുന്നു. ഡയറക്‌ടറി ആകസ്‌മികമായി വായിക്കാൻ മാത്രമായി മൌണ്ട് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്, പക്ഷേ റീബൂട്ടുകളിലുടനീളം ഇത് നിലനിൽക്കില്ല.
അനുമതികൾ നിയന്ത്രിക്കുന്നതിന് ഡോക്കർ കമ്പോസ് ശുപാർശ ചെയ്യുന്നത് എന്തുകൊണ്ട്?
വീണ്ടും ഉപയോഗിക്കാവുന്ന ഫോർമാറ്റിൽ വോള്യങ്ങളും അനുമതികളും കോൺഫിഗർ ചെയ്യാൻ ഡോക്കർ കമ്പോസ് നിങ്ങളെ അനുവദിക്കുന്നു. ഉയർന്ന അനുമതികൾ ആവശ്യമുള്ള GitLab Runner പോലുള്ള സേവനങ്ങൾക്ക് ഉപയോഗപ്രദമായ പ്രിവിലേജ്ഡ് ആക്‌സസ് പോലുള്ള ക്രമീകരണങ്ങൾ നിങ്ങൾക്ക് വ്യക്തമാക്കാം.
വായന-മാത്രം പിശകുകൾ തടയാൻ സ്ഥിരമായ പരിഹാരങ്ങളുണ്ടോ?
അതെ. എഡിറ്റിംഗ് /etc/fstab ഡയറക്‌ടറികൾ ബൂട്ടിൽ ശാശ്വതമായി എഴുതാൻ കഴിയുന്ന ഒരു സമീപനമാണ്, എന്നിരുന്നാലും അഡ്മിൻ ആക്‌സസും ശ്രദ്ധാപൂർവ്വമായ കോൺഫിഗറേഷനും ആവശ്യമാണ്.
നിർദ്ദിഷ്ട ഡോക്കർ പതിപ്പുകൾ മൗണ്ടിംഗ് അനുമതികളെ ബാധിക്കുമോ?
അതെ, പ്രത്യേകിച്ചും നിങ്ങൾ ഓവർലേ 2 പോലുള്ള സ്റ്റോറേജ് ഡ്രൈവറുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ. ഡോക്കറിൻ്റെ പതിപ്പും സ്റ്റോറേജ് ഡ്രൈവറുകളും തമ്മിലുള്ള അനുയോജ്യത പ്രശ്നങ്ങൾ മൗണ്ടിംഗ് സ്വഭാവത്തെ ബാധിക്കും.
എന്താണ് ഡോക്കർ റൂട്ട് ദിർ, അത് എങ്ങനെ സഹായിക്കുന്നു?
ഡോക്കർ റൂട്ട് ദിർ, കാണിച്ചിരിക്കുന്നു docker info, ഇവിടെയാണ് ഡോക്കർ കണ്ടെയ്‌നർ ഡാറ്റ സംഭരിക്കുന്നത്. ഇത് എഴുതാവുന്ന പാതയിലേക്ക് മാറ്റുന്നത് ചിലപ്പോൾ മൗണ്ടിംഗ് പിശകുകൾ ഒഴിവാക്കാം.
ഒരു ഡയറക്‌ടറി എഴുതാനാകുന്നതാണോ എന്ന് പ്രോഗ്രമാറ്റിക്കായി പരിശോധിക്കാൻ എന്തെങ്കിലും മാർഗമുണ്ടോ?
അതെ, ഡോക്കർ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് പെർമിഷൻ ചെക്കുകൾ ഓട്ടോമേറ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ഡയറക്‌ടറി റൈറ്റബിൾ ആണോ എന്ന് പരിശോധിക്കാൻ പൈത്തൺ അല്ലെങ്കിൽ ബാഷ് സ്‌ക്രിപ്റ്റുകൾ ഉപയോഗിക്കാം.
എല്ലാ ഡോക്കർ കണ്ടെയ്‌നറുകൾക്കും മൗണ്ടുചെയ്യുന്നതിന് പ്രത്യേക ആക്‌സസ് ആവശ്യമുണ്ടോ?
ഇല്ല, എന്നാൽ GitLab Runner പോലുള്ള സേവനങ്ങൾക്ക് ചില പ്രവർത്തനങ്ങൾക്ക് ഇത് ആവശ്യമായി വന്നേക്കാം. ചേർക്കുന്നു --privileged നിങ്ങളുടെ ഡോക്കർ കമാൻഡിൽ കണ്ടെയ്‌നറിന് ഹോസ്റ്റിലേക്ക് പൂർണ്ണ ആക്‌സസ് നൽകുന്നു.
ഉൽപ്പാദനത്തിൽ വിന്യസിക്കുന്നതിന് മുമ്പ് എനിക്ക് ഈ പരിഹാരങ്ങൾ പ്രാദേശികമായി പരിശോധിക്കാൻ കഴിയുമോ?
അതെ! ഈ കോൺഫിഗറേഷനുകൾ എളുപ്പത്തിൽ പരിശോധിക്കാൻ ഡോക്കർ അനുവദിക്കുന്നു. നിങ്ങൾക്ക് പരിഷ്‌ക്കരിച്ച അനുമതികളോടെ ടെസ്റ്റ് കണ്ടെയ്‌നറുകൾ സജ്ജീകരിക്കാം അല്ലെങ്കിൽ പ്രൊഡക്ഷൻ എൻവയോൺമെൻ്റുകൾ അനുകരിക്കാൻ പ്രാദേശിക ഡോക്കർ കമ്പോസ് ഫയലുകൾ ഉപയോഗിക്കാം.

ഡോക്കർ മൗണ്ട് പെർമിഷൻ പിശകുകൾ പരിഹരിക്കുന്നു

ഡോക്കർ മൗണ്ട് പിശകുകൾ, പ്രത്യേകിച്ച് റീഡ്-ഒൺലി ഫയൽ സിസ്റ്റങ്ങളിൽ, നിരാശാജനകമായേക്കാം, എന്നാൽ ശരിയായ സമീപനത്തിലൂടെ അവ കൈകാര്യം ചെയ്യാവുന്നതാണ്. സിസ്റ്റം കോൺഫിഗറേഷനുകൾ അല്ലെങ്കിൽ ഡോക്കറിൻ്റെ സ്റ്റോറേജ് ഡ്രൈവറുകൾ പോലുള്ള മൂലകാരണങ്ങൾ മനസ്സിലാക്കുന്നതിലൂടെ നിങ്ങൾക്ക് ഈ പ്രശ്നങ്ങൾ ഫലപ്രദമായി പരിഹരിക്കാനാകും. അനുമതികൾ ക്രമീകരണം, മൗണ്ട് ഓപ്‌ഷനുകൾ പരിശോധിക്കൽ, ഡോക്കർ കമ്പോസ് ഉപയോഗിക്കൽ എന്നിവ പ്രധാന തന്ത്രങ്ങളാണ്.

ഭാവിയിൽ ഈ പ്രശ്നം ഒഴിവാക്കാൻ, ഓട്ടോമേറ്റഡ് ചെക്കുകൾ സജ്ജീകരിക്കുകയോ ഡോക്കറിനായി കോൺഫിഗർ ചെയ്‌തിരിക്കുന്ന സമർപ്പിത മൗണ്ട് പാത്തുകൾ ഉപയോഗിക്കുകയോ ചെയ്യുക. ഇത് നിയന്ത്രിത സിസ്റ്റങ്ങളിൽ ഡോക്കറുമായുള്ള സുഗമമായ ഇടപെടലുകൾ ഉറപ്പാക്കുന്നു, വിന്യാസ പ്രശ്നങ്ങൾ കുറയ്ക്കുന്നു. ഈ അനുമതികൾ മുൻകൂട്ടി കൈകാര്യം ചെയ്യുന്നത് GitLab റണ്ണറും സമാന സേവനങ്ങളും തടസ്സങ്ങളില്ലാതെ പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു. 🚀

റഫറൻസുകളും തുടർ വായനയും

കണ്ടെയ്‌നർ ഡയറക്‌ടറികളിലെ റീഡ്-ഒൺലി പിശകുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള പ്രായോഗിക പരിഹാരങ്ങൾക്കൊപ്പം ഡോക്കർ വോളിയം അനുമതികളുടെയും ട്രബിൾഷൂട്ടിംഗിൻ്റെയും ആഴത്തിലുള്ള പര്യവേക്ഷണം. കൂടുതലറിയാൻ, സന്ദർശിക്കുക ഡോക്കർ ഡോക്യുമെൻ്റേഷൻ .
കണ്ടെയ്‌നറൈസ്ഡ് പരിതസ്ഥിതികളിൽ GitLab റണ്ണറിൻ്റെ കോൺഫിഗറേഷനും ഉപയോഗവും വിശദീകരിക്കുന്ന ഔദ്യോഗിക GitLab റണ്ണർ ഡോക്കർ ഇമേജ് ഡോക്യുമെൻ്റേഷൻ. കാണുക ഡോക്കറിൽ GitLab റണ്ണർ .
Linux ഫയൽസിസ്റ്റം അനുമതികളെക്കുറിച്ചും മൗണ്ടിംഗ് ഓപ്ഷനുകളെക്കുറിച്ചും സമഗ്രമായ ഗൈഡ്, റീഡ്-ഒൺലി പ്രശ്നങ്ങൾ, റീമൗണ്ട് കമാൻഡുകൾ എന്നിവയെക്കുറിച്ചുള്ള സ്ഥിതിവിവരക്കണക്കുകൾ നൽകുന്നു. എന്ന വിലാസത്തിൽ ലഭ്യമാണ് LinuxConfig .
ഉബുണ്ടു കോർ സിസ്റ്റം ആർക്കിടെക്ചറിൻ്റെ അവലോകനവും സ്നാപ്പ് പാക്കേജുകളുമായുള്ള പ്രത്യേക നിയന്ത്രണങ്ങളും, സാധ്യതയുള്ള റീഡ്-ഒൺലി സിസ്റ്റം മൗണ്ടുകൾ വിശദീകരിക്കുന്നു. എന്ന മുഴുവൻ ലേഖനവും പരിശോധിക്കുക ഉബുണ്ടു കോർ ഡോക്യുമെൻ്റേഷൻ .

ഡോക്കർ മൗണ്ട് പിശകുകൾ പരിഹരിക്കുന്നു: GitLab റണ്ണർ റീഡ്-ഒൺലി ഫയൽ സിസ്റ്റം പ്രശ്നങ്ങൾ