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

# ---- 最终阶段 ----
FROM gcr.io/distroless/static-debian12
COPY --from=builder /server /server
ENTRYPOINT ["/server"]

# 对比镜像大小
docker images my-app
# REPOSITORY   TAG           SIZE
# my-app       single-stage  1.2GB    ← 单阶段
# my-app       multi-stage   15MB     ← 多阶段

# ❌ 多个 RUN 产生多层
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y wget
RUN rm -rf /var/lib/apt/lists/*

# ✅ 合并为一层，最后清理
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        curl \
        wget \
        ca-certificates && \
    rm -rf /var/lib/apt/lists/*

# .dockerignore
.git
node_modules
__pycache__
*.pyc
.env
*.md
Dockerfile
docker-compose*.yml
dist
build
coverage
.vscode
.idea

# 安装 dive
# https://github.com/wagoodman/dive

# 分析镜像层
dive nginx:alpine

# dive 界面:
#   左侧: 镜像层列表
#   右侧上: 选中层的文件变更
#   右侧下: 最终文件系统
#   底部: 镜像效率评分

# 快速概览
docker scout quickview nginx:alpine

# 详细漏洞报告
docker scout cves nginx:alpine

# 仅查看高危漏洞
docker scout cves --only-severity critical,high nginx:alpine

# 比较两个镜像
docker scout compare nginx:1.25-alpine nginx:1.24-alpine

# 推荐修复版本
docker scout recommendations nginx:alpine

# SBOM（软件物料清单）
docker scout sbom nginx:alpine

# 扫描镜像漏洞
trivy image nginx:alpine

# 仅扫描高危和严重漏洞
trivy image --severity HIGH,CRITICAL nginx:alpine

# 以 JSON 格式输出
trivy image --format json --output results.json nginx:alpine

# 扫描 Dockerfile
trivy config Dockerfile

# 扫描文件系统
trivy fs --security-checks vuln,config .

# 作为 CI/CD 中的门禁
trivy image --exit-code 1 --severity CRITICAL my-app:latest

漏洞严重等级:
  CRITICAL (严重)  → 必须立即修复，阻断部署
  HIGH (高危)      → 24 小时内修复
  MEDIUM (中危)    → 1 周内修复
  LOW (低危)       → 下次版本修复

处理流程:
  1. CI/CD 中自动扫描
  2. CRITICAL/HIGH 阻断部署
  3. 查看修复建议（升级基础镜像/依赖）
  4. 修复后重新构建和扫描
  5. 记录已知漏洞的例外（accepted risk）

# ✅ 生产环境 Dockerfile 规范

# 1. 使用官方最小基础镜像
FROM python:3.11-slim-bookworm

# 2. 设置元数据
LABEL maintainer="[email protected]"
LABEL version="1.0.0"
LABEL description="My application"

# 3. 设置工作目录
WORKDIR /app

# 4. 安装系统依赖（合并层 + 清理缓存）
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        libpq-dev \
        curl && \
    rm -rf /var/lib/apt/lists/*

# 5. 复制依赖文件（利用缓存）
COPY requirements.txt .

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

# 7. 创建非 root 用户
RUN addgroup --system appgroup && \
    adduser --system --ingroup appgroup appuser

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

# 9. 切换到非 root 用户
USER appuser

# 10. 声明端口
EXPOSE 8000

# 11. 健康检查
HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=10s \
    CMD curl -f http://localhost:8000/health || exit 1

# 12. 设置停止信号
STOPSIGNAL SIGTERM

# 13. 启动命令（exec 格式）
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "4", "app:app"]

# ✅ 生产环境容器运行规范
docker run -d \
    --name my-app \
    --user 1000:1000 \
    --read-only \
    --tmpfs /tmp:rw,noexec,nosuid,size=100m \
    --cap-drop ALL \
    --cap-add NET_BIND_SERVICE \
    --security-opt no-new-privileges \
    --security-opt seccomp=default.json \
    --memory 512m \
    --memory-reservation 256m \
    --cpus 1.0 \
    --pids-limit 100 \
    --restart unless-stopped \
    --health-cmd "curl -f http://localhost:8000/health || exit 1" \
    --health-interval 30s \
    --log-driver json-file \
    --log-opt max-size=10m \
    --log-opt max-file=3 \
    -p 8000:8000 \
    my-app:1.0.0

services:
  app:
    image: my-app:1.0.0  # 使用具体版本，不要用 latest
    read_only: true
    tmpfs:
      - /tmp:rw,noexec,nosuid,size=100m
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE
    security_opt:
      - no-new-privileges:true
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 128M
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 10s
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"
    networks:
      - app-net

networks:
  app-net:
    driver: bridge

# 语义化版本 (SemVer)
docker build -t my-app:1.0.0 -t my-app:1.0 -t my-app:1 -t my-app:latest .

# Git commit hash
GIT_SHA=$(git rev-parse --short HEAD)
docker build -t my-app:sha-${GIT_SHA} .

# CI/CD 构建
BUILD_DATE=$(date +%Y%m%d)
BUILD_NUM=${BUILD_NUMBER:-local}
docker build -t my-app:${BUILD_DATE}-${BUILD_NUM} .

// 结构化日志（JSON 格式）
{
  "timestamp": "2024-01-01T12:00:00.000Z",
  "level": "info",
  "message": "User login successful",
  "service": "auth-service",
  "request_id": "abc-123",
  "user_id": "42",
  "duration_ms": 150
}

#!/bin/bash
# docker-backup.sh — Docker 数据备份脚本

BACKUP_DIR="/backup/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# 备份所有命名卷
for volume in $(docker volume ls -q); do
    echo "Backing up volume: $volume"
    docker run --rm \
        -v "$volume":/source:ro \
        -v "$BACKUP_DIR":/backup \
        alpine:latest \
        tar czf "/backup/volume-${volume}.tar.gz" -C /source .
done

# 备份 compose 配置
cp /opt/myapp/docker-compose.yml "$BACKUP_DIR/"
cp /opt/myapp/.env "$BACKUP_DIR/" 2>/dev/null

# 保留最近 7 天的备份
find /backup -maxdepth 1 -mtime +7 -exec rm -rf {} \;

echo "Backup completed: $BACKUP_DIR"

Kubernetes 资源模型:
  ┌────── Cluster ──────┐
  │                      │
  │  ┌──── Node ────┐   │
  │  │               │   │
  │  │  ┌─── Pod ───┐│   │
  │  │  │ Container ││   │
  │  │  │ Container ││   │
  │  │  └───────────┘│   │
  │  │               │   │
  │  │  ┌─── Pod ───┐│   │
  │  │  │ Container ││   │
  │  │  └───────────┘│   │
  │  └───────────────┘   │
  │                      │
  │  ┌──── Node ────┐   │
  │  │  ┌─── Pod ───┐│   │
  │  │  │ Container ││   │
  │  │  └───────────┘│   │
  │  └───────────────┘   │
  └──────────────────────┘

核心资源:
  Pod          → 最小部署单元（1+ 容器）
  Deployment   → 管理 Pod 副本和滚动更新
  Service      → 网络服务发现和负载均衡
  ConfigMap    → 配置数据
  Secret       → 敏感数据
  Ingress      → HTTP(S) 路由
  PV/PVC       → 持久化存储
  Namespace    → 资源隔离

# docker-compose.yaml
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    environment:
      - NODE_ENV=production
    depends_on:
      - api

  api:
    image: my-api:v1
    ports:
      - "8080:3000"
    environment:
      - DB_HOST=db

# 等效的 Kubernetes 配置
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: web
          image: nginx:alpine
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 80
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
        - name: api
          image: my-api:v1
          ports:
            - containerPort: 3000
          env:
            - name: DB_HOST
              value: "db"

# 安装 kompose
# https://kompose.io/

# 将 docker-compose.yaml 转换为 Kubernetes 资源
kompose convert

# 直接部署到 K8s 集群
kompose up

# 清理
kompose down

# 使用 kind 创建本地集群
kind create cluster --name my-cluster

# 使用 kubectl 操作
kubectl get nodes
kubectl get pods -A

# 部署应用
kubectl apply -f deployment.yaml
kubectl get pods
kubectl logs -f <pod-name>

# 删除集群
kind delete cluster --name my-cluster

Docker 学习路线:
  初级 (1-2 周):
    ├── 理解容器概念
    ├── 掌握 Docker 基本命令
    ├── 编写简单 Dockerfile
    └── 使用 Docker Compose

  中级 (2-4 周):
    ├── 深入理解镜像分层和缓存
    ├── 多阶段构建优化
    ├── 网络模型和存储方案
    ├── CI/CD 集成
    └── 基本安全加固

  高级 (4-8 周):
    ├── 生产环境部署规范
    ├── 监控和日志方案
    ├── 安全扫描和合规
    ├── Swarm 集群管理
    └── Kubernetes 入门

  专家:
    ├── Kubernetes 深入
    ├── 服务网格 (Istio)
    ├── GitOps (ArgoCD)
    ├── 平台工程
    └── 成本优化

回顾你的学习成果:
  ✅ 理解容器技术原理和 OCI 标准
  ✅ 掌握 Docker 安装、配置和镜像管理
  ✅ 熟练编写 Dockerfile 和多阶段构建
  ✅ 掌握网络模型和数据持久化
  ✅ 使用 Compose 编排多容器应用
  ✅ 了解 Swarm 集群和服务编排
  ✅ 实施安全加固和监控方案
  ✅ 集成 CI/CD 自动化流水线
  ✅ 具备故障排查能力
  ✅ 了解 Kubernetes 入门知识

下一步建议:
  1. 实战: 将自己的项目容器化
  2. 深入: 学习 Kubernetes
  3. 认证: 考取 Docker DCA 认证
  4. 社区: 参与开源项目贡献