ഡോക്കറിലെ ഉപയോക്താവ്

ആൻഡ്രി കോപിലോവ്, ഞങ്ങളുടെ CTO, ഡോക്കറിനെ സ്നേഹിക്കുകയും സജീവമായി ഉപയോഗിക്കുകയും പ്രോത്സാഹിപ്പിക്കുകയും ചെയ്യുന്നു. ഒരു പുതിയ ലേഖനത്തിൽ, ഡോക്കറിൽ ഉപയോക്താക്കളെ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് അദ്ദേഹം വിശദീകരിക്കുന്നു. അവരുമായുള്ള ശരിയായ ജോലി, എന്തുകൊണ്ട് ഉപയോക്താക്കൾക്ക് റൂട്ട് അവകാശങ്ങൾ നൽകരുത്, ഡോക്കർഫയിലെ പൊരുത്തമില്ലാത്ത സൂചകങ്ങളുടെ പ്രശ്നം എങ്ങനെ പരിഹരിക്കാം.

കണ്ടെയ്നറിലെ എല്ലാ പ്രക്രിയകളും റൂട്ട് ഉപയോക്താവായി പ്രവർത്തിക്കും, നിങ്ങൾ അത് ഒരു പ്രത്യേക രീതിയിൽ വ്യക്തമാക്കിയില്ലെങ്കിൽ. ഇത് വളരെ സൗകര്യപ്രദമാണെന്ന് തോന്നുന്നു, കാരണം ഈ ഉപയോക്താവിന് നിയന്ത്രണങ്ങളൊന്നുമില്ല. അതുകൊണ്ടാണ് റൂട്ട് ആയി പ്രവർത്തിക്കുന്നത് സുരക്ഷാ വീക്ഷണകോണിൽ തെറ്റാണ്. ശരിയായ മനസ്സിലുള്ള ആരും പ്രാദേശിക കമ്പ്യൂട്ടറിൽ റൂട്ട് അവകാശങ്ങളോടെ പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, പലരും കണ്ടെയ്‌നറുകളിൽ റൂട്ടിന് കീഴിൽ പ്രോസസ്സുകൾ പ്രവർത്തിപ്പിക്കുന്നു.

കണ്ടെയ്‌നറിൽ നിന്ന് രക്ഷപ്പെട്ട് ഹോസ്റ്റ് കമ്പ്യൂട്ടറിൽ കയറാൻ ക്ഷുദ്രവെയറിനെ അനുവദിക്കുന്ന ബഗുകൾ എപ്പോഴും ഉണ്ട്. ഏറ്റവും മോശമായ കാര്യം അനുമാനിക്കുകയാണെങ്കിൽ, ഹോസ്റ്റ് മെഷീനിൽ അവകാശങ്ങളൊന്നും ഇല്ലാത്ത ഒരു ഉപയോക്താവാണ് കണ്ടെയ്‌നറിനുള്ളിലെ പ്രക്രിയകൾ നടത്തുന്നതെന്ന് ഞങ്ങൾ ഉറപ്പാക്കണം.

ഒരു ഉപയോക്താവിനെ സൃഷ്ടിക്കുന്നു

ഒരു കണ്ടെയ്‌നറിൽ ഒരു ഉപയോക്താവിനെ സൃഷ്‌ടിക്കുന്നത് ലിനക്‌സ് വിതരണങ്ങളിൽ സൃഷ്‌ടിക്കുന്നതിൽ നിന്ന് വ്യത്യസ്തമല്ല. എന്നിരുന്നാലും, വ്യത്യസ്ത അടിസ്ഥാന ഇമേജുകൾക്കായി കമാൻഡുകൾ വ്യത്യാസപ്പെടാം.

ഡെബിയൻ അധിഷ്‌ഠിത വിതരണങ്ങൾക്കായി, ഡോക്കർഫയലിലേക്ക് ഇനിപ്പറയുന്നവ ചേർക്കേണ്ടതുണ്ട്:

RUN groupadd --gid 2000 node 
  && useradd --uid 2000 --gid node --shell /bin/bash --create-home node

ആൽപൈനിന്:

RUN addgroup -g 2000 node 
    && adduser -u 2000 -G node -s /bin/sh -D node

ഉപയോക്താവിൽ നിന്നുള്ള പ്രക്രിയകൾ പ്രവർത്തിപ്പിക്കുന്നു

UID 2000 ഉള്ള ഒരു ഉപയോക്താവായി തുടർന്നുള്ള എല്ലാ പ്രക്രിയകളും പ്രവർത്തിപ്പിക്കാൻ, പ്രവർത്തിപ്പിക്കുക:

USER 2000

നോഡ് ഉപയോക്താവായി തുടർന്നുള്ള എല്ലാ പ്രക്രിയകളും പ്രവർത്തിപ്പിക്കുന്നതിന്, പ്രവർത്തിപ്പിക്കുക:

USER node

കൂടുതൽ പ്രമാണീകരണം.

മൗണ്ടിംഗ് വോള്യങ്ങൾ

ഒരു കണ്ടെയ്‌നറിനുള്ളിൽ വോള്യങ്ങൾ മൗണ്ട് ചെയ്യുമ്പോൾ, ഫയലുകൾ വായിക്കാനും/അല്ലെങ്കിൽ എഴുതാനുമുള്ള കഴിവ് ഉപയോക്താവിന് നൽകുക. ഇത് ചെയ്യുന്നതിന്, കണ്ടെയ്‌നറിലെ ഉപയോക്താവിന്റെയും, ഫയൽ ആക്‌സസ് ചെയ്യാൻ ഉചിതമായ അനുമതിയുള്ള കണ്ടെയ്‌നറിന് പുറത്തുള്ള ഉപയോക്താവിന്റെയും യുഐഡി (ജിഐഡി) പൊരുത്തപ്പെടണം. ഈ സാഹചര്യത്തിൽ, ഉപയോക്തൃനാമങ്ങൾ പ്രശ്നമല്ല.

പലപ്പോഴും ഒരു ലിനക്സ് കമ്പ്യൂട്ടറിൽ, ഒരു ഉപയോക്താവിന്റെ യുഐഡിയും ജിഐഡിയും 1000-ന് തുല്യമാണ്. ഈ ഐഡന്റിഫയറുകൾ കമ്പ്യൂട്ടറിന്റെ ആദ്യ ഉപയോക്താവിന് നൽകിയിട്ടുണ്ട്.

നിങ്ങളുടെ ഐഡന്റിഫയറുകൾ കണ്ടെത്തുന്നത് എളുപ്പമാണ്:

id

നിങ്ങളുടെ ഉപയോക്താവിനെക്കുറിച്ചുള്ള സമഗ്രമായ വിവരങ്ങൾ നിങ്ങൾക്ക് ലഭിക്കും.
ഉദാഹരണങ്ങളിൽ നിന്ന് 2000 എന്നത് നിങ്ങളുടെ ഐഡന്റിഫയർ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക, എല്ലാം ശരിയാകും.

ഒരു ഉപയോക്താവിന് യുഐഡിയും ജിഐഡിയും നൽകുന്നു

ഉപയോക്താവ് മുമ്പ് സൃഷ്ടിച്ചതാണെങ്കിലും നിങ്ങൾ ഐഡന്റിഫയറുകൾ മാറ്റേണ്ടതുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇത് ഇതുപോലെ ചെയ്യാൻ കഴിയും:

RUN usermod -u 1000 node 
  && groupmod -g 1000 node

നിങ്ങൾ ആൽപൈൻ ബേസ് ഇമേജാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിങ്ങൾ ഷാഡോ പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:

RUN apk add —no-cache shadow

ചിത്രം നിർമ്മിക്കുമ്പോൾ കണ്ടെയ്‌നറിനുള്ളിൽ ഉപയോക്തൃ ഐഡി കൈമാറുന്നു

നിങ്ങളുടെ ഐഡിയും പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുന്ന എല്ലാ ആളുകളുടെ ഐഡികളും പൊരുത്തപ്പെടുന്നുണ്ടെങ്കിൽ, ഡോക്കർഫയലിൽ ഈ ഐഡി വ്യക്തമാക്കുക. എന്നിരുന്നാലും, പലപ്പോഴും ഉപയോക്തൃ ഐഡികൾ പൊരുത്തപ്പെടുന്നില്ല.

നിങ്ങൾ ആഗ്രഹിക്കുന്നത് എങ്ങനെ നേടാം എന്നത് ഉടനടി വ്യക്തമല്ല. എന്നെ സംബന്ധിച്ചിടത്തോളം, ഡോക്കറിനെ മാസ്റ്റേഴ്സ് ചെയ്യുന്ന പ്രക്രിയയിലെ ഏറ്റവും ബുദ്ധിമുട്ടുള്ള കാര്യമായിരുന്നു ഇത്. ഒരു ഇമേജിന്റെ ജീവിതത്തിൽ വ്യത്യസ്ത ഘട്ടങ്ങളുണ്ടെന്ന് പല ഡോക്കർ ഉപയോക്താക്കൾക്കും മനസ്സിലാകുന്നില്ല. ആദ്യം, ചിത്രം ഒരു ഡോക്കർഫയൽ ഉപയോഗിച്ച് കൂട്ടിച്ചേർക്കുന്നു. ഒരു ഇമേജിൽ നിന്ന് ഒരു കണ്ടെയ്നർ പ്രവർത്തിപ്പിക്കുമ്പോൾ, ഡോക്കർഫയൽ ഇനി ഉപയോഗിക്കില്ല.

ഇമേജ് നിർമ്മിക്കുമ്പോൾ ഉപയോക്താവിനെ സൃഷ്ടിക്കണം. പ്രോസസ്സുകൾ ലോഞ്ച് ചെയ്യുന്ന ഉപയോക്താവിനെ നിർണ്ണയിക്കുന്നതിനും ഇത് ബാധകമാണ്. ഇതിനർത്ഥം നമ്മൾ എങ്ങനെയെങ്കിലും UID (GID) കണ്ടെയ്‌നറിനുള്ളിൽ കടത്തിവിടണം എന്നാണ്.

ഡോക്കർഫയലിൽ ബാഹ്യ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നതിന് നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു ENV и ARG. നിർദ്ദേശങ്ങളുടെ വിശദമായ താരതമ്യം ഇവിടെ.

Dockerfile

ARG UID=1000
ARG GID=1000
ENV UID=${UID}
ENV GID=${GID}
RUN usermod -u $UID node 
  && groupmod -g $GID node

ഇതുപോലെയുള്ള ഡോക്കർ-കമ്പോസ് വഴി നിങ്ങൾക്ക് ആർഗ്യുമെന്റുകൾ കൈമാറാൻ കഴിയും:

ഡോക്കർ-രചിക്കുക

build:
  context: ./src/backend
  args:
    UID: 1000
    GID: 1000

PS ഡോക്കറിന്റെ എല്ലാ സങ്കീർണതകളും പഠിക്കാൻ, ഡോക്യുമെന്റേഷനോ ലേഖനങ്ങളോ വായിച്ചാൽ മാത്രം പോരാ. നിങ്ങൾ വളരെയധികം പരിശീലിക്കേണ്ടതുണ്ട്, ഡോക്കറിനെക്കുറിച്ച് നിങ്ങൾക്ക് ഒരു അനുഭവം നേടേണ്ടതുണ്ട്.

അവലംബം: www.habr.com