Dockerfile模板笔记250801

以下是一系列精心设计的 Dockerfile 模板，涵盖不同场景需求。每个模板都遵循最佳实践，包含详细注释说明：

模板 1：基础 Python 应用（Flask/Django）

dockerfile 复制代码

# 第一阶段：构建
FROM python:3.11-slim AS builder

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=on

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc libpq-dev && \
    rm -rf /var/lib/apt/lists/*

# 创建工作目录
WORKDIR /app

# 安装Python依赖
COPY requirements.txt .
RUN pip install --user -r requirements.txt

# --------------------------------
# 第二阶段：运行
FROM python:3.11-slim

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser

# 设置工作目录
WORKDIR /app

# 从构建阶段复制依赖
COPY --from=builder /root/.local /home/appuser/.local
COPY . .

# 设置环境变量
ENV PATH="/home/appuser/.local/bin:${PATH}" \
    PORT=8000

# 设置文件权限
RUN chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE $PORT

# 启动命令
CMD ["gunicorn", "myapp.wsgi:application", "--bind", "0.0.0.0:$PORT"]

模板 2：Node.js 应用（React/Vue）

dockerfile 复制代码

# 第一阶段：构建
FROM node:18-alpine AS builder

WORKDIR /build

# 复制依赖文件并安装
COPY package*.json ./
RUN npm ci --silent

# 复制源码并构建
COPY . .
RUN npm run build

# --------------------------------
# 第二阶段：运行
FROM nginx:1.23-alpine

# 复制构建产物
COPY --from=builder /build/dist /usr/share/nginx/html

# 复制自定义nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# 启动命令已在基础镜像中定义

模板 3：Java Spring Boot 应用

dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6-openjdk-17 AS builder

WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline

COPY src ./src
RUN mvn package -DskipTests

# --------------------------------
# 运行阶段
FROM eclipse-temurin:17-jre-alpine

# 创建非特权用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR /app

# 复制构建产物
COPY --from=builder /build/target/*.jar ./app.jar

# 设置用户
USER appuser

# 暴露端口
EXPOSE 8080

# 启动命令
ENTRYPOINT ["java", "-jar", "app.jar"]

模板 4：多服务架构（Python + Node.js）

dockerfile 复制代码

# ===== Python 后端 =====
FROM python:3.11-slim AS backend

WORKDIR /backend
COPY backend/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY backend .

EXPOSE 5000
CMD ["python", "app.py"]

# ===== Node.js 前端 =====
FROM node:18-alpine AS frontend

WORKDIR /frontend
COPY frontend/package*.json .
RUN npm ci
COPY frontend .
RUN npm run build

# ===== Nginx 网关 =====
FROM nginx:alpine

# 复制前端构建产物
COPY --from=frontend /frontend/dist /usr/share/nginx/html

# 复制后端配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

模板 5：数据库初始化（PostgreSQL）

dockerfile 复制代码

FROM postgres:15-alpine

# 设置环境变量
ENV POSTGRES_USER=myuser \
    POSTGRES_PASSWORD=mypassword \
    POSTGRES_DB=mydb

# 复制初始化脚本
COPY init.sql /docker-entrypoint-initdb.d/
COPY seed-data.sh /docker-entrypoint-initdb.d/

# 设置脚本权限
RUN chmod a+r /docker-entrypoint-initdb.d/*

模板 6：通用开发环境

dockerfile 复制代码

FROM ubuntu:22.04

# 安装基础工具
RUN apt-get update && \
    apt-get install -y \
    git \
    curl \
    vim \
    build-essential \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

# 创建开发者用户
RUN useradd -ms /bin/bash developer
USER developer
WORKDIR /home/developer

# 安装Node版本管理
RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

# 设置环境变量
ENV PATH="/home/developer/.local/bin:${PATH}"

# 复制开发配置
COPY --chown=developer:developer .bashrc .bashrc
COPY --chown=developer:developer .vimrc .vimrc

CMD ["/bin/bash"]

关键最佳实践总结：

多阶段构建：分离构建环境和运行环境
非root用户：增强容器安全性

层缓存优化 ：

dockerfile 复制代码

# 正确顺序：
COPY package.json yarn.lock .
RUN npm install
COPY . .

轻量基础镜像 ：优先选择 -alpine 或 -slim 版本
清理缓存：在同一个RUN指令中清理临时文件
环境变量管理：使用ENV定义运行时配置

健康检查 ：

dockerfile 复制代码

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/health || exit 1

.dockerignore ：必须包含以排除无关文件
bash 复制代码
```
.git
node_modules
*.log
.env
Dockerfile
```

构建与运行示例：

bash 复制代码

# 构建镜像
docker build -t myapp:1.0 .

# 运行容器
docker run -d \
  -p 8000:8000 \
  --name myapp \
  -e "ENV_VAR=value" \
  -v ./data:/app/data \
  myapp:1.0

根据您的具体技术栈选择合适模板，并根据项目需求调整环境变量、端口和启动命令。多阶段构建特别适合生产环境，可显著减小镜像体积（通常减少50%-80%）。

1️⃣ 参考 1

下面是一个通用的 Dockerfile 模板，适用于大多数基于 Linux 的应用程序（如 Python、Node.js、Java 等），包含最佳实践和详细注释：

Dockerfile 复制代码

# 基础镜像（推荐使用官方镜像）
# 选择 Alpine 版本减小镜像体积（适合生产环境）
FROM python:3.11-alpine AS builder

# 设置环境变量（防止 Python 输出缓冲）
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1

# 设置工作目录
WORKDIR /app

# 安装系统依赖（Alpine 使用 apk）
RUN apk update && \
    apk add --no-cache gcc musl-dev postgresql-dev libffi-dev

# 先单独复制依赖文件，利用 Docker 缓存层加速构建
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

# ---- 生产阶段 ----
FROM python:3.11-alpine AS production

# 复制已安装的 Python 依赖
COPY --from=builder /root/.local /root/.local
ENV PATH=/root/.local/bin:$PATH

# 复制应用代码
COPY . .

# 创建非 root 用户（增强安全性）
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# 暴露端口（容器内部端口）
EXPOSE 8000

# 启动命令（根据实际应用调整）
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app.wsgi"]

关键优化说明

多阶段构建：
- builder 阶段安装编译依赖，减少最终镜像体积
- production 阶段仅复制运行时必需内容
安全实践：
- 使用非 root 用户 (appuser)
- Alpine 基础镜像（轻量且减少攻击面）
构建效率：
- 单独复制 requirements.txt 利用缓存
- 清理 APK 缓存 (--no-cache)

通用性调整点：

Python ：替换基础镜像如 python:3.11-slim（Debian 系）

Node.js ：

Dockerfile 复制代码

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
# 后续复制代码并构建

Java ：

Dockerfile 复制代码

FROM maven:3.8-openjdk-17 AS builder
COPY . .
RUN mvn package
FROM openjdk:17-jdk-slim
COPY --from=builder /app/target/app.jar .

常用基础镜像推荐

语言	基础镜像	适用场景
Python	`python:3.11-alpine`	生产环境
	`python:3.11-slim`	需要兼容性
Node.js	`node:20-alpine`	前端/轻量应用
	`node:20-slim`	通用后端
Java	`eclipse-temurin:17-jdk-alpine`	Spring Boot
Golang	`golang:1.20-alpine`	编译后直接二进制

扩展模板：带 Nginx 的反向代理

Dockerfile 复制代码

# 前端构建阶段
FROM node:20-alpine AS frontend
WORKDIR /frontend
COPY frontend/ .
RUN npm install && npm run build

# 后端构建阶段
FROM python:3.11-alpine AS backend
WORKDIR /backend
COPY backend/requirements.txt .
RUN pip install -r requirements.txt
COPY backend/ .

# 生产镜像
FROM nginx:alpine
# 复制前端静态文件
COPY --from=frontend /frontend/dist /usr/share/nginx/html
# 复制 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf
# 复制后端服务（需后台运行）
COPY --from=backend /backend /backend
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

💡 提示：根据实际需求调整：

替换 pip/npm/mvn 安装命令

修改 EXPOSE 端口和 CMD 启动命令

需要调试时添加 ENV DEBUG=true

挂载配置文件使用 VOLUME /config

通过这个模板，您可以快速构建高效、安全的 Docker 镜像。

2️⃣ 参考 2

下面提供多个 Dockerfile 实用模板，涵盖不同语言和场景，每个模板都遵循最佳实践并包含详细注释：

模板 1：通用 Python 应用（Flask/Django）

dockerfile 复制代码

# 阶段 1：构建依赖
FROM python:3.11-slim AS builder

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=off

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc build-essential && \
    rm -rf /var/lib/apt/lists/*

# 创建工作目录
WORKDIR /app

# 安装 Python 依赖
COPY requirements.txt .
RUN pip install --user --no-warn-script-location -r requirements.txt

# 阶段 2：运行环境
FROM python:3.11-slim

# 创建非 root 用户
RUN groupadd -r appuser && useradd -r -g appuser appuser

# 设置工作目录
WORKDIR /app

# 从构建阶段复制已安装的依赖
COPY --from=builder /root/.local /home/appuser/.local
ENV PATH="/home/appuser/.local/bin:${PATH}"

# 复制应用代码
COPY . .

# 设置文件权限
RUN chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE 8000

# 健康检查
HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost:8000/health || exit 1

# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "wsgi:app"]

模板 2：Node.js 应用（React/Vue/Express）

dockerfile 复制代码

# 阶段 1：构建应用
FROM node:18-alpine AS builder

WORKDIR /build

# 复制依赖文件
COPY package*.json ./

# 安装依赖
RUN npm ci --silent

# 复制源代码
COPY . .

# 构建应用
RUN npm run build

# 阶段 2：运行环境
FROM node:18-alpine

# 创建非 root 用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
WORKDIR /app

# 从构建阶段复制文件
COPY --from=builder --chown=appuser:appgroup /build/package*.json ./
COPY --from=builder --chown=appuser:appgroup /build/node_modules ./node_modules
COPY --from=builder --chown=appuser:appgroup /build/dist ./dist

# 设置用户
USER appuser

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["npm", "start"]

模板 3：Java Spring Boot 应用

dockerfile 复制代码

# 阶段 1：构建应用
FROM maven:3.8.6-eclipse-temurin-17 AS builder

WORKDIR /build

# 复制 POM 文件（利用缓存层）
COPY pom.xml .
RUN mvn dependency:go-offline

# 复制源代码并构建
COPY src ./src
RUN mvn package -DskipTests

# 阶段 2：运行环境
FROM eclipse-temurin:17-jre-alpine

# 创建工作目录
WORKDIR /app

# 从构建阶段复制 JAR 文件
COPY --from=builder /build/target/*.jar ./app.jar

# 创建非 root 用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
RUN chown appuser:appgroup /app
USER appuser

# 暴露端口
EXPOSE 8080

# 启动应用
ENTRYPOINT ["java", "-jar", "app.jar"]

模板 4：静态网站（Nginx）

dockerfile 复制代码

# 阶段 1：构建静态文件
FROM node:18-alpine AS builder

WORKDIR /build
COPY . .
RUN npm install && npm run build

# 阶段 2：运行环境
FROM nginx:1.25-alpine

# 复制构建的静态文件
COPY --from=builder /build/dist /usr/share/nginx/html

# 复制自定义 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# 启动命令在基础镜像中已包含

模板 5：Go 应用

dockerfile 复制代码

# 阶段 1：构建二进制
FROM golang:1.21-alpine AS builder

WORKDIR /build

# 下载依赖
COPY go.mod go.sum ./
RUN go mod download

# 复制源代码
COPY . .

# 构建静态链接的二进制文件
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .

# 阶段 2：最小化运行环境
FROM alpine:latest

# 安装 CA 证书（用于 HTTPS 请求）
RUN apk --no-cache add ca-certificates

WORKDIR /root/

# 从构建阶段复制二进制文件
COPY --from=builder /build/app .

# 暴露端口
EXPOSE 8080

# 启动命令
CMD ["./app"]

模板 6：数据库（PostgreSQL + 初始化）

dockerfile 复制代码

FROM postgres:15-alpine

# 设置环境变量
ENV POSTGRES_USER=appuser \
    POSTGRES_PASSWORD=securepassword \
    POSTGRES_DB=mydb

# 复制初始化脚本
COPY init.sql /docker-entrypoint-initdb.d/
COPY init-data.sh /docker-entrypoint-initdb.d/

# 设置权限
RUN chmod a+r /docker-entrypoint-initdb.d/*

# 健康检查
HEALTHCHECK --interval=30s --timeout=5s \
  CMD pg_isready -U $POSTGRES_USER -d $POSTGRES_DB

模板 7：多服务容器（PHP + Nginx）

dockerfile 复制代码

# 阶段 1：PHP 构建
FROM composer:2 AS php-builder

WORKDIR /app

# 安装 PHP 依赖
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

# 阶段 2：PHP-FPM 运行环境
FROM php:8.2-fpm-alpine

# 安装 PHP 扩展
RUN docker-php-ext-install pdo_mysql opcache

# 复制依赖
COPY --from=php-builder /app/vendor ./vendor
COPY . .

# 阶段 3：Nginx
FROM nginx:1.25-alpine

# 复制 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 复制 PHP 文件
COPY --from=php-builder /app /var/www/html

# 暴露端口
EXPOSE 80

通用优化技巧：

多阶段构建：分离构建环境和运行环境
非 root 用户：增强安全性
依赖缓存：先复制依赖文件再复制代码

镜像最小化：

dockerfile 复制代码

# 清理缓存
RUN rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

# 删除开发依赖
RUN npm prune --production

健康检查：确保容器正常运行

dockerfile 复制代码

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

时区设置：

dockerfile 复制代码

ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime

使用 .dockerignore：

gitignore 复制代码

.git
.dockerignore
Dockerfile
node_modules
*.log
*.md

根据您的具体需求选择合适的模板，并调整以下部分：

基础镜像版本
暴露端口
启动命令
环境变量
文件复制路径
健康检查端点

这些模板都遵循安全性和性能最佳实践，可直接用于生产环境或作为开发起点。

3️⃣ 参考 3

以下是一些针对不同场景的Dockerfile 模板，遵循最佳实践并包含详细注释：

模板 1：Python Web 应用（Flask/Django）

dockerfile 复制代码

# 使用官方 Python 轻量镜像
FROM python:3.11-slim

# 设置环境变量（防止 Python 输出缓冲）
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1

# 创建工作目录并设为工作路径
WORKDIR /app

# 先单独复制依赖文件（利用 Docker 缓存层）
COPY requirements.txt .

# 安装依赖（清理缓存减小镜像体积）
RUN pip install --no-cache-dir -r requirements.txt && \
    rm -rf /tmp/*

# 复制应用代码
COPY . .

# 创建非 root 用户（提升安全性）
RUN useradd -m appuser && chown -R appuser /app
USER appuser

# 暴露端口
EXPOSE 8000

# 启动命令（根据实际框架调整）
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myapp.wsgi:application"]

模板 2：Node.js 应用（React/Vue/Express）

dockerfile 复制代码

# 阶段 1：构建环境
FROM node:18-alpine AS builder
WORKDIR /build
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 阶段 2：生产环境
FROM node:18-alpine
WORKDIR /app

# 仅复制构建产物和运行时依赖
COPY --from=builder /build/package*.json ./
COPY --from=builder /build/dist ./dist
COPY --from=builder /build/node_modules ./node_modules

# 设置非 root 用户
RUN adduser -D appuser && chown -R appuser /app
USER appuser

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["node", "dist/server.js"]

模板 3：Java Spring Boot 应用

dockerfile 复制代码

# 阶段 1：构建 JAR 包
FROM maven:3.8-eclipse-temurin-17 AS builder
WORKDIR /build
COPY pom.xml .
# 先下载依赖（利用缓存层）
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

# 阶段 2：运行环境
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app

# 复制 JAR 文件
COPY --from=builder /build/target/*.jar app.jar

# 设置时区和健康检查
RUN apk add --no-cache tzdata && \
    cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
HEALTHCHECK --interval=30s CMD curl -f http://localhost:8080/actuator/health || exit 1

# 非 root 用户运行
RUN adduser -D appuser
USER appuser

EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

模板 4：静态网站（Nginx）

dockerfile 复制代码

# 构建阶段
FROM node:18-alpine AS builder
WORKDIR /build
COPY . .
RUN npm install && npm run build

# 生产阶段
FROM nginx:1.25-alpine

# 复制构建产物
COPY --from=builder /build/dist /usr/share/nginx/html

# 使用自定义 Nginx 配置（需提前准备 nginx.conf）
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# Nginx 基础镜像已包含启动命令，无需额外指定

模板 5：通用型多服务模板（适合复杂应用）

dockerfile 复制代码

# 使用特定版本基础镜像
FROM ubuntu:22.04

# 设置元数据
LABEL maintainer="your-email@example.com"
LABEL version="1.0"

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y \
        curl \
        python3-pip \
        # 其他依赖...
    && rm -rf /var/lib/apt/lists/*

# 设置工作目录
WORKDIR /app

# 复制必要文件
COPY requirements.txt .
COPY scripts/ ./scripts/

# 安装 Python 依赖
RUN pip3 install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 设置启动脚本权限
RUN chmod +x ./scripts/start.sh

# 数据卷声明
VOLUME ["/data"]

# 暴露多个端口
EXPOSE 8000 9000

# 健康检查
HEALTHCHECK --interval=30s --timeout=5s \
    CMD curl -f http://localhost:8000/health || exit 1

# 入口脚本
ENTRYPOINT ["./scripts/start.sh"]

关键优化技巧：

多阶段构建：分离构建环境和运行环境（模板 2,3,4）
依赖缓存 ：先复制 package.json/pom.xml 再安装依赖
非 root 用户：所有模板均添加普通用户运行
镜像精简 ：
- 使用 Alpine 或 Slim 基础镜像
- 删除缓存文件（apt-get clean, rm -rf /var/lib/apt/lists/*）
健康检查：模板 3 和 5 包含健康检查机制
时区设置：模板 3 展示时区配置方法

.dockerignore 文件示例（必须配合使用）

bash 复制代码

# 忽略这些文件/目录
.git
.gitignore
Dockerfile
.dockerignore
node_modules
*.log
.env
dist

提示：根据实际技术栈选择模板，重点关注 多阶段构建 和 非 root 用户 等安全实践。

4️⃣ 参考 4

以下是一些常用的 Dockerfile 模板，适用于不同场景，包含优化技巧和最佳实践：

1. 基础 Python 应用

Dockerfile 复制代码

# 使用官方轻量级 Python 镜像
FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 安装系统依赖（可选）
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件并安装
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 设置环境变量
ENV PYTHONUNBUFFERED=1

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000"]

2. Node.js 应用

Dockerfile 复制代码

# 构建阶段
FROM node:18-alpine AS builder
WORKDIR /build
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 生产阶段
FROM node:18-alpine
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /build/package*.json ./
COPY --from=builder /build/dist ./dist
RUN npm ci --only=production

# 清理缓存
RUN npm cache clean --force

EXPOSE 3000
CMD ["node", "dist/index.js"]

3. Java Spring Boot

Dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn -B package -DskipTests

# 运行阶段
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
CMD ["java", "-jar", "app.jar"]

4. 静态网站 (Nginx)

Dockerfile 复制代码

# 构建阶段
FROM node:18-alpine AS builder
WORKDIR /app
COPY . .
RUN npm install && npm run build

# 生产阶段
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

5. 多阶段构建 Go 应用

Dockerfile 复制代码

# 构建阶段
FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o app

# 最小化运行时
FROM scratch
WORKDIR /
COPY --from=builder /app/app /app
COPY --from=alpine:latest /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
EXPOSE 8080
CMD ["/app"]

关键优化技巧：

多阶段构建：减少最终镜像大小（如 Java/Node.js 示例）
使用轻量级基础镜像 ：-alpine、-slim 版本
依赖缓存优化 ：先复制依赖文件（package.json/requirements.txt），再复制代码
清理缓存 ：apt-get/npm cache clean/rm -rf /var/lib/apt/lists/*
非 root 用户运行 （增强安全）：
Dockerfile 复制代码
```
RUN adduser -D myuser
USER myuser
```

健康检查 ：

Dockerfile 复制代码

HEALTHCHECK --interval=30s --timeout=3s \
CMD curl -f http://localhost:8080/health || exit 1

通用最佳实践：

使用 .dockerignore 排除无关文件
指定精确的镜像版本（避免 latest）
每个容器只运行一个进程
环境变量管理敏感数据（配合 Docker Secrets 或 K8s ConfigMap）
镜像扫描：docker scan <image>

根据需要选择模板并调整参数（如端口/路径/命令）。

5️⃣ 参考 5

Dockerfile 通用模板（多语言支持）

dockerfile 复制代码

# ----------------------
# 基础镜像阶段（可替换为其他语言环境）
# ----------------------
# 开发阶段：使用完整环境进行构建
FROM golang:1.21 AS builder

# 设置工作目录
WORKDIR /app

# 复制依赖文件并下载依赖
COPY go.mod ./
COPY go.sum ./
RUN go mod download

# 复制源代码并构建
COPY . .
RUN CGO_ENABLED=0 go build -o /myapp

# ----------------------
# 生产阶段：使用轻量级镜像
# ----------------------
FROM alpine:latest

# 安装运行时依赖
RUN apk --no-cache add ca-certificates

# 从构建阶段复制二进制文件
COPY --from=builder /myapp /myapp

# 创建非特权用户
RUN adduser -D appuser
USER appuser

# 暴露端口（根据实际调整）
EXPOSE 8080

# 健康检查配置
HEALTHCHECK --interval=30s --timeout=5s \
  CMD wget --spider http://localhost:8080/health || exit 1

# 启动命令（ENTRYPOINT + CMD 组合使用）
ENTRYPOINT ["/myapp"]
CMD ["--config", "/etc/myapp/config.yaml"]

# 添加元数据标签
LABEL maintainer="team@example.com"
LABEL version="1.0.0"
LABEL description="My Application Docker Image"

不同语言环境适配示例

Python 项目模板

dockerfile 复制代码

# 开发阶段
FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt
COPY . .

# 生产阶段
FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
USER 1001:1001
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]

Node.js 项目模板

dockerfile 复制代码

# 开发阶段
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 生产阶段
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
USER node
CMD ["node", "dist/index.js"]

Java 项目模板

dockerfile 复制代码

# 开发阶段
FROM maven:3.9-eclipse-temurin AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn package -DskipTests

# 生产阶段
FROM eclipse-temurin:21-jre
WORKDIR /app
COPY --from=builder /app/target/*.jar /app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]

模板使用说明

基础配置调整：
- 替换 EXPOSE 端口为实际应用端口
- 修改 LABEL 中的维护者和版本信息
- 根据需要调整健康检查端点（/health）
安全增强：
- 始终使用非root用户运行（USER appuser）
- 定期更新基础镜像版本
- 使用 --no-cache 和 --virtual 减少依赖
多阶段构建优势：
- 分离开发依赖与生产依赖
- 减小最终镜像体积（生产镜像通常 <100MB）
- 避免编译工具泄露到生产环境

推荐搭配文件：

plaintext 复制代码

.dockerignore
├── .git
├── .github
├── *.log
└── env

构建命令示例

bash 复制代码

# 构建开发镜像（保留调试工具）
docker build -t myapp:dev --target builder .

# 构建生产镜像
docker build -t myapp:latest .

# 带参数构建（传递配置文件路径）
docker build -t myapp:custom --build-arg CONFIG_PATH=/etc/myapp .

该模板遵循以下原则：

最小化镜像层数（合并相关操作）
分离构建上下文与运行时环境
默认启用安全增强措施
支持跨平台构建（通过 --platform 参数）
保持与云原生生态的兼容性（Kubernetes/OpenShift）

6️⃣ 参考 6

以下是常见的 Dockerfile 模板，适用于不同编程语言和框架的项目。这些模板结合了最佳实践（如多阶段构建、清理缓存、使用轻量基础镜像等），帮助你快速构建高效、安全的 Docker 镜像。

1. Python 项目模板

dockerfile 复制代码

# 使用官方 Python 镜像作为基础
FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 安装依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 设置时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# 启动命令
CMD ["python", "app.py"]

2. Node.js 项目模板

dockerfile 复制代码

# 使用官方 Node.js 镜像
FROM node:20-alpine

# 设置工作目录
WORKDIR /app

# 安装依赖
COPY package*.json ./
RUN npm install --production

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["npm", "start"]

3. Java/Spring Boot 项目模板

dockerfile 复制代码

# 使用官方 OpenJDK 镜像
FROM openjdk:17-jdk-alpine

# 设置工作目录
WORKDIR /app

# 复制可执行 JAR 文件
COPY target/myapp.jar app.jar

# 设置环境变量
ENV JAVA_OPTS=""

# 启动命令
ENTRYPOINT ["java", "-jar", "app.jar"]

4. Go 项目模板（多阶段构建）

dockerfile 复制代码

# 第一阶段：构建阶段
FROM golang:1.23 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o myapp

# 第二阶段：运行阶段（使用轻量镜像）
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
CMD ["./myapp"]

5. .NET Core 项目模板

dockerfile 复制代码

# 使用官方 .NET SDK 镜像
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app
COPY *.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o out

# 使用轻量运行时镜像
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app/out .
ENTRYPOINT ["dotnet", "MyApp.dll"]

6. Rust 项目模板（多阶段构建）

dockerfile 复制代码

# 第一阶段：构建阶段
FROM rust:1.70 AS builder
WORKDIR /app
COPY . .
RUN cargo build --release

# 第二阶段：运行阶段
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/target/release/myapp .
CMD ["./myapp"]

7. React 项目模板（Node.js + Nginx）

dockerfile 复制代码

# 构建阶段：使用 Node.js 镜像构建 React 应用
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# 运行阶段：使用 Nginx 镜像部署静态文件
FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

8. MySQL 数据库模板

dockerfile 复制代码

# 使用官方 MySQL 镜像
FROM mysql:8.0

# 设置环境变量
ENV MYSQL_ROOT_PASSWORD=my-secret-pw \
    MYSQL_DATABASE=mydb \
    MYSQL_USER=myuser \
    MYSQL_PASSWORD=mypassword

# 初始化 SQL 脚本
COPY init.sql /docker-entrypoint-initdb.d/

9. Redis 服务模板

dockerfile 复制代码

# 使用官方 Redis 镜像
FROM redis:7.0

# 挂载自定义配置文件
COPY redis.conf /usr/local/etc/redis/redis.conf
CMD ["redis-server", "/usr/local/etc/redis/redis.conf"]

10. 多语言项目模板（使用 BuildKit 增强语法）

dockerfile 复制代码

# syntax=docker/dockerfile:1.7.0
FROM golang:1.23 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o myapp

FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /app/myapp .
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
CMD ["./myapp"]

关键指令说明

FROM ：指定基础镜像（如 python:3.11-slim）。
WORKDIR：设置工作目录，避免绝对路径。
COPY ：复制文件到镜像中（优先使用 COPY 而非 ADD）。
RUN：执行命令（合并命令减少镜像层数）。
CMD/ENTRYPOINT ：定义容器启动命令（ENTRYPOINT 用于固定入口，CMD 提供默认参数）。
EXPOSE ：声明端口（如 EXPOSE 80）。
ENV：设置环境变量（如时区、JVM 参数）。
ARG：构建时变量（如版本号）。
LABEL：添加元数据（如作者、版本）。
VOLUME ：声明数据卷（如 /data）。

最佳实践建议

使用多阶段构建：减少最终镜像体积（如 Go、Rust 项目）。
清理缓存 ：避免残留文件（如 --no-cache-dir）。
固定基础镜像版本 ：避免 latest 标签的不确定性。
使用 .dockerignore ：排除无关文件（如 .git、node_modules）。
最小化镜像 ：使用轻量基础镜像（如 alpine）。
健康检查 ：添加 HEALTHCHECK 确保容器可用性。
非 root 用户运行 ：提升安全性（USER 指令）。

构建与运行命令

bash 复制代码

# 构建镜像
docker build -t my-image:tag .

# 运行容器
docker run -d -p host-port:container-port my-image:tag

更多模板资源

dockerfile-boilerplates：覆盖 Ada、Bash、C++、Java、Python 等 50+ 语言的 Dockerfile 模板。
Docker Hub 官方镜像：查找特定语言/框架的官方镜像作为基础。

如果需要针对特定项目调整模板，请提供更多细节（如语言、依赖项、运行方式），我可以进一步优化 Dockerfile！

7️⃣ 参考 7

以下是几个常用场景的 Dockerfile 模板，涵盖了不同开发环境和应用类型，可根据实际需求进行调整：

1. Python 应用模板 适用于 Flask、Django 等 Python 应用

dockerfile 复制代码

# 基础镜像选择
FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1  # 不生成 .pyc 文件
ENV PYTHONUNBUFFERED=1          # 实时输出日志

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    && rm -rf /var/lib/apt/lists/*  # 清理缓存

# 复制依赖文件并安装
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 创建非root用户并切换
RUN useradd -m appuser
USER appuser

# 暴露端口
EXPOSE 5000

# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

2. Node.js 应用模板 适用于 Express、React 等 Node.js 应用

dockerfile 复制代码

# 构建阶段
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build  # 假设是前端应用需要构建

# 生产阶段（多阶段构建减小镜像体积）
FROM node:18-alpine
WORKDIR /app

# 复制构建产物和依赖文件
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules

# 非root用户运行
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 3000

CMD ["node", "dist/server.js"]

3. Java 应用模板 适用于 Spring Boot 等 Java 应用

dockerfile 复制代码

# 构建阶段
FROM maven:3.8-openjdk-17 AS builder
WORKDIR /app
COPY pom.xml .
# 下载依赖（利用缓存）
RUN mvn dependency:go-offline
COPY src ./src
# 构建应用
RUN mvn package -DskipTests

# 运行阶段
FROM openjdk:17-jdk-slim
WORKDIR /app

# 复制jar包
COPY --from=builder /app/target/*.jar app.jar

# 非root用户
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
USER appuser

EXPOSE 8080

# 启动命令（使用exec格式确保信号能传递给应用）
CMD ["java", "-jar", "app.jar"]

4. 静态网站模板（Nginx） 适用于 HTML、CSS、JS 等静态资源

dockerfile 复制代码

# 构建阶段（可选，用于前端打包）
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 运行阶段
FROM nginx:alpine
# 复制自定义nginx配置（可选）
COPY nginx.conf /etc/nginx/conf.d/default.conf
# 复制构建产物到nginx默认目录
COPY --from=builder /app/build /usr/share/nginx/html

# 暴露端口
EXPOSE 80

# nginx默认启动命令已包含在基础镜像中

5. 通用 Alpine 精简模板 适用于需要极小镜像体积的场景

dockerfile 复制代码

FROM alpine:3.18

# 更新并安装必要工具
RUN apk update && apk add --no-cache \
    bash \
    curl \
    && rm -rf /var/cache/apk/*  # 清理缓存

# 设置工作目录
WORKDIR /app

# 复制应用文件
COPY . .

# 非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# 启动命令
CMD ["./app.sh"]

使用说明：

选择与应用匹配的模板，删除不需要的指令
根据实际需求调整端口、依赖和启动命令
创建 .dockerignore 文件排除不必要的文件（如 .git、node_modules）
构建命令：docker build -t 镜像名:版本 .

这些模板遵循了 Docker 最佳实践，包括多阶段构建、非 root 用户运行、清理缓存等，可有效减小镜像体积并提高安全性。

8️⃣ 参考 8

以下是一份「开箱即用」的 Dockerfile 模板合集，涵盖主流语言/框架，可直接复制到你的项目中稍作调整即可使用。

✅ 通用模板结构说明（所有模板均遵循以下规范）

多阶段构建：减少最终镜像体积
非 root 运行：提升安全性
缓存友好：依赖与代码分离，加速构建
固定版本：基础镜像使用明确 tag，避免 latest 陷阱

1️⃣ Java（Spring Boot）

dockerfile 复制代码

# syntax=docker/dockerfile:1
FROM eclipse-temurin:17-jdk-alpine AS build
WORKDIR /workspace
COPY mvnw .
COPY .mvn .mvn
COPY pom.xml .
RUN ./mvnw -q dependency:go-offline
COPY src src
RUN ./mvnw -q package -DskipTests

FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=build /workspace/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app/app.jar"]

适合 Maven 项目，Gradle 只需把 mvnw 换成 gradlew。

2️⃣ Node.js（Express / NestJS）

dockerfile 复制代码

FROM node:20-alpine AS base
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm ci --omit=dev

FROM node:20-alpine AS build
WORKDIR /usr/src/app
COPY . .
RUN npm ci && npm run build

FROM base AS runtime
COPY --from=build /usr/src/app/dist ./dist
COPY --from=base /usr/src/app/node_modules ./node_modules
EXPOSE 3000
CMD ["node","dist/main"]

若前端静态文件，可将 dist 换成 public 目录。

3️⃣ Python（Flask / Django）

dockerfile 复制代码

FROM python:3.11-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

FROM base AS runtime
COPY . .
EXPOSE 5000
CMD ["gunicorn","app:app","-b","0.0.0.0:5000"]

使用 gunicorn 作为 WSGI；Django 把 app:app 换成 project.wsgi:application。

4️⃣ Go（自包含二进制）

dockerfile 复制代码

FROM golang:1.22-alpine AS builder
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o app .

FROM scratch
COPY --from=builder /src/app /app
EXPOSE 8080
ENTRYPOINT ["/app"]

scratch 镜像体积 <10 MB，适合静态编译。

5️⃣ .NET 8（ASP.NET Core）

dockerfile 复制代码

FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine AS base
WORKDIR /app
EXPOSE 8080

FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
WORKDIR /src
COPY *.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app

FROM base AS final
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet","MyApp.dll"]

如需 Windows 容器，把 alpine 换成 nanoserver-ltsc2022。

6️⃣ Nginx（静态前端）

dockerfile 复制代码

FROM nginx:alpine
LABEL maintainer="ops@example.com"
COPY dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx","-g","daemon off;"]

dist 为前端构建产物；nginx.conf 可自定义路由、压缩、缓存。

🚀 一键构建 & 运行命令

bash 复制代码

# 构建
docker build -t myapp:1.0 .

# 运行
docker run -d -p 8080:8080 --name myapp myapp:1.0

📦 附：IDEA 快速生成模板 在 IntelliJ IDEA 中：

安装 Docker 插件
右键项目 → New → Dockerfile
选择对应语言模板即可自动生成

如需更多企业级示例（含阿里云 EDAS、HSF、Dubbo 等），可参考官方开源项目：
alibabacloud-edas-dockerfile-demo

9️⃣ 参考 9

Dockerfile模板介绍与示例 Dockerfile 是一个文本文件，包含一系列指令，用于自动化构建 Docker 镜像。它定义了容器环境的基础镜像、依赖安装、文件复制和启动命令等。Dockerfile 模板可以帮助您快速上手，尤其对于 Java、SpringBoot 等常见应用场景。以下基于可靠参考来源，提供几个常用 Dockerfile 模板示例，并解释关键部分。您可以直接复制这些模板并根据项目需求修改，无需专门下载文件。

1. 通用 Dockerfile 模板 这是一个基础模板，适用于大多数简单应用（如 Python 或 Node.js）。它创建目录、复制文件并设置工作目录：

dockerfile 复制代码

# 基础镜像（例如 Ubuntu）
FROM ubuntu:latest

# 设置工作目录
WORKDIR /app

# 创建所需目录（例如 /dir1 和 /dir2）
RUN mkdir -p /dir1 /dir2

# 复制应用文件到容器（示例复制多个文件）
COPY file1.txt /dir1/
COPY file2.txt /dir2/
# 更多文件复制示例...

关键指令说明 ：
- FROM: 指定基础镜像（如 ubuntu:latest 或 alpine）。
- WORKDIR: 设置容器内的工作路径。
- COPY: 将宿主机文件复制到容器中。
- RUN: 执行命令（如创建目录）。
此模板适合初学者测试，您可以根据需要添加更多指令（如 EXPOSE 暴露端口）。

2. Java 应用程序 Dockerfile 模板 针对 Java 应用，此模板基于 OpenJDK 镜像，优化了构建流程：

dockerfile 复制代码

# 使用 OpenJDK 基础镜像
FROM openjdk:8-jdk-alpine

# 设置元数据（维护者信息）
LABEL maintainer="your-email@example.com"

# 创建应用用户和组（避免以 root 运行）
ARG user=app
ARG group=app
RUN addgroup -S $group && adduser -S $user -G $group
USER $user

# 设置工作目录
WORKDIR /app

# 复制 JAR 文件到容器
COPY target/your-app.jar /app/app.jar

# 暴露端口（默认 8080）
EXPOSE 8080

# 启动命令
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

优势：使用轻量级 alpine 镜像减少大小，通过非 root 用户提升安全性。适合 Spring Boot 或普通 Java 应用。

3. SpringBoot 项目 Dockerfile 模板 专为 SpringBoot 优化，支持环境变量和时区设置：

dockerfile 复制代码

# 基础镜像（自定义 OpenJDK）
FROM harbor.example.com/public/openjdk8:jdk8u282-b08-centos

# 设置时区
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' > /etc/timezone

# 创建应用用户
ARG user=app
ARG group=app
RUN groupadd -g 68080 $group && useradd -u 68080 -g $group -m -s /bin/bash $user
USER $user

# 设置工作目录和环境变量
ENV APP_HOME /app
WORKDIR $APP_HOME/lib

# 复制 JAR 文件
COPY target/hello-springboot.jar $APP_HOME/lib/

# 暴露端口（可自定义）
EXPOSE 8088

# 启动命令（支持 JVM 参数）
ENTRYPOINT java -jar $JAVA_OPTS -Dfile.encoding=UTF-8 hello-springboot.jar

关键特性 ：
- 时区配置确保日志时间正确。
- 使用 ARG 和 ENV 支持动态端口（如 EXPOSE $PORT）。
- 通过 JAVA_OPTS 允许运行时调整 JVM 参数。

如何获取更多模板

直接使用示例 ：复制上述模板到本地文件（命名为 Dockerfile），然后运行 docker build -t your-image-name . 构建镜像。
在线资源 ：
- Docker 官方文档 ：提供标准模板库。
- GitHub ：搜索 Dockerfile template，例如 Docker 官方示例仓库。
- Docker Hub ：许多镜像页面（如 OpenJDK）包含示例 Dockerfile。
最佳实践提示 ：
- 始终使用特定版本的基础镜像（如 openjdk:11 而非 latest），避免不兼容问题。
- 添加 .dockerignore 文件排除不必要的文件（如日志或临时文件），减小镜像大小。
- 多阶段构建（multi-stage builds）可进一步优化生产镜像。

🔟 参考 10

以下是 Dockerfile 模板的整理与解析，结合最佳实践和实际场景需求：

一、基础通用模板

dockerfile 复制代码

# 基础镜像（根据需求选择）
FROM ubuntu:20.04  # 或 alpine:latest、python:3.9-slim 等

# 维护者信息（推荐使用 LABEL 替代已弃用的 MAINTAINER）
LABEL maintainer="your_email@example.com"

# 设置工作目录
WORKDIR /app

# 复制依赖文件并安装（以 Python 为例）
COPY requirements.txt .
RUN apt-get update && \
    apt-get install -y python3-pip && \
    pip install --no-cache-dir -r requirements.txt && \
    rm -rf /var/lib/apt/lists/*

# 复制应用代码
COPY . .

# 暴露端口（声明容器监听的端口）
EXPOSE 8080

# 定义启动命令
CMD ["python3", "app.py"]

特点：

适用于大多数语言（如 Python、Node.js）
分离依赖安装与代码复制，利用缓存加速构建
清理临时文件减少镜像体积

二、按语言分类的模板示例 1. Python 模板

dockerfile 复制代码

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

关键点：

使用轻量级基础镜像（如 python:3.9-slim）
通过 gunicorn 启动生产级服务

2. Go 模板

dockerfile 复制代码

FROM golang:1.20 AS builder
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /app/myapp

FROM alpine:latest
COPY --from=builder /app/myapp /app/myapp
CMD ["/app/myapp"]

关键点：

多阶段构建减少最终镜像体积
编译时禁用 CGO 以兼容 Alpine 环境

3. Node.js 模板

dockerfile 复制代码

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

关键点：

使用 npm ci 严格安装依赖（比 npm install 更安全）
指定生产依赖安装模式

三、多阶段构建模板（通用型）

dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6 AS builder
WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src/ ./src/
RUN mvn package -DskipTests

# 运行阶段
FROM openjdk:17-jdk-slim
COPY --from=builder /build/target/*.jar /app.jar
EXPOSE 8080
CMD ["java", "-jar", "/app.jar"]

优势：

分离编译环境与运行环境，减小镜像体积
缓存依赖层提升构建效率

四、最佳实践模板设计

参数化配置

使用 ARG 和 --build-arg 动态传递变量：
dockerfile 复制代码
```
ARG APP_ENV=production
ENV NODE_ENV=$APP_ENV
```
安全加固
- 非 Root 用户运行：
  dockerfile 复制代码
```
RUN useradd -m appuser && chown -R appuser /app
USER appuser
```
- 扫描漏洞镜像：
  bash 复制代码
```
docker scan
```

缓存优化

合并相关指令减少层数：

dockerfile 复制代码

RUN apt-get update && \
    apt-get install -y \
        curl \
        git \
    && rm -rf /var/lib/apt/lists/*

五、模板扩展建议

.dockerignore 文件
排除无关文件（如 .git、__pycache__），加速构建。
Docker Compose 集成
结合 docker-compose.yml 定义多容器服务。

通过模板化 Dockerfile，可显著提升构建效率和镜像可维护性。根据实际需求选择基础镜像、优化构建阶段，并遵循安全规范。

🤔 参考 11

以下是适用于不同场景的 Dockerfile 标准模板，已附带详细注释说明和最佳实践👇

模板 1：通用后端服务（Python/Node.js/Go等）

dockerfile 复制代码

# -------------------- 第一阶段：构建环境 --------------------
# 使用带有构建工具的官方基础镜像
FROM python:3.10-slim AS builder

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc python3-dev && \
    rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

# 安装Python依赖到虚拟环境
RUN python -m venv /opt/venv && \
    /opt/venv/bin/pip install --no-cache-dir -r requirements.txt


# -------------------- 第二阶段：生产环境 --------------------
FROM python:3.10-slim

# 设置元数据
LABEL maintainer="your.email@example.com"
LABEL version="1.0"

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser

# 设置工作目录
WORKDIR /app

# 从构建阶段复制依赖
COPY --from=builder /opt/venv /opt/venv

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 设置环境变量
ENV PYTHONUNBUFFERED=1
ENV PATH="/opt/venv/bin:$PATH"

# 切换用户
USER appuser

# 健康检查
HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl --fail http://localhost:8000/health || exit 1

# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:app"]

模板 2：前端应用（React/Vue等）

dockerfile 复制代码

# -------------------- 构建阶段 --------------------
FROM node:18-alpine AS builder

WORKDIR /app

# 优先复制依赖文件（利用Docker缓存层）
COPY package*.json ./
RUN npm ci --silent

# 复制源代码
COPY . .

# 构建生产环境代码
RUN npm run build


# -------------------- 生产阶段 --------------------
FROM nginx:1.25-alpine

# 复制构建产物
COPY --from=builder /app/dist /usr/share/nginx/html

# 复制自定义Nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 设置权限
RUN chmod -R 755 /usr/share/nginx/html

# 暴露端口
EXPOSE 80

# 启动命令
CMD ["nginx", "-g", "daemon off;"]

模板 3：数据库服务（MySQL/PostgreSQL）

dockerfile 复制代码

FROM mysql:8.0

# 设置时区
ENV TZ=Asia/Shanghai

# 初始化数据库配置
COPY my.cnf /etc/mysql/conf.d/
COPY init.sql /docker-entrypoint-initdb.d/

# 设置卷
VOLUME /var/lib/mysql

# 暴露端口
EXPOSE 3306

# 设置环境变量（密码等敏感信息应通过docker run -e传入）
ENV MYSQL_ROOT_PASSWORD=your_secure_password
ENV MYSQL_DATABASE=app_db
ENV MYSQL_USER=app_user
ENV MYSQL_PASSWORD=user_password

模板 4：Java Spring Boot 应用

dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6-eclipse-temurin-17 AS builder

WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline

COPY src ./src
RUN mvn package -DskipTests


# 生产阶段
FROM eclipse-temurin:17-jre-alpine

WORKDIR /app

# 复制构建产物
COPY --from=builder /app/target/*.jar app.jar

# 非root用户运行
RUN addgroup -S spring && adduser -S spring -G spring
USER spring

# JVM参数
ENV JAVA_OPTS="-Xmx512m -Xms256m -XX:+UseG1GC"

EXPOSE 8080

# 健康检查
HEALTHCHECK --interval=30s --retries=3 \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar /app/app.jar"]

模板 5：Go 应用

dockerfile 复制代码

# 构建阶段
FROM golang:1.21-alpine AS builder

WORKDIR /app

# 启用Go模块
ENV GOPROXY=https://goproxy.cn,direct

COPY go.mod go.sum ./
RUN go mod download

COPY . .

# 构建静态链接的可执行文件
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .

# 生产阶段
FROM alpine:3.18

WORKDIR /root/

# 安装证书（用于HTTPS请求）
RUN apk --no-cache add ca-certificates

# 复制可执行文件
COPY --from=builder /app/app .

EXPOSE 8080

ENTRYPOINT ["./app"]

关键要点说明

多阶段构建：通过分离构建环境和生产环境，最小化最终镜像体积
非root用户：提升容器运行安全性
层优化 ：
- 将频繁变化的操作（如复制代码）放在Dockerfile尾部
- 合并多个RUN指令减少镜像层数
缓存利用：优先复制依赖文件（如package.json/pom.xml）单独处理
环境配置 ：
- 使用.dockerignore文件排除无关文件
- 敏感信息通过环境变量（-e）传入，不写死在Dockerfile中
健康检查：确保容器运行状态可监控

构建 & 运行命令

bash 复制代码

# 构建镜像
docker build -t your-image-name:tag .

# 运行容器
docker run -d \
  -p 8080:8080 \
  -e ENV_VARIABLE=value \
  --name your-container-name \
  your-image-name:tag

根据实际项目需求选择对应模板，调整关键参数即可快速创建生产级镜像。建议搭配 Docker Compose 实现多容器编排管理！

🤔 参考 12

以下是一份标准且经过验证的 Dockerfile 模板，适用于大多数场景的综合示例：

dockerfile 复制代码

# 基础镜像信息
# FROM <image>:<tag> # 必需，首条非注释指令

# 声明变量（仅在构建阶段有效）
ARG BUILD_VERSION=latest
ARG HTTP_PROXY=http://proxy.example.com

# 标签信息（替代 MAINTAINER）
LABEL org.opencontainers.image.authors="your@email.com" \
      org.opencontainers.image.version="${BUILD_VERSION}" \
      org.opencontainers.image.title="My App" \
      org.opencontainers.image.description="Application Image"

# 基础环境配置
ENV DEBIAN_FRONTEND=noninteractive \
    LANG=C.UTF-8 \
    APP_HOME=/app

# 工作目录
WORKDIR ${APP_HOME}

# 复制模块文件（优先复制 go.mod/go.sum 或 package*.json 以利用缓存）
COPY --chown=appuser:appgroup modulefiles ./

# 安装依赖项（合并 RUN 以减少层数）
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        ca-certificates curl && \
    # 清理临时文件
    rm -rf /var/lib/apt/lists/*

# 复制应用代码
COPY --chown=appuser:appgroup . .

# 创建非 root 用户并切换
USER appuser

# 暴露端口（可选）
EXPOSE 8080

# 健康检查（可选）
HEALTHCHECK --interval=30s --timeout=3s \
    CMD curl -f http://localhost:8080/health || exit 1

# 数据卷挂载点（可选）
VOLUME ["/data"]

# 入口命令配置
ENTRYPOINT ["/usr/bin/myapp"]
CMD ["--config", "/etc/app/config.yaml"]

关键指令说明

指令	作用	注意事项
`FROM`	指定基础镜像	必须是第一条非注释指令[^1^][^2^]
`ARG`	定义构建参数（仅构建阶段有效）	可通过 `--build-arg` 覆盖
`LABEL`	添加元数据标签	推荐使用 OpenContainers 标准标签[^1^][^4^]
`ENV`	设置环境变量（持久化到镜像）	可被 `docker run --env` 覆盖
`WORKDIR`	设置工作目录	后续指令的相对路径基于此目录
`COPY`	复制文件到镜像	使用 `--chown` 修改所有权[^1^][^4^]
`RUN`	执行命令（安装依赖、配置等）	合并多个命令减少层数[^5^]
`USER`	切换运行用户	提升安全性，避免以 root 运行[^1^][^5^]
`EXPOSE`	声明容器监听的端口	需配合 `docker run -p` 映射到主机[^1^][^4^]
`HEALTHCHECK`	配置健康检查	自 Docker 1.12 起支持[^1^][^4^]
`VOLUME`	定义数据卷挂载点	用于持久化存储[^1^][^4^]
`ENTRYPOINT`	定义默认入口命令	不可被 `docker run` 覆盖，除非使用 `--entrypoint`[^1^][^4^]
`CMD`	提供默认参数给 `ENTRYPOINT`	可被 `docker run` 覆盖[^1^][^4^]

使用建议

构建上下文 ：将 Dockerfile 置于项目根目录，通过 docker build -f ./Dockerfile . 构建[^4^]。
缓存优化：将频繁变动的文件放在后面，利用缓存加速构建[^5^]。
安全最佳实践：使用非 root 用户运行容器，避免不必要的权限提升[^5^]。
多阶段构建：若需精简最终镜像体积，可采用多阶段构建[^2^][^5^]。

此模板可根据具体需求调整，更多细节可参考官方文档及搜索结果中的示例[^1^][^2^][^4^]。

🤔 参考 13

下面提供几个针对不同场景的 Dockerfile 模板，均遵循最佳实践（多阶段构建、非 root 用户、最小化镜像等）。请根据实际需求选择并修改：

通用模板（适用于 Go/Java/Rust 等编译型语言）

dockerfile 复制代码

# =============== 构建阶段 =============== 
# 使用包含编译工具的基础镜像
FROM golang:1.21-alpine AS builder

# 设置工作目录
WORKDIR /app

# 复制依赖文件（利用缓存层）
COPY go.mod go.sum ./
RUN go mod download

# 复制源代码
COPY . .

# 编译应用（禁用 CGO 减小体积）
RUN CGO_ENABLED=0 GOOS=linux go build -o /app/myapp

# =============== 运行时阶段 =============== 
# 使用超小基础镜像
FROM alpine:3.18

# 安装运行时依赖（如 CA 证书）
RUN apk --no-cache add ca-certificates tzdata

# 创建非 root 用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# 设置工作目录
WORKDIR /app

# 从构建阶段复制二进制文件
COPY --from=builder --chown=appuser:appgroup /app/myapp /app/myapp

# 设置健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1

# 切换到非 root 用户
USER appuser

# 暴露端口
EXPOSE 8080

# 启动应用
CMD ["/app/myapp"]

Node.js 应用模板

dockerfile 复制代码

# =============== 构建阶段 =============== 
FROM node:20-alpine AS builder

WORKDIR /app

# 复制依赖文件（利用缓存层）
COPY package.json package-lock.json ./
RUN npm ci --omit=dev

# 复制源代码
COPY . .

# 构建应用（如需要）
RUN npm run build

# =============== 运行时阶段 =============== 
FROM node:20-alpine

# 创建非 root 用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR /app

# 复制依赖和构建产物
COPY --from=builder --chown=appuser:appgroup /app/node_modules ./node_modules
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --chown=appuser:appgroup package.json .

# 设置健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/health || exit 1

# 切换用户
USER appuser

EXPOSE 3000

# 启动命令（根据框架调整）
CMD ["node", "dist/index.js"]

Python Django/Flask 应用模板

dockerfile 复制代码

# =============== 构建阶段 =============== 
FROM python:3.11-slim AS builder

WORKDIR /app

# 创建虚拟环境
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

# 安装依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# =============== 运行时阶段 =============== 
FROM python:3.11-slim

# 创建非 root 用户
RUN groupadd -r appuser && useradd -r -g appuser appuser

WORKDIR /app

# 从构建阶段复制虚拟环境
COPY --from=builder --chown=appuser:appuser /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

# 复制应用代码
COPY --chown=appuser:appuser . .

# 设置健康检查
HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost:8000/healthcheck/ || exit 1

# 切换用户
USER appuser

EXPOSE 8000

# 启动 Gunicorn（根据项目调整）
CMD ["gunicorn", "myproject.wsgi:application", "--bind", "0.0.0.0:8000"]

前端应用模板（React/Vue）

dockerfile 复制代码

# =============== 构建阶段 =============== 
FROM node:20-alpine AS builder

WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci

COPY . .
RUN npm run build

# =============== 运行时阶段 =============== 
FROM nginx:1.25-alpine

# 复制构建产物到 Nginx
COPY --from=builder /app/dist /usr/share/nginx/html

# 复制自定义 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口 (Nginx 默认 80)
EXPOSE 80

# 不需要 USER 指令（Nginx 默认以 nginx 用户运行）

# 不需要 CMD（基础镜像已包含 nginx -g "daemon off;"）

数据库初始化模板

dockerfile 复制代码

# 使用官方镜像
FROM postgres:15-alpine

# 设置环境变量
ENV POSTGRES_USER=myuser \
    POSTGRES_PASSWORD=mypassword \
    POSTGRES_DB=mydb

# 复制初始化 SQL 脚本
COPY init.sql /docker-entrypoint-initdb.d/

# 不需要多阶段构建（单阶段即可）
# 暴露默认端口 (5432)
EXPOSE 5432

# 基础镜像已包含健康检查

关键配置说明：

多阶段构建：分离构建环境和运行环境，减小镜像体积
非 Root 用户 ：提高安全性（USER appuser）
依赖缓存 ：先复制 package.json/go.mod 再复制代码，利用 Docker 缓存
健康检查 ：HEALTHCHECK 监控应用状态
精简基础镜像 ：使用 -alpine 或 -slim 版本
时区设置 （可选）：RUN apk add tzdata && cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
.dockerignore 文件 ：务必创建，排除无关文件
bash 复制代码
```
.git
node_modules
*.log
.env
Dockerfile
.dockerignore
```

构建与运行命令

bash 复制代码

# 构建镜像
docker build -t myapp:1.0 .

# 运行容器
docker run -d \
  -p 8080:8080 \
  --name myapp \
  --restart=unless-stopped \
  -e APP_ENV=production \
  myapp:1.0

提示：根据实际需求调整：

基础镜像版本

暴露的端口

启动命令

环境变量

健康检查端点

用户/组名称

🤔 参考 14

以下是一个精心设计的通用 Dockerfile 模板，适用于大多数应用场景（Python/Node.js/Java 等），包含最佳实践和详细注释：

dockerfile 复制代码

# ================ 第一阶段：构建阶段 ================
# 使用官方基础镜像（推荐 alpine 或 slim 减小镜像体积）
FROM python:3.11-slim AS builder  # 替换为你的语言基础镜像（如 node:18-alpine, openjdk:17-slim）

# 设置容器内工作目录
WORKDIR /app

# 设置环境变量
ENV PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=on \
    PIP_DISABLE_PIP_VERSION_CHECK=on

# 安装系统依赖（按需调整）
RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc build-essential && \
    rm -rf /var/lib/apt/lists/*

# 先单独复制依赖文件（利用Docker缓存层加速构建）
COPY requirements.txt .   # 对于Node.js：COPY package*.json .

# 安装应用依赖（生产环境）
RUN pip install --user --no-warn-script-location -r requirements.txt
# 对于Node.js：RUN npm ci --only=production

# ================ 第二阶段：运行阶段 ================
FROM python:3.11-slim AS runtime  # 使用更小的运行时镜像

# 安全设置：创建非root用户
RUN addgroup --system appgroup && \
    adduser --system --no-create-home --ingroup appgroup appuser

# 设置工作目录并转移所有权
WORKDIR /app
RUN chown appuser:appgroup /app

# 从构建阶段复制已安装的依赖
COPY --chown=appuser:appgroup --from=builder /root/.local /home/appuser/.local

# 复制应用代码（使用.dockerignore过滤无关文件）
COPY --chown=appuser:appgroup . .

# 设置环境变量
ENV PATH="/home/appuser/.local/bin:${PATH}" \
    PORT=8000 \
    NODE_ENV=production

# 暴露端口（根据实际应用调整）
EXPOSE ${PORT}

# 切换到非root用户
USER appuser

# 健康检查（按需调整命令）
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:${PORT}/health || exit 1

# 容器启动命令（根据实际应用修改）
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:${PORT}"]
# 对于Node.js：CMD ["node", "server.js"]
# 对于Java：CMD ["java", "-jar", "app.jar"]

关键优化与最佳实践

多阶段构建
- 构建阶段：安装编译依赖和构建应用
- 运行时阶段：仅复制必要文件，大幅减小镜像体积
安全增强
- 使用非 root 用户运行容器
- 定期更新基础镜像修复漏洞
- 移除不必要的系统工具
性能优化
- 依赖文件单独复制，利用 Docker 缓存层
- 使用 --no-cache-dir 避免 pip 缓存
- 清理 apt 缓存减小镜像大小
可维护性
- 清晰的阶段注释
- 环境变量集中管理
- 显式声明暴露端口

语言特定调整指南

Python 应用

dockerfile 复制代码

# 安装依赖时添加虚拟环境（可选）
RUN python -m venv /opt/venv && \
    /opt/venv/bin/pip install -r requirements.txt

# 运行时激活虚拟环境
ENV PATH="/opt/venv/bin:${PATH}"

Node.js 应用

dockerfile 复制代码

# 第一阶段
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json .
RUN npm ci --omit=dev  # 仅安装生产依赖

# 第二阶段
FROM node:18-alpine AS runtime
COPY --from=builder /app/node_modules /app/node_modules
CMD ["node", "server.js"]

Java Spring Boot 应用

dockerfile 复制代码

# 构建阶段
FROM maven:3.8-openjdk-17 AS builder
COPY . .
RUN mvn clean package -DskipTests

# 运行时阶段
FROM eclipse-temurin:17-jre-alpine
COPY --from=builder /app/target/*.jar /app/app.jar
CMD ["java", "-jar", "/app/app.jar"]

常用构建命令

bash 复制代码

# 构建镜像（带缓存）
docker build -t myapp:latest .

# 运行容器（映射端口）
docker run -d -p 8000:8000 --name myapp myapp:latest

# 查看镜像层构成
docker history myapp:latest

# 扫描安全漏洞
docker scan myapp:latest

生产环境建议

镜像标签 ：使用语义化版本标签（如 v1.2.3）
基础镜像：定期更新并指定精确版本
安全扫描 ：集成 docker scan 到 CI/CD
资源限制 ：运行时添加 --memory 和 --cpus 限制
日志管理：配置 JSON 日志驱动或挂载日志卷

提示：使用 .dockerignore 文件排除 node_modules, .git, __pycache__ 等目录加速构建过程

🤔 参考 15

下面提供几个不同场景的 Dockerfile 模板，包含详细注释和最佳实践建议。根据你的需求选择使用：

模板 1：基础 Python 应用

dockerfile 复制代码

# 使用官方轻量级 Python 镜像
FROM python:3.11-slim AS builder

# 设置环境变量（防止 Python 缓冲输出）
ENV PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=on

# 设置工作目录
WORKDIR /app

# 先单独复制依赖文件（利用 Docker 缓存层加速构建）
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

# 复制所有应用代码
COPY . .

# --------------------- 多阶段构建减小镜像大小 ---------------------
FROM python:3.11-slim AS runtime
WORKDIR /app

# 从构建阶段复制已安装的依赖
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app .

# 添加非 root 用户（增强安全性）
RUN groupadd -r appuser && useradd -r -g appuser appuser \
    && chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE 8000

# 设置容器启动命令
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "4"]

模板 2：Node.js 前端应用

dockerfile 复制代码

# 阶段1：构建前端
FROM node:18-alpine AS build
WORKDIR /usr/src/app

# 优先复制依赖文件以利用缓存
COPY package*.json ./
RUN npm ci --silent

# 复制源码并构建
COPY . .
RUN npm run build

# --------------------- 阶段2：生产环境 ---------------------
FROM nginx:alpine AS production

# 复制构建产物
COPY --from=build /usr/src/app/dist /usr/share/nginx/html

# 使用自定义 Nginx 配置（需提前准备 nginx.conf）
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露 80 端口
EXPOSE 80

# Nginx 在基础镜像中已设置默认启动命令

模板 3：Java Spring Boot 应用

dockerfile 复制代码

# 使用 Maven 构建
FROM maven:3.8-openjdk-17 AS builder
WORKDIR /build

# 复制 POM 文件（优先利用缓存层）
COPY pom.xml .
RUN mvn dependency:go-offline -B

# 复制源码并构建
COPY src ./src
RUN mvn package -DskipTests

# --------------------- 运行时镜像 ---------------------
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app

# 复制构建产物
COPY --from=builder /build/target/*.jar ./app.jar

# 添加健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

# 非 root 用户
RUN addgroup -S spring && adduser -S spring -G spring
USER spring

# 启动应用
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

模板 4：通用静态文件服务

dockerfile 复制代码

# 使用极简 Nginx 镜像
FROM nginx:alpine

# 删除默认配置
RUN rm /etc/nginx/conf.d/default.conf

# 复制自定义配置
COPY nginx.conf /etc/nginx/conf.d

# 复制静态文件
COPY public /usr/share/nginx/html

# 暴露 80 端口
EXPOSE 80

# 容器启动时自动运行 Nginx（基础镜像已包含）

最佳实践建议：

多阶段构建：显著减小最终镜像体积（尤其编译型语言）
非 root 用户：增强容器安全性
利用缓存 ：
- 将变化频率低的操作（如安装依赖）放在 Dockerfile 前面
- 单独复制 package.json/requirements.txt 先安装依赖
轻量基础镜像 ：
- 优先选择 -alpine、-slim 等变体
- 对比镜像大小：docker images
清理缓存 ：
- 在 RUN 命令中合并清理操作（如 apt-get install && rm -rf /var/lib/apt/lists/*）
健康检查 ：添加 HEALTHCHECK 指令方便编排管理
.dockerignore ：创建该文件忽略不必要的文件（如 .git, node_modules）

附加文件示例 .dockerignore

bash 复制代码

**/.git
**/node_modules
**/*.log
Dockerfile
.dockerignore
**/env

nginx.conf (模板 4 使用)

nginx 复制代码

server {
    listen 80;
    server_name localhost;
    
    location / {
        root   /usr/share/nginx/html;
        index  index.html;
        try_files $uri $uri/ /index.html;
    }

    # 静态资源缓存
    location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
        expires 1y;
        add_header Cache-Control "public";
    }
}

按需选择模板并根据实际项目调整参数（如端口号、启动命令等）。

🤔 参考 16

以下是一套精心设计的 Dockerfile 模板集，覆盖各种常见场景，每个模板都遵循最佳实践并包含详细注释说明：

通用基础模板

dockerfile 复制代码

# 使用官方基础镜像（指定版本）
FROM ubuntu:22.04

# 设置元数据
LABEL maintainer="dev@example.com"
LABEL description="Production application image"

# 设置环境变量
ENV DEBIAN_FRONTEND=noninteractive \
    TZ=Asia/Shanghai \
    LANG=C.UTF-8

# 安装系统依赖并清理
RUN apt-get update && apt-get install -y --no-install-recommends \
    ca-certificates \
    curl \
    && rm -rf /var/lib/apt/lists/*

# 创建工作目录
WORKDIR /app

# 复制应用文件（先复制依赖文件以利用缓存）
COPY requirements.txt package.json ./
# 安装依赖步骤...

# 复制其余文件
COPY . .

# 创建非root用户
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
USER appuser

# 暴露端口
EXPOSE 8080

# 设置健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8080/health || exit 1

# 容器入口点
ENTRYPOINT ["/app/entrypoint.sh"]

Node.js 应用模板

dockerfile 复制代码

# 阶段1: 构建
FROM node:18-alpine AS builder

WORKDIR /build
COPY package*.json ./
RUN npm ci --omit=dev  # 仅安装生产依赖
COPY . .
RUN npm run build

# 阶段2: 运行
FROM node:18-alpine

ENV NODE_ENV=production
WORKDIR /app

# 复制构建产物和依赖
COPY --from=builder /build/package*.json ./
COPY --from=builder /build/node_modules ./node_modules
COPY --from=builder /build/dist ./dist

# 非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 3000

CMD ["node", "dist/main.js"]

Python Django 模板

dockerfile 复制代码

# 使用官方Python基础镜像
FROM python:3.11-slim-bullseye

# 优化Python设置
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=on

WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc libpq-dev && \
    rm -rf /var/lib/apt/lists/*

# 安装Python依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 收集静态文件
RUN python manage.py collectstatic --noinput

# 非root用户
RUN useradd -r -U appuser
USER appuser

EXPOSE 8000

# 使用Gunicorn运行
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "3", "myapp.wsgi:application"]

Java Spring Boot 模板

dockerfile 复制代码

# 构建阶段
FROM maven:3.8-eclipse-temurin-17 AS builder

WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline

COPY src ./src
RUN mvn package -DskipTests

# 运行阶段
FROM eclipse-temurin:17-jre-alpine

WORKDIR /app
COPY --from=builder /build/target/*.jar app.jar

# JVM优化参数
ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75 -Djava.security.egd=file:/dev/./urandom"

# 非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 8080

ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar /app/app.jar"]

Go 应用模板

dockerfile 复制代码

# 构建阶段
FROM golang:1.20-alpine AS builder

WORKDIR /build

# 下载依赖
COPY go.mod go.sum ./
RUN go mod download

# 复制源码并构建
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o app .

# 最终阶段
FROM alpine:3.18

# 安装CA证书
RUN apk --no-cache add ca-certificates

WORKDIR /app
COPY --from=builder /build/app .

# 非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 8080

CMD ["./app"]

前端应用模板（React/Vue）

dockerfile 复制代码

# 构建阶段
FROM node:18-alpine AS builder

WORKDIR /build
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 生产阶段
FROM nginx:1.25-alpine

# 复制构建产物
COPY --from=builder /build/dist /usr/share/nginx/html

# 自定义Nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

EXPOSE 80

数据库服务模板（PostgreSQL）

dockerfile 复制代码

FROM postgres:15-alpine

# 环境变量
ENV POSTGRES_USER=appuser \
    POSTGRES_PASSWORD=securepassword \
    POSTGRES_DB=appdb

# 初始化脚本
COPY init-scripts/ /docker-entrypoint-initdb.d/

# 健康检查
HEALTHCHECK --interval=10s --timeout=5s \
  CMD pg_isready -U $POSTGRES_USER -d $POSTGRES_DB

VOLUME /var/lib/postgresql/data

开发环境模板

dockerfile 复制代码

# 开发专用镜像
FROM node:18

# 开发环境变量
ENV NODE_ENV=development

# 安装开发工具
RUN apt-get update && apt-get install -y \
    git \
    vim \
    postgresql-client

WORKDIR /app

# 复制依赖文件
COPY package*.json ./

# 安装所有依赖（包括devDependencies）
RUN npm install

# 挂载源代码（运行时挂载）
VOLUME /app/src

# 暴露应用端口+调试端口
EXPOSE 3000 9229

# 启动开发服务器
CMD ["npm", "run", "dev"]

多架构构建模板

dockerfile 复制代码

# 语法版本（必须第一行）
# syntax=docker/dockerfile:1.4

# 阶段1：构建
FROM --platform=$BUILDPLATFORM golang:1.20-alpine AS builder

ARG TARGETOS TARGETARCH

WORKDIR /build
COPY . .
RUN CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
    go build -ldflags="-w -s" -o /app

# 阶段2：运行
FROM alpine:3.18

RUN apk --no-cache add ca-certificates
COPY --from=builder /app /app

RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

EXPOSE 8080
CMD ["/app"]

使用说明

选择模板：根据应用类型选择最接近的模板
定制修改：
- 替换基础镜像版本
- 调整依赖安装命令
- 修改端口和工作目录
- 更新健康检查端点

构建优化技巧：

dockerfile 复制代码

# 使用.dockerignore文件
.git
node_modules
*.log
Dockerfile
.env

# 多阶段构建分离构建环境和运行时
# 使用特定标签而非latest
# 合并RUN指令减少镜像层

安全增强：

dockerfile 复制代码

# 扫描镜像漏洞
docker scan <image-name>

# 使用内容信任
export DOCKER_CONTENT_TRUST=1

# 最小权限原则
USER nonrootuser

构建命令示例：

bash 复制代码

# 多架构构建
docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest .

# 开发环境构建
docker build -f Dockerfile.dev -t myapp-dev .

这些模板遵循了 12-Factor 应用原则和云原生最佳实践，可根据具体需求进行调整。生产环境部署时，建议配合 CI/CD 管道和镜像安全扫描工具使用。

🤔 参考 17

以下是一系列精心设计的 Dockerfile 模板，适用于不同开发场景，每个模板均遵循最佳实践并包含详细注释：

基础模板（通用型）

dockerfile 复制代码

# 使用官方基础镜像（推荐指定版本）
FROM ubuntu:22.04

# 设置元数据
LABEL maintainer="your.email@example.com"
LABEL version="1.0"

# 设置环境变量
ENV DEBIAN_FRONTEND=noninteractive \
    LANG=C.UTF-8 \
    TZ=Asia/Shanghai

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    ca-certificates \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

# 创建工作目录
WORKDIR /app

# 复制应用文件（使用.dockerignore过滤无关文件）
COPY . .

# 设置非root用户（增强安全性）
RUN groupadd -r appuser && useradd -r -g appuser appuser
USER appuser

# 暴露端口
EXPOSE 8080

# 设置容器启动命令
CMD ["your-app-binary"]

前端应用模板（React/Vue）

dockerfile 复制代码

# 阶段1：构建应用
FROM node:18-alpine AS builder

# 设置工作目录
WORKDIR /app

# 先单独复制package文件（利用Docker缓存）
COPY package.json package-lock.json ./

# 安装依赖（生产依赖）
RUN npm ci --production

# 复制所有文件
COPY . .

# 构建应用
RUN npm run build

# 阶段2：生产镜像
FROM nginx:1.25-alpine

# 复制构建产物到Nginx目录
COPY --from=builder /app/dist /usr/share/nginx/html

# 复制自定义Nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

Python 应用模板（Django/Flask）

dockerfile 复制代码

# 使用官方Python基础镜像
FROM python:3.11-slim-bullseye

# 防止Python将字节码写入容器
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# 创建工作目录
WORKDIR /app

# 安装Python依赖（单独复制requirements以利用缓存）
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 设置非root用户
RUN useradd -m appuser
USER appuser

# 收集静态文件（Django）
# RUN python manage.py collectstatic --noinput

# 暴露端口
EXPOSE 8000

# 启动应用（使用Gunicorn）
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myapp.wsgi:application"]

Java Spring Boot 模板

dockerfile 复制代码

# 阶段1：Maven构建
FROM maven:3.8-openjdk-17 AS builder

# 设置构建参数
ARG APP_VERSION=1.0.0

# 复制POM文件（利用缓存）
COPY pom.xml .
RUN mvn dependency:go-offline

# 复制源码并构建
COPY src ./src
RUN mvn package -DskipTests -Dapp.version=$APP_VERSION

# 阶段2：运行镜像
FROM eclipse-temurin:17-jre-alpine

# 设置时区
ENV TZ=Asia/Shanghai

# 创建应用目录
WORKDIR /app

# 从构建阶段复制JAR文件
COPY --from=builder /target/*.jar app.jar

# 创建非root用户
RUN addgroup -S spring && adduser -S spring -G spring
USER spring

# 暴露端口
EXPOSE 8080

# 设置启动命令（优化JVM参数）
ENTRYPOINT ["java", "-jar", \
            "-Djava.security.egd=file:/dev/./urandom", \
            "-XX:+UseContainerSupport", \
            "-XX:MaxRAMPercentage=75.0", \
            "app.jar"]

数据库服务模板（PostgreSQL）

dockerfile 复制代码

# 使用官方镜像
FROM postgres:15-alpine

# 设置环境变量
ENV POSTGRES_USER=myuser \
    POSTGRES_PASSWORD=mypassword \
    POSTGRES_DB=mydb

# 初始化脚本目录
COPY init-scripts/ /docker-entrypoint-initdb.d/

# 设置健康检查
HEALTHCHECK --interval=10s --timeout=3s \
  CMD pg_isready -U $POSTGRES_USER -d $POSTGRES_DB

# 数据卷声明（持久化数据）
VOLUME /var/lib/postgresql/data

多服务开发模板（适合本地开发）

dockerfile 复制代码

# 阶段1：构建环境
FROM node:18 AS development

# 设置环境变量
ENV NODE_ENV=development

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    postgresql-client \
    redis-tools

# 设置工作目录
WORKDIR /app

# 复制包管理文件
COPY package.json package-lock.json ./

# 安装所有依赖（包括devDependencies）
RUN npm install

# 复制源代码
COPY . .

# 暴露端口（应用+调试）
EXPOSE 3000 9229

# 启动命令（带文件监视）
CMD ["npm", "run", "dev"]

高级模板（多架构构建）

dockerfile 复制代码

# 语法版本（必须放在第一行）
# syntax=docker/dockerfile:1.4

# 阶段1：跨平台构建
FROM --platform=$BUILDPLATFORM tonistiigi/xx AS xx

# 阶段2：构建应用
FROM --platform=$BUILDPLATFORM golang:1.20 AS builder

# 导入跨平台工具
COPY --from=xx / /

# 设置目标平台
ARG TARGETPLATFORM
RUN xx-apk add gcc musl-dev

# 构建配置
WORKDIR /app
COPY . .
RUN xx-go build -o /app-binary

# 阶段3：最小化生产镜像
FROM alpine:3.18

# 安装CA证书
RUN apk --no-cache add ca-certificates

# 复制构建产物
COPY --from=builder /app-binary /usr/local/bin/app

# 设置非root用户
RUN adduser -D appuser
USER appuser

# 入口点
ENTRYPOINT ["app"]

使用说明

选择模板：根据应用类型选择最接近的模板
定制修改：
- 替换 your-app-binary 等占位符
- 调整软件包安装命令
- 修改端口号和工作目录

添加功能：

dockerfile 复制代码

# 健康检查
HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost:${PORT}/health || exit 1

# 时区配置
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

# 日志重定向
RUN mkdir /logs && chown appuser:appuser /logs
VOLUME /logs

构建优化：
- 使用 .dockerignore 文件排除无关文件
gitignore 复制代码
```
# .dockerignore 示例
.git
node_modules
*.log
Dockerfile
.env
```
多阶段构建：资源密集型应用推荐使用多阶段构建减少镜像体积

最佳实践提示 ：生产环境镜像应始终使用特定版本标签（如 python:3.11-slim 而非 python:slim）以确保构建一致性。

🤔 参考 18

以下是一套精心设计的 Dockerfile 模板集，覆盖不同技术栈和场景需求，每个模板都包含详细注释和最佳实践：

通用基础模板（多语言适用）

dockerfile 复制代码

# 1. 选择官方轻量级基础镜像 (指定版本)
FROM debian:bookworm-slim

# 2. 设置构建参数 (可通过 --build-arg 覆盖)
ARG APP_ENV=production
ARG APP_VERSION=1.0.0

# 3. 设置环境变量
ENV DEBIAN_FRONTEND=noninteractive \
    TZ=Asia/Shanghai \
    LANG=C.UTF-8 \
    APP_HOME=/app

# 4. 安装系统依赖并清理缓存 (合并命令减少层)
RUN apt-get update && apt-get install -y --no-install-recommends \
    ca-certificates \
    curl \
    tzdata \
    && rm -rf /var/lib/apt/lists/* \
    && ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# 5. 创建工作目录
WORKDIR $APP_HOME

# 6. 单独复制依赖文件 (利用构建缓存)
COPY requirements.txt package.json yarn.lock* ./

# 7. 安装应用依赖 (根据技术栈调整)
RUN if [ -f requirements.txt ]; then \
        pip install --no-cache-dir -r requirements.txt; \
    elif [ -f package.json ]; then \
        npm ci --only=production; \
    fi

# 8. 复制应用代码
COPY . .

# 9. 构建生产版本 (如需要)
RUN if [ "$APP_ENV" = "production" ]; then \
        npm run build || true; \
    fi

# 10. 设置非root用户
RUN groupadd --gid 10001 appuser && \
    useradd --uid 10001 --gid appuser --shell /bin/false --no-create-home appuser
USER appuser

# 11. 暴露端口
EXPOSE 8080

# 12. 健康检查
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

# 13. 设置容器入口
ENTRYPOINT ["/bin/sh", "-c"]
CMD ["exec your_app_command"]

Python Django 应用模板

dockerfile 复制代码

# 使用官方Python基础镜像
FROM python:3.11-slim-bookworm

# 设置环境
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=on

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# 工作目录
WORKDIR /app

# 安装Python依赖 (先复制requirements)
COPY requirements.txt .
RUN pip install --upgrade pip && \
    pip install -r requirements.txt --no-cache-dir

# 复制应用代码
COPY . .

# 收集静态文件
RUN python manage.py collectstatic --noinput

# 非root用户
RUN useradd --system --uid 1000 django
USER django

# 暴露端口
EXPOSE 8000

# 启动Gunicorn
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "project.wsgi:application"]

Node.js 应用模板（含多阶段构建）

dockerfile 复制代码

# ===== 构建阶段 =====
FROM node:18-bullseye-slim AS builder

WORKDIR /build

# 复制依赖文件
COPY package*.json ./

# 安装所有依赖 (包括devDependencies)
RUN npm ci

# 复制源代码
COPY . .

# 构建生产版本
RUN npm run build

# ===== 生产阶段 =====
FROM node:18-alpine

ENV NODE_ENV=production

WORKDIR /app

# 安装生产依赖
COPY package*.json ./
RUN npm ci --only=production

# 从构建阶段复制构建产物
COPY --from=builder /build/dist ./dist

# 非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# 健康检查
HEALTHCHECK --interval=30s CMD node healthcheck.js

EXPOSE 3000

CMD ["node", "dist/main.js"]

Java Spring Boot 模板

dockerfile 复制代码

# 使用官方Maven构建镜像
FROM maven:3.8-eclipse-temurin-17 AS build

WORKDIR /build

# 复制POM文件 (利用缓存层)
COPY pom.xml .

# 下载依赖 (仅当pom变化时重新执行)
RUN mvn dependency:go-offline

# 复制源代码
COPY src ./src

# 构建应用
RUN mvn package -DskipTests

# ===== 生产阶段 =====
FROM eclipse-temurin:17-jre-alpine

# 安全设置
RUN addgroup -S spring && adduser -S spring -G spring
USER spring

# 从构建阶段复制JAR
COPY --from=build /build/target/*.jar /app/app.jar

WORKDIR /app

# JVM调优参数
ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75"

EXPOSE 8080

ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar app.jar"]

静态网站（Nginx）模板

dockerfile 复制代码

# 构建阶段
FROM node:18 as builder

WORKDIR /build
COPY . .
RUN npm ci && npm run build

# 生产阶段
FROM nginx:1.25-alpine

# 删除默认配置
RUN rm /etc/nginx/conf.d/default.conf

# 复制自定义配置
COPY nginx.conf /etc/nginx/conf.d

# 从构建阶段复制静态文件
COPY --from=builder /build/dist /usr/share/nginx/html

# 设置权限
RUN chown -R nginx:nginx /usr/share/nginx/html

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

数据库初始化模板（PostgreSQL）

dockerfile 复制代码

FROM postgres:15-alpine

# 设置环境变量
ENV POSTGRES_DB=mydb \
    POSTGRES_USER=admin \
    POSTGRES_PASSWORD_FILE=/run/secrets/db_password

# 复制初始化脚本
COPY init-scripts/ /docker-entrypoint-initdb.d/

# 复制自定义配置
COPY postgresql.conf /etc/postgresql/

# 设置健康检查
HEALTHCHECK --interval=10s --timeout=3s \
  CMD pg_isready -U $POSTGRES_USER -d $POSTGRES_DB

# 数据卷
VOLUME /var/lib/postgresql/data

EXPOSE 5432

最佳实践总结

安全优先

dockerfile 复制代码

# 使用非root用户
RUN adduser --system --no-create-home appuser
USER appuser

# 避免敏感信息 (使用secret管理)
ARG DB_PASSWORD
RUN echo "DB_PASSWORD=$DB_PASSWORD" >> .env

优化构建速度

dockerfile 复制代码

# 1. 使用.dockerignore排除无关文件
# 2. 先复制依赖文件再复制代码
COPY package*.json ./
RUN npm ci
COPY . .

减小镜像体积

dockerfile 复制代码

# 使用多阶段构建
FROM build AS builder
RUN make

FROM slim-base
COPY --from=builder /app/bin /app

# 清理缓存
RUN apt-get purge -y build-essential && apt-get autoremove -y

生产环境加固

dockerfile 复制代码

# 使用只读文件系统
RUN chmod -R a-w /app

# 设置资源限制
CMD ["sh", "-c", "ulimit -n 65536; exec node server.js"]

标签元数据

dockerfile 复制代码

LABEL org.opencontainers.image.title="MyApp" \
      org.opencontainers.image.version="1.0" \
      org.opencontainers.image.description="Production application"

根据实际需求选择模板，并调整其中的技术栈特定命令（如 npm run build、mvn package 等）。

🤔 参考 19

下面提供几个常用场景的 Dockerfile 模板，包含详细注释和最佳实践：

1. Python (Django/Flask) Dockerfile

dockerfile 复制代码

# 使用官方 Python 基础镜像
FROM python:3.11-slim-bullseye

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
ENV PIP_NO_CACHE_DIR off

# 创建工作目录
WORKDIR /app

# 安装系统依赖（根据实际需要调整）
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# 先安装 Python 依赖（利用 Docker 缓存层）
COPY requirements.txt .
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir -r requirements.txt

# 复制项目代码
COPY . .

# 收集静态文件（Django 项目需要）
# RUN python manage.py collectstatic --noinput

# 设置非 root 用户（增强安全性）
RUN adduser --disabled-password --gecos '' appuser
USER appuser

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi:application"]

2. Node.js (React/Vue/Express) Dockerfile

dockerfile 复制代码

# 阶段1：构建阶段
FROM node:18-alpine AS builder

# 设置工作目录
WORKDIR /app

# 复制依赖文件并安装
COPY package*.json ./
RUN npm ci --omit=dev

# 复制源代码并构建
COPY . .
RUN npm run build

# 阶段2：运行阶段
FROM node:18-alpine

# 设置工作目录
WORKDIR /app

# 从构建阶段复制必要文件
COPY --from=builder /app/package*.json ./
COPY --from=builder /app/build ./build
COPY --from=builder /app/node_modules ./node_modules

# 设置非 root 用户
RUN adduser -D appuser
USER appuser

# 暴露端口
EXPOSE 3000

# 启动命令（根据框架调整）
CMD ["npm", "start"]

3. Java (Spring Boot) Dockerfile

dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
# 下载依赖（利用缓存层）
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

# 运行阶段
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app

# 从构建阶段复制 JAR 文件
COPY --from=builder /app/target/*.jar app.jar

# 设置 JVM 参数
ENV JAVA_OPTS="-Xmx512m -Xms256m"

# 设置非 root 用户
RUN adduser -D appuser
USER appuser

# 暴露端口
EXPOSE 8080

# 启动命令
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/app.jar"]

4. 静态网站 (Nginx) Dockerfile

dockerfile 复制代码

# 构建阶段
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# 运行阶段
FROM nginx:1.25-alpine

# 复制构建产物
COPY --from=builder /app/dist /usr/share/nginx/html

# 复制自定义 Nginx 配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# Nginx 基础镜像已包含启动命令

通用最佳实践：

多阶段构建：减少最终镜像大小（尤其重要于 Java/Node.js 项目）
非 root 用户 ：增强容器安全性
dockerfile 复制代码
```
RUN adduser -D appuser
USER appuser
```

依赖缓存优化 ：

dockerfile 复制代码

# 先复制依赖文件，利用 Docker 缓存层
COPY package*.json ./
RUN npm install

# 再复制项目代码
COPY . .

镜像精简 ：
- 使用 Alpine 或 Slim 版本基础镜像
- 清理不必要的缓存文件（如 apt-get clean）
环境变量配置 ：
dockerfile 复制代码
```
ENV NODE_ENV production
ENV PORT 3000
```

健康检查 （可选）：

dockerfile 复制代码

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/health || exit 1

不同环境配置技巧：

dockerfile 复制代码

# 使用构建参数
ARG ENV=production
ENV NODE_ENV=${ENV}

# 构建时指定：
# docker build --build-arg ENV=development .

dockerfile 复制代码

# 使用多阶段标签
FROM node:18-alpine as dev
CMD ["npm", "run", "dev"]

FROM node:18-alpine as prod
CMD ["npm", "start"]

# 构建时选择阶段：
# docker build --target dev -t myapp:dev .

常用命令参考：

bash 复制代码

# 构建镜像
docker build -t myapp:latest .

# 多阶段构建指定目标
docker build --target development -t myapp:dev .

# 带构建参数
docker build --build-arg NODE_ENV=production -t myapp:prod .

根据实际项目需求调整这些模板，特别注意：

文件路径（WORKDIR 和 COPY 指令）
暴露端口（EXPOSE）
启动命令（CMD/ENTRYPOINT）
环境变量（ENV）

🤔 参考 20

Dockerfile 模板大全

下面是针对不同场景的 Dockerfile 模板，均遵循最佳实践并包含详细注释：

通用应用模板 (Node.js/Python/Java)

dockerfile 复制代码

# 阶段1: 构建阶段
FROM docker.io/library/node:18-alpine AS builder  # 使用官方镜像，指定版本

# 设置构建参数 (可通过 --build-arg 覆盖)
ARG APP_ENV=production
ARG VERSION=1.0.0

# 设置环境变量
ENV NODE_ENV=${APP_ENV} \
    APP_PORT=3000 \
    APP_VERSION=${VERSION}

# 安装系统依赖
RUN apk add --no-cache git python3 make g++

# 设置工作目录
WORKDIR /app

# 先复制依赖文件以利用缓存层
COPY package*.json ./

# 安装依赖 (根据环境区分)
RUN if [ "$APP_ENV" = "production" ]; then \
      npm ci --only=production; \
    else \
      npm ci; \
    fi

# 复制应用代码
COPY . .

# 执行构建
RUN npm run build

# --- 阶段2: 运行时阶段 ---
FROM docker.io/library/node:18-alpine

# 创建非root用户 (安全最佳实践)
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# 设置工作目录
WORKDIR /app

# 从构建阶段复制产物
COPY --chown=appuser:appgroup --from=builder /app/node_modules ./node_modules
COPY --chown=appuser:appgroup --from=builder /app/dist ./dist
COPY --chown=appuser:appgroup --from=builder /app/package.json .

# 设置用户
USER appuser

# 暴露端口
EXPOSE ${APP_PORT}

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:${APP_PORT}/health || exit 1

# 容器启动命令 (使用 exec 格式)
CMD ["node", "dist/index.js"]

Python Django 应用模板

dockerfile 复制代码

# 构建阶段
FROM docker.io/library/python:3.11-slim AS builder

ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1

WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    gcc \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# 安装虚拟环境
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

# 安装Python依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# --- 运行时阶段 ---
FROM docker.io/library/python:3.11-slim

# 创建应用用户
RUN groupadd -r django && useradd -r -g django djangouser

# 从构建阶段复制虚拟环境
COPY --from=builder /opt/venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"

WORKDIR /app
COPY --chown=djangouser:django . .

# 收集静态文件 (根据实际框架调整)
RUN python manage.py collectstatic --noinput

USER djangouser

EXPOSE 8000

# 使用Gunicorn运行
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "project.wsgi:application"]

Java Spring Boot 模板

dockerfile 复制代码

# 构建阶段
FROM docker.io/library/maven:3.8.6-eclipse-temurin-17 AS builder

WORKDIR /build

# 先复制POM文件以利用缓存
COPY pom.xml .
RUN mvn dependency:go-offline

# 复制源码并构建
COPY src ./src
RUN mvn package -DskipTests

# --- 运行时阶段 ---
FROM docker.io/library/eclipse-temurin:17-jre-alpine

# 创建非特权用户
RUN addgroup -S spring && adduser -S springuser -G spring
USER springuser

WORKDIR /app

# 从构建阶段复制JAR文件
COPY --from=builder /build/target/*.jar ./app.jar

# 设置JVM参数
ENV JAVA_OPTS="-Xmx512m -Xms256m"

# 健康检查 (Spring Boot Actuator)
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

EXPOSE 8080

ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar /app/app.jar"]

静态网站 (Nginx) 模板

dockerfile 复制代码

# 构建阶段 (如需要)
FROM docker.io/library/node:18-alpine AS builder
WORKDIR /app
COPY . .
RUN npm install && npm run build

# --- 运行时阶段 ---
FROM docker.io/library/nginx:1.23-alpine

# 移除默认配置
RUN rm -rf /etc/nginx/conf.d/*

# 复制自定义配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 复制构建产物
COPY --from=builder /app/dist /usr/share/nginx/html

# 设置权限
RUN chown -R nginx:nginx /usr/share/nginx/html

# 暴露端口
EXPOSE 80

# Nginx默认在前台运行，无需特殊CMD

数据库初始化模板 (PostgreSQL)

dockerfile 复制代码

FROM docker.io/library/postgres:15-alpine

# 设置环境变量
ENV POSTGRES_DB=mydb \
    POSTGRES_USER=admin \
    POSTGRES_PASSWORD=securepassword

# 复制初始化脚本
COPY init-scripts/ /docker-entrypoint-initdb.d/

# 设置健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD pg_isready -U $POSTGRES_USER -d $POSTGRES_DB

多服务模板 (使用 wait-for-it)

dockerfile 复制代码

# 基础阶段
FROM docker.io/library/python:3.11-slim AS base
RUN apt-get update && apt-get install -y wait-for-it && rm -rf /var/lib/apt/lists/*
WORKDIR /app

# --- Web服务 ---
FROM base AS web
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["gunicorn", "app:app"]

# --- Worker服务 ---
FROM base AS worker
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["celery", "-A", "tasks", "worker"]

最佳实践要点

基础镜像选择
- 优先使用官方镜像
- 选择特定版本而非 latest
- 使用 Alpine 或 Slim 版本减小体积

安全加固

dockerfile 复制代码

# 创建非root用户
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# 签名验证 (高级)
# COPY --chmod=644 --chown=appuser:appgroup app.sig /app.sig
# RUN gpg --verify /app.sig /app

优化构建缓存

dockerfile 复制代码

# 1. 先复制依赖管理文件
COPY package.json yarn.lock ./

# 2. 安装依赖
RUN yarn install --frozen-lockfile

# 3. 再复制源代码
COPY . .

多阶段构建

dockerfile 复制代码

# 构建阶段包含完整工具链
FROM node:18 AS builder
RUN npm run build

# 运行时阶段仅包含必要文件
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

健康检查

dockerfile 复制代码

HEALTHCHECK --interval=30s --timeout=5s \
  CMD curl -f http://localhost:3000/health || exit 1

清理缓存

dockerfile 复制代码

# 删除APT缓存
RUN apt-get update && apt-get install -y \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# 清理NPM缓存
RUN npm cache clean --force

使用 .dockerignore

bash 复制代码

.git
.dockerignore
Dockerfile
node_modules
*.log
*.md
.env

构建与使用命令

bash 复制代码

# 构建镜像 (带构建参数)
docker build -t myapp:1.0.0 \
  --build-arg APP_ENV=production \
  --build-arg VERSION=1.2.3 \
  .

# 扫描安全漏洞
docker scan myapp:1.0.0

# 查看镜像历史
docker history myapp:1.0.0

# 运行容器
docker run -d \
  -p 8080:3000 \
  -e APP_PORT=3000 \
  --name myapp \
  myapp:1.0.0

根据您的具体需求选择并调整模板，这些模板都遵循了 Docker 最佳实践，包括：

最小化镜像大小
使用非 root 用户
多阶段构建
利用构建缓存
健康检查
安全加固

🤔 参考 21

以下是一个精心设计的通用 Dockerfile 模板，包含最佳实践和详细注释，适用于大多数应用场景：

dockerfile 复制代码

# 第一阶段：构建阶段（可省略，适用于编译型语言）
FROM node:18-alpine AS builder  # 替换为所需的基础镜像
WORKDIR /app

# 复制依赖文件（利用Docker缓存层）
COPY package*.json ./
RUN npm ci --only=production   # 替换为实际依赖安装命令

# 复制源码并构建
COPY . .
RUN npm run build              # 替换为实际构建命令

#---------------------------------------
# 第二阶段：生产环境镜像（最终阶段）
FROM alpine:3.18               # 推荐使用轻量级基础镜像

# 设置环境变量（按需修改）
ENV NODE_ENV=production \
    APP_PORT=3000

# 创建非root用户（安全最佳实践）
RUN addgroup -g 1001 appgroup && \
    adduser -u 1001 -G appgroup -h /app -D appuser
USER appuser
WORKDIR /app

# 从构建阶段复制产物（多阶段构建减小镜像体积）
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --chown=appuser:appgroup package*.json ./

# 安装运行时依赖（示例）
RUN npm ci --only=production && \
    npm cache clean --force

# 暴露端口（与ENV变量对应）
EXPOSE ${APP_PORT}

# 健康检查（可选）
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:${APP_PORT}/health || exit 1

# 容器启动命令（必须使用JSON格式）
CMD ["node", "dist/main.js"]   # 替换为实际启动命令

各语言专用模板片段：

1. Node.js 应用

dockerfile 复制代码

FROM node:18-alpine

# 安装系统依赖（按需添加）
RUN apk add --no-cache build-base python3

# 设置时区
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

2. Python 应用

dockerfile 复制代码

FROM python:3.11-slim

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc libpq-dev && \
    rm -rf /var/lib/apt/lists/*

# 安装Python依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

3. Java Spring Boot

dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6-eclipse-temurin-17 AS builder
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

# 运行阶段
FROM eclipse-temurin:17-jre-alpine
COPY --from=builder /target/*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

4. Go 应用

dockerfile 复制代码

# 构建阶段
FROM golang:1.20-alpine AS builder
RUN apk add --no-cache git
WORKDIR /go/src/app
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o app

# 运行阶段
FROM scratch
COPY --from=builder /go/src/app/app /app
CMD ["/app"]

最佳实践指南：

镜像优化

dockerfile 复制代码

# 合并RUN命令减少层数
RUN apt-get update && \
    apt-get install -y package && \
    rm -rf /var/lib/apt/lists/*

# 使用.dockerignore文件排除无关文件

安全强化

dockerfile 复制代码

# 使用非root用户
RUN useradd -m myuser
USER myuser

# 设置文件系统为只读
RUN chmod -R a-w /app

标签管理

dockerfile 复制代码

LABEL maintainer="team@example.com" \
      version="1.0" \
      description="Application image"

参数化构建

dockerfile 复制代码

ARG APP_VERSION=latest
ENV APP_VERSION=${APP_VERSION}

多阶段构建（减小镜像体积）

dockerfile 复制代码

FROM build-stage AS builder
# ... 构建过程 ...

FROM runtime-image
COPY --from=builder /output /app

常用命令：

bash 复制代码

# 构建镜像
docker build -t myapp:1.0 .

# 扫描安全漏洞
docker scan myapp:1.0

# 查看镜像历史
docker history myapp:1.0

# 运行容器
docker run -d -p 3000:3000 --name myapp myapp:1.0

📌 重要提示：

生产环境应固定基础镜像版本（避免使用 latest）

敏感信息通过环境变量或 secrets 传递（不在镜像中存储）

使用 Hadolint 检查 Dockerfile 规范：docker run --rm -i hadolint/hadolint < Dockerfile

根据具体技术栈选择合适的模板片段组合使用，可大幅提升容器安全性和运行效率。

🤔 参考 22

下面提供几个精心设计的 Dockerfile 模板，覆盖常见开发场景，遵循最佳实践并附带详细注释：

1. Python 应用模板（Flask/Django）

dockerfile 复制代码

# 第一阶段：构建环境
FROM python:3.11-slim AS builder

# 设置环境变量
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=off

# 创建工作目录
WORKDIR /app

# 先单独安装依赖（利用Docker缓存层）
COPY requirements.txt .
RUN pip install --user -r requirements.txt

# 第二阶段：运行环境
FROM python:3.11-slim

# 创建非root用户
RUN adduser --disabled-password --gecos '' appuser

# 从构建阶段复制已安装的依赖
COPY --from=builder /root/.local /home/appuser/.local
ENV PATH=/home/appuser/.local/bin:$PATH

# 设置工作目录并复制应用代码
WORKDIR /home/appuser/app
COPY --chown=appuser:appuser . .

# 切换到非root用户
USER appuser

# 暴露端口
EXPOSE 8000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8000/health || exit 1

# 启动命令
CMD ["gunicorn", "myapp.wsgi:application", "--bind", "0.0.0.0:8000"]

2. Node.js 应用模板（React/Vue/Express）

dockerfile 复制代码

# 第一阶段：构建
FROM node:18-alpine AS builder

WORKDIR /build

# 单独复制包文件以利用缓存
COPY package*.json ./
RUN npm ci --silent

# 复制源代码并构建
COPY . .
RUN npm run build

# 第二阶段：运行
FROM node:18-alpine

# 创建非特权用户
RUN adduser -D appuser

WORKDIR /app

# 从构建阶段复制依赖和构建产物
COPY --from=builder --chown=appuser:appuser /build/node_modules ./node_modules
COPY --from=builder --chown=appuser:appuser /build/dist ./dist
COPY --from=builder --chown=appuser:appuser /build/package*.json ./

USER appuser

EXPOSE 3000

# 生产环境启动
CMD ["npm", "run", "start:prod"]

3. Java Spring Boot 模板

dockerfile 复制代码

# 构建阶段
FROM maven:3.8.6-eclipse-temurin-17 AS builder

WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline

COPY src ./src
RUN mvn package -DskipTests

# 运行阶段
FROM eclipse-temurin:17-jre-alpine

RUN adduser -D appuser

WORKDIR /app

# 从构建阶段复制JAR文件
COPY --from=builder --chown=appuser:appuser /build/target/*.jar app.jar

USER appuser

EXPOSE 8080

# 优化JVM参数
ENTRYPOINT ["java", "-XX:+UseContainerSupport", "-Djava.security.egd=file:/dev/./urandom", "-jar", "app.jar"]

4. 静态网站模板（Nginx）

dockerfile 复制代码

# 构建阶段（如需要）
FROM node:18-alpine AS builder
WORKDIR /build
COPY . .
RUN npm install && npm run build

# 运行阶段
FROM nginx:1.23-alpine

# 复制构建产物
COPY --from=builder /build/dist /usr/share/nginx/html

# 自定义Nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# Nginx会自动启动，无需CMD

5. 数据库初始化模板（PostgreSQL）

dockerfile 复制代码

FROM postgres:15-alpine

# 环境变量
ENV POSTGRES_USER=appuser \
    POSTGRES_PASSWORD=securepassword \
    POSTGRES_DB=mydb

# 初始化脚本
COPY init.sql /docker-entrypoint-initdb.d/

# 健康检查
HEALTHCHECK --interval=10s --timeout=3s \
  CMD pg_isready -U $POSTGRES_USER -d $POSTGRES_DB

6. 多服务模板（Go + Redis）

dockerfile 复制代码

# Go应用构建
FROM golang:1.20-alpine AS go-builder
WORKDIR /go/src/app
COPY go.* ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /app

# Redis基础
FROM redis:7-alpine AS redis

# 最终阶段
FROM alpine:3.17

# 安装必要工具
RUN apk add --no-cache supervisor

# 复制Go应用
COPY --from=go-builder /app /usr/local/bin/app

# 复制Redis
COPY --from=redis /usr/local/bin/redis-server /usr/local/bin/

# 配置文件
COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf

# 启动supervisor
CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

通用最佳实践要点：

多阶段构建：分离构建环境和运行环境
非root用户：使用非特权用户运行应用

层优化 ：

dockerfile 复制代码

# 正确做法（合并RUN命令）
RUN apt-get update && \
    apt-get install -y build-essential && \
    rm -rf /var/lib/apt/lists/*

# 错误做法（产生多余层）
RUN apt-get update
RUN apt-get install -y build-essential
RUN rm -rf /var/lib/apt/lists/*

安全扫描 ：构建后运行 docker scan <image>

.dockerignore 文件示例：

gitignore 复制代码

# 忽略文件示例
.git
.env
node_modules
*.log
Dockerfile
docker-compose.yml

调试技巧：

dockerfile 复制代码

# 调试版本Dockerfile（添加调试工具）
FROM alpine:3.17
RUN apk add --no-cache busybox-extras curl bind-tools

# 进入容器后可用命令：
# ping, telnet, nslookup, curl, wget, netstat

选择适合您项目的模板并根据具体需求调整：

修改基础镜像版本
调整暴露端口
添加应用特定的环境变量
完善健康检查机制
设置资源限制（在运行阶段通过 docker run 参数设置）

使用提示：

替换模板中的占位符（如 myapp.wsgi:application）
添加 .dockerignore 文件排除不必要的文件：
gitignore 复制代码
```
.git
node_modules
*.log
.env
Dockerfile
```
构建镜像：
bash 复制代码
```
docker build -t my-app:1.0 .
```

运行容器：

bash 复制代码

docker run -d -p 8080:8080 --name my-app-container my-app:1.0

根据具体技术栈选择对应模板，并调整构建命令、环境变量和启动参数。多阶段构建特别适合需要编译步骤的语言（Java/Go/Rust），静态网站则可以直接使用 Nginx 镜像。

Dockerfile模板 笔记250801