在Dockerfile中，有两个命令与我类似：CMD和ENTRYPOINT。但我想它们之间有一个（微妙的）区别——否则，对同一件事使用两个命令是没有意义的。
CMD的文档状态-
CMD的主要目的是为正在执行的容器提供默认值。
对于入口点：
ENTRYPOINT帮助您配置可以作为可执行文件运行的容器。
那么，这两个命令之间有什么区别？
是的，这是个好问题。我还不完全理解，但是：
我知道ENTRYPOINT是正在执行的二进制文件。可以通过--entrypoint=“”覆盖entrypoint。
docker run -t -i --entrypoint="/bin/bash" ubuntu
CMD是容器的默认参数。如果没有入口点，默认参数是执行的命令。使用entrypoint，cmd将作为参数传递给entryppoint。您可以使用入口点模拟命令。
# no entrypoint
docker run ubuntu /bin/cat /etc/passwd
# with entry point, emulating cat command
docker run --entrypoint="/bin/cat" ubuntu /etc/passwd
所以，主要优点是使用entrypoint可以将参数（cmd）传递给容器。要做到这一点，您需要同时使用：
# Dockerfile
FROM ubuntu
ENTRYPOINT ["/bin/cat"]
and
docker build -t=cat .
那么您可以使用：
docker run cat /etc/passwd
# ^^^^^^^^^^^
# CMD
# ^^^
# image (tag)- using the default ENTRYPOINT
Docker有一个默认入口点/bin/sh-c，但没有默认命令。
当你这样运行docker时：docker运行-i-t ubuntu bash入口点是默认的/bin/sh-c，图像是ubuntu，命令是bash。
该命令通过入口点运行。即，实际执行的是/bin/sh-cbash。这允许Docker依靠shell的解析器快速实现RUN。
后来，人们要求能够定制这个，所以引入了ENTRYPOINT和--ENTRYPOINT。
在上面的示例中，图像名称ubuntu之后的所有内容都是命令，并传递给入口点。当使用CMD指令时，它就像您在执行docker运行-i-t ubuntu<cmd>入口点的参数为＜cmd＞。
如果改为键入以下命令docker run-i-t ubuntu，也会得到相同的结果：bash shell将在容器中启动，因为在ubuntu Dockerfile中指定了默认CMD：CMD[“bash”]。
当一切都传递到入口点时，您可以从图像中获得非常好的行为@Jiri示例很好，它展示了如何将图像用作“二进制”。当使用[“/bin/cat”]作为入口点，然后执行docker运行img/etc/passwd时，您会发现，/etc/passwd是一个命令，并被传递到入口点，因此最终执行的结果只是/bin/cat/etc/passwd。
另一个示例是将任意cli作为入口点。例如，如果您有一个redis映像，而不是运行docker run redisig redis-H something-u to get key，您可以简单地使用ENTRYPOINT[“redis”，“-H”，“something”，“-u”，”toto“]，然后像这样运行以获得相同的结果：docker run reisig get key。
ENTRYPOINT指定在容器启动时始终执行的命令。
CMD指定将被馈送到ENTRYPOINT的参数。
如果要使图像专用于特定命令，则将使用ENTRYPOINT[“/path/dessisted_command”]
否则，如果您想为通用目的生成图像，可以不指定ENTRYPOINT，使用CMD[“/path/dessisted_command”]，因为您可以通过为docker运行提供参数来覆盖设置。
例如，如果Dockerfile是：
FROM debian:wheezy
ENTRYPOINT ["/bin/ping"]
CMD ["localhost"]
在没有任何参数的情况下运行映像将ping本地主机：
$ 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
现在，运行带有参数的图像将ping该参数：
$ 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
作为比较，如果Dockerfile是：
FROM debian:wheezy
CMD ["/bin/ping", "localhost"]
在没有任何参数的情况下运行映像将ping本地主机：
$ 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:/#
有关更多详细信息，请参阅Brian DeHamer的这篇文章：https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/
CMD:
CMD[“executable”，“param1”，“param2”]：[“executible”，”param1“，”param2“]是第一个进程。CMD命令param1 param2：/bin/sh-c CMD命令param1 param2是第一个进程。CMD命令param1 param2从第一个进程分叉。CMD[“param1”，“param2”]：此表单用于为ENTRYPOINT提供默认参数。
ENTRYPOINT（以下列表不考虑CMD和ENTRYPOINT一起使用的情况）：
ENTRYPOINT[“executable”，“param1”，“param2”]：[“executible”，”param1“，”param2“]是第一个进程。ENTRYPOINT命令param1 param2：/bin/sh-c命令param1 param2是第一个进程。命令param1 param2从第一个进程分叉。
正如creack所说，CMD是第一个开发的。然后，ENTRYPOINT被开发用于更多的定制。由于它们不是一起设计的，CMD和ENTRYPOINT之间存在一些功能重叠，这常常会让人感到困惑。
代码中EntryPoint函数的注释
//入口/usr/sbin/nginx。//将入口点（默认为sh-c）设置为/usr/sbin/nginx。//将接受CMD作为/usr/sbin/nginx的参数。
文件中的另一个参考
您可以使用ENTRYPOINT的exec形式设置相当稳定的默认命令和参数，然后使用CMD设置更可能更改的其他默认值。
例子：
FROM ubuntu:14.04.3
ENTRYPOINT ["/bin/ping"]
CMD ["localhost", "-c", "2"]
Build：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
附笔：在存在EntryPoint的情况下，CMD将保存要馈送到EntryPoint的参数。如果没有EntryPoint，CMD将是将要运行的命令。
简而言之：
CMD设置默认命令和/或参数，当docker容器运行时，可以从命令行覆盖这些命令和/参数。ENTRYPOINT命令和参数不会从命令行覆盖。相反，所有命令行参数都将添加到ENTRYPOINT参数之后。
如果你需要更多的细节，或者想看到例子上的差异，有一篇博客文章将CMD和ENTRYPOINT与很多例子进行了全面比较https://codewithyury.com/docker-run-vs-cmd-vs-entrypoint/
根据docker文档，
CMD和ENTRYPOINT指令都定义执行什么命令当运行容器时。很少有规则描述合作。Dockerfile应至少指定CMD或ENTRYPOINT命令之一。将容器用作可执行文件时，应定义ENTRYPOINT。CMD应用作为ENTRYPOINT命令或在容器当使用可选参数运行容器时，CMD将被重写。
下表显示了对不同ENTRYPOINT/CMD组合执行的命令：
--无入口点
╔════════════════════════════╦═════════════════════════════╗
║ 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 ║
╚════════════════════════════╩═════════════════════════════╝
--入口点执行_入口p1_入口
╔════════════════════════════╦══════════════════════════════════╗
║ 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 ║
╚════════════════════════════╩══════════════════════════════════╝
--入口[“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 ║
╚════════════════════════════╩═════════════════════════════════════════════════╝
CMD和ENTRYPOINT之间的直觉差异：
ENTRYPOINT：容器启动时运行的命令。CMD：容器启动时运行的命令，或ENTRYPOINT的参数（如果指定）。
是的，这令人困惑。
在运行docker run时，可以覆盖其中任何一个。
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）会覆盖我们在Dockerfile中编写的任何CMD命令。
ENTRYPOINT不能在运行时被docker run[args]等正常命令覆盖。docker运行结束时的args[args]作为ENTRYPOINT的参数提供。通过这种方式，我们可以创建一个像ls这样的普通二进制文件的容器。
因此，CMD可以作为ENTRYPOINT的默认参数，然后我们可以从[args]重写CMD参数。
ENTRYPOINT可以用--ENTRYPOINT重写。
大多数人在这里都解释得很好，所以我不会重复所有的答案。但为了得到一个好的感觉，我建议自己通过查看容器中的流程来测试它。
创建一个小型Dockerfile，格式如下：
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”]...
这样，您将很容易看到所有可能的方法之间的差异。
我将把我的答案作为一个例子，1这样可以帮助你更好地理解其中的区别。
假设我们希望创建一个图像，该图像在启动时始终运行sleep命令。我们将创建自己的映像并指定一个新命令：
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
虽然这是可行的，但这不是一个好的解决方案，因为我们有一个冗余的“睡眠”命令。为什么冗余？因为容器的唯一目的是睡眠，所以必须显式指定睡眠命令有点尴尬。
现在，让我们尝试使用ENTRYPOINT指令：
FROM ubuntu
ENTRYPOINT sleep
此指令指定容器启动时将运行的程序。
现在我们可以运行：
docker run custom_sleep 20
默认值如何？嗯，你猜对了：
FROM ubuntu
ENTRYPOINT ["sleep"]
CMD ["10"]
ENTRYPOINT是将要运行的程序，传递给容器的值将附加到该程序。
可以通过指定--ENTRYPOINT标志，后跟要使用的新入口点来覆盖ENTRYPOINT。
不是我的，我曾经看过一个提供了这个例子的教程
Dockerfile最佳实践的官方文档很好地解释了这些差异。Dockerfile最佳实践
CMD:
CMD指令应用于运行映像中包含的软件以及任何参数。CMD几乎应始终以CMD[“executable”，“param1”，“param2”…]的形式使用。因此，如果映像用于服务，例如Apache和Rails，则可以运行类似CMD[“apache2”，“-DFOREGROUND”]的命令。实际上，对于任何基于服务的图像，都建议使用这种形式的说明。
入口点：
ENTRYPOINT的最佳用法是设置映像的主命令，允许该映像像运行该命令一样运行（然后使用CMD作为默认标志）。
我已经阅读了所有答案，我想总结一下，以便更好地理解以下内容：
首先，在容器中执行的整个命令包括两部分：命令和参数
ENTRYPOINT定义当容器已启动（用于命令）CMD指定传递给ENTRYPOINT的参数（用于参数）
在《Kubernetes In Action》一书中指出了一个重要的注意事项。（第7章）
尽管可以使用CMD指令指定命令要在运行映像时执行，正确的方法是执行通过ENTRYPOINT指令，并仅在以下情况下指定CMD希望定义默认参数。
你也可以阅读这篇文章，以简单的方式获得很好的解释
•Dockerfile应至少指定一条CMD或ENTRYPOINT指令
•仅使用Dockerfile中的最后一个CMD和ENTRYPOINT
•将容器用作可执行文件时，应定义ENTRYPOINT
•您应该使用CMD指令来定义默认参数定义为ENTRYPOINT的命令或用于在容器
•使用替代参数运行容器时，CMD将被覆盖
•ENTRYPOINT设置每次容器是使用图像创建的
•如果您将ENTRYPOINT与CMD结合，则可以从CMD中删除可执行文件并且只留下将传递给ENTRYPOINT的参数
•ENTRYPOINT的最佳用途是设置图像的主命令，允许映像要像运行该命令一样运行（然后使用CMD作为默认值标志）
我遇到了这个问题，一开始我发现老实说，这真的很令人困惑，我认为这种困惑来自于使用“CMD”一词，因为事实上，那里的东西充当了论据。所以挖了一点后，我明白了它是如何工作的。基本上：
ENTRYPOINT-->此处指定的是容器启动时要执行的命令。如果省略此定义，docker将使用/bin/sh-cbash来运行容器。
CMD-->这些是附加到ENTRYPOINT的参数，除非用户指定了一些自定义参数，即：docker run ubuntu＜custom_CMD＞在这种情况下，docker将运行ENTRYPOINT＜custom_CMD＞，而不是附加在CMD部分的图像上指定的内容。如果未指定ENTRYPOINT，则此处的内容将传递给/bin/sh-c，实际上作为启动容器时要执行的命令。
作为一切，最好用例子来解释发生了什么。因此，假设我使用以下规范Dockerfile创建了一个简单的docker映像：
From ubuntu
ENTRYPOINT ["sleep"]
然后我通过运行以下命令来构建它：
docker build . -t testimg
这将创建一个容器，每次运行时它都会休眠。所以，如果我按如下方式运行：
docker run testimg
我会得到以下信息：
sleep: missing operand
Try 'sleep --help' for more information.
这是因为入口点是需要参数的“sleep”命令。为了解决这个问题，我只需要提供睡眠量：
docker run testimg 5
这将正确运行，因此容器将运行，休眠5秒并退出。正如我们在这个示例中看到的，docker只是将图像名称后面的内容添加到入口点二进制docker runtestimg<my_cmd>。如果我们想将默认值（默认参数）传递给入口点，会发生什么？在这种情况下，我们只需要在CMD部分中指定它，例如：
From ubuntu
ENTRYPOINT ["sleep"]
CMD ["10"]
在这种情况下，如果用户没有传递任何参数，容器将使用默认值（10）并将其传递给入口点睡眠。
现在，让我们只使用CMD并省略ENTRYPOINT定义：
FROM ubuntu
CMD ["sleep", "5"]
如果我们重建并运行此图像，它将基本休眠5秒。
总之，您可以使用ENTRYPOINT使容器充当可执行文件。您可以使用CMD为入口点提供默认参数，或者在启动容器时运行自定义命令，该命令可以由用户从外部重写。
有一些很好的答案。我想通过每个文档的演示来解释
CMD定义容器的默认命令和/或参数。如果您需要用户可以轻松覆盖的默认命令，则最好使用CMD指令。如果Dockerfile有多个CMD，它只应用最后一个CMD中的指令。当您想要定义具有特定可执行文件的容器时，首选ENTRYPOINT。
除非添加--ENTRYPOINT标志，否则无法在启动容器时重写ENTRYPOINT。
命令
Docker文件
FROM centos:8.1.1911
CMD ["echo", "Hello Docker"]
运行结果
$ sudo docker run <image-id>
Hello Docker
$ sudo docker run <image-id> hostname # hostname is exec to override CMD
244be5006f32
入口点
Docker文件
FROM centos:8.1.1911
ENTRYPOINT ["echo", "Hello Docker"]
运行结果
$ sudo docker run <image-id>
Hello Docker
$ sudo docker run <image-id> hostname # hostname as parameter to exec
Hello Docker hostname
在许多情况下，将CMD和ENTRYPOINT结合起来是Docker容器的最佳解决方案。在这种情况下，可执行文件使用ENTRYPOINT定义，而CMD指定默认参数。
Docker文件
FROM centos:8.1.1911
ENTRYPOINT ["echo", "Hello"]
CMD ["Docker"]
运行结果
$ sudo docker run <image-id>
Hello Docker
$ sudo docker run <image-id> Ben
Hello Ben
我想以轻松的方式区分CMD、RUN和ENTRYPOINT之间的差异。
让我们以节点的npm init为例。
命令：
假设下面是我们在dockerfile中添加的初始命令
CMD [ "npm", "init" ]
现在，如果我运行docker，运行-t node npm install
它将覆盖dockerfile中的npm init命令。
CMD [ "npm", "init" ] This will become CMD [ "npm", "install" ]
它将执行npm install命令，而不是npm init，因为它会使用npm install。
现在，我们来谈谈
入口点：
假设在docker文件中添加了相同的命令，但使用ENTRYPOINT
ENTRYPOINT [ "npm", "init" ]
现在，如果我运行docker，运行-t节点安装
它将在dockerfile中附加npm init命令和npm install。
ENTRYPOINT [ "npm", "init" ] This will become ENTRYPOINT [ "npm", "init", "install" ]
它将同时执行npm init和npm install命令。
总结如下：
RUN：这将在生成图像时执行。用于安装任何依赖项，如node_modules。例如RUN npm安装
CMD：要覆盖完整命令时使用
ENTRYPOINT：要附加一些附加命令时使用。
通过从头开始重建OS映像（只需从头开始编写，并在dockerfile中使用COPY复制最小的文件系统），我了解到，
如果没有在dockerfile中指定ENTRYPOINT和CMD，docker将使用
/bin/sh -c
作为默认ENTRYPOINT，如果在docker文件中定义CMD或在运行容器时传递命令行参数（这将覆盖已定义的CMD），则将采用CMD。
假设您传递一个参数（或在dockerfile中定义CMD）ls，那么它将被馈送到ENTRYPOINT。即，
/bin/sh -c ls
/bin/sh-c将运行传递给它的任何参数。您将获得“ls”命令的输出，然后容器将退出。
ubuntu映像没有显式定义ENTRYPOINT，因此docker将使用/bin/sh-c，但包含CMD定义，即bash运行容器的以下命令，
docker container run -it ubuntu
Docker实际上使用ENTRYPOINT作为/bin/sh-c，然后使用bash为其提供数据最终运行的是
/bin/sh -c bash
它启动交互式bash终端（仅当如上所述指定了-i标志并可选地指定了-t以获得类似本地终端的体验时）
当您通过命令行提供参数时，bash将被替换为您传递的任何内容，输出将根据该内容，即
/bin/sh -c passed_argument
您可以定义自定义ENTRYPOINT，它将覆盖默认ENTRYPOINT，但随后需要相应地使用CMD。
对于dockerfile中的RUN命令，它不考虑定义的ENTRYPOINT和CMD，而是运行指定的命令，因为它们被提供给中间容器中的交互式bash终端
推荐文章
- 如何从私有docker注册表中删除图像?
- 创建多个标签码头镜像
- Docker -如何将文件从镜像复制到主机?
- 如何防止docker在系统启动时自动启动容器?
- 什么是Docker映像“层”?
- 无法从docker-compose连接到docker
- Docker错误无法删除Docker容器，冲突:无法删除存储库引用
- 如何让容器在Kubernetes上运行?
- 如何备份docker容器的数据卷?
- Docker入口点运行bash脚本被“拒绝权限”
- 我如何复制Docker作为非根?
- 如何禁用容器上的自动重启?
- 如何传递参数到Dockerfile?
- 如何知道docker是否已经登录到docker注册服务器
- 为什么安装了Docker而没有安装Docker Compose?
