ചെറിയതും സുരക്ഷിതവുമായ കണ്ടെയ്നർ ചിത്രങ്ങൾ

ഓടിപ്പോകുക. docker images ഏതാണ്ട് ഏത് പ്രോജക്റ്റിലും 800 MB, 1 GB, ചിലപ്പോൾ അതിലധികവും വലുപ്പമുള്ള ചിത്രങ്ങൾ കാണാം. ഏതാനും മെഗാബൈറ്റ് കോഡുള്ള ഒരു ആപ്ലിക്കേഷന് വേണ്ടി. ബാക്കി ഒരു പൂർണ്ണ ഓപ്പറേറ്റിങ് സിസ്റ്റം ആണ്, കമ്പൈലറുകൾ, പാക്കേജ് മാനേജർമാർ, ഷെല്ലുകൾ, ഡീബഗ്ഗിംഗ് ടൂളുകൾ, അവശേഷിക്കുന്ന ഫയലുകൾ.

വലിയ ചിത്രങ്ങള് നിർമ്മിക്കാനും, വലിച്ചെടുക്കാനും തുടങ്ങാനും കൂടുതൽ സമയമെടുക്കും. കൂടാതെ, ഓരോ അധിക പാക്കേജും സുരക്ഷാ അപകടം കൂട്ടുന്നു. ഇതാ എന്റെ കയ്യിലെ പൈപ്പ് ചെറുതും സുരക്ഷിതവുമാക്കുന്നു.

പല ഘട്ടങ്ങളുള്ള കെട്ടിടങ്ങൾ

ഏറ്റവും വലിയ വിജയം, ഇതുവരെ. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ കംപൈൽ ചെയ്യുന്നതിന് എല്ലാ ബിൽഡ് ടൂളുകളുമായും ഒരു ഘട്ടം ഉപയോഗിക്കുക, തുടർന്ന് ഫലം മാത്രം ഒരു മിനിമം അന്തിമ ചിത്രത്തിലേക്ക് പകർത്തുക.

# Build stage
FROM golang:1.25 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /app ./cmd/server

# Final stage
FROM gcr.io/distroless/static-debian12:nonroot
COPY --from=build /app /app
USER nonroot
ENTRYPOINT ["/app"]

അവസാന ചിത്രത്തില് ബൈനറി അടങ്ങിയിരിക്കുന്നു. മറ്റൊന്നും ഇല്ല. ഷെല്ലും പാക്കേജ് മാനേജറും കംപൈലറും ഇല്ല. ഒരു ഗോ ആപ്പിനായി, അതായത് ഒരു ജിഗാബൈറ്റിൽ നിന്ന് ഇരുപത് മെഗാബൈറ്റിലേക്ക് പോകുക.

മറ്റ് ഭാഷകളിലും ഇതേ രീതി തന്നെ: പൂർണ്ണ SDK ഇമേജ് ഉപയോഗിച്ച് നിർമ്മിക്കുക, സ്ലിം റൺടൈം ഇമേജ് കൊണ്ട് പ്രവർത്തിപ്പിക്കുക.

ഒരു അടിസ്ഥാന ചിത്രം തിരഞ്ഞെടുക്കുന്നു

നിങ്ങളുടെ ചിത്രത്തിന്റെ വലുപ്പവും അതിന്റെ ദുർബലതയും അടിസ്ഥാന ചിത്രമാണ് തീരുമാനിക്കുന്നത്.

• വിതരണത്തിന്റെ പൂർണ്ണ ചിത്രങ്ങൾ (ubuntu, debian, node, python): സുഖകരവും വലുതും, ആവശ്യമില്ലാത്ത ധാരാളം പാക്കേജുകളും.
• സ്ലിം വേരിയന്റുകൾ (python:3.13-slim, node:22-slim): നല്ലൊരു മധ്യസ്ഥം.
• ആല് പീൻ: വളരെ ചെറുതാണ്, പക്ഷേ glibc എന്നതിനു പകരം musl ഉപയോഗിക്കുന്നു, ഇത് ചിലപ്പോൾ സൂക്ഷ്മമായ അനുയോജ്യത അല്ലെങ്കിൽ പ്രകടന പ്രശ്നങ്ങൾക്ക് കാരണമാകുന്നു.
• വിഭജനം ഇല്ലാത്തവ (ഗൂഗിൾ): നിങ്ങളുടെ ആപ്ലിക്കേഷനും അതിന്റെ റൺടൈം ആശ്രയത്വങ്ങളും മാത്രം. ഷെല്ലില്ല.
• കഠിനമാക്കിയ മിനിമം ചിത്രങ്ങൾ: ചൈൻഗാർഡ് ഇമേജുകൾ (വോൾഫിയിൽ നിർമ്മിച്ചിരിക്കുന്നത്), ഡോക്കർ ഹാർഡൻഡ് ഇമേജ്സ്, സമാന ഓഫറുകൾ എന്നിവ പതിവായി പുനർനിർമ്മിക്കുകയും പൂജ്യം അല്ലെങ്കിൽ പൂജ്യം-പരാജയങ്ങൾ ലക്ഷ്യമിടുകയും ചെയ്യുന്നു.

ഒരു കുറിപ്പ് ബിറ്റനാമി: ബിറ്റ്നാമിയുടെ സൌജന്യ കണ്ടെയ്നർ ചിത്രങ്ങളും ഹെൽം ചാർട്ടുകളും പല ടീമുകളും ആശ്രയിച്ചു. 2025 ൽ, ബ്രോഡ്കോം സ്വതന്ത്ര കാറ്റലോഗ് ഗണ്യമായി മാറ്റി, മിക്ക പതിപ്പുകളുള്ള ചിത്രങ്ങളും അപ്ഡേറ്റുകൾ ലഭിക്കാത്ത ഒരു ലെഗസി റിപ്പോസിറ്ററിയിലേക്ക് നീക്കി. നിങ്ങളുടെ ചാർട്ടുകളോ ഡോക്കർ ഫയലുകളോ ഇപ്പോഴും ബിറ്റ്നാമി ഇമേജുകളിലേക്ക് റഫറൻസ് ചെയ്യുന്നുണ്ടെങ്കിൽ, അവ ഇപ്പോൾ പരിശോധിച്ച് പിന്തുണയ്ക്കുന്ന ബദലുകളിലേക്ക് മാറുക.

നിങ്ങളുടെ ചിത്രത്തിലെ ഓരോ പാക്കേജും നിങ്ങൾ പായ്ച്ച് ചെയ്യേണ്ട ഒരു പാക്കേജ് ആണ്. പരിഹരിക്കാന് ഏറ്റവും എളുപ്പമുള്ള ദോഷം നിങ്ങള് ഒരിക്കലും അയക്കാത്തതാണ്.

കാഷിംഗിലൂടെ വേഗത്തിൽ നിർമ്മിക്കുന്നു

ഡോക്കർ ലെയറുകളെ ക്രമത്തിൽ നിർമ്മിക്കുന്നു, എന്തെങ്കിലും മാറ്റം വരുന്നതുവരെ കാഷെ ചെയ്ത ലെയറുകളെയും പുനരുപയോഗിക്കുന്നു. അതുകൊണ്ട് ക്രമം പ്രധാനമാണ്:

1. ആദ്യം ആശ്രിതത്വ ഫയലുകൾ പകർത്തുക (package.json, go.mod, requirements.txt), ആശ്രിതത്വങ്ങള് ഇൻസ്റ്റോൾ ചെയ്യുക, പിന്നെ കോഡിന്റെ ബാക്കി പകര് ക്കുക. കോഡ് മാറ്റം അനുസരണ പാളി അസാധുവാക്കുന്നില്ല.
2. ഒരു .dockerignore സൂക്ഷിക്കുക node_modules, .git, ടെസ്റ്റ് ഡാറ്റയും പ്രാദേശിക രഹസ്യങ്ങളും ബിൽഡ് പശ്ചാത്തലത്തിൽ നിന്ന്.
3. ബിൽഡ്കിറ്റ് കാഷെ മൌണ്ടുകൾ ഉപയോഗിക്കുക പാക്കേജ് മാനേജർ കാഷെകൾക്കായി:

RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

4. CI ൽ രജിസ്ട്രി കാഷെ ഉപയോഗിക്കുക (--cache-to ഒപ്പം --cache-from കൂടെ docker buildx), അതിനാൽ പൈപ്പ്ലൈൻ പഴയ പണിയുന്ന നിന്ന് പാളികൾ വീണ്ടും ഉപയോഗിക്കുന്നു.

കട്ടിയാക്കൽ ചെക്ക്ലിസ്റ്റ്

• റൂട്ട് അല്ലാത്ത ഉപയോക്താവായി പ്രവർത്തിപ്പിക്കുക. സജ്ജീകരിച്ചു USER ഡോക്കര് ഫയലിലും runAsNonRoot: true കുബർനെറ്റീസിൽ.
• പിൻ ബേസ് ചിത്രങ്ങൾ പതിപ്പുകൾ അനുസരിച്ച്, നല്ലത് ഡൈജസ്റ്റ് അനുസരിച്ച്, അവ പുതുക്കാനും അപ്ഡേറ്റ് ചെയ്യാനും അനുവദിക്കുക.
• ചിത്രങ്ങളില് രഹസ്യങ്ങളില്ല. ബിൽഡ് രഹസ്യങ്ങൾ ഉപയോഗിക്കുക (--mount=type=secret) നിർമ്മാണ സമയത്ത് ആവശ്യമുള്ള എല്ലാത്തിനും.
• റൂട്ട് ഫയൽ സിസ്റ്റം വായിക്കാൻ മാത്രമുള്ളതാണ് സാധ്യമാകുമ്പോഴെല്ലാം കുബർനെറ്റീസിൽ.
• ലിനക്സ് ശേഷി കുറയ്ക്കുക നിനക്ക് വേണ്ട.
• ലേബലുകൾ ചേർക്കുക ഉറവിടം, പതിപ്പ്, പരിപാലകന് (ഒസിഐ കുറിപ്പുകൾ)

കയറ്റുമതി ചെയ്യുന്നതിനു മുമ്പ് സ്കാൻ ചെയ്യുക

ഐ. സി. യിൽ ചിത്രങ്ങൾ സ്കാൻ ചെയ്ത്, ഗുരുതരമായ, പരിഹരിക്കാവുന്ന ദോഷങ്ങളുള്ള ബിൽഡിൽ പരാജയപ്പെടുക:

trivy image --severity HIGH,CRITICAL --ignore-unfixed \
  --exit-code 1 registry.example.com/shop-api:1.4.2

ട്രിവി ഒപ്പം ഗ്രിപ്പ് രണ്ടും മികച്ച ഓപ്പൺ സോഴ്സ് സ്കാനറുകളാണ്. ഡോക്കർ സ്കൌട്ടും മിക്ക രജിസ്ട്രികളും ഓട്ടോമാറ്റിക് സ്കാൻ ചെയ്യുന്നു.

രണ്ടു നുറുങ്ങുകൾ: ഉപയോഗിക്കുക --ignore-unfixed (അല്ലെങ്കിൽ സമാനമായ) അതിനാൽ നിങ്ങൾ ആരും പരിഹരിക്കാൻ കഴിയില്ല ദോഷങ്ങളുമുണ്ട് തടയുന്നില്ല, പതിവായി ചിത്രങ്ങൾ വീണ്ടും സ്കാൻ, മാത്രമല്ല ബിൽഡ് സമയം, പുതിയ ദോഷങ്ങളുണ്ട് കാരണം പഴയ ചിത്രങ്ങൾ എല്ലാ ദിവസവും കണ്ടെത്തി.

എവിടെ നിന്നാണ് ഞാൻ തുടങ്ങേണ്ടത്?

നിങ്ങളുടെ ഏറ്റവും വലിയ ചിത്രം എടുക്കുക. ഒരു മൾട്ടി-സ്റ്റേജ് ബിൽഡും ഒരു സ്ലിം അല്ലെങ്കിൽ ഡിസ്ട്രോലെസ് ബേസും ചേർക്കുക. ട്രിവിയെ മുമ്പും ശേഷവും ഓടിക്കുക. വലിപ്പത്തിലും സുരക്ഷയിലും വ്യത്യാസം സാധാരണയായി വളരെ വലുതാണ്, ടീമിലെ മറ്റുള്ളവരും അത് ആഗ്രഹിക്കുന്നു.

എന്റെ അഭിപ്രായം: നിങ്ങളുടെ ആപ്പ് ഷിപ്പ് ചെയ്യുക, ഒരു ഓപ്പറേറ്റിങ് സിസ്റ്റം മുഴുവനല്ല. ചെറിയ ചിത്രങ്ങൾ വേഗതയേറിയതും വിലകുറഞ്ഞതും സുരക്ഷിതവുമാണ്.

ഡെസ്ലി