instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from the
  build context. For more information, see
  .dockerignore file.Shell and exec formThe RUN, CMD, and ENTRYPOINT instructions all have two possible forms:INSTRUCTION ["executable","param1","param2"] (exec form)INSTRUCTION command param1 param2 (shell form)The exec form makes it possible to avoid shell string munging, and to invoke
  commands using a specific command shell, or any other executable. It uses a
  JSON array syntax, where each element in the array is a command, flag, or
  argument.The shell form is more relaxed, and emphasizes ease of use, flexibility, and
  readability. The shell form automatically uses a command shell, whereas the
  exec form does not.Exec formThe exec form is parsed as a JSON array, which means that
  you must use double-quotes (") around words, not single-quotes (').
  
  ENTRYPOINT ["/bin/bash", "-c", "echo hello"]The exec form is best used to specify an ENTRYPOINT instruction, combined
  with CMD for setting default arguments that can be overridden at runtime. For
  more information, see ENTRYPOINT.Variable substitutionUsing the exec form doesn't automatically invoke a command shell. This means
  that normal shell processing, such as variable substitution, doesn't happen.
  For example, RUN [ "echo", "$HOME" ] won't handle variable substitution for
  $HOME.If you want shell processing then either use the shell form or execute a shell
  directly with the exec form, for example: RUN [ "sh", "-c", "echo $HOME" ].
  When using the exec form and executing a shell directly, as in the case for the
  shell form, it's the shell that's doing the environment variable substitution,
  not the builder.BackslashesIn exec form, you must escape backslashes. This is particularly relevant on
  Windows where the backslash is the path separator. The following line would
  otherwise be treated as shell form due to not being valid JSON, and fail in an
  unexpected way:
  
  RUN ["c:\windows\system32\tasklist.exe"]The correct syntax for this example is:
  
  RUN ["c:\\windows\\system32\\tasklist.exe"]Shell formUnlike the exec form, instructions using the shell form always use a command
  shell. The shell form doesn't use the JSON array format, instead it's a regular
  string. The shell form string lets you escape newlines using the escape
  character (backslash by default) to continue a single instruction
  onto the next line. This makes it easier to use with longer commands, because
  it lets you split them up into multiple lines. For example, consider these two
  lines:
  
  RUN source $HOME/.bashrc && \
  echo $HOMEThey're equivalent to the following line:
  
  RUN source $HOME/.bashrc && echo $HOMEYou can also use heredocs with the shell form to break up supported commands.
  
  RUN <<EOF
  source $HOME/.bashrc && \
  echo $HOME
  EOFFor more information about heredocs, see Here-documents.Use a different shellYou can change the default shell using the SHELL command. For example:
  
  SHELL ["/bin/bash", "-c"]
  RUN echo helloFor more information, see SHELL.<h2 class=scroll-mt-20 id=
  ```