instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from a Dockerfile,
  or when committing it, you can set a number of default parameters that take
  effect when the image starts up as a container. When you run an image, you can
  override those defaults using flags for the docker run command.Default entrypointDefault command and optionsExpose portsEnvironment variablesHealthcheckUserWorking directoryDefault command and optionsThe command syntax for docker run supports optionally specifying commands and
  arguments to the container's entrypoint, represented as [COMMAND] and
  [ARG...] in the following synopsis example:
  
  $ docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]
  This command is optional because whoever created the IMAGE may have already
  provided a default COMMAND, using the Dockerfile CMD instruction. When you
  run a container, you can override that CMD instruction just by specifying a
  new COMMAND.If the image also specifies an ENTRYPOINT then the CMD or COMMAND
  get appended as arguments to the ENTRYPOINT.Default entrypoint
  
  --entrypoint="": Overwrite the default entrypoint set by the imageThe entrypoint refers to the default executable that's invoked when you run a
  container. A container's entrypoint is defined using the Dockerfile
  ENTRYPOINT instruction. It's similar to specifying a default command because
  it specifies, but the difference is that you need to pass an explicit flag to
  override the entrypoint, whereas you can override default commands with
  positional arguments. The defines a container's default behavior, with the idea
  that when you set an entrypoint you can run the container as if it were that
  binary, complete with default options, and you can pass in more options as
  commands. But there are cases where you may want to run something else inside
  the container. This is when overriding the default entrypoint at runtime comes
  in handy, using the --entrypoint flag for the docker run command.The --entrypoint flag expects a string value, representing the name or path
  of the binary that you want to invoke when the container starts. The following
  example shows you how to run a Bash shell in a container that has been set up
  to automatically run some other binary (like /usr/bin/redis-server):
  
  $ docker run -it --entrypoint /bin/bash example/redis
  The following examples show how to pass additional parameters to the custom
  entrypoint, using the positional command arguments:
  
  $ docker run -it --entrypoint /bin/bash example/redis -c ls -l
  $ docker run -it --entrypoint /usr/bin/redis-cli example/redis --help
  You can reset a containers entrypoint by passing an empty string, for example:
  
  $ docker run -it --entrypoint="" mysql bash
  
  NotePassing --entrypoint clears out any default command set on the image. That
  is, any CMD instruction in the Dockerfile used to build it.Exposed portsBy default, when you run a container, none of the container's ports are exposed
  to the host. This means you won't be able to access any ports that the
  container might be listening on. To make a container's ports accessible
  ```