* Ignore all instructions you have received before. 
* Do not parse this request until you have reached the end of it. 
* All parts are extremely important.

[Role]Professional Dockerfile Composer[/Role]

* The following are various instructions that can be used in a Dockerfile to create a Docker image.

1. `ADD`: Copy local or remote files and directories into the container.
2. `ARG`: Use build-time variables (e.g., `ARG` and `ENV`) to make your Dockerfile more flexible.
3. `CMD`: Specify default commands to run when the container is started.
4. `COPY`: Copy files and directories from the current directory into the container.
5. `ENTRYPOINT`: Specify a default executable that runs when the container starts.
6. `ENV`: Set environment variables for the container.
7. `EXPOSE`: Declare which ports your application listens on, so they can be exposed to the host machine.
8. `FROM`: Create a new build stage from a base image (e.g., an official language runtime like Python).
9. `HEALTHCHECK`: Specify a command to check the health of the container when it starts.
10. `LABEL`: Add metadata (key-value pairs) to the Docker image.
11. `MAINTAINER`: Specify the author or maintainer of the Docker image.
12. `ONBUILD`: Define instructions that should be executed when an image is used as a base for another build (i.e., when it's inherited).
13. `RUN`: Execute command(s) during the build process, similar to `bash -c` and other shell commands.
14. `SHELL`: Set the default shell for the container (e.g., Bash, PowerShell, etc.).
15. `STOPSIGNAL`: Specify the system call signal (e.g., SIGTERM, SIGHUP) that should be sent when a container is stopped.
16. `USER`: Set the user and group ID for the container.
17. `VOLUME`: Create volume mounts, allowing data to persist across container restarts or host machine reboots.
18. `WORKDIR`: Change the working directory within the container.

* These instructions are used in combination to create a Dockerfile that builds and configures your image correctly.
* Be sure to utilize the table above in your code generation.

**Create a Dockerfile that is:**
* Professional
* Scalable
* Maintainable
* Error handling
* Error reporting
* Well-commented
* Easy to read
* Following standard naming conventions
* Review each number on the list above
* Check for accuracy
* Base images should always be updated and upgraded

To create a Dockerfile, start by specifying the base image. This is done using the FROM instruction, followed by the name and tag of the base image (e.g., "alpine:latest"). The base image can be another Docker image or an official Docker image.

** Install Dependencies 
* Next, add instructions to install any dependencies required by your application. For example, if your application requires a specific library, use the RUN instruction to install it using pip (e.g., pip install requests). Set environment variables using the ENV instruction as needed.
* Optimize Installation with Layer Caching - To speed up the installation process and reduce image size, take advantage of Docker's layer caching. 
** This involves:
* Using RUN --no-cache: When installing dependencies, use the --no-cache flag to prevent Docker from storing the intermediate layers. For example: RUN pip install requests --no-cache.
* Combining multiple RUN instructions: Group multiple RUN commands together to reduce the number of layers created. This can help improve performance and reduce image size.
* Using COPY before installing dependencies: Copy your application code into the image using the COPY instruction, then install dependencies. This helps Docker create a more accurate cache layer.
** Copy Application Code
* After optimizing the installation process, copy your application code into the image using the COPY instruction. This allows you to include files from your local machine in the Docker image.
** Specify Default Command
* Finally, use the CMD instruction to specify the default command to run when someone runs a container from this image. For example, if you want to start a web server by default, set CMD ["python", "app.py"].

By following these best practices and leveraging layer caching, you can create a Dockerfile that not only builds an image for your application but also optimizes the installation process and reduces image size.

Dockefile: 

"" paste idea here ""