Sự khác biệt giữa CMD và ENTRYPOINT trong Dockerfile là gì?

Trong Dockerfiles có hai lệnh trông giống tôi: CMDvà ENTRYPOINT. Nhưng tôi đoán rằng có một sự khác biệt (tinh tế?) Giữa chúng - nếu không, sẽ không có ý nghĩa gì khi có hai lệnh cho cùng một thứ.

Các tài liệu nêu CMD

Mục đích chính của CMD là cung cấp mặc định cho vùng chứa thực thi.

và cho ENTRYPOINT:

ENTRYPOINT giúp bạn định cấu hình vùng chứa mà bạn có thể chạy dưới dạng thực thi.

Vậy, sự khác biệt giữa hai lệnh này là gì?

Docker có một điểm vào mặc định /bin/sh -cnhưng không có lệnh mặc định.

Khi bạn chạy docker như thế này: docker run -i -t ubuntu bash điểm vào là mặc định /bin/sh -c, hình ảnh ubuntuvà lệnh là bash.

Lệnh được chạy thông qua điểm vào. tức là, điều thực tế được thực hiện là /bin/sh -c bash. Điều này cho phép Docker thực hiện RUNnhanh chóng bằng cách dựa vào trình phân tích cú pháp của trình bao.

Sau đó, mọi người yêu cầu có thể tùy chỉnh điều này, vì vậy ENTRYPOINTvà --entrypointđã được giới thiệu.

Tất cả mọi thứ sau ubuntutrong ví dụ trên là lệnh và được chuyển đến điểm vào. Khi sử dụng CMDhướng dẫn, nó chính xác như thể bạn đang làm docker run -i -t ubuntu <cmd>. <cmd>sẽ là tham số của điểm vào.

Bạn cũng sẽ nhận được kết quả tương tự nếu bạn thay vào đó gõ lệnh này docker run -i -t ubuntu. Bạn vẫn sẽ bắt đầu một bash shell trong vùng chứa vì Dockerfile ub Ubuntu đã chỉ định một CMD mặc định:CMD ["bash"]

Khi mọi thứ được chuyển đến điểm vào, bạn có thể có một hành vi rất đẹp từ hình ảnh của mình. Ví dụ @Jiri là tốt, nó cho thấy cách sử dụng một hình ảnh như là một "nhị phân". Khi sử dụng ["/bin/cat"]làm điểm truy cập và sau đó thực hiện docker run img /etc/passwd, bạn nhận được nó, /etc/passwdlà lệnh và được chuyển đến điểm nhập cảnh để thực hiện kết quả cuối cùng đơn giản /bin/cat /etc/passwd.

Một ví dụ khác là có bất kỳ cli nào làm điểm vào. Chẳng hạn, nếu bạn có một hình ảnh redis, thay vì chạy docker run redisimg redis -H something -u toto get key, bạn có thể chỉ cần có ENTRYPOINT ["redis", "-H", "something", "-u", "toto"]và sau đó chạy như thế này cho cùng một kết quả : docker run redisimg get key.

Lệnh ENTRYPOINTchỉ định một lệnh sẽ luôn được thực thi khi container bắt đầu.

Các CMDđối số chỉ định sẽ được đưa đến ENTRYPOINT.

Nếu bạn muốn tạo một hình ảnh dành riêng cho một lệnh cụ thể, bạn sẽ sử dụng ENTRYPOINT ["/path/dedicated_command"]

Mặt khác, nếu bạn muốn tạo một hình ảnh cho mục đích chung, bạn có thể để lại ENTRYPOINTkhông xác định và sử dụng CMD ["/path/dedicated_command"]vì bạn sẽ có thể ghi đè cài đặt bằng cách cung cấp đối số docker run.

Ví dụ: nếu Dockerfile của bạn là:

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

Chạy hình ảnh mà không có bất kỳ đối số sẽ ping địa phương:

$ 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

Bây giờ, chạy hình ảnh với một đối số sẽ ping đối số:

$ 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

Để so sánh, nếu Dockerfile của bạn là:

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

Chạy hình ảnh mà không có bất kỳ đối số sẽ ping địa phương:

$ 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

Nhưng chạy hình ảnh với một đối số sẽ chạy đối số:

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

Xem bài viết này từ Brian De Hamer để biết thêm chi tiết: https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/

Theo tài liệu docker ,

Cả hai lệnh CMD và ENTRYPOINT đều xác định lệnh nào được thực thi khi chạy container. Có một vài quy tắc mô tả sự hợp tác của họ.

1. Dockerfile nên chỉ định ít nhất một CMDhoặc một số ENTRYPOINTlệnh.
2. ENTRYPOINT nên được xác định khi sử dụng container như là một thực thi.
3. CMDnên được sử dụng như một cách xác định các đối số mặc định cho một ENTRYPOINTlệnh hoặc để thực thi một lệnh ad-hoc trong một thùng chứa.
4. CMD sẽ bị ghi đè khi chạy container với các đối số thay thế.

Các bảng dưới đây cho thấy lệnh nào được thực thi cho các kết hợp ENTRYPOINT/ khác nhauCMD :

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

Vâng, đó là một câu hỏi hay. Tôi chưa hiểu đầy đủ về nó, nhưng:

Tôi hiểu đó ENTRYPOINTlà nhị phân đang được thực thi. Bạn có thể ghi đè điểm nhập cảnh bằng --entrypoint = "".

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

CMD là đối số mặc định cho container. Không có điểm vào, đối số mặc định là lệnh được thực thi. Với điểm truy cập, cmd được chuyển đến điểm nhập dưới dạng đối số. Bạn có thể mô phỏng một lệnh với điểm vào.

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

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

Vì vậy, lợi thế chính là với điểm vào, bạn có thể truyền đối số (cmd) cho vùng chứa của mình. Để thực hiện điều này, bạn cần sử dụng cả hai:

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

và

docker build -t=cat .

sau đó bạn có thể sử dụng:

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

Sự khác biệt giữa CMD và ENTRYPOINT theo trực giác :

• ENTRYPOINT: lệnh để chạy khi container bắt đầu.
• CMD: lệnh để chạy khi container bắt đầu hoặc đối số với ENTRYPOINT nếu được chỉ định.

Vâng, nó đang trộn lẫn.

Bạn có thể ghi đè bất kỳ trong số chúng khi chạy docker chạy.

Sự khác biệt giữa CMD và ENTRYPOINT bằng ví dụ :

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

Thêm về sự khác biệt giữa CMDvà ENTRYPOINT:

Đối số docker runnhư / bin / bash ghi đè bất kỳ lệnh CMD nào chúng ta đã viết trong Dockerfile.

ENTRYPOINT không thể được ghi đè khi chạy với các lệnh thông thường như docker run [args]. Phần argscuối của docker run [args]được cung cấp làm đối số cho ENTRYPOINT. Theo cách này, chúng ta có thể tạo một containercái giống như một nhị phân bình thường như ls.

Vì vậy, CMD có thể hoạt động như các tham số mặc định cho ENTRYPOINT và sau đó chúng ta có thể ghi đè lên các đối số CMD từ [args].

ENTRYPOINT có thể được ghi đè bằng --entrypoint.

Tóm lại:

• CMD đặt lệnh và / hoặc tham số mặc định, có thể được ghi đè từ dòng lệnh khi bộ chứa docker chạy.
• Các tham số và lệnh ENTRYPOINT sẽ không bị ghi đè từ dòng lệnh. Thay vào đó, tất cả các đối số dòng lệnh sẽ được thêm vào sau các tham số ENTRYPOINT.

Nếu bạn cần biết thêm chi tiết hoặc muốn thấy sự khác biệt trên ví dụ, có một bài đăng blog so sánh toàn diện CMD và ENTRYPOINT với rất nhiều ví dụ - http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/

Tôi sẽ thêm câu trả lời của tôi làm ví dụ ¹ có thể giúp bạn hiểu rõ hơn về sự khác biệt.

Giả sử chúng ta muốn tạo một hình ảnh sẽ luôn chạy lệnh ngủ khi nó bắt đầu. Chúng tôi sẽ tạo hình ảnh của riêng mình và chỉ định một lệnh mới:

FROM ubuntu
CMD sleep 10

Bây giờ, chúng tôi xây dựng hình ảnh:

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

Nếu chúng ta muốn thay đổi số giây thì sao? Chúng ta sẽ phải thay đổi Dockerfilekhi giá trị được mã hóa cứng ở đó hoặc ghi đè lệnh bằng cách cung cấp một giá trị khác:

docker run custom_sleep sleep 20

Trong khi điều này hoạt động, đó không phải là một giải pháp tốt, vì chúng ta có lệnh "ngủ" dư thừa (mục đích của người chứa là để ngủ , do đó phải xác định rõ ràng sleeplệnh không phải là một cách thực hành tốt).

Bây giờ hãy thử sử dụng ENTRYPOINThướng dẫn:

FROM ubuntu
ENTRYPOINT sleep

Hướng dẫn này chỉ định chương trình sẽ được chạy khi container khởi động .

Bây giờ chúng ta có thể chạy:

docker run custom_sleep 20

Giá trị mặc định thì sao? Vâng, bạn đã đoán đúng:

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

Đây ENTRYPOINTlà chương trình sẽ được chạy và giá trị được chuyển đến vùng chứa sẽ được thêm vào nó.

Có ENTRYPOINTthể được ghi đè bằng cách chỉ định một --entrypointcờ, theo sau là điểm vào mới mà bạn muốn sử dụng.

^{Không phải của tôi, tôi đã từng xem một hướng dẫn cung cấp ví dụ này}

Câu trả lời được chấp nhận là tuyệt vời trong việc giải thích lịch sử. Tôi thấy bảng này giải thích nó rất tốt từ tài liệu chính thức về 'cách thức CMD và ENTRYPOINT tương tác' :

Nhận xét về chức năng Entrypoint trong mã

// ENTRYPOINT / usr / sbin / nginx.

// Đặt điểm truy cập (mặc định là sh -c) thành / usr / sbin / nginx.

// Sẽ chấp nhận CMD làm đối số cho / usr / sbin / nginx.

Một tài liệu tham khảo khác từ các tài liệu

Bạn có thể sử dụng hình thức thực thi của ENTRYPOINT để đặt các lệnh và đối số mặc định khá ổn định và sau đó sử dụng CMD để đặt các mặc định bổ sung có nhiều khả năng được thay đổi.

Thí dụ:

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

Bản dựng : 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: Với sự có mặt của EntryPoint, CMD sẽ giữ các đối số được cung cấp cho Entrypoint. Khi vắng mặt EntryPoint, CMD sẽ là lệnh sẽ được chạy.

CMDlệnh được đề cập bên trong Dockerfiletập tin có thể được ghi đè thông qua docker runlệnh trong khi ENTRYPOINTkhông thể.

Tôi đã đọc tất cả các câu trả lời và tôi muốn tóm tắt để hiểu rõ hơn từ cái nhìn đầu tiên như sau:

Đầu tiên, toàn bộ lệnh được thực thi trong vùng chứa bao gồm hai phần: lệnh và đối số

• ENTRYPOINT định nghĩa thực thi được gọi khi container được khởi động (đối với lệnh)

• CMD chỉ định các đối số được truyền cho ENTRYPOINT (đối với đối số)

Trong cuốn sách Kubernetes In Action chỉ ra một ghi chú quan trọng về nó. (Chương 7)

Mặc dù bạn có thể sử dụng lệnh CMD để chỉ định lệnh bạn muốn thực thi khi hình ảnh được chạy, nhưng cách chính xác là thực hiện thông qua hướng dẫn ENTRYPOINT và chỉ chỉ định CMD nếu bạn muốn xác định các đối số mặc định.

Bạn cũng có thể đọc này bài viết cho lời giải thích tuyệt vời trong một cách đơn giản

CMD:

• CMD ["executable","param1","param2"]: ["executable","param1","param2"]là quá trình đầu tiên.
• CMD command param1 param2: /bin/sh -c CMD command param1 param2là quá trình đầu tiên. CMD command param1 param2được rẽ nhánh từ quá trình đầu tiên.
• CMD ["param1","param2"]: Biểu mẫu này được sử dụng để cung cấp các đối số mặc định cho ENTRYPOINT.

ENTRYPOINT (Danh sách sau đây không xem xét trường hợp sử dụng CMD và ENTRYPOINT cùng nhau):

• ENTRYPOINT ["executable", "param1", "param2"]: ["executable", "param1", "param2"]là quá trình đầu tiên.
• ENTRYPOINT command param1 param2: /bin/sh -c command param1 param2là quá trình đầu tiên. command param1 param2được rẽ nhánh từ quá trình đầu tiên.

Như creack đã nói, CMD được phát triển đầu tiên. Sau đó, ENTRYPOINT được phát triển để tùy biến nhiều hơn. Vì chúng không được thiết kế cùng nhau, nên có một số chức năng chồng chéo giữa CMD và ENTRYPOINT, thường khiến mọi người nhầm lẫn.

Hầu hết mọi người giải thích nó hoàn hảo ở đây, vì vậy tôi sẽ không lặp lại tất cả các câu trả lời. Nhưng để có được cảm giác tốt, tôi sẽ đề nghị tự kiểm tra nó bằng cách xem xét các quy trình trong container.

Tạo một Dockerfile nhỏ có dạng:

FROM ubuntu:latest
CMD /bin/bash

Xây dựng nó, chạy nó với docker run -it theimagevà chạy ps -eo ppid,pid,argstrong container. So sánh đầu ra này với đầu ra bạn nhận được từ ps khi sử dụng:

• docker run -it theimage bash
• Xây dựng lại hình ảnh nhưng với ENTRYPOINT /bin/bashvà chạy nó theo cả hai cách
• Sử dụng CMD ["/bin/bash"]
• ...

Bằng cách này, bạn sẽ dễ dàng nhìn thấy sự khác biệt giữa tất cả các phương pháp có thể cho chính mình.

Các tài liệu chính thức về thực hành tốt nhất của Dockerfile thực hiện một công việc tuyệt vời giải thích sự khác biệt. Dockerfile thực hành tốt nhất

CMD:

Hướng dẫn CMD nên được sử dụng để chạy phần mềm chứa trong hình ảnh của bạn, cùng với mọi đối số. CMD hầu như luôn luôn được sử dụng ở dạng CMD ["executable", "param1", "param2"…]. Do đó, nếu hình ảnh dành cho một dịch vụ, chẳng hạn như Apache và Rails, bạn sẽ chạy một cái gì đó như thế CMD ["apache2","-DFOREGROUND"]. Thật vậy, hình thức hướng dẫn này được khuyến nghị cho bất kỳ hình ảnh dựa trên dịch vụ nào.

GIỚI THIỆU:

Cách sử dụng tốt nhất cho ENTRYPOINT là đặt lệnh chính của hình ảnh, cho phép hình ảnh đó được chạy như thể đó là lệnh đó (và sau đó sử dụng CMD làm cờ mặc định).