149 lines
4.8 KiB
Markdown
Executable File
149 lines
4.8 KiB
Markdown
Executable File
## What is a Dockerfile?
|
||
|
||
A **Dockerfile** is a simple text file containing instructions to create a Docker image. Docker images provide a consistent and reproducible environment for running applications in containers. By defining dependencies, configurations, and the operating system, Dockerfiles automate the image creation process, ensuring version-controlled and portable environments.
|
||
|
||
### Key Concepts:
|
||
|
||
- **Base Image**: The foundational layer of your image, typically an official operating system like Ubuntu, CentOS, or Alpine Linux.
|
||
- **Instructions**: Commands such as `RUN`, `COPY`, and `CMD` define what’s installed, how the image behaves, and which files to include.
|
||
|
||
Common instructions include:
|
||
- **`RUN`**: Executes commands (e.g., installing software) inside the container.
|
||
- **`COPY`**: Copies files from your local machine to the image.
|
||
- **`CMD`**: Specifies the default command to run when the container starts.
|
||
|
||
---
|
||
|
||
## Step-by-Step Guide to Creating a Dockerfile
|
||
|
||
### 1. Create a File Named `Dockerfile`
|
||
|
||
Start by creating a file called `Dockerfile` in your project directory. If you name it something else, you'll need to specify the file name during the build process.
|
||
|
||
#### Example 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
|
||
```
|
||
|
||
#### Breakdown of Instructions:
|
||
|
||
- **`FROM ubuntu:22.04`**: Defines Ubuntu 22.04 as the base image.
|
||
- **`LABEL version="0.0.1"`**: Adds metadata, such as the version label.
|
||
- **`RUN`**: Runs commands inside the container. In this case, it updates package lists and installs `bash`, `vim`, `curl`, and `nginx`.
|
||
|
||
---
|
||
|
||
### 2. Example Using Alpine Linux
|
||
|
||
Alpine Linux is a lightweight option that results in smaller images. Here's an example of a Dockerfile using Alpine:
|
||
|
||
```dockerfile
|
||
# Use Alpine as the 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
|
||
```
|
||
|
||
This example is perfect for when you need a compact, minimalistic image.
|
||
|
||
---
|
||
|
||
### 3. Complex Dockerfile with a Script
|
||
|
||
In this example, you'll learn how to copy a script into the container, set a working directory, and make the script executable.
|
||
|
||
```dockerfile
|
||
# Start with Alpine as the base image
|
||
FROM alpine
|
||
|
||
# Add metadata
|
||
LABEL version="0.0.1"
|
||
|
||
# Update package lists and install essential tools
|
||
RUN apk update && apk add bash vim curl iputils-ping
|
||
|
||
# Copy the script into the image
|
||
COPY <local-file-path> <container-destination-path>
|
||
|
||
# Set the working directory for subsequent commands
|
||
WORKDIR <container-destination-path>
|
||
|
||
# Add environment variables
|
||
ENV API_KEY="123445"
|
||
|
||
# Set user and expose ports
|
||
USER deploy
|
||
EXPOSE 3210
|
||
|
||
# Give execution permissions to the script
|
||
RUN chmod +x app.sh
|
||
|
||
# Define the default command to run
|
||
CMD ["./app.sh"]
|
||
# Alternatively, you can use ENTRYPOINT
|
||
ENTRYPOINT ["bash", "./app.sh"]
|
||
```
|
||
|
||
#### Key Concepts in This Example:
|
||
- **`COPY`**: Copies a file from your local machine to the container.
|
||
- **`WORKDIR`**: Sets the working directory inside the container for subsequent commands.
|
||
- **`RUN chmod +x app.sh`**: Grants execution permissions to the `app.sh` script.
|
||
- **`CMD` vs. `ENTRYPOINT`**: `CMD` provides default behavior, while `ENTRYPOINT` is used when you want to ensure the container always runs a specific executable.
|
||
|
||
---
|
||
|
||
### 4. Build Your Docker Image
|
||
|
||
Once your `Dockerfile` is ready, build the Docker image using the `docker build` command.
|
||
|
||
```bash
|
||
docker build -t <app-name> <path-to-dockerfile>
|
||
```
|
||
|
||
#### Usage Examples:
|
||
|
||
- To build with a `Dockerfile` in the current directory:
|
||
```bash
|
||
docker build -t app-test .
|
||
```
|
||
Here, the `.` indicates the current directory as the build context.
|
||
|
||
- If your file is named something other than `Dockerfile` (e.g., `CustomDockerfile`):
|
||
```bash
|
||
docker build -t app-test -f <CustomDockerfile> .
|
||
```
|
||
- If you want build file without use cache
|
||
```bash
|
||
docker build -t app-test:v1 -f <Custom-Dir> . --no-cache
|
||
```
|
||
|
||
#### Explanation:
|
||
- **`docker build`**: Builds a Docker image.
|
||
- **`-t <app-name>`**: Tags the image with a name (e.g., `app-test`).
|
||
- **`<path-to-dockerfile>`**: Specifies the location of the `Dockerfile`. Use `.` for the current directory or provide an absolute path.
|
||
|
||
---
|
||
|
||
## Summary
|
||
|
||
A **Dockerfile** is a powerful tool for automating the creation of Docker images. Here’s a quick recap:
|
||
|
||
1. **Create a Dockerfile**: Use instructions like `FROM`, `RUN`, `COPY`, and `CMD` to define the image.
|
||
2. **Build the Image**: Run the `docker build` command to turn your Dockerfile into a Docker image.
|
||
3. **Run the Container**: Once the image is built, use `docker run` to create and run a container based on it.
|