Not understanding what is happening when I try to execute two commands at runtime via CMD directive in `Dockerfile. I assumed that this should work:

CMD ["/etc/init.d/nullmailer", "start", ";", "/usr/sbin/php5-fpm"]

But it's not working. Container has not started. So I had to do it like this:

CMD ["sh", "-c", "/etc/init.d/nullmailer start ; /usr/sbin/php5-fpm"]

I don't understand. Why is that? Why first line is not the right way? Can somebody explain me these "CMD shell format vs JSON format, etc" stuff. In simple words.

Just to note - the same was with command: directive in docker-compose.yml, as expected.


I believe the difference might have to do with, the the second command does shell processing, while the first does not. Per the official documentation , there is the exec and shell form, your first command is an exec form and it does not for instance expand environment variables, while the second one does. So it is possible that, by using the exec form, the command might failing due to its dependence on shell processing. You can check this by running docker logs CONTAINERID

Your second command, the shell form, is equivalent to -

CMD /etc/init.d/nullmailer start ; /usr/sbin/php5-fpm

Excerpts from the documentation -

Note: Unlike the shell form, the exec form does not invoke a command shell. This means that normal shell processing does not happen. For example, CMD [ "echo", "$HOME" ] will not do variable substitution on $HOME. If you want shell processing then either use the shell form or execute a shell directly, for example: CMD [ "sh", "-c", "echo", "$HOME" ].

  • Probably command failed because of environment variables. Should I still use this exec form, as it is the preferred form? Why it is preferred? Or should I use simpler shell form? – Vladan Apr 27 '15 at 10:46
  • It failed because executing one command after another is a shell function. Environment variables is a red herring. – Bryan Apr 27 '15 at 12:02
  • If you are running multiple services in Docker, I would recommend using a process manager like supervisor. That way you launch only supervisord under the CMD section and it will take care of starting the services. You can check for details here - docs.docker.com/articles/using_supervisord – Daniel t. Apr 27 '15 at 14:36
  • This is an exact article I was just reading :) Thanks. – Vladan Apr 29 '15 at 17:24
  • I still don't understand why you need to do CMD [ "sh", "-c", "echo", "$HOME"]. Why not CMD ["sh", "-c", "echo $HOME"] or, for that matter, CMD ["sh -c echo $HOME"]? – sixty4bit Jan 6 '18 at 0:41

Don't make it hard on yourself. Just create a bash file "start.sh":


/usr/bin/command2 param1

in your Dockerfile do:

ADD start.sh /

CMD ["/start.sh"]

I guess first command fails because in DOCKER CMD form, only the first parameter is executed, the rest is fed into this command.

The second form works because all commands seperated with ";" are fed into sh command, which executes them.


I don't think you should put semi comma after "start"

instead of using



CMD ["/etc/init.d/nullmailer", "start", "/usr/sbin/php5-fpm"]

as docker uses "sh -c", above command will be executed as below

/etc/init.d/nullmailer start
/etc/init.d/nullmailer /usr/sbin/php5-fpm
  • The json syntax does not run commands with a shell, there is not sh -c in that scenario. – BMitch Aug 7 at 14:39

The json syntax of CMD (and RUN and ENTRYPOINT) pass the arguments to the kernel directly as an exec syscall. There is no separating of the command from the arguments by spaces, escaping of quotes, IO redirection, variable substitution, piping between commands, running multiple commands, etc, in the exec syscall. The syscall only takes the executable to run and list of arguments to pass to that executable, and it runs it.

Characters like $ to expand variables, ; to separate commands, (space) to separate arguments, && and || to chain commands, > for output redirection, | to pipe between commands, etc, are all features of the shell and need something like /bin/sh or /bin/bash to interpret and implement them.

If you switch to the string syntax of CMD, docker will run your command with a shell:


Otherwise, your second syntax does the exact same thing:


Note that I do not recommend running multiple commands this way inside of a container since there is no error handling if your first command fails, especially if it runs in the background. You also leave a shell running as pid 1 inside the container which will break signal handling, resulting in a 10 second delay and ungraceful kill of your container by docker. The signal handling can be mitigated by using the shell exec command:

CMD /etc/init.d/nullmailer start ; exec /usr/sbin/php5-fpm

However, handling processes silently failing in the background requires you switch to some kind of multi-process manager like supervisord, or preferably breakup your application into multiple containers and deploy them with something like docker-compose.

Your Answer

