The entry point instruction sets an executable to be run

each time a container starts.

If you're always going to want the container to run the same executable,

whether that Python, MongoDB, Redis or whatever, you should set it here.

Just like the run instruction, both shell and exec forms,

that is the form with the square brackets, are supported.

But the exec form is preferred,

because the command can be shutdown more cleanly when the container stops.

Unlike run, you can have only one entrypoint instruction per Dockerfile.

If there are additional arguments that you always want passed to the command,

you can add them after the executable.

Here's the Dockerfile for the Apache image, again.

It gives us the entrypoint instruction to run the Apache server.

By default, Apache runs in the background, but we want to run it in the foreground so

we can simple press Ctrl+C to stop it.

To do that, we need to pass -D and

FOREGROUND arguments to the apache2ctl executable.

So this entrypoint runs the Apache2ctl executable, and

ensures that -D and FOREGROUND are passed to it as arguments.

The CMD or command instruction is a list

of arguments that get passed to the entrypoint executable.

Or, if no entrypoint has been set,

the first argument is treated as the executable to be run.

As with entrypoint, you can only have one command instruction per Dockerfile.

So this command instruction combined with the entrypoint instruction,

causes a command of python3 app.py to be rung when the container starts.

The user can override the value of the command instruction by passing additional

arguments when they call docker run.

If we call docker run with the same command line we've been using to run our

Python web app all along, We'll see the usual message in our web browser.

But if we stop the container, And

then call docker run again with an additional alternate.py argument.

Our default command value of app.py will be overridden, and

the container will end up running a command of python3 alternate.py.

We've set up alternate.py to contain a web app that's just like app.py but

prints a different message.

And if we visit local host port 8080 in our browser,

we'll see it's the alternate app that's running.

Like run an entrypoint, the command instruction also has a shell form.

Whatever command you type in shell form will be executed in the /bin/sh shell.

Here's a minimal Dockerfile that just uses the shell to

echo a message to the terminal.

If we build it with docker build -t echo,

In the current directory, and run it with docker run echo,

The container will simply print that message and exit.