instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from being accessed,
  even though it still exists in the image (lowerdir).Renaming directoriesCalling rename(2) for a directory is allowed only when both the source and
  the destination path are on the top layer. Otherwise, it returns EXDEV error
  ("cross-device link not permitted"). Your application needs to be designed to
  handle EXDEV and fall back to a "copy and unlink" strategy.OverlayFS and Docker Performanceoverlay2 may perform better than btrfs. However, be aware of the following details:Page cachingOverlayFS supports page cache sharing. Multiple containers accessing the same
  file share a single page cache entry for that file. This makes the overlay2
  drivers efficient with memory and a good option for high-density use cases such
  as PaaS.CopyupAs with other copy-on-write filesystems, OverlayFS performs copy-up operations
  whenever a container writes to a file for the first time. This can add latency
  into the write operation, especially for large files. However, once the file
  has been copied up, all subsequent writes to that file occur in the upper
  layer, without the need for further copy-up operations.Performance best practicesThe following generic performance best practices apply to OverlayFS.Use fast storageSolid-state drives (SSDs) provide faster reads and writes than spinning disks.Use volumes for write-heavy workloadsVolumes provide the best and most predictable performance for write-heavy
  workloads. This is because they bypass the storage driver and don't incur any
  of the potential overheads introduced by thin provisioning and copy-on-write.
  Volumes have other benefits, such as allowing you to share data among
  containers and persisting your data even if no running container is using them.Limitations on OverlayFS compatibilityTo summarize the OverlayFS's aspect which is incompatible with other
  filesystems:open(2)OverlayFS only implements a subset of the POSIX standards.
  This can result in certain OverlayFS operations breaking POSIX standards. One
  such operation is the copy-up operation. Suppose that your application calls
  fd1=open("foo", O_RDONLY) and then fd2=open("foo", O_RDWR). In this case,
  your application expects fd1 and fd2 to refer to the same file. However, due
  to a copy-up operation that occurs after the second calling to open(2), the
  descriptors refer to different files. The fd1 continues to reference the file
  in the image (lowerdir) and the fd2 references the file in the container
  (upperdir). A workaround for this is to touch the files which causes the
  copy-up operation to happen. All subsequent open(2) operations regardless of
  read-only or read-write access mode reference the file in the
  container (upperdir).yum is known to be affected unless the yum-plugin-ovl package is installed.
  If the yum-plugin-ovl package is not available in your distribution such as
  RHEL/CentOS prior to 6.8 or 7.2, you may need to run touch /var/lib/rpm/*
  before running yum install. This package implements the touch workaround
  referenced above for yum.rename(2)OverlayFS does not fully support the rename(2) system call. Your
  application needs to detect its failure and fall back to a "copy and unlink"
  strategy.
  Request changesTable of contentsPrerequisitesConfigure Docker with the overlay2 storage driverHow the overlay2 driver worksImage and container layers on-diskImage and container layers on-diskHow container reads and writes work with overlay2Reading filesModifying files or directoriesOverlayFS and Docker PerformancePage cachingCopyupPerformance best practicesLimitations on OverlayFS compatibility
  
  Product offerings
  Pricing
  About us
  Contribute
  Read llms.txt
  Cookies Settings
  
  Status
  Legal```