ඩොකර් ෆයිල් එකක CMD සහ ENTRYPOINT අතර වෙනස කුමක්ද?

ඩොකර්ෆයිල්ස් හි මට සමාන විධාන දෙකක් තිබේ: CMDසහ ENTRYPOINT. නමුත් මම හිතන්නේ ඔවුන් අතර (සියුම්?) වෙනසක් ඇත - එසේ නොවුවහොත් එකම දෙයකට විධාන දෙකක් තිබීම තේරුමක් නැත.

ලියකියවිලි සඳහා සඳහන් වේ CMD

සීඑම්ඩී හි ප්‍රධාන අරමුණ වන්නේ ක්‍රියාත්මක කරන බහාලුමක් සඳහා පෙරනිමි ලබා දීමයි.

සහ සඳහා ENTRYPOINT:

ඔබට ක්‍රියාත්මක කළ හැකි ලෙස ක්‍රියාත්මක කළ හැකි බහාලුමක් වින්‍යාස කිරීමට ENTRYPOINT ඔබට උදව් කරයි.

ඉතින්, එම විධාන දෙක අතර වෙනස කුමක්ද?

ඩොකර් සතුව පෙරනිමි පිවිසුම් ලක්ෂ්‍යයක් ඇති /bin/sh -cනමුත් එය පෙරනිමි විධානයක් නොමැත.

ඔබ මේ ආකාරයට ඩොකර් ධාවනය කරන විට: docker run -i -t ubuntu bash පිවිසුම් ලක්ෂ්‍යය පෙරනිමිය වේ /bin/sh -c, රූපය ubuntuසහ විධානය වේ bash.

විධානය ක්‍රියාත්මක වන්නේ පිවිසුම් ස්ථානය හරහා ය. එනම්, ක්‍රියාත්මක වන සත්‍ය දෙයයි /bin/sh -c bash. මෙය ෂෝකර්ගේ RUNවිග්‍රහකය මත රඳා සිටීමෙන් ඉක්මණින් ක්‍රියාත්මක කිරීමට ඩෝකර්ට ඉඩ ලබා දුන්නේය .

පසුකාලීනව, මෙය අභිරුචිකරණය කළ හැකි යැයි ජනතාව ඉල්ලා සිටි ENTRYPOINTඅතර --entrypointඒවා හඳුන්වා දෙන ලදී.

ubuntuඉහත උදාහරණයේ ඇති සෑම දෙයක්ම විධානය වන අතර එය පිවිසුම් ස්ථානයට යවනු ලැබේ. CMDඋපදෙස් භාවිතා කරන විට , එය හරියටම ඔබ කරමින් සිටින්නාක් මෙනි docker run -i -t ubuntu <cmd>. <cmd>පිවිසුම් ස්ථානයේ පරාමිතිය වනු ඇත.

ඔබ ඒ වෙනුවට මෙම විධානය ටයිප් කළහොත් ඔබට එම ප්‍රති result ලයම ලැබෙනු ඇත docker run -i -t ubuntu. උබුන්ටු ඩොකර්ෆයිල් පෙරනිමි CMD එකක් නියම කර ඇති නිසා ඔබ තවමත් කන්ටේනරයේ බෑෂ් කවචයක් ආරම්භ කරනු ඇත:CMD ["bash"]

සෑම දෙයක්ම පිවිසුම් ස්ථානයට යවන විට, ඔබේ රූප වලින් ඉතා හොඳ හැසිරීමක් ඔබට ලබා ගත හැකිය. Ir ජිරි උදාහරණය හොඳයි, එය රූපයක් "ද්විමය" ලෙස භාවිතා කරන්නේ කෙසේදැයි පෙන්වයි. ["/bin/cat"]පිවිසුම් ලක්ෂ්‍යයක් ලෙස භාවිතා කරන විට සහ එසේ කරන විට docker run img /etc/passwd, ඔබට එය ලැබෙනුයේ /etc/passwdවිධානය වන අතර එය පිවිසුම් ස්ථානයට යවනු ලැබේ /bin/cat /etc/passwd.

තවත් උදාහරණයක් වනුයේ පිවිසුම් ලක්ෂ්‍යයක් ලෙස ඕනෑම ක්ලයි එකක් තිබීමයි. නිදසුනක් ලෙස, ඔබ සතුව රෙඩිස් රූපයක් තිබේ නම්, ධාවනය වෙනුවට docker run redisimg redis -H something -u toto get key, ඔබට එකම ප්‍රති result ලය සඳහා මේ ආකාරයට ධාවනය කළ හැකිය ENTRYPOINT ["redis", "-H", "something", "-u", "toto"]: docker run redisimg get key.

මෙම ENTRYPOINTනිශ්චිතව දක්වා කන්ටේනර් ආරම්භ කරන විට සැමවිටම ක්රියාත්මක කරන බව විධාන.

මෙම CMDකිරීමට පෝෂණය කළ බව සඳහන් කරනුයේ තර්ක ENTRYPOINT.

නිශ්චිත විධානයකට කැප වූ රූපයක් සෑදීමට ඔබට අවශ්‍ය නම් ඔබ භාවිතා කරනු ඇත ENTRYPOINT ["/path/dedicated_command"]

එසේ නොමැතිනම්, ඔබට පොදු අරමුණු සඳහා රූපයක් සෑදීමට අවශ්‍ය නම්, ඔබට ENTRYPOINTනිශ්චිතව දක්වා නොමැති අතර CMD ["/path/dedicated_command"]තර්ක ඉදිරිපත් කිරීමෙන් ඔබට සැකසුම අභිබවා යා හැකි බැවින් භාවිතා කළ හැකිය docker run.

උදාහරණයක් ලෙස, ඔබේ ඩොකර්ෆයිල් නම්:

FROM debian:wheezy
ENTRYPOINT ["/bin/ping"]
CMD ["localhost"]

කිසිදු තර්කයක් නොමැතිව රූපය ධාවනය කිරීමෙන් දේශීය හොස්ට් පිං වනු ඇත:

$ docker run -it test
PING localhost (127.0.0.1): 48 data bytes
56 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.096 ms
56 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.088 ms
56 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.088 ms
^C--- localhost ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.088/0.091/0.096/0.000 ms

දැන්, රූපය තර්කයක් සමඟ ධාවනය කිරීමෙන් තර්කය පිං වනු ඇත:

$ docker run -it test google.com
PING google.com (173.194.45.70): 48 data bytes
56 bytes from 173.194.45.70: icmp_seq=0 ttl=55 time=32.583 ms
56 bytes from 173.194.45.70: icmp_seq=2 ttl=55 time=30.327 ms
56 bytes from 173.194.45.70: icmp_seq=4 ttl=55 time=46.379 ms
^C--- google.com ping statistics ---
5 packets transmitted, 3 packets received, 40% packet loss
round-trip min/avg/max/stddev = 30.327/36.430/46.379/7.095 ms

සංසන්දනය කිරීම සඳහා, ඔබේ ඩොකර්ෆයිල් නම්:

FROM debian:wheezy
CMD ["/bin/ping", "localhost"]

කිසිදු තර්කයක් නොමැතිව රූපය ධාවනය කිරීමෙන් දේශීය හොස්ට් පිං වනු ඇත:

$ docker run -it test
PING localhost (127.0.0.1): 48 data bytes
56 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.076 ms
56 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.087 ms
56 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.090 ms
^C--- localhost ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.076/0.084/0.090/0.000 ms

නමුත් තර්කයක් සමඟ රූපය ධාවනය කිරීමෙන් තර්කය ක්‍රියාත්මක වේ:

docker run -it test bash
root@e8bb7249b843:/#

ඊටත් වඩා විස්තර සඳහා බ්‍රයන් ඩීහැමර්ගේ මෙම ලිපිය බලන්න: https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/

ඩොකර් ලියකියවිලි වලට අනුව ,

CMD සහ ENTRYPOINT උපදෙස් දෙකම බහාලුමක් ධාවනය කිරීමේදී ක්‍රියාත්මක වන විධානය නිර්වචනය කරයි. ඔවුන්ගේ සහයෝගිතාව විස්තර කරන නීති කිහිපයක් තිබේ.

1. Dockerfile අවම වශයෙන් එකක් CMDහෝ ENTRYPOINTවිධානයක්වත් සඳහන් කළ යුතුය .
2. ENTRYPOINT කන්ටේනරය ක්‍රියාත්මක කළ හැකි ලෙස භාවිතා කරන විට අර්ථ දැක්විය යුතුය.
3. CMDENTRYPOINTවිධානයක් සඳහා පෙරනිමි තර්ක නිර්වචනය කිරීමේ ක්‍රමයක් ලෙස හෝ බහාලුමක් තුළ තාවකාලික විධානයක් ක්‍රියාත්මක කිරීම සඳහා භාවිතා කළ යුතුය.
4. CMD විකල්ප තර්ක සමඟ බහාලුම ධාවනය කිරීමේදී එය අභිබවා යනු ඇත.

විවිධ ENTRYPOINT/ CMDසංයෝජන සඳහා ක්‍රියාත්මක වන විධානය පහත වගුවේ දැක්වේ :

- No ENTRYPOINT

╔════════════════════════════╦═════════════════════════════╗
║ No CMD                     ║ error, not allowed          ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ exec_cmd p1_cmd             ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ p1_cmd p2_cmd               ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_cmd p1_cmd  ║
╚════════════════════════════╩═════════════════════════════╝

- ENTRYPOINT exec_entry p1_entry

╔════════════════════════════╦══════════════════════════════════╗
║ No CMD                     ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_entry p1_entry   ║
╚════════════════════════════╩══════════════════════════════════╝

- ENTRYPOINT [“exec_entry”, “p1_entry”]

╔════════════════════════════╦═════════════════════════════════════════════════╗
║ No CMD                     ║ exec_entry p1_entry                             ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ exec_entry p1_entry exec_cmd p1_cmd             ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ exec_entry p1_entry p1_cmd p2_cmd               ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ exec_entry p1_entry /bin/sh -c exec_cmd p1_cmd  ║
╚════════════════════════════╩═════════════════════════════════════════════════╝

ඔව්, එය හොඳ ප්‍රශ්නයකි. මට එය තවම තේරෙන්නේ නැත, නමුත්:

මට තේරෙනවා ENTRYPOINTඒක ක්‍රියාත්මක කරන ද්විමය බව. ඔබට --entrypoint = "" මගින් පිවිසුම් ලක්ෂ්‍යය ඉක්මවා යා හැකිය.

docker run -t -i --entrypoint="/bin/bash" ubuntu

CMD යනු බහාලුමේ පෙරනිමි තර්කයයි. පිවිසුම් ලක්ෂ්‍යය නොමැතිව පෙරනිමි පරාමිතිය ක්‍රියාත්මක වන විධානයකි. පිවිසුම් ලක්ෂ්‍යය සමඟ cmd තර්කය ලෙස පිවිසුම් ස්ථානයට යවනු ලැබේ. ඔබට පිවිසුම් ලක්ෂ්‍යය සමඟ විධානයක් අනුකරණය කළ හැකිය.

# no entrypoint
docker run ubuntu /bin/cat /etc/passwd

# with entry point, emulating cat command
docker run --entrypoint="/bin/cat" ubuntu /etc/passwd

එබැවින්, ප්‍රධාන වාසිය නම්, පිවිසුම් ලක්ෂ්‍යය සමඟ ඔබේ බහාලුමට තර්ක (cmd) යැවිය හැකිය. මෙය ඉටු කිරීම සඳහා, ඔබ මේ දෙකම භාවිතා කළ යුතුය:

# Dockerfile
FROM ubuntu
ENTRYPOINT ["/bin/cat"]

සහ

docker build -t=cat .

එවිට ඔබට භාවිතා කළ හැකිය:

docker run cat /etc/passwd
#              ^^^^^^^^^^^
#                   CMD
#          ^^^      
#          image (tag)- using the default ENTRYPOINT

ප්‍රතිභානය අනුව CMD සහ ENTRYPOINT අතර වෙනස :

• ENTRYPOINT: බහාලුම් ආරම්භ වන විට ක්‍රියාත්මක කිරීමට විධානය.
• CMD: බහාලුම් ආරම්භ වූ විට ක්‍රියාත්මක කිරීමට විධානය හෝ නිශ්චිතව දක්වා ඇත්නම් ENTRYPOINT වෙත තර්ක කරන්න.

ඔව්, එය මිශ්ර වෙමින් පවතී.

ඩොකර් ධාවනය කිරීමේදී ඔබට ඒවායින් ඕනෑම එකක් අභිබවා යා හැකිය.

උදාහරණයක් ලෙස CMD සහ ENTRYPOINT අතර වෙනස :

docker run -it --rm yourcontainer /bin/bash            <-- /bin/bash overrides CMD
                                                       <-- /bin/bash does not override ENTRYPOINT
docker run -it --rm --entrypoint ls yourcontainer      <-- overrides ENTRYPOINT with ls
docker run -it --rm --entrypoint ls yourcontainer  -la  <-- overrides ENTRYPOINT with ls and overrides CMD with -la

CMDසහ අතර වෙනස පිළිබඳ තවත් ENTRYPOINT:

docker run/ Bin / bash වැනි තර්ක අප ඩොකර්ෆයිල් හි ලියා ඇති ඕනෑම CMD විධානයක් අභිබවා යයි.

වැනි සාමාන්‍ය විධානයන් සමඟ ක්‍රියාත්මක වන වේලාවේදී ENTRYPOINT අභිබවා යා නොහැක docker run [args]. මෙම argsඅවසානයේ docker run [args]ENTRYPOINT කිරීමට තර්ක ලෙස සපයනු ලැබේ. මේ ආකාරයෙන් අපට containerසාමාන්‍ය ද්විමය වැනි දෙයක් නිර්මාණය කළ හැකිය ls.

එබැවින් CMD හට ENTRYPOINT හි පෙරනිමි පරාමිතීන් ලෙස ක්‍රියා කළ හැකි අතර පසුව අපට CMD args [args] වෙතින් අභිබවා යා හැකිය.

ENTRYPOINT සමඟ අභිබවා යා හැකිය --entrypoint.

කෙටියෙන්:

• CMD පෙරනිමි විධානය සහ / හෝ පරාමිතීන් සකසයි, එය ඩොකර් බහාලුම් ධාවනය වන විට විධාන රේඛාවෙන් නැවත ලිවිය හැකිය.
• ENTRYPOINT විධානය සහ පරාමිතීන් විධාන රේඛාවෙන් නැවත ලියනු නොලැබේ. ඒ වෙනුවට, සියලු විධාන රේඛා තර්ක ENTRYPOINT පරාමිතීන්ගෙන් පසුව එකතු වේ.

ඔබට වැඩි විස්තර අවශ්‍ය නම් හෝ උදාහරණයක් ලෙස වෙනසක් දැකීමට කැමති නම්, CMD සහ ENTRYPOINT උදාහරණ රාශියක් සමඟ සංසන්දනය කරන බ්ලොග් සටහනක් ඇත - http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/

වෙනස වඩා හොඳින් තේරුම් ගැනීමට ඔබට උපකාරී වන උදාහරණ ¹ ලෙස මම මගේ පිළිතුර එක් කරමි .

දැන් අපි බලමු අපි කරන බව රූපයක් නිර්මාණය කර ගැනීමට අවශ්ය සිතමු ඉඩ සෑම විටම එය ආරම්භ කරන විට නින්ද විධානය ක්රියාත්මක කරන්න. අපි අපේම රූපයක් සාදා නව විධානයක් නියම කරමු:

FROM ubuntu
CMD sleep 10

රූපය ගොඩනැගීම:

docker build -t custom_sleep .
docker run custom_sleep
# sleeps for 10 seconds and exits

තත්පර ගණන වෙනස් කිරීමට අපට අවශ්‍ය නම් කුමක් කළ යුතුද? Dockerfileඑහි අගය දෘඩ කේත කර ඇති බැවින් අපට වෙනස් කිරීමට සිදු වේ, නැතහොත් වෙනත් එකක් ලබා දීමෙන් විධානය අභිබවා යන්න:

docker run custom_sleep sleep 20

මෙය ක්‍රියාත්මක වන අතර, එය අතිරික්ත "නින්ද" විධානයක් ඇති බැවින් එය හොඳ විසඳුමක් නොවේ. අතිරික්ත ඇයි? කන්ටේනරයේ එකම අරමුණ වන්නේ නිදා ගැනීමයි , එබැවින් sleepවිධානය පැහැදිලිව සඳහන් කිරීම ටිකක් අමුතුයි.

දැන් අපි ENTRYPOINTඋපදෙස් භාවිතා කිරීමට උත්සාහ කරමු :

FROM ubuntu
ENTRYPOINT sleep

මෙම උපදෙස් මඟින් බහාලුම ආරම්භ වන විට ක්‍රියාත්මක වන වැඩසටහන නියම කරයි .

දැන් අපට ධාවනය කළ හැකිය:

docker run custom_sleep 20

පෙරනිමි අගයක් ගැන කුමක් කිව හැකිද? හොඳයි, ඔබ එය නිවැරදිව අනුමාන කළා:

FROM ubuntu
ENTRYPOINT ["sleep"]
CMD ["10"]

එම ENTRYPOINT ක්රියාත්මක කරන බව එම වැඩසටහන වන අතර, රුවනයකි කිරීමට සමත් අගය එය ඇත්තා වූ ද, ඇත.

එම ENTRYPOINT ක නියම විසින් ඉක්මවනු කළ හැකි --entrypointඔබට භාවිතා කිරීමට අවශ්ය නව පිවිසුම් ස්ථානය විසින් අනුගමනය, ධජය.

^{මගේ නොවේ, වරක් මම මෙම උදාහරණය සපයන නිබන්ධනයක් නැරඹුවෙමි}

පිළිගත් පිළිතුර ඉතිහාසය පැහැදිලි කිරීමේදී විශිෂ්ටයි. 'CMD සහ ENTRYPOINT අන්තර්ක්‍රියා කරන ආකාරය' පිළිබඳ නිල ලේඛනයෙන් මෙම වගුව ඉතා හොඳින් පැහැදිලි කරන බව මට පෙනේ :

දී EntryPoint කාර්යය අදහස් කේතය

// ENTRYPOINT / usr / sbin / nginx.

// පිවිසුම් ස්ථානය (පෙරනිමිය sh -c ලෙස) / usr / sbin / nginx ලෙස සකසන්න.

// / usr / sbin / nginx සඳහා වන තර්ක ලෙස CMD පිළිගනු ඇත.

ලේඛන වලින් තවත් සඳහනක්

තරමක් ස්ථාවර පෙරනිමි විධාන සහ තර්ක සැකසීමට ඔබට ENTRYPOINT හි ක්‍රියාකාරී ආකෘතිය භාවිතා කළ හැකි අතර පසුව වෙනස් කිරීමට වැඩි ඉඩක් ඇති අතිරේක පෙරනිමි සැකසීමට CMD භාවිතා කරන්න.

උදාහරණයක්:

FROM ubuntu:14.04.3
ENTRYPOINT ["/bin/ping"]
CMD ["localhost", "-c", "2"]

ගොඩනැගීම : sudo docker build -t ent_cmd.

CMD arguments are easy to override.

NO argument (sudo docker -it ent_cmd)                :  ping localhost 
argument    (sudo docker run -it ent_cmd google.com) :  ping google.com

.

To override EntryPoint argument, you need to supply entrypoint
sudo docker run -it --entrypoint="/bin/bash" ent_cmdd

ps: එන්ට්‍රිපොයින්ට් ඉදිරිපිටදී, සීඑම්ඩී විසින් එන්ට්‍රිපොයින්ට් වෙත පෝෂණය කිරීම සඳහා තර්ක ඉදිරිපත් කරනු ඇත. එන්ට්‍රිපොයින්ට් හි අක්‍රමිකතාවයේ දී, ක්‍රියාත්මක වන විධානය CMD වේ.

CMDDockerfileගොනුව තුළ සඳහන් කර ඇති docker runවිධානය විධාන හරහා අභිබවා යා හැකි අතර ENTRYPOINTවිය නොහැක.

මම සියලු පිළිතුරු කියවා ඇති අතර බැලූ බැල්මට වඩා හොඳ අවබෝධයක් සඳහා සාරාංශ කිරීමට මට අවශ්‍යය:

පළමුවෙන්ම, කන්ටේනරය තුළ ක්‍රියාත්මක වන සම්පූර්ණ විධානයට කොටස් දෙකක් ඇතුළත් වේ: විධානය සහ තර්ක

• කන්ටේනරය ආරම්භ කරන විට ක්‍රියාත්මක කළ හැකි ක්‍රියාකාරීත්වය ENTRYPOINT අර්ථ දක්වයි (විධානය සඳහා)

• CMD විසින් ENTRYPOINT වෙත ලබා දෙන තර්ක නියම කරයි (තර්ක සඳහා)

තුළ Kubernetes දී ක්රියාකාරී පොත ගැන වැදගත් සටහනක් පෙන්වා දෙයි. (7 වන පරිච්ඡේදය)

රූපය ක්‍රියාත්මක වන විට ඔබට ක්‍රියාත්මක කිරීමට අවශ්‍ය විධානය නියම කිරීමට ඔබට CMD උපදෙස් භාවිතා කළ හැකි වුවද , නිවැරදි ක්‍රමය වන්නේ එය ENTRYPOINT උපදෙස් හරහා සිදු කිරීම සහ පෙරනිමි තර්ක නිර්වචනය කිරීමට අවශ්‍ය නම් පමණක් CMD නියම කිරීම ය .

සරල පැහැදිලි කිරීමක් සඳහා ඔබට මෙම ලිපිය කියවිය හැකිය

සීඑම්ඩී:

• CMD ["executable","param1","param2"]: ["executable","param1","param2"]පළමු ක්‍රියාවලියයි.
• CMD command param1 param2: /bin/sh -c CMD command param1 param2පළමු ක්‍රියාවලියයි. CMD command param1 param2පළමු ක්‍රියාවලියෙන් ඉවත් කර ඇත.
• CMD ["param1","param2"]: පෙරනිමි තර්ක සැපයීම සඳහා මෙම පෝරමය භාවිතා කරයි ENTRYPOINT.

ENTRYPOINT (CMD සහ ENTRYPOINT එකට භාවිතා කරන අවස්ථාව පහත ලැයිස්තුවෙන් සලකා බලනු නොලැබේ):

• ENTRYPOINT ["executable", "param1", "param2"]: ["executable", "param1", "param2"]පළමු ක්‍රියාවලියයි.
• ENTRYPOINT command param1 param2: /bin/sh -c command param1 param2පළමු ක්‍රියාවලියයි. command param1 param2පළමු ක්‍රියාවලියෙන් ඉවත් කර ඇත.

ලෙස creack කොට, CMD පළමු දියුණු කරන ලදී. පසුව වඩාත් අභිරුචිකරණය සඳහා ENTRYPOINT සංවර්ධනය කරන ලදි. ඒවා එකට නිර්මාණය කර නොමැති බැවින්, CMD සහ ENTRYPOINT අතර සමහර ක්‍රියාකාරී අතිච්ඡාදනයන් ඇති අතර ඒවා බොහෝ විට මිනිසුන් ව්‍යාකූල කරයි.

බොහෝ අය එය මෙහි පරිපූර්ණ ලෙස පැහැදිලි කරයි, එබැවින් මම සියලු පිළිතුරු නැවත නොකියමි. නමුත් හොඳ හැඟීමක් ලබා ගැනීම සඳහා කන්ටේනරයේ ඇති ක්‍රියාවලීන් දෙස බැලීමෙන් එය ඔබම පරීක්ෂා කර බැලීමට යෝජනා කරමි.

පෝරමයේ කුඩා ඩොකර්ෆයිල් එකක් සාදන්න:

FROM ubuntu:latest
CMD /bin/bash

එය සාදන්න, එය සමඟ docker run -it theimageධාවනය ps -eo ppid,pid,argsකර කන්ටේනරය තුළ ධාවනය කරන්න. භාවිතා කරන විට මෙම ප්‍රතිදානය ps වෙතින් ඔබට ලැබෙන ප්‍රතිදානය සමඟ සසඳන්න:

• docker run -it theimage bash
• රූපය නැවත ගොඩනැඟීම නමුත් ENTRYPOINT /bin/bashඑය දෙයාකාරයෙන්ම ක්‍රියාත්මක කිරීම
• භාවිතා කිරීම CMD ["/bin/bash"]
• ...

මේ ආකාරයෙන් ඔබට ඔබටම කළ හැකි සියලු ක්‍රම අතර වෙනස්කම් පහසුවෙන් දැකගත හැකිය.

ඩොකර්ෆයිල් හොඳම භාවිතයන් පිළිබඳ නිල ලියකියවිලි වෙනස්කම් පැහැදිලි කිරීම සඳහා විශාල කාර්යයක් ඉටු කරයි. ඩොකර්ෆයිල් හොඳම භාවිතයන්

සීඑම්ඩී:

ඕනෑම තර්කයක් සමඟ ඔබේ රූපයේ අඩංගු මෘදුකාංග ක්‍රියාත්මක කිරීමට CMD උපදෙස් භාවිතා කළ යුතුය. CMD සෑම විටම පාහේ ස්වරූපයෙන් භාවිතා කළ යුතුය CMD ["executable", "param1", "param2"…]. මේ අනුව, රූපය අපාචේ සහ රේල්ස් වැනි සේවාවක් සඳහා නම්, ඔබ වැනි දෙයක් ක්‍රියාත්මක කරනු ඇතCMD ["apache2","-DFOREGROUND"] . ඇත්ත වශයෙන්ම, මෙම උපදෙස් ක්‍රමය ඕනෑම සේවා පාදක රූපයක් සඳහා නිර්දේශ කරනු ලැබේ.

එන්ට්‍රොපොයින්ට්:

ENTRYPOINT සඳහා ඇති හොඳම භාවිතය නම් රූපයේ ප්‍රධාන විධානය සැකසීමයි, එම රූපය එම විධානය මෙන් ක්‍රියාත්මක කිරීමට ඉඩ සලසයි (ඉන්පසු පෙරනිමි ධජ ලෙස CMD භාවිතා කරන්න).