instruction: Create a Dockerfile for Nginx with production best practices
output: ```dockerfile
  from previous steps. As a result the apt-get update isn't executed
  because the build uses the cached version. Because the apt-get update isn't
  run, your build can potentially get an outdated version of the curl and
  nginx packages.Using RUN apt-get update && apt-get install -y --no-install-recommends ensures your Dockerfile
  installs the latest package versions with no further coding or manual
  intervention. This technique is known as cache busting. You can also achieve
  cache busting by specifying a package version. This is known as version pinning.
  For example:
  
  RUN apt-get update && apt-get install -y --no-install-recommends \
   package-bar \
   package-baz \
   package-foo=1.3.*Version pinning forces the build to retrieve a particular version regardless of
  whatâs in the cache. This technique can also reduce failures due to unanticipated changes
  in required packages.Below is a well-formed RUN instruction that demonstrates all the apt-get
  recommendations.
  
  RUN apt-get update && apt-get install -y --no-install-recommends \
   aufs-tools \
   automake \
   build-essential \
   curl \
   dpkg-sig \
   libcap-dev \
   libsqlite3-dev \
   mercurial \
   reprepro \
   ruby1.9.1 \
   ruby1.9.1-dev \
   s3cmd=1.1.* \
   && rm -rf /var/lib/apt/lists/*The s3cmd argument specifies a version 1.1.*. If the image previously
  used an older version, specifying the new one causes a cache bust of apt-get update and ensures the installation of the new version. Listing packages on
  each line can also prevent mistakes in package duplication.In addition, when you clean up the apt cache by removing /var/lib/apt/lists it
  reduces the image size, since the apt cache isn't stored in a layer. Since the
  RUN statement starts with apt-get update, the package cache is always
  refreshed prior to apt-get install.Official Debian and Ubuntu images automatically run apt-get clean, so explicit invocation is not required.Using pipesSome RUN commands depend on the ability to pipe the output of one command into another, using the pipe character (|), as in the following example:
  
  RUN wget -O - https://some.site | wc -l > /numberDocker executes these commands using the /bin/sh -c interpreter, which only
  evaluates the exit code of the last operation in the pipe to determine success.
  In the example above, this build step succeeds and produces a new image so long
  as the wc -l command succeeds, even if the wget command fails.If you want the command to fail due to an error at any stage in the pipe,
  prepend set -o pipefail && to ensure that an unexpected error prevents the
  build
  ```