Docker Compose build vs image: VPS-ல் என்ன வித்தியாசம்?
Docker Compose கோப்பில் image மற்றும் build கீகளுக்கு இடையே உள்ள வேறுபாடுகளை அறியுங்கள். Dockerfile மாற்றங்களை ஏன் compose up கண்டுகொள்வதில்லை என்பதற்கான தீர்வை இங்கே காணலாம்.
Docker Compose build மற்றும் image: சுருக்கமான விளக்கம்
Docker Compose கோப்பில், image: பயன்படுத்த வேண்டிய image-ஐக் குறிக்கிறது; இதில் local image, tag அல்லது digest reference ஆகியவை அடங்கும். build: என்பது மூலக் குறியீட்டிலிருந்து (source) ஒரு image-ஐ எவ்வாறு உருவாக்குவது என்பதை Compose-க்குத் தெரிவிக்கிறது. image:-ஐ மட்டும் அமைத்தால், pull_policy-ன் படி Compose அந்த image-ஐப் பயன்படுத்தும் அல்லது பதிவிறக்கும் (pull). build:-ஐ மட்டும் அமைத்தால், கட்டமைக்கப்பட்ட builder மூலம் Compose அந்த image-ஐ உருவாக்கும்; அதற்கு project பெயர் மற்றும் service பெயரிலிருந்து பெறப்பட்ட ஒரு பெயர் இடப்படும். இரண்டையும் அமைத்தால், pull_policy-ன் மூலம் Compose பதிவிறக்க வேண்டுமா அல்லது உருவாக்க வேண்டுமா என்பது தீர்மானிக்கப்படும்; அது உருவாக்கும்போது, image:-ல் உள்ள பெயரைக் கொண்டு tag செய்யும். இதன் மூலமே நீங்கள் ஒரு image-ஐ உருவாக்கி, உங்களுக்குத் தேவையான பெயரில் push செய்ய முடியும். இந்த builder உள்ளூர் கணினியிலோ அல்லது remote Docker host-லோ இயங்கலாம்.
இதுவே அவற்றுக்கிடையேயான அடிப்படை வேறுபாடு. கீழே உள்ளவை அனைத்தும் ஒரு server-ல் இவை எவ்வாறு செயல்படுகின்றன என்பது பற்றியது. Docker Engine மற்றும் Compose plugin ஏற்கனவே நிறுவப்பட்டிருப்பதாக இது கருதுகிறது; VPS-ல் Docker-ஐ இயக்குதல் என்ற பகுதி அதை விளக்குகிறது.
மூன்று வடிவங்கள் முழுமையாக
வெளியிடப்பட்ட tag-ஐப் பயன்படுத்தவும்; அது இல்லையெனில், default pull policy-ன் கீழ் அதைத் தரவிறக்கம் செய்யவும். இதில் எந்த இடத்திலும் Dockerfile பயன்படுத்தப்படுவதில்லை.
services:
web:
image: nginx:1.27
restart: unless-stopped
ports:
- "80:80"Project directory-ல் உள்ள Dockerfile-லிருந்து build செய்யவும். இந்த build, Dockerfile-க்குத் தேவையான images-ஐத் தரவிறக்கம் செய்யவும் மற்றும் dependencies-ஐப் பதிவிறக்கவும் முடியும்.
services:
web:
build: .
restart: unless-stopped
ports:
- "80:80"Build செய்து, அதன் முடிவை docker compose build மூலம் tag செய்யவும்; explicit pull policy இல்லையெனில், build செய்வதற்கு முன்பு up அந்த image-ஐத் தரவிறக்கம் செய்ய முயற்சிக்கும். அதன் பிறகு, docker compose push அந்த குறிப்பிட்ட tag-ஐ registry-க்கு அனுப்ப முடியும்.
services:
web:
build:
context: .
dockerfile: Dockerfile
image: registry.example.com/acme/web:1.4.2
restart: unless-stopped
ports:
- "80:80"context என்பது builder-க்கு அனுப்பப்படும் directory ஆகும். dockerfile அந்த context-ஐப் பொறுத்தே அமையும், எனவே dockerfile: docker/prod.Dockerfile உடன் context: .-ஐப் பயன்படுத்துவது இயல்பானதும் சரியானதுமாகும். ஒவ்வொரு service container-க்கு பின்னால் உள்ள image பெயர் மற்றும் image ID-ஐப் பார்க்க docker compose images-ஐ இயக்கவும்; அந்த service image:, build: அல்லது இரண்டையும் பயன்படுத்துகிறதா என்பதை உறுதிப்படுத்த Compose file-ஐச் சரிபார்க்கவும்.
Dockerfile-ஐ மாற்றிய பிறகு ஏன் docker compose up கட்டளை rebuild செய்வதில்லை?
சாதாரண up கட்டளையானது, நீங்கள் ஒரு build-ஐக் கோராதவரை அல்லது அதற்கான கொள்கையை (policy) அமைக்காதவரை, ஏற்கனவே உள்ள image-ஐயே மீண்டும் பயன்படுத்தும்.
ஒரு service-ல் build: பகுதி மட்டுமே இருக்கும்போது, Compose அதைத் தொடங்க முற்படும்போது ஏற்கனவே உள்ள image கிடைத்தால் அதையே பயன்படுத்தும். அது உங்கள் Dockerfile-ஐப் படிப்பதோ, source files-ஐ ஒப்பிட்டுப் பார்ப்பதோ அல்லது timestamp-ஐக் கவனிப்பதோ இல்லை. image: மற்றும் build: ஆகிய இரண்டையும் குறிப்பிட்டு, எந்த ஒரு pull_policy-ம் இல்லாத நிலையில், Compose முதலில் image-ஐப் பதிவிறக்க (pull) முயற்சிக்கும்; registry-யிலோ அல்லது platform cache-லோ image இல்லை என்றால் மட்டுமே அது build செய்யும். ஏற்கனவே இருப்பது போதுமானது எனக் கருதப்படும்.
எனவே, நீங்கள் app.py-ஐத் திருத்திவிட்டு, docker compose up -d-ஐ இயக்கினால், Compose அந்த container இயங்கிக்கொண்டிருப்பதாகவே காட்டும், ஆனால் பழைய code-ஐயே அது வழங்கும். எதிலும் பிழை ஏற்படாததால், எந்த எச்சரிக்கையும் வராது. container பெயருக்கு அருகில் Compose காட்டும் status வார்த்தையே இதற்கான அடையாளம்: Compose மாற்றியமைத்த container 'recreated' அல்லது 'started' என்று காட்டும், மாற்றமில்லாத container 'running' என்று காட்டும்.
இதை உறுதிப்படுத்த இரண்டு வழிகள் உள்ளன. docker compose images ஒவ்வொரு container-ம் பயன்படுத்தும் image ID-ஐக் காட்டும், எனவே deploy செய்வதற்கு முன் அதைக் குறித்துக்கொண்டு, பிறகு ஒப்பிட்டுப் பார்க்கவும். docker image ls கட்டளையில் CREATED நெடுவரிசை உள்ளது, ஆனால் cached builds மற்றும் மீண்டும் உருவாக்கக்கூடிய timestamps காரணமாக, அந்தத் தேதியை மட்டும் வைத்து உங்கள் சமீபத்திய source build செய்யப்பட்டதா என்பதை உறுதிப்படுத்த முடியாது.
எந்தெந்த flags rebuild செய்யத் தூண்டும்
docker compose up -d --buildமுதலில் build செய்து, பின்னர் image மாறிய எந்தவொரு container-ஐயும் மீண்டும் உருவாக்கும். பெரும்பாலான பயனர்கள் தேடும் flag இதுவே.docker compose build webஒரு service-ஐ மட்டும் build செய்யும், எதையும் start செய்யாது. அந்த container-ஐ மட்டும் மாற்றிவிட்டு, மற்ற stack-ஐ தொடர்ந்து இயக்க, இதைத் தொடர்ந்துdocker compose up --no-deps -d web-ஐப் பயன்படுத்தவும்.docker compose build --no-cache webcached layers-ஐத் தவிர்த்துவிட்டு, service-ஐ மீண்டும் build செய்யும்.docker compose build --pullFROM-ல் உள்ள base image-ன் புதிய பதிப்பைப் பதிவிறக்க முயற்சிக்கும். எனவே,node:22போன்ற நகரும் tag, மார்ச் மாதம் நீங்கள் பதிவிறக்கிய நகலுக்குப் பதிலாக அதன் தற்போதைய உள்ளடக்கத்தைப் பெறும்.docker compose up -d --force-recreateconfiguration மற்றும் image மாறவில்லை என்றாலும், container-ஐ மீண்டும் உருவாக்கக் கட்டாயப்படுத்தும். இந்த flag தானாகவே build செய்யாது, ஆனால் image விடுபட்டிருந்தாலோ அல்லது pull policy தேவைப்பட்டாலோupஇன்னும் build செய்யக்கூடும்.--build-க்கு பதிலாக இதைத் தேர்ந்தெடுப்பது பெரும்பாலும் பயனற்ற முடிவில் தான் முடியும்.
நீங்கள் இந்த முடிவை file-க்குள்ளேயே மாற்றலாம். Compose specification-ன் படி, pull_policy: build என்பது Compose image-ஐ build செய்யும் என்பதையும், அது ஏற்கனவே இருந்தால் மீண்டும் build செய்யும் என்பதையும் குறிக்கிறது. ஒவ்வொரு up-ம் build-க்கான நேரத்தை எடுத்துக்கொள்ளும்; இது laptop-ல் தேவைப்படலாம், ஆனால் server-ல் அரிதாகவே தேவைப்படும்.
services:
web:
build: .
image: registry.example.com/acme/web:dev
pull_policy: buildஇன்னொரு செயல்பாட்டையும் தெரிந்துகொள்வது அவசியம். docker compose pull என்பது build பகுதியைக் கொண்ட services-க்கும் images-ஐப் பதிவிறக்க முயற்சிக்கும். அந்தப் பதிவிறக்கம் தோல்வியுற்றால், image-ஐ build செய்ய வேண்டும் என்று அது உங்களுக்குத் தெரிவிக்கும். அந்த services-ஐ அமைதியாகத் தவிர்க்க --ignore-buildable-ஐப் பயன்படுத்தவும்.
Build cache உங்கள் deploy நேரத்தை எவ்வாறு தீர்மானிக்கிறது
ஒரு Dockerfile instruction மற்றும் அதன் உள்ளீடுகள் மாறாமல் இருக்கும்போது, மீண்டும் பயன்படுத்தக்கூடிய cached முடிவை builder சரிபார்க்கிறது. COPY-ஐப் பொறுத்தவரை, உள்ளீடுகளில் கோப்பின் உள்ளடக்கம் மற்றும் metadata ஆகியவை அடங்கும், ஆனால் மாற்றியமைக்கப்பட்ட நேரங்கள் (modification times) கணக்கில் கொள்ளப்படாது. ஒரு layer cache-ல் கிடைக்கவில்லை என்றால், அதைச் சார்ந்திருக்கும் அடுத்தடுத்த படிகள் மீண்டும் உருவாக்கப்படும்.
இந்த ஒரு விதிதான் உங்கள் deploy சில வினாடிகளில் முடியுமா அல்லது பல நிமிடங்கள் ஆகுமா என்பதைத் தீர்மானிக்கிறது. அரிதாக மாறும் விஷயங்களிலிருந்து தொடங்கி, ஒவ்வொரு commit-லும் மாறும் விஷயங்கள் வரை Dockerfile-ஐ வரிசைப்படுத்துங்கள்.
FROM node:22-slim
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
CMD ["node", "server.js"]npm ci என்பது COPY . .-க்கு மேலே உள்ளது. எனவே, ஒரு source file-ஐ மாற்றும்போது install layer cache-லேயே இருக்கும், மேலும் copy படியிலிருந்து build தொடரும். இந்த இரண்டு வரிகளையும் மாற்றினால், ஒரு சிறிய எழுத்து மாற்றத்திற்குக்கூட அனைத்து dependency-களும் மீண்டும் install செய்யப்படும். ஏனெனில், COPY . . என்பது npm ci கட்டமைக்கப்பட்டுள்ள layer-ஐ செல்லாததாக்குகிறது. இதே தர்க்கம் pip install -r requirements.txt மற்றும் go mod download ஆகியவற்றிற்கும் பொருந்தும்.
உங்கள் திருத்தத்தை ஒரு பழைய layer மறைத்து வைத்திருப்பதாக நீங்கள் சந்தேகிக்கும்போது, --no-cache சரியான கருவியாகும். ஆனால், இதை இயல்பான அமைப்பாக (default) வைத்திருப்பது தவறு. ஏனெனில், Dockerfile வரிசைப்படுத்துவதன் மூலம் கிடைக்கும் cache பயன்பாட்டை இது முழுமையாக நீக்கிவிடும்.
Image அமைக்கும் ஒரு விஷயம் மற்றும் Compose மூலம் மாற்றக்கூடிய ஒன்று: Dockerfile-ன் CMD என்பது image இயல்பாக இயக்கும் கட்டளையாகும், மேலும் service-ல் உள்ள command: key அதை மாற்றியமைக்கும். Command மற்றும் entrypoint எவ்வாறு ஒன்றோடொன்று செயல்படுகின்றன என்பது இங்கே முக்கியமானது. ஏனெனில், Compose override மூலம் புதிதாக build செய்யப்பட்ட image-ஐ பழைய image போலவே செயல்பட வைக்க முடியும்.
Build context மற்றும் .dockerignore
context: ., project directory-ஐ builder-க்கு அணுகக்கூடியதாக மாற்றுகிறது. கோப்புகளைத் தவிர்க்கவில்லை என்றால், அதில் .git மற்றும் source கோப்பிற்கு அருகில் நீங்கள் வைத்திருக்கும் எந்தவொரு தரவு கோப்பகமும் அடங்கும். இருப்பினும், BuildKit பயன்படுத்தப்படாத கோப்புகளைத் தவிர்த்து, மாற்றங்களை மட்டும் படிப்படியாக மாற்றுகிறது. மாற்றமில்லாத ஒரு project-ன் transferring-context நிலையில் build நின்றால், context அளவு மிக அதிகமாக உள்ளது என்று அர்த்தம்.
Context-ன் root-ல் உள்ள ஒரு .dockerignore கோப்பு, அந்தப் பரிமாற்றத்திலிருந்து குறிப்பிட்ட பாதைகளை நீக்குகிறது. இதன் syntax .gitignore-ஐப் போன்றது.
.git
node_modules
*.log
data/
.envஇதனால் இரண்டு நன்மைகள் உள்ளன. கோப்புப் பரிமாற்ற அளவு குறைவதால், கோப்புகளை அனுப்பும் நேரம் மிச்சமாகும். மேலும், COPY . .-ஆல் இனி .env-ஐ image-க்குள் நகலெடுக்க முடியாது; இதனால் அந்த image-ஐப் பதிவிறக்கும் எவராலும் அதை வாசிக்க முடியாது.
காலப்போக்கில் build வேகம் குறைவதற்கு bind mount ஒரு முக்கிய காரணம். Named volume உங்கள் project directory-க்கு வெளியே இருக்கும், ஆனால் ./data:/var/lib/postgresql/data போன்ற bind mount-கள் build context-க்கு உள்ளேயே இருக்கும். இதனால் database வளர வளர, ஒவ்வொரு வாரமும் உங்கள் build வேகம் குறையும். .dockerignore-ல் உள்ள ஒரே ஒரு வரி இதைச் சரிசெய்யும். Bind mounts against named volumes பகுதி இதைப் பற்றிய விரிவான ஒப்பீட்டை வழங்குகிறது.
Build arguments-ம் இதே போன்ற சிறிய ஆபத்தைக் கொண்டுள்ளன. args: வழியாக அனுப்பப்படும் மதிப்புகள் image history அல்லது provenance metadata-வில் தங்கிவிடக்கூடும். எனவே, அங்கு version number-ஐ மட்டும் பயன்படுத்தவும், ஒருபோதும் token-களைப் பயன்படுத்த வேண்டாம். Dockerfile-ல் வெளிப்படையாகக் குறிப்பிடப்படாவிட்டால், முன்னரே வரையறுக்கப்பட்ட proxy arguments இயல்பாகவே build cache மற்றும் docker history-லிருந்து தவிர்க்கப்படும். Env files and secrets in Compose பகுதி, credentials-ஐ எங்கு வைக்க வேண்டும் என்பதை விளக்குகிறது.
VPS-ல் build செய்வதா அல்லது பிற இடத்தில் build செய்து pull செய்வதா?
உங்கள் traffic-ஐ கையாளும் server-லேயே build செய்வது இயல்பான முறை, ஏனெனில் இதுவே மிகக் குறுகிய வழி: git pull, பிறகு docker compose up -d --build. யாரும் சார்ந்திருக்காத சிறிய server-களில் இது சரியாக இருக்கும். ஆனால், அளவிடக்கூடிய இரண்டு காரணங்களுக்காகவும், ஒரு மோசமான சூழலில் மட்டும் வெளிப்படும் ஒரு காரணத்திற்காகவும் இது தவிர்க்கப்பட வேண்டும்.
Memory. ஒரு build செயல்முறை, உங்கள் live application-க்கு அருகிலேயே compilers மற்றும் bundlers-ஐ இயக்கும். பெரும்பாலான stack-களில் இவைதான் அதிக memory-ஐப் பயன்படுத்தும். ஒரு JavaScript bundler அல்லது Rust compile, 1 GB VPS-ல் உள்ள memory-ஐ முழுமையாகப் பயன்படுத்தக்கூடும். Memory தீர்ந்துவிடும்போது, kernel ஒரு OOM victim-ஐத் தேர்வு செய்யும். இது memory பயன்பாடு, allocation context மற்றும் oom_score_adj ஆகியவற்றின் அடிப்படையில் ஒரு badness score-ஐக் கொண்டு தீர்மானிக்கப்படும்; இது வெறுமனே பெரிய process-ஐ மட்டும் kill செய்யாது. Build செயல்முறை Killed பிழையுடன் exit status 137-ல் நின்றுவிடலாம், அல்லது உங்கள் database kill செய்யப்பட்டு deploy நடக்கும்போதே தளம் முடக்கப்படலாம். dmesg -T | grep -i oom kernel log-ல் OOM செய்திகளைத் தேடும்; இந்த log-ஐப் படிக்கத் தேவையான அனுமதி உங்களுக்கு இருக்க வேண்டும்.
Disk. Build-கள் image layers மற்றும் build cache-ஐ விட்டுச் செல்லும். docker system df அவற்றின் disk பயன்பாட்டைக் காட்டும்; BuildKit-ன் காலமுறை garbage collection, அதன் கொள்கைகளுக்கு ஏற்ப cache-ஐ மீட்டெடுக்கும். Dangling images-ஐ நீக்க docker image prune-ஐயும், cached layers-ஐ நீக்க docker builder prune-ஐயும் பயன்படுத்தவும். Disk முழுமையாக நிரம்பினால் build மட்டும் நிற்காது. Database-ன் எழுதும் பணியும் நின்றுவிடும், இந்தத் தோல்வி மெதுவான deploy-ஐ விட அதிக பாதிப்பை ஏற்படுத்தும்.
Reproducibility. Server-ல் build செய்யப்படும் image-ஐ push அல்லது export செய்யாவிட்டால், அது அந்த server-ல் மட்டுமே இருக்கும். பழைய image கிடைக்கவில்லை என்றால், rollback செய்ய பழைய commit-ஐ checkout செய்து மீண்டும் build செய்ய வேண்டும். ஆனால், base tag மாறியிருக்கலாம் அல்லது package mirrors மாறியிருக்கலாம் என்பதால், அதே output கிடைக்கும் என்பதற்கு உத்தரவாதம் இல்லை. பிற இடத்தில் build செய்து ஒரு tag-ஐ push செய்வது, rollback-ஐ ஒரு எளிய மாற்றமாக மாற்றும்: image:-ஐ முந்தைய tag-க்கு மாற்றி, docker compose up -d-ஐ இயக்கினால் போதும்.
நிலைத்தன்மை கொண்ட முறை தெளிவானது. உங்கள் continuous integration build-ஐ இயக்கி registry.example.com/acme/web:<git-sha>-ஐ push செய்யும், VPS-ல் உள்ள Compose file image:-ஐக் கொண்டிருக்கும், அதில் build: key இருக்காது. இப்போது deployment என்பது மிகக் குறைந்த memory தேவைப்படும் இரண்டு கட்டளைகள் மட்டுமே.
docker compose pull
docker compose up -dPrivate tags-ஐ pull செய்யத் தேவையான credentials-ஐச் சேமிக்க server-ல் docker login registry.example.com-ஐ இயக்கவும்.
Build பகுதியை நீக்குவதற்குப் பதிலாக, நீங்கள் பெயரிடும் ஒரு தனி file-ல் வைத்து, development-க்காகப் பயன்படுத்தவும்.
# compose.dev.yaml
services:
web:
build:
context: .
pull_policy: builddocker compose -f compose.yaml -f compose.dev.yaml up -d --buildஅந்த file-க்கு compose.dev.yaml என்று பெயரிடவும், compose.override.yaml என்று பெயரிட வேண்டாம். Compose ஒரு override file-ஐ அது இருக்கும்போதெல்லாம் தானாகவே load செய்யும். எனவே, தவறுதலாக ஒரு override file server-க்கு நகலெடுக்கப்பட்டால், அது மீண்டும் server-லேயே build செய்யத் தொடங்கிவிடும். பல Compose file-களை அடுக்குதல் பகுதி, ஒவ்வொரு key-யும் எவ்வாறு merge செய்யப்படுகிறது என்பதை விளக்குகிறது.
பிற இடங்களில் உருவாக்கும்போது ஏற்படும் கட்டமைப்பு சிக்கல்
ஒரே platform image அது உருவாக்கப்பட்ட CPU கட்டமைப்பைக் கொண்டிருக்கும். Apple Silicon laptop-ல் ஒரு ARM image-ஐ உருவாக்கி, அதை push செய்து, பின் x86_64 VPS-ல் பயன்படுத்தினால்: explicit platform குறிப்பிடப்படாமல், பொருந்தாத cached image-ஐப் பயன்படுத்தும்போது container உருவாக்கும்போது Docker எச்சரிக்கை செய்யும். Emulation இல்லையென்றால், செயல்முறை exec format error பிழையுடன் தோல்வியடையும்; இது ஒரு சிதைந்த binary கோப்பு போலத் தோன்றும், ஆனால் அது அவ்வாறு இல்லை. இலக்கு கட்டமைப்பிற்காக (target architecture) தெளிவாக உருவாக்கவும்:
docker buildx build --platform linux/amd64 \
-t registry.example.com/acme/web:1.4.2 --push .உங்கள் laptop x86 ஆக இருந்து, நீங்கள் x86-க்கு பதிலாக ARM VPS-ல் இயக்கும்போதும் இதே பொருந்தாமை ஏற்படும். நீங்கள் deploy செய்யும் அதே கட்டமைப்பில் CI-ஐ உருவாக்க அனுமதிப்பது இந்தச் சிக்கலை நீக்கும். Multi-platform image-ம் இதைத் தீர்க்கும்: image-ஐ pull செய்யும்போது Docker அதற்குப் பொருத்தமான variant-ஐத் தேர்ந்தெடுத்துக்கொள்ளும்.
deploy செய்த பிறகு சரிபார்க்க வேண்டியவை
docker compose imagesஒவ்வொரு இயங்கும் container-க்கு பின்னால் உள்ள image மற்றும் tag-ஐக் காட்டும். மாறியுள்ள image ID, புதிய build பயன்பாட்டில் இருப்பதற்கான சான்றாகும்.docker compose configvariable substitution செய்த பிறகு இணைக்கப்பட்ட கோப்பை அச்சிடும். எனவே, எதையும் இயக்கும் முன்பே Compose பயன்படுத்தும் இறுதி image பெயரை உங்களால் படிக்க முடியும்.docker compose logs -f webswap செய்த பிறகு முதல் அரை நிமிடத்திற்கு இதைப் பயன்படுத்தவும். ஒரு container அடிக்கடி தொடங்கி நின்றுவிட்டால், அதன் restart policy-ல் குறிப்பிடப்பட்டிருந்தால் மட்டுமே அது மீண்டும் தொடங்கும்; அதற்கான காரணத்தை அறிய logs-ஐச் சரிபார்க்கவும்.docker image lsஇது CREATED என்ற நெடுவரிசையைக் காட்டும். build output மற்றும் deploy செய்யப்பட்ட image ID ஆகியவற்றைச் சரிபார்க்கவும், ஏனெனில் creation timestamp மட்டும் rebuild நடந்ததா என்பதை உறுதிப்படுத்தாது.
இவை இயங்கும் கோப்பை நீங்கள் இன்னும் உருவாக்கிக் கொண்டிருக்கிறீர்கள் என்றால், VPS-ல் Compose கோப்பின் அடிப்படைகள் பகுதியில் அதற்கான முக்கிய அம்சங்கள் உள்ளன, மேலும் Compose கட்டளைகளின் சுருக்கக் குறிப்பு பகுதியில் மீதமுள்ள subcommands பட்டியலிடப்பட்டுள்ளன.
FAQ
ஒரே service-ல் build மற்றும் image ஆகிய இரண்டையும் பயன்படுத்த முடியுமா?
ஆம், நீங்கள் சொந்தமாக உருவாக்கும் ஒரு project-க்கு இதுவே வழக்கமான அமைப்பாகும். build: பகுதியில் இருந்து Compose build செய்யும்போது, அது image:-ன் மதிப்பை வைத்து அந்த result-க்கு tag இடுகிறது; ஒரு தெளிவான pull_policy இல்லையென்றால், up முதலில் pull செய்ய முயற்சிக்கும். அந்த tag-ஐத்தான் docker compose push ஒரு registry-க்கு அனுப்பும் மற்றும் மற்றொரு machine அதை pull செய்யும். image: key இல்லையென்றாலும் Compose build செய்யும், ஆனால் அது project மற்றும் service பெயரையே image-க்கு வைக்கும், மேலும் அந்த attribute விடுபட்டதால் image-ஐ push செய்ய முடியாது என்று எச்சரிக்கும்.
docker compose up ஏன் எனது Dockerfile மாற்றத்தை எடுத்துக்கொள்வதில்லை?
ஏனெனில், சாதாரண up ஒரு build-ஐ நீங்கள் கோரினாலோ அல்லது அதற்கான policy-ஐ அமைத்தாலோ ஒழிய, ஏற்கனவே உள்ள image-ஐயே மீண்டும் பயன்படுத்தும். ஒரு rebuild தேவைதானா என்பதை முடிவு செய்ய, அது அந்த image-ஐ உங்கள் Dockerfile அல்லது source files-உடன் ஒப்பிட்டுப் பார்ப்பதில்லை. docker compose up -d --build-ஐ இயக்கவும், அல்லது ஒரு குறிப்பிட்ட service-ஐ மாற்ற docker compose build web-ஐத் தொடர்ந்து docker compose up --no-deps -d web-ஐ இயக்கவும். service-ல் pull_policy: build-ஐ அமைப்பது ஒவ்வொரு up-யையும் rebuild செய்ய வைக்கும், இது development machine-க்கு ஏற்றது.
--build மற்றும் --force-recreate ஆகியவற்றுக்கு என்ன வித்தியாசம்?
--build image-ஐ மீண்டும் build செய்யும், பிறகு image மாறிய containers-ஐ மீண்டும் உருவாக்கும். --force-recreate configuration மற்றும் image மாறவில்லை என்றாலும் container-ஐ மீண்டும் உருவாக்க கட்டாயப்படுத்தும்; இது தானாகவே build-ஐ கோருவதில்லை. உங்கள் மாற்றம் source-ல் அல்லது Dockerfile-ல் இருந்தால், உங்களுக்குத் தேவையான flag --build ஆகும். --force-recreate என்பது container-ஐயே reset செய்யப் பயன்படும், உதாரணமாக, அதே image-ஐ வைத்துக்கொண்டு அதன் writable layer-ஐ மட்டும் நீக்க இது உதவும்.
எனது Docker images-ஐ VPS-ல் build செய்ய வேண்டுமா அல்லது வேறு எங்காவது செய்ய வேண்டுமா?
வேறு இடத்தில் build செய்துவிட்டு, server traffic-ஐக் கையாளத் தொடங்கிய பிறகு ஒரு tag-ஐ pull செய்யவும். ஒரு build உங்கள் application-ன் memory-க்காக போட்டியிடும்; memory தீர்ந்துவிட்டால், kernel ஒரு OOM score-ஐப் பயன்படுத்தி ஒரு process-ஐத் தேர்ந்தெடுத்து நீக்கும், அது உங்கள் build-ஆகவோ அல்லது database-ஆகவோ இருக்கலாம். Build-கள் disk-ல் cache-ஐ விட்டுச் செல்லும், இருப்பினும் BuildKit அதன் garbage collection கொள்கைகளின்படி அதைத் தானாகவே மீட்டெடுக்கும். பயனர்கள் இல்லாத சிறிய project-களுக்கு server-ல் build செய்வது சரிதான், மேலும் பிற்காலத்தில் மாற்றிக்கொள்வது எளிது, அதற்கு build: பகுதியை development-க்கு மட்டுமேயான Compose file-ல் வைத்திருந்தால் போதும்.
Docker build cache எனது disk-ஐ நிரப்புவதை எப்படித் தடுப்பது?
உங்கள் images மற்றும் build cache எவ்வளவு இடத்தை ஆக்கிரமித்துள்ளன என்பதைப் பார்க்க docker system df-ஐ இயக்கவும். docker builder prune cached layers-ஐ நீக்கும் மற்றும் docker image prune முந்தைய build-களால் விடப்பட்ட dangling images-ஐ நீக்கும். -a-ஐச் சேர்ப்பது பயன்படுத்தப்படாத அனைத்து build cache அல்லது containers-ஆல் குறிக்கப்படாத அனைத்து images-ஐயும் நீக்கும்; இது அடுத்த build-ஐ முழுமையாக cold build-ஆக மாற்றும் என்று உத்தரவாதம் அளிக்காது. server-ல் docker system prune -af --volumes-ஐ schedule செய்ய வேண்டாம், ஏனெனில் இது நிறுத்தப்பட்ட containers மற்றும் பயன்படுத்தப்படாத anonymous volumes-ஐ நீக்கும், இது பராமரிப்பின் போது anonymous volume-ல் உள்ள database தரவை ஆபத்தில் ஆழ்த்தும்.