SSD Nodes Learn Hosting plans →

Docker Compose-ல் command மற்றும் entrypoint பயன்பாடு

Docker Compose-ல் ENTRYPOINT மற்றும் command எவ்வாறு செயல்படுகின்றன என்பதை அறியுங்கள். ENTRYPOINT அமைக்கும்போது ஏன் CMD நீக்கப்படுகிறது மற்றும் நான்கு முக்கிய மாற்றங்களை விளக்குகிறோம்.

Docker Compose command மற்றும் entrypoint: ஒரே விதி

Docker Compose-ல், entrypoint: என்பது இயங்கும் நிரலை அமைக்கிறது, command: என்பது அந்த நிரலுக்கு அனுப்பப்படும் வாதங்களை (arguments) அமைக்கிறது. Container-ன் process என்பது entrypoint பட்டியலுடன் command பட்டியலை இறுதியில் இணைத்து உருவாக்கப்படும் ஒன்றாகும். இந்தப் பக்கத்தில் உள்ள மற்ற அனைத்து செயல்பாடுகளும் இந்த ஒரே விதியிலிருந்தே பெறப்படுகின்றன.

இந்த இரண்டு keys-களும் இரண்டு Dockerfile அறிவுறுத்தல்களுக்கு இணையாகச் செயல்படுகின்றன. entrypoint: என்பது image-ன் ENTRYPOINT-ஐ மாற்றியமைக்கிறது. command: என்பது image-ன் CMD-ஐ மாற்றியமைக்கிறது. இவை ஒன்றையொன்று சார்ந்துள்ளன, இதில்தான் பயனர்கள் பெரும்பாலும் தடுமாறுகின்றனர்: entrypoint:-ஐ அமைப்பது, image-ன் CMD-ஐ நீக்கிவிடும். Compose விவரக்குறிப்பு இதை நேரடியாகக் குறிப்பிடுகிறது. entrypoint என்பது null அல்லாததாக இருந்தால், image-ல் உள்ள எந்தவொரு default command-ஐயும் Compose புறக்கணித்துவிடும்.

படத்தின் தற்போதைய அமைப்புகளைச் சரிபார்த்தல்

எந்தவொரு மாற்றத்தையும் (override) செய்வதற்கு முன்பு, அந்த image எதைக் கொண்டுள்ளது என்பதைப் பார்க்கவும்.

docker image inspect --format '{{json .Config.Entrypoint}}' postgres:16
docker image inspect --format '{{json .Config.Cmd}}' postgres:16

உங்களுக்கு ["docker-entrypoint.sh"] மற்றும் ["postgres"] கிடைக்கின்றன, எனவே container docker-entrypoint.sh postgres-ஐ இயக்குகிறது. அந்த script முதல்முறை boot ஆகும்போது data directory-ஐ உருவாக்குகிறது, POSTGRES_* மாறிகளை (variables) வாசிக்கிறது, postgres பயனருக்கு உரிமைகளைக் குறைக்கிறது (drops privileges), இறுதியாக அதற்கு வழங்கப்பட்ட வாதங்களை (arguments) exec செய்கிறது. நீங்கள் எதை மாற்ற விரும்புகிறீர்கள் என்பதை அறிவதே முழு முடிவாகும். database-க்கு ஒரு flag-ஐ அனுப்ப, நீங்கள் command:-ஐ மாற்ற வேண்டும். நீங்கள் entrypoint:-ஐ மாற்றினால், அந்த setup செயல்முறை எதுவுமே இயங்காது.

நான்கு சேர்க்கைகள், ஒரு சிறிய படத்தில் காட்டப்பட்டுள்ளன

தொடங்கப்படும்போது அதற்கு வழங்கப்பட்ட argument பட்டியலை அச்சிடுவதை மட்டுமே பணியாகக் கொண்ட ஒரு image-ஐ உருவாக்கவும்.

FROM alpine:3.20
ENTRYPOINT ["/bin/echo", "ep"]
CMD ["cmd"]
docker build -t argdemo .
services:
  demo:
    image: argdemo

ஒவ்வொரு மாற்றத்திற்குப் பிறகும் docker compose up-ஐ இயக்கவும், அது பதிவு செய்யும் ஒற்றை வரியைப் படிக்கவும்.

  • எந்த key-யும் அமைக்கப்படவில்லை. process /bin/echo ep cmd ஆக உள்ளது மற்றும் log ep cmd என்பதைக் காட்டுகிறது.
  • command: ["cmd2"] மட்டும். process /bin/echo ep cmd2 ஆக உள்ளது. entrypoint மாற்றப்படாமல் உள்ளது, arguments மட்டுமே மாறியுள்ளன.
  • entrypoint: ["/bin/echo", "ep2"] மட்டும். process /bin/echo ep2 ஆக உள்ளது மற்றும் log ep2 என்பதைக் காட்டுகிறது. image-ல் இருந்த cmd நீக்கப்பட்டுவிட்டது, இது குறித்து எந்த எச்சரிக்கையும் இல்லை.
  • இரண்டு key-களும் அமைக்கப்பட்டுள்ளன. process /bin/echo ep2 cmd2 ஆக உள்ளது. முழு argument பட்டியலையும் நீங்கள் கட்டுப்படுத்தும் ஒரே சூழல் இதுதான்.

Entrypoint அமைக்கும்போது ஏன் image-ன் CMD நீக்கப்படுகிறது

ஒரு image-ன் CMD என்பது அந்த image-ன் ENTRYPOINT-க்கான இயல்புநிலை (default) வாதப் பட்டியலாக (argument list) எழுதப்படுகிறது. நீங்கள் entrypoint-ஐ மாற்றினால், அந்த வாதங்கள் தற்போது இயங்காத ஒரு நிரலுக்குச் சொந்தமானதாகிவிடும். எனவே, image-ஐ உருவாக்கியவர் திட்டமிடாத ஒரு command line-ஐ உருவாக்குவதற்குப் பதிலாக, Compose அந்த வாதங்களை நீக்கிவிடுகிறது. docker run --entrypoint-ம் இதேபோலவே செயல்படுகிறது, எனவே இது Docker-ன் செயல்பாடே தவிர, Compose-ன் குறைபாடு அல்ல.

இதன் விளைவு தெளிவாக உள்ளது. nginx:1.27 என்பது ENTRYPOINT ["/docker-entrypoint.sh"] மற்றும் CMD ["nginx", "-g", "daemon off;"] ஆகியவற்றை அறிவிக்கிறது. நீங்கள் entrypoint: /custom-init.sh-ஐ அமைத்தால், உங்கள் script காலியான வாதப் பட்டியலுடன் தொடங்கும். வழக்கமான exec "$@"-ல் முடியும் ஒரு script-க்கு exec செய்ய எதுவும் இருக்காது. எனவே exec எதையும் செய்யாது, script அதன் கடைசி வரியை அடையும், மேலும் container எந்த பிழைச் செய்தியும் இன்றி 0 என்ற code-உடன் வெளியேறும். வாதங்களை நீங்களே மீண்டும் சேர்க்கவும்:

services:
  web:
    image: nginx:1.27
    entrypoint: /custom-init.sh
    command: ["nginx", "-g", "daemon off;"]

நீங்கள் நினைவில் கொள்ள வேண்டிய விதி: எப்போது நீங்கள் entrypoint:-ஐ அமைக்கிறீர்களோ, அதே மாற்றத்தின்போது command: என்னவாக இருக்க வேண்டும் என்பதையும் முடிவு செய்யுங்கள்.

Exec form மற்றும் shell form, மேலும் Compose எவ்வாறு வேறுபடுகிறது

Dockerfile இரண்டு வகையான syntax-களை ஏற்கிறது. CMD ["nginx", "-g", "daemon off;"] என்பது exec form: இதில் shell இன்றி binary நேரடியாக இயங்கும். CMD nginx -g "daemon off;" என்பது shell form: இதை Docker /bin/sh -c 'nginx -g "daemon off;"' என மாற்றியமைக்கும், எனவே முதலில் ஒரு shell இயங்கி, உங்கள் நிரல் அதன் child process-ஆக மாறும்.

Compose இந்த விதியைப் பின்பற்றுவதில்லை, இது பலரை ஆச்சரியப்படுத்துகிறது. command:-ல் உள்ள ஒரு string, வாதங்களாகப் (arguments) பிரிக்கப்பட்டு நேரடியாக இயக்கப்படும், எந்த ஒரு /bin/sh -c wrapper-ம் இருக்காது. Compose reference இதைத் தெளிவாகக் குறிப்பிடுகிறது: command புலம், image-ல் வரையறுக்கப்பட்ட SHELL சூழலுக்குள் இயங்காது. எனவே, உங்களுக்கு shell வசதிகள் தேவைப்பட்டால், நீங்களே ஒரு shell-ஐ அழைக்க வேண்டும்.

இதனால்தான் command: echo "hello $$HOSTNAME", hello $HOSTNAME என்ற உரையை அப்படியே அச்சிடுகிறது. எந்த shell-ம் அந்த string-ஐப் பார்க்காததால், எதுவும் விரிவுபடுத்தப்படவில்லை (expanded). உங்களுக்கு shell தேவைப்படும்போது, அதை வெளிப்படையாகக் கேட்கவும்:

services:
  demo:
    image: alpine:3.20
    command: /bin/sh -c 'echo "hello $$HOSTNAME"'

Signals, PID 1, மற்றும் clean docker compose down

docker compose stop மற்றும் docker compose down ஒவ்வொரு container-க்குள்ளும் உள்ள PID 1-க்கு அந்த container-ன் stop signal-ஐ அனுப்பும். அந்த signal, image-ன் STOPSIGNAL அல்லது service-ன் stop_signal: வேறு signal-ஐ அமைக்காத வரை SIGTERM ஆக இருக்கும். அதன் பிறகு Compose அதிகபட்சம் stop_grace_period வரை காத்திருந்து, container இன்னும் இயங்கிக்கொண்டிருந்தால் மட்டும் SIGKILL-ஐ அனுப்பும். இயல்புநிலை grace period 10 seconds ஆகும்.

Linux-ல் PID 1 சிறப்பானது. PID namespace-ன் init process, பிற processes-லிருந்து வரும் ordinary signals-ஐ அவற்றுக்கான handler-ஐ நிறுவியிருந்தால் மட்டுமே பெறும். ஆகவே PID 1 ஆக இயங்கும் போது எந்த SIGTERM handler-ஐயும் நிறுவாத process, SIGTERM-ஐ வெறுமனே புறக்கணிக்கும். Ancestor PID namespace-லிருந்து அனுப்பப்படும் SIGKILL மற்றும் SIGSTOP இதற்கு விதிவிலக்குகள்: அவை PID 1-ஐ முறையே கட்டாயமாக முடிக்கும் அல்லது நிறுத்தும். அது முழு grace period-க்கும் அங்கேயே இருக்கும்; பின்னர் முற்றிலும் kill செய்யப்படும். இதனால் திறந்த connection அல்லது commit செய்யப்படாத transaction துண்டிக்கப்படும்.

உங்கள் program-க்கு முன்பாக shell இருந்தால் இது அதிகம் நிகழலாம், ஏனெனில் shell தான் PID 1 ஆக இருக்கும்; பெரும்பாலான shells child process-க்கு signals-ஐ forward செய்யாது. சில shells, -c string-ல் உள்ள இறுதி command-ஆக தங்களை மாற்றிக்கொள்ளும். ஆகவே சில நேரங்களில் உங்கள் program எப்படியோ PID 1-ஐ அடையும். இது shell மற்றும் சரியான string ஆகியவற்றைப் பொறுத்தது. எனவே ஊகிக்க வேண்டாம். இதைப் பாருங்கள்:

docker compose exec -T web cat /proc/1/cmdline | tr '\0' ' '; echo

உங்கள் program-க்குப் பதிலாக PID 1, /bin/sh -c ... எனக் காட்டப்பட்டால், இரண்டு தீர்வுகள் உள்ளன. Image-ல் exec form-ஐ பயன்படுத்துங்கள். அல்லது shell-ஐ வைத்துக்கொண்டு, exec மூலம் process-ஐ அடுத்ததாக ஒப்படையுங்கள்:

services:
  web:
    image: myapp:1.4
    command: /bin/sh -c 'exec myapp --config /etc/myapp.toml'

exec child process-ஐ fork செய்வதற்குப் பதிலாக shell process-ஐ உங்கள் program-ஆக மாற்றுகிறது. இதனால் உங்கள் program PID 1-ஐப் பெறுகிறது மற்றும் signal-ஐப் பெறும்.

சில programs children-ஐ உருவாக்கிய பிறகு அவற்றை ஒருபோதும் reap செய்வதில்லை. இதனால் zombie processes உருவாகும், ஏனெனில் PID 1 reaper ஆகவும் செயல்படுகிறது. இதற்காக Compose-ல் ஒரு switch உள்ளது:

services:
  web:
    image: myapp:1.4
    init: true
    stop_grace_period: 30s

init: true, PID 1 ஆக ஒரு சிறிய init process-ஐ இயக்குகிறது. அது signals-ஐ உங்கள் process-க்கு forward செய்வதுடன் children-ஐயும் reap செய்கிறது. stop_grace_period உண்மையிலேயே மெதுவான shutdown-க்கு கூடுதல் நேரத்தை வழங்குகிறது. உங்கள் program வேறு signal-ஐ எதிர்பார்த்தால், Compose அனுப்பும் signal-ஐ stop_signal: SIGQUIT மாற்றுகிறது. Image ஏற்கனவே எந்த signal-ஐக் கோருகிறது என்பதை docker image inspect --format '{{.Config.StopSignal}}' nginx:1.27 மூலம் பாருங்கள்.

ஒவ்வொரு service-க்கும் docker compose down எப்போதும் ten seconds எடுக்கும் stack, PID 1 configured stop signal-ஐ கையாளுகிறதா என்பதையும், shutdown-க்கு grace period-ஐ விட அதிக நேரம் தேவையா என்பதையும் நீங்கள் சோதிக்க வேண்டும் என்று காட்டுகிறது. Tooling-ஐ குற்றம் சாட்டுவதற்கு முன் இதைச் சரிசெய்யுங்கள். ஒவ்வொரு subcommand எதை remove செய்கிறது என்பதை அறிய docker compose down மற்றும் stop ஆகியவற்றுக்கிடையிலான வேறுபாடு பார்க்கவும்.

இதே exec-versus-shell பிரிவு இன்னொரு இடத்திலும் வருகிறது. test: ["CMD", "curl", "-f", "http://localhost/"] ஆக எழுதப்பட்ட healthcheck binary-ஐ நேரடியாக இயக்கும். அதேவேளை test: ["CMD-SHELL", "curl -f http://localhost/ || exit 1"] shell வழியாக இயங்கும்; எனவே || பொருள் பெறும். அந்த field பற்றிய மீதியை நேர்மையாக fail ஆகும் Compose healthchecks எழுதுதல் விளக்குகிறது.

அதிகாரப்பூர்வ image-ல் ஒரு flag-ஐச் சேர்த்தல்

பெரும்பாலான வாசகர்கள் இதற்காகவே வந்துள்ளனர். உங்களுக்கு postgres-ல் ஒரு கூடுதல் flag தேவைப்படுகிறது, அதே சமயம் ஆரம்பகால initialization script-ஐ நீங்கள் மாற்றக்கூடாது.

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - pgdata:/var/lib/postgresql/data
    command: postgres -c max_connections=200 -c shared_buffers=256MB

volumes:
  pgdata:

command: மட்டுமே மாற்றப்பட்டுள்ளதால், docker-entrypoint.sh தொடர்ந்து இயங்கும் மற்றும் நீங்கள் கொடுத்த கட்டளையை அதுவே செயல்படுத்தும். முடிவை ஊகிப்பதற்குப் பதிலாகச் சரிபார்க்கவும்:

docker compose up -d db
docker compose exec -T db psql -U postgres -c 'show max_connections;'

வெளியீடு 200-ஐக் காட்ட வேண்டும். அது இன்னும் 100-ஐக் காட்டினால், docker compose config-ஐ இயக்கி, நீங்கள் எதிர்பார்க்கும் command இணைக்கப்பட்ட வெளியீட்டில் இருப்பதை உறுதிப்படுத்தவும். Compose கோப்புகளை இணைக்கும்போது, அவை command-ஐ அப்படியே மாற்றியமைக்கின்றன, அதற்குப் பின்னால் சேர்ப்பதில்லை. எனவே, command:-ஐ அமைக்கும் இரண்டாவது கோப்பு அமைதியாக முன்னுரிமை பெற்றுவிடும்.

மேலே உள்ள ${POSTGRES_PASSWORD}, container உருவாவதற்கு முன்பே, உங்கள் .env கோப்பிலிருந்து Compose மூலம் host-ல் விரிவாக்கப்படுகிறது. Compose-ல் Env கோப்புகள் மற்றும் secrets என்ற பகுதி அந்த மதிப்பை எங்கு பாதுகாப்பாக வைக்கலாம் என்பதை விளக்குகிறது.

docker compose run மூலம் ஒருமுறை மட்டும் இயங்கும் migration-ஐ இயக்குதல்

docker compose run ஆனது அதே service definition-லிருந்து ஒரு புதிய container-ஐ உருவாக்கி, நீங்கள் service பெயருக்குப் பின் குறிப்பிடும் கட்டளைக்கு ஏற்ப அதன் command-ஐ மாற்றியமைக்கிறது. Image-ன் entrypoint தொடர்ந்து இயங்குவதால், நீண்ட நேரம் இயங்கும் container-ஐப் போலவே இதுவும் சரியாகத் தயாராகிறது.

docker compose run --rm app python manage.py migrate
  • --rm ஆனது கட்டளை முடிந்ததும் container-ஐ நீக்கிவிடும். இதைப் பயன்படுத்தாவிட்டால், ஒவ்வொரு முறையும் இயக்கும்போதும் ஒரு stopped container எஞ்சியிருக்கும், அதை docker compose ps -a மூலம் பார்க்கலாம்.
  • Ports வெளியிடப்படாது. ஒரு run container, நீங்கள் --service-ports-ஐச் சேர்த்தால் ஒழிய, service-ன் ports:-ஐப் புறக்கணிக்கும். எனவே, ஏற்கனவே இயங்கிக்கொண்டிருக்கும் service-உடன் இது மோதிக்கொள்ளாது.
  • Dependencies முதலில் தொடங்கும். depends_on-ல் உள்ளவை உங்கள் கட்டளைக்கு முன்பே இயங்கத் தொடங்கும், --no-deps இதைப் புறக்கணிக்கும்.
  • Container-க்கு myproject-app-run-9f2c1a போன்ற ஒரு பெயர் உருவாக்கப்படும், எனவே இது service container-உடன் மோதிக்கொள்ளாது.

Entrypoint-ஐயும் மாற்ற, அதற்கென ஒரு flag உள்ளது:

docker compose run --rm --entrypoint /bin/sh app -c 'python manage.py migrate'

இதன் விளைவாகக் கிடைக்கும் argument பட்டியல் /bin/sh -c 'python manage.py migrate' ஆகும், ஏனெனில் service பெயருக்குப் பின் உள்ள சொற்கள் இன்னும் கட்டளையாகவே கருதப்படுகின்றன. docker compose exec என்பது மற்றொரு கருவி, இது வித்தியாசமாகச் செயல்படுகிறது: இது ஏற்கனவே இயங்கிக்கொண்டிருக்கும் ஒரு container-க்குள் process-ஐ இயக்குகிறது, மேலும் இது entrypoint: மற்றும் command: ஆகிய இரண்டையும் முழுமையாகப் புறக்கணிக்கிறது. புதிய container தேவைப்படும் பணிக்கு run-ஐயும், இயங்கும் container-க்குள் பார்க்க exec-ஐயும் பயன்படுத்தவும். Compose கட்டளைகளின் சுருக்கக் குறிப்பு மற்ற subcommands-களை ஒப்பிட்டுப் பார்க்க உதவுகிறது.

எனது container ஏன் உடனடியாக வெளியேறுகிறது?

முதலில் exit code-ஐப் பார்க்கவும், ஏனெனில் இது காரணத்தை விரைவாகக் கண்டறிய உதவும்.

docker compose ps -a
docker compose logs app

Exit code 0 மற்றும் வெளியீடு ஏதுமில்லை. கட்டளை இயங்கி முடிந்துவிட்டது. இதற்கு மிக முக்கியமான காரணம், ஒரு entrypoint: மாற்றீடு, image-ன் CMD-ஐ நீக்கியதுதான். இதனால் entrypoint காலியான argument பட்டியலுடன் இயங்கியது, அதற்குச் செயல்பட ஏதுமில்லை.

permission denied என முடியும் பிழை. image-க்குள் அந்த script-க்கு executable bit இல்லை. பொதுவாக, repository-ல் உள்ள கோப்பில் அந்த bit அமைக்கப்படாததே இதற்குக் காரணம். build செய்யும்போது COPY --chmod=0755 entrypoint.sh /entrypoint.sh மூலம் அதை அமைக்கவும்.

image-ல் தெளிவாகத் தெரியும் ஒரு கோப்பிற்கு no such file or directory என முடியும் பிழை. அந்த script-ல் Windows line endings உள்ளன. அதன் முதல் வரி #!/bin/sh மற்றும் ஒரு carriage return byte-ஐக் கொண்டுள்ளது. எனவே, kernel அந்த byte-ஐயும் சேர்த்து ஒரு interpreter-ஐத் தேடுகிறது, அது கிடைக்கவில்லை. dos2unix entrypoint.sh-ஐ இயக்கவும், பிறகு அது மீண்டும் வராமல் தடுக்க * text eol=lf-ஐ .gitattributes-ல் சேர்க்கவும்.

executable file not found in $PATH. command:-ல் குறிப்பிடப்பட்டுள்ள நிரல், container-ன் PATH-ல் உள்ள எந்தக் கோப்பகத்திலும் இல்லை. ஒன்று அந்த image-ல் அது இல்லை, அல்லது அது PATH-க்கு வெளியே நிறுவப்பட்டுள்ளது (அதற்குப் பதிலாக அதன் முழுப் பாதையை எழுதவும்), அல்லது நீங்கள் cd போன்ற shell built-in-ஐப் பயன்படுத்தியிருக்கலாம், ஆனால் அங்கு ஒரு உண்மையான நிரல் மட்டுமே இருக்க வேண்டும்.

Entrypoint தோல்வியடையும் போது ஒரு image-க்குள் shell பெறுதல்

Entrypoint இயங்குவதற்கு முன்பே நின்றுவிட்டால், அதை ஆய்வு செய்ய பின்வருமாறு மாற்றவும்:

docker compose run --rm --entrypoint /bin/sh app

இது stat /bin/sh: no such file or directory பிழையுடன் தோல்வியடைந்தால், அந்த image-ல் /bin/sh இல்லை என்று அர்த்தம். Distroless மற்றும் scratch அடிப்படையிலான images-ல் பெரும்பாலும் shell இருக்காது. Entrypoint-ஐத் தொடங்காமலேயே நீங்கள் filesystem-ஐ வெளியில் இருந்து பார்க்கலாம்:

docker create --name probe myapp:1.4
docker export probe | tar -tv | head -40
docker rm probe

Container தொடர்ந்து இயங்க வேண்டும், அப்போதுதான் நீங்கள் மீண்டும் மீண்டும் அதனுடன் இணைய முடியும் என்றால், அதை ஒருபோதும் முடியாத ஒரு process-ல் நிறுத்தவும். இதை நீங்கள் commit செய்யாத ஒரு override கோப்பில் சேர்க்கவும்:

services:
  app:
    entrypoint: ["tail", "-f", "/dev/null"]
    command: []

entrypoint:-ஐ அமைப்பதன் மூலமே image-ன் CMD நீக்கப்பட்டுவிட்டதால், command: [] கண்டிப்பாகத் தேவையில்லை. இருப்பினும், இதைக் குறிப்பிடுவது கோப்பை வாசிப்பவர்களுக்கு உங்கள் நோக்கத்தைத் தெளிவாக விளக்கும். இப்போது அதைத் தொடங்கி உள்ளே நுழையவும்:

docker compose -f compose.yaml -f compose.debug.yaml up -d app
docker compose exec app /bin/sh

இப்போது உண்மையான entrypoint-ஐ நீங்களே நேரடியாக இயக்கி, அது எங்கே நிற்கிறது என்று கவனிக்கவும். அரை வினாடிக்கு முன் செயலிழந்த container-ல் பார்ப்பதற்குப் பதிலாக, உங்கள் terminal-லேயே பிழைச் செய்தியைப் பெற இது உதவும். நீங்கள் இன்னும் உங்கள் முதல் stack-ஐ உருவாக்குகிறீர்கள் என்றால், VPS-ல் முதல் Compose stack என்பது மேலே கூறப்பட்டுள்ள அனைத்து கோப்பு அமைப்புகளையும் விளக்குகிறது.

FAQ

எனது container, docker compose up செய்த உடனேயே ஏன் வெளியேறுகிறது?

Exit code-ஐ அறிய docker compose ps -a-ஐ பார்க்கவும். எந்த output-உம் இல்லாமல் Exit 0 கிடைத்தால், service-ல் entrypoint: அமைத்திருக்கலாம். இதனால் image-ன் CMD-உம் நீக்கப்பட்டிருக்கும். எனவே entrypoint காலியான argument list-உடன் இயங்கி முடிந்துவிடும். command: மூலம் arguments-ஐ மீண்டும் சேர்க்கவும். permission denied-ல் முடியும் error ஏற்பட்டால், entrypoint script-க்கு executable bit இல்லை. இருக்கும் file-க்கு no such file or directory-ல் முடியும் error ஏற்பட்டால், அந்த script-ல் Windows line endings உள்ளன. எனவே அதன் shebang line இல்லாத interpreter-ஐ குறிப்பிடுகிறது.

Compose-ல் entrypoint அமைத்தால் image-ன் CMD நீக்கப்படுமா?

ஆம். entrypoint non-null ஆக இருந்தால், image அறிவித்துள்ள default command-ஐ Compose புறக்கணிக்கும். இது ஆவணப்படுத்தப்பட்ட behaviour ஆகும். இது docker run --entrypoint உடன் பொருந்துகிறது. Image-ன் CMD, அந்த image-ன் ENTRYPOINT-க்கு arguments ஆக எழுதப்பட்டிருப்பதே காரணம். Entry point-ஐ மாற்றியதும் பழைய arguments எதற்கும் பொருந்தாது. புதிய entrypoint-க்கு arguments தேவைப்பட்டால், அதே service-ல் command: அமைக்கவும்.

Compose-ல் உள்ள string command shell மூலம் இயக்கப்படுமா?

இல்லை. Dockerfile-ன் CMD போலல்லாமல், Compose-ல் உள்ள string command: arguments-ஆகப் பிரிக்கப்பட்டு நேரடியாக இயக்கப்படும். /bin/sh -c wrapper எதுவும் பயன்படுத்தப்படாது. எனவே, $VARIABLE-ஐ expand செய்வதற்காக Compose container-க்குள் shell-ஐ தானாகத் தொடங்காது. Shell தேவைப்படும்போது, command: /bin/sh -c 'echo "hello $$HOSTNAME"'-ல் காட்டியுள்ளதுபோல் நீங்களே அதை அழைக்கவும். இரட்டை $$ dollar sign-ஐ escape செய்கிறது. இதனால் Compose அதை host-ல் expand செய்யாமல் container-க்கு அனுப்பும்.

ஒரே container-க்கு docker compose down செய்ய பத்து seconds ஏன் ஆகிறது?

Compose, PID 1-க்கு stop signal-ஐ அனுப்பும். Image அல்லது service வேறு signal அமைக்கவில்லை என்றால் அது SIGTERM ஆகும். பின்னர் அதிகபட்சம் stop_grace_period வரை காத்திருக்கும். இயல்புநிலை 10 seconds ஆகும். Container இன்னும் இயங்கினால், Compose SIGKILL-ஐ அனுப்பும். Handler இல்லாத நிலையில், PID namespace-ன் init process SIGTERM-ஐ புறக்கணிக்கும். எனவே அது முழு காலத்தையும் காத்திருக்கும். Ancestor PID namespace-லிருந்து வரும் SIGKILL மற்றும் SIGSTOP இதற்கு விதிவிலக்குகள். அவை process-ஐ கட்டாயமாக terminate அல்லது stop செய்யும். உண்மையில் PID 1 எது என்பதை docker compose exec -T app cat /proc/1/cmdline | tr '\0' ' ' மூலம் கண்டறியவும். அது shell ஆக இருந்தால், image-ஐ exec form-க்கு மாற்றவும் அல்லது shell string-க்குள் exec எழுதவும். Process உருவாக்கும் child processes-ஐ reap செய்யாமல் இருந்தால், service-ல் init: true அமைக்கவும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?