instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from an underlying storage pool. They can also be
  nested and snapshotted. The diagram below shows 4 subvolumes. 'Subvolume 2' and
  'Subvolume 3' are nested, whereas 'Subvolume 4' shows its own internal directory
  tree.
  Only the base layer of an image is stored as a true subvolume. All the other
  layers are stored as snapshots, which only contain the differences introduced
  in that layer. You can create snapshots of snapshots as shown in the diagram
  below.
  On disk, snapshots look and feel just like subvolumes, but in reality they are
  much smaller and more space-efficient. Copy-on-write is used to maximize storage
  efficiency and minimize layer size, and writes in the container's writable layer
  are managed at the block level. The following image shows a subvolume and its
  snapshot sharing data.
  For maximum efficiency, when a container needs more space, it is allocated in
  chunks of roughly 1 GB in size.Docker's btrfs storage driver stores every image layer and container in its
  own Btrfs subvolume or snapshot. The base layer of an image is stored as a
  subvolume whereas child image layers and containers are stored as snapshots.
  This is shown in the diagram below.
  The high level process for creating images and containers on Docker hosts
  running the btrfs driver is as follows:The image's base layer is stored in a Btrfs subvolume under
  /var/lib/docker/btrfs/subvolumes.Subsequent image layers are stored as a Btrfs snapshot of the parent
  layer's subvolume or snapshot, but with the changes introduced by this
  layer. These differences are stored at the block level.The container's writable layer is a Btrfs snapshot of the final image layer,
  with the differences introduced by the running container. These differences
  are stored at the block level.How container reads and writes work with btrfsReading filesA container is a space-efficient snapshot of an image. Metadata in the snapshot
  points to the actual data blocks in the storage pool. This is the same as with
  a subvolume. Therefore, reads performed against a snapshot are essentially the
  same as reads performed against a subvolume.Writing filesAs a general caution, writing and updating a large number of small files with
  Btrfs can result in slow performance.Consider three scenarios where a container opens a file for write access with
  Btrfs.Writing new filesWriting a new file to a container invokes an allocate-on-demand operation to
  allocate new data block to the container's snapshot. The file is then written
  to this new space. The allocate-on-demand operation is native to all writes
  with Btrfs and is the same as writing new data to a subvolume. As a result,
  writing new files to a container's snapshot operates at native Btrfs speeds.Modifying existing filesUpdating an existing file in a container is a copy-on-write operation
  (redirect-on-write is the Btrfs terminology). The original data is read
  ```