instruction: Create a Dockerfile for Alpine Linux with production best practices
output: ```dockerfile
  from
  within the container.Image layering and sharingThe devicemapper storage driver uses dedicated block devices rather than
  formatted filesystems, and operates on files at the block level for maximum
  performance during copy-on-write (CoW) operations.SnapshotsAnother feature of devicemapper is its use of snapshots (also sometimes called
  thin devices or virtual devices), which store the differences introduced in
  each layer as very small, lightweight thin pools. Snapshots provide many
  benefits:Layers which are shared in common between containers are only stored on disk
  once, unless they are writable. For instance, if you have 10 different
  images which are all based on alpine, the alpine image and all its
  parent images are only stored once each on disk.Snapshots are an implementation of a copy-on-write (CoW) strategy. This means
  that a given file or directory is only copied to the container's writable
  layer when it is modified or deleted by that container.Because devicemapper operates at the block level, multiple blocks in a
  writable layer can be modified simultaneously.Snapshots can be backed up using standard OS-level backup utilities. Just
  make a copy of /var/lib/docker/devicemapper/.Devicemapper workflowWhen you start Docker with the devicemapper storage driver, all objects
  related to image and container layers are stored in
  /var/lib/docker/devicemapper/, which is backed by one or more block-level
  devices, either loopback devices (testing only) or physical disks.The base device is the lowest-level object. This is the thin pool itself.
  You can examine it using docker info. It contains a filesystem. This base
  device is the starting point for every image and container layer. The base
  device is a Device Mapper implementation detail, rather than a Docker layer.Metadata about the base device and each image or container layer is stored in
  /var/lib/docker/devicemapper/metadata/ in JSON format. These layers are
  copy-on-write snapshots, which means that they are empty until they diverge
  ```