Pertanyaan Apa perbedaan antara CMD dan ENTRYPOINT dalam Dockerfile?


Di Dockerfiles ada dua perintah yang terlihat mirip dengan saya: CMD dan ENTRYPOINT. Tapi saya kira ada perbedaan (halus?) Di antara mereka - jika tidak, tidak masuk akal untuk memiliki dua perintah untuk hal yang sama.

Dokumentasi menyatakan untuk CMD

Tujuan utama CMD adalah menyediakan default untuk wadah eksekusi.

dan untuk ENTRYPOINT:

ENTRYPOINT membantu Anda mengonfigurasi penampung yang dapat Anda jalankan sebagai yang dapat dijalankan.

Jadi, apa perbedaan antara kedua perintah itu?


1030
2018-02-04 13:04


asal


Jawaban:


Docker memiliki entrypoint default yang /bin/sh -c tetapi tidak memiliki perintah default.

Ketika Anda menjalankan buruh pelabuhan seperti ini: docker run -i -t ubuntu bash entrypoint adalah default /bin/sh -c, gambarnya ubuntu dan perintahnya bash.

Perintah dijalankan melalui entrypoint. yaitu, hal sebenarnya yang dieksekusi adalah /bin/sh -c bash. Ini memungkinkan Docker untuk menerapkan RUN cepat dengan mengandalkan parser shell.

Kemudian, orang-orang meminta untuk dapat menyesuaikan ini, jadi ENTRYPOINT dan --entrypoint diperkenalkan.

Segalanya setelah ubuntu pada contoh di atas adalah perintah dan diteruskan ke entrypoint. Saat menggunakan CMD instruksi, persis seperti yang Anda lakukan docker run -i -t ubuntu <cmd>. <cmd> akan menjadi parameter dari entrypoint.

Anda juga akan mendapatkan hasil yang sama jika Anda mengetikkan perintah ini docker run -i -t ubuntu. Anda masih akan memulai shell bash dalam wadah karena ubuntu Dockerfile menetapkan CMD default: CMD ["bash"]

Saat semuanya diteruskan ke titik masuk, Anda dapat memiliki perilaku yang sangat bagus dari gambar Anda. @Jiri contohnya bagus, ini menunjukkan bagaimana cara menggunakan gambar sebagai "biner". Ketika menggunakan ["/bin/cat"] sebagai entrypoint dan kemudian lakukan docker run img /etc/passwd, kau mengerti, /etc/passwd adalah perintah dan diteruskan ke entrypoint sehingga eksekusi hasil akhirnya adalah sederhana /bin/cat /etc/passwd.

Contoh lain adalah memiliki cli sebagai entrypoint. Misalnya, jika Anda memiliki gambar redis, alih-alih berjalan docker run redisimg redis -H something -u toto get key, Anda dapat memiliki ENTRYPOINT ["redis", "-H", "something", "-u", "toto"] lalu jalankan seperti ini untuk hasil yang sama: docker run redisimg get key.


1083
2018-02-04 22:34



Itu ENTRYPOINT menentukan perintah yang akan selalu dijalankan saat penampung dimulai.

Itu CMD menentukan argumen yang akan diumpankan ke ENTRYPOINT.

Jika Anda ingin membuat gambar yang didedikasikan untuk perintah khusus yang akan Anda gunakan ENTRYPOINT ["/path/dedicated_command"]

Jika tidak, jika Anda ingin membuat gambar untuk tujuan umum, Anda dapat pergi ENTRYPOINT tidak ditentukan dan digunakan CMD ["/path/dedicated_command"] karena Anda akan dapat mengganti pengaturan dengan menyediakan argumen untuk docker run.

Misalnya, jika Dockerfile Anda adalah:

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

Menjalankan gambar tanpa argumen apa pun akan melakukan ping ke 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

Sekarang, menjalankan gambar dengan argumen akan melakukan ping argumen:

$ 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

Sebagai perbandingan, jika Dockerfile Anda adalah:

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

Menjalankan gambar tanpa argumen apa pun akan melakukan ping ke 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

Namun menjalankan gambar dengan argumen akan menjalankan argumen:

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

Lihat artikel ini dari Brian DeHamer untuk detail lebih lanjut: https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/


264
2017-12-12 22:17



Ya, itu pertanyaan yang bagus. Saya belum mengerti sepenuhnya, tetapi:

aku mengerti itu ENTRYPOINT adalah biner yang sedang dieksekusi. Anda dapat melewati entrypoint dengan --entrypoint = "".

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

CMD adalah argumen default untuk penampung. Tanpa entrypoint, argumen default adalah perintah yang dieksekusi. Dengan entrypoint, cmd dilewatkan ke entrypoint sebagai argumen. Anda dapat meniru perintah dengan entrypoint.

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

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

Jadi, keuntungan utama adalah bahwa dengan entrypoint Anda dapat meneruskan argumen (cmd) ke penampung Anda. Untuk mencapai ini, Anda perlu menggunakan keduanya:

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

dan

docker build -t=cat .

maka Anda bisa menggunakan:

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

138
2018-02-04 17:12



Menurut doker doker,

Kedua instruksi CMD dan ENTRYPOINT menentukan perintah apa yang dijalankan   saat menjalankan kontainer. Ada beberapa aturan yang menggambarkan mereka   kerja sama.

  1. Dockerfile harus menentukan setidaknya satu dari CMD atau ENTRYPOINT perintah.
  2. ENTRYPOINT harus ditentukan saat menggunakan penampung sebagai dapat dieksekusi.
  3. CMD harus digunakan sebagai cara untuk mendefinisikan argumen default untuk suatu ENTRYPOINT perintah atau untuk menjalankan perintah ad-hoc di a   wadah.
  4. CMD akan ditimpa saat menjalankan penampung dengan argumen alternatif.

Tabel di bawah ini menunjukkan apa perintah dijalankan untuk berbeda ENTRYPOINT / CMD kombinasi:

- 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 exec_cmd p1_cmd            ║
╟────────────────────────────╫───────────────────────────────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ /bin/sh -c exec_entry p1_entry p1_cmd p2_cmd              ║
╟────────────────────────────╫───────────────────────────────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_entry p1_entry /bin/sh -c exec_cmd p1_cmd ║
╚════════════════════════════╩═══════════════════════════════════════════════════════════╝

- 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  ║
╚════════════════════════════╩═════════════════════════════════════════════════╝

109
2017-09-09 09:52



Pendeknya:

  • CMD menetapkan perintah dan / atau parameter default, yang dapat ditimpa dari baris perintah ketika kontainer docker berjalan.
  • Perintah dan parameter ENTRYPOINT tidak akan ditimpa dari baris perintah. Sebagai gantinya, semua argumen baris perintah akan ditambahkan setelah parameter ENTRYPOINT.

Jika Anda memerlukan detail lebih lanjut atau ingin melihat perbedaan pada contoh, ada posting blog yang membandingkan CMD dan ENTRYPOINT secara komprehensif dengan banyak contoh - http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/ 


27
2018-04-03 09:32



Perbedaan antara CMD dan ENTRYPOINT dengan intuisi:

  • ENTRYPOINT: perintah untuk dijalankan saat penampung dimulai.
  • CMD: perintah untuk dijalankan ketika kontainer dimulai atau argumen ke ENTRYPOINT jika ditentukan.

Ya, ini bercampur.

Anda dapat mengesampingkan salah satu dari mereka ketika menjalankan menjalankan galangan.

Perbedaan antara CMD dan ENTRYPOINT contohnya:

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

Lebih lanjut tentang perbedaan antara CMD dan ENTRYPOINT:

Argumen untuk docker run seperti / bin / bash menimpa perintah CMD yang kami tulis di Dockerfile.

ENTRYPOINT tidak dapat ditimpa saat dijalankan dengan perintah normal seperti docker run [args]. Itu args pada akhir docker run [args] disediakan sebagai argumen ke ENTRYPOINT. Dengan cara ini kita dapat membuat container yang seperti biner normal seperti ls.

Jadi CMD dapat bertindak sebagai parameter default ke ENTRYPOINT dan kemudian kita dapat mengesampingkan argumen CMD dari [args].

ENTRYPOINT dapat ditimpa --entrypoint.


16
2018-01-16 12:34



Jawaban yang diterima sangat luar biasa dalam menjelaskan sejarah. Saya menemukan tabel ini menjelaskannya dengan sangat baik dokumen resmi tentang 'bagaimana CMD dan ENTRYPOINT berinteraksi': enter image description here


7
2018-05-31 07:12



Komentar tentang fungsi EntryPoint di kode

// ENTRYPOINT / usr / sbin / nginx.

// Atur entry point (yang defaultnya shc) ke / usr / sbin / nginx.

// Akan menerima CMD sebagai argumen ke / usr / sbin / nginx.

Referensi lain dari dokumen

Anda dapat menggunakan bentuk exec dari ENTRYPOINT untuk mengatur perintah dan argumen standar yang cukup stabil dan kemudian gunakan CMD untuk mengatur default tambahan yang lebih mungkin diubah.

Contoh:

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

Membangun: 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

p.s: Di hadapan EntryPoint, CMD akan menahan argumen untuk diumpankan ke EntryPoint. Dalam absennya EntryPoint, CMD akan menjadi perintah yang akan dijalankan.


5
2018-01-16 07:32



CMD:

  • CMD ["executable","param1","param2"]: ["executable","param1","param2"] adalah proses pertama.
  • CMD command param1 param2: /bin/sh -c CMD command param1 param2 adalah proses pertama. CMD command param1 param2 bercabang dari proses pertama.
  • CMD ["param1","param2"]: Formulir ini digunakan untuk menyediakan argumen default untuk ENTRYPOINT.

ENTRYPOINT (Daftar berikut ini tidak mempertimbangkan kasus di mana CMD dan ENTRYPOINT digunakan bersama-sama):

  • ENTRYPOINT ["executable", "param1", "param2"]: ["executable", "param1", "param2"] adalah proses pertama.
  • ENTRYPOINT command param1 param2: /bin/sh -c command param1 param2 adalah proses pertama. command param1 param2 bercabang dari proses pertama.

Sebagai creack kata, CMD dikembangkan terlebih dahulu. Kemudian ENTRYPOINT dikembangkan untuk lebih banyak penyesuaian. Karena keduanya tidak dirancang bersama, ada beberapa fungsi yang tumpang tindih antara CMD dan ENTRYPOINT, yang sering membingungkan orang.


1
2018-01-05 06:42