instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from the output, without requiring
  additional tools such as awk or sed. To learn more about formatting
  the output of docker commands using the --format flag, refer to the
  format command and log output section.
  We also pretty-printed the JSON output using the jq utility
  for readability.Copying makes containers efficientWhen you start a container, a thin writable container layer is added on top of
  the other layers. Any changes the container makes to the filesystem are stored
  here. Any files the container doesn't change don't get copied to this writable
  layer. This means that the writable layer is as small as possible.When an existing file in a container is modified, the storage driver performs a
  copy-on-write operation. The specific steps involved depend on the specific
  storage driver. For the overlay2 driver, the copy-on-write operation follows
  this rough sequence:Search through the image layers for the file to update. The process starts
  at the newest layer and works down to the base layer one layer at a time.
  When results are found, they're added to a cache to speed future operations.Perform a copy_up operation on the first copy of the file that's found, to
  copy the file to the container's writable layer.Any modifications are made to this copy of the file, and the container can't
  see the read-only copy of the file that exists in the lower layer.Btrfs, ZFS, and other drivers handle the copy-on-write differently. You can
  read more about the methods of these drivers later in their detailed
  descriptions.Containers that write a lot of data consume more space than containers
  that don't. This is because most write operations consume new space in the
  container's thin writable top layer. Note that changing the metadata of files,
  for example, changing file permissions or ownership of a file, can also result
  in a copy_up operation, therefore duplicating the file to the writable layer.
  TipUse volumes for write-heavy applications.Don't store the data in the container for write-heavy applications. Such
  applications, for example write-intensive databases, are known to be
  problematic particularly when pre-existing data exists in the read-only
  layer.Instead, use Docker volumes, which are independent of the running container,
  and designed to be efficient for I/O. In addition, volumes can be shared
  among containers and don't increase the size of your container's writable
  layer. Refer to the use volumes section to learn about
  volumes.A copy_up operation can incur a noticeable performance overhead. This overhead
  is different depending on which storage driver is in use. Large files,
  lots of layers, and deep directory trees can make the impact more noticeable.
  This is mitigated by the fact that each copy_up operation only occurs the first
  time a given file is modified.To verify the way that copy-on-write works, the following procedure spins up 5
  containers based on the acme/my-final-image:1.0 image we built earlier and
  examines how much room they take up.
  ```