Update Docker Doc

Containerization & Orchestration/Docker/3-Docker-File.md

@@ -0,0 +1,137 @@
+
+# Dockerfile: A Complete Guide
+
+## What is a Dockerfile?
+
+A **Dockerfile** is a simple text file that contains a list of instructions and commands to create a Docker image. Docker images serve as a blueprint for containers, providing a consistent and reproducible environment to run applications.
+
+Using a Dockerfile, you can automate the process of creating these images, making it easy to define software dependencies, configuration, and the operating system in a clear, version-controlled format.
+
+### Key Concepts:
+- **Base Image**: This is the starting point for your Docker image. You typically begin with an official operating system image like Ubuntu, CentOS, or Alpine Linux.
+- **Instructions**: Commands like `RUN`, `COPY`, and `CMD` define what gets installed, how the image behaves, and which files to include.
+  
+  Common instructions include:
+  - **`RUN`**: Executes commands (like installing software) inside the container.
+  - **`COPY`**: Copies files from your local machine into the image.
+  - **`CMD`**: Specifies the default command to run when a container starts.
+
+---
+
+## Step-by-Step Guide to Creating a Dockerfile
+
+### 1. Create a File Named `Dockerfile`
+
+The first step is to create a file called `Dockerfile` in your project directory. If you name it something other than `Dockerfile`, you'll need to specify the file name when building the image (more on that later).
+
+Here’s a basic example of a Dockerfile:
+
+```dockerfile
+# Use Ubuntu 22.04 as the base image
+FROM ubuntu:22.04
+
+# Add metadata such as version information
+LABEL version="0.0.1"
+
+# Update package lists and install essential tools
+RUN apt update && apt install -y bash vim curl
+
+# Install Nginx web server
+RUN apt install -y nginx
+```
+
+#### Explanation of Instructions:
+- **`FROM ubuntu:22.04`**: Sets the base image to Ubuntu 22.04.
+- **`LABEL version="0.0.1"`**: Adds metadata to the image (in this case, a version label).
+- **`RUN`**: Executes commands inside the container, such as updating the package list and installing tools like `bash`, `vim`, `curl`, and `nginx`.
+
+---
+
+### 2. Another Example Using Alpine Linux
+
+Alpine Linux is a minimal, lightweight distribution often used to create smaller Docker images. Below is an example Dockerfile using Alpine as the base image:
+
+```dockerfile
+# Use the lightweight Alpine base image
+FROM alpine
+
+# Add version metadata
+LABEL version="0.0.1"
+
+# Update package lists and install essential tools
+RUN apk update && apk add bash vim curl
+```
+
+---
+
+### 3. Complex Dockerfile Example with a Script
+
+This example shows how to copy a script into the image, set the working directory, and grant execution permissions to the script.
+
+```dockerfile
+# Use the lightweight Alpine base image
+FROM alpine
+
+# Add version metadata
+LABEL version="0.0.1"
+
+# Update package lists and install essential tools and network utilities
+RUN apk update && apk add bash vim curl iputils-ping
+
+# Copy the script file from the local machine into the image
+COPY <location-of-file> <dest-location>
+
+# Set the working directory inside the container
+WORKDIR <dest-location>
+
+# Give execution permissions to the script
+RUN chmod +x app.sh
+
+# Define the default command to run when the container starts
+CMD ["./app.sh"]
+```
+
+#### Key Additions in This Example:
+- **`COPY <src> <dest>`**: Copies a file from the local system into the container.
+- **`WORKDIR`**: Sets the working directory for subsequent commands (like `RUN`, `CMD`).
+- **`RUN chmod +x app.sh`**: Grants execute permissions to the script `app.sh`.
+- **`CMD ["./app.sh"]`**: Specifies the command to run when the container starts (in this case, running the `app.sh` script).
+
+---
+
+### 4. Build an Image from the Dockerfile
+
+Once you have your `Dockerfile` set up, the next step is to build the Docker image. You can do this with the `docker build` command.
+
+```bash
+docker build -t <app-name> <path-to-dockerfile>
+```
+
+#### Usage Examples:
+
+- If the file is named `Dockerfile` and is located in the current directory:
+  ```bash
+  docker build -t app-test .
+  ```
+  Here, the `.` specifies the current directory as the build context (where Docker looks for the `Dockerfile`).
+
+- If the file is named something else (e.g., `CustomDockerfile`):
+  ```bash
+  docker build -t app-test -f CustomDockerfile .
+  ```
+  In this case, `-f CustomDockerfile` tells Docker to use the custom-named Dockerfile.
+
+#### Explanation of the Build Command:
+- **`docker build`**: Command to build a Docker image.
+- **`-t <app-name>`**: Tags the image with a name (e.g., `app-test`). This is useful for referring to the image later.
+- **`<path-to-dockerfile>`**: Specifies the location of the `Dockerfile`. You can use `.` to refer to the current directory or provide an absolute path.
+
+---
+
+## Summary
+
+A Dockerfile simplifies the process of creating Docker images, allowing you to automate the creation of a consistent and reproducible environment for your applications. Here’s a quick recap of the process:
+
+1. **Create a Dockerfile**: Define the image using instructions like `FROM`, `RUN`, `COPY`, and `CMD`.
+2. **Build the Image**: Use the `docker build` command to turn the Dockerfile into a Docker image.
+3. **Run the Container**: After building the image, you can create and run a container using the `docker run` command.