Docker容器日志的轮转与清理方案

/var/lib/docker/containers/<container-id>/<container-id>-json.log

{"log":"2024-06-15 10:23:41.872  INFO [my-service,,] 1 --- [nio-8080-exec-3] c.e.c.PaymentController : Payment processed for order #ORD-7892\n","stream":"stdout","time":"2024-06-15T10:23:41.8727429Z"}

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3",
    "compress": "true",
    "tag": "{{.Name}}/{{.ImageName}}/{{.ID}}"
  }
}

sudo systemctl daemon-reload
sudo systemctl restart docker

docker run -d \
  --name spring-boot-api \
  --log-driver json-file \
  --log-opt max-size=20m \
  --log-opt max-file=5 \
  --log-opt compress=true \
  --log-opt tag="{{.Name}}-{{.ImageName}}-{{.ID}}" \
  -p 8080:8080 \
  my-registry.com/my-java-app:1.2.3

version: '3.8'
services:
  api:
    image: my-registry.com/my-java-app:1.2.3
    ports:
      - "8080:8080"
    logging:
      driver: "json-file"
      options:
        max-size: "20m"
        max-file: "5"
        compress: "true"
        tag: "{{.Name}}-{{.ImageName}}-{{.ID}}"
    # 其他配置...

docker inspect spring-boot-api | jq '.[0].HostConfig.LogConfig'

{
  "Type": "json-file",
  "Config": {
    "max-size": "20m",
    "max-file": "5",
    "compress": "true",
    "tag": "{{.Name}}-{{.ImageName}}-{{.ID}}"
  }
}

import com.google.common.util.concurrent.RateLimiter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
/**
 * 智能日志采样服务 —— 防止高频 DEBUG/INFO 日志刷爆磁盘
 * ✅ 支持按业务 Key（如 orderId）独立限流
 * ✅ 支持时间窗口内最大打印次数（如 10次/分钟）
 * ✅ 采样日志自动附加触发时间与计数
 */
@Slf4j
@Service
public class LogSampledService {
    // 每个业务 Key 对应一个独立限流器（ConcurrentHashMap 线程安全）
    private final ConcurrentHashMap<String, RateLimiter> rateLimiters = new ConcurrentHashMap<>();
    // 记录每个 Key 的累计打印次数（用于诊断）
    private final ConcurrentHashMap<String, AtomicLong> counters = new ConcurrentHashMap<>();
    /**
     * 按 Key 采样打印 DEBUG 日志（推荐用于循环内、高频事件）
     * @param key 业务唯一标识，如 "order-12345", "user-67890"
     * @param message 日志模板，支持 {} 占位符
     * @param args 日志参数
     */
    public void debugSampled(String key, String message, Object... args) {
        // 创建或获取该 key 的限流器（10 permits per minute）
        RateLimiter limiter = rateLimiters.computeIfAbsent(key,
                k -> RateLimiter.create(10.0 / 60.0)); // 10次/分钟 ≈ 0.167次/秒
        if (limiter.tryAcquire()) {
            long count = counters.computeIfAbsent(key, k -> new AtomicLong(0)).incrementAndGet();
            String sampledMsg = String.format("[SAMPLED-%d] %s | at %s",
                    count, message, LocalDateTime.now().toString());
            log.debug(sampledMsg, args);
        }
        // 若未获得许可，静默丢弃（可选：记录到监控指标）
    }
    /**
     * 安全打印 ERROR 日志（带堆栈限流，防异常雪崩）
     * @param key 错误类型标识，如 "db-connection-fail", "redis-timeout"
     * @param t 异常对象
     * @param context 上下文信息（如 userId, orderId）
     */
    public void errorLimited(String key, Throwable t, String context) {
        RateLimiter limiter = rateLimiters.computeIfAbsent(key,
                k -> RateLimiter.create(1.0)); // 严格限制：1次/秒
        if (limiter.tryAcquire()) {
            log.error("CRITICAL ERROR [{}] Context: {} | Exception:", key, context, t);
        } else {
            // 降级：只打简短摘要，不带堆栈
            log.warn("ERROR THROTTLED [{}]: {} | at {}", key, context, LocalDateTime.now());
        }
    }
}

@RestController
@RequestMapping("/api/orders")
@Slf4j
public class OrderController {
    @Autowired
    private LogSampledService logSampler;
    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
        String orderKey = "order-" + request.getOrderId();
        // ✅ 替代原本的 log.debug("Creating order: {}", request)
        logSampler.debugSampled(orderKey, "Creating order with items: {}, total: {}",
                request.getItems().size(), request.getTotalAmount());
        try {
            Order order = orderService.process(request);
            return ResponseEntity.ok(order);
        } catch (PaymentException e) {
            // ✅ 替代原本的 log.error("Payment failed", e)
            logSampler.errorLimited("payment-fail", e, "orderId=" + request.getOrderId());
            throw e;
        }
    }
}

logging:
  level:
    # 🔻 关键：关闭 MyBatis 全量 SQL（DEBUG 会打印参数，极占空间）
    org.mybatis: TRACE  # 仅 SQL，无参数；或直接注释掉
    # 🔻 关闭 Hibernate 统计（除非压测需要）
    org.hibernate.stat: OFF
    # 🔻 关闭 Spring Security 详细认证日志
    org.springframework.security: WARN
    # 🔻 关闭 Netty 冗余日志
    io.netty: ERROR
    # 🔻 自定义包设为 INFO，禁用 DEBUG
    com.example.myapp: INFO
# 🔻 Actuator 安全加固：不暴露敏感详情
management:
  endpoint:
    health:
      show-details: WHEN_AUTHORIZED
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus,loggers

# 清理已停止容器、网络、悬空镜像、**以及所有容器日志文件**
docker system prune --volumes --all --force

# ✅ 更安全的生产用法：只清理已停止容器日志（不碰 volumes）
docker container prune --force
# 此命令会自动删除已停止容器的 -json.log 和 .gz 文件！

#!/bin/bash
# 安全 Docker 日志清理脚本 —— 只清理已停止容器日志，绝不碰运行中容器

LOG_FILE="/var/log/docker-log-clean-$(date +\%Y\%m\%d).log"
echo "=== $(date) ===" >> "$LOG_FILE"

# 1. 获取所有已停止容器 ID
STOPPED_IDS=$(docker ps -aq --filter "status=exited" --filter "status=created")

if [ -z "$STOPPED_IDS" ]; then
    echo "No stopped containers found." >> "$LOG_FILE"
else
    echo "Found stopped containers: $STOPPED_IDS" >> "$LOG_FILE"
    # 2. 逐个清理（更可控，可加日志）
    for cid in $STOPPED_IDS; do
        echo "Pruning logs for container $cid..." >> "$LOG_FILE"
        # docker container prune 不支持单个容器，故用 rm + 精确路径
        LOG_PATH=$(docker inspect "$cid" 2>/dev/null | jq -r '.[0].LogPath' 2>/dev/null)
        if [[ "$LOG_PATH" != "null" ]] && [[ -n "$LOG_PATH" ]]; then
            # 删除主日志 + 所有 .gz 归档
            BASE_DIR=$(dirname "$LOG_PATH")
            BASE_NAME=$(basename "$LOG_PATH" | sed 's/-json\.log$//')
            find "$BASE_DIR" -maxdepth 1 \( -name "${BASE_NAME}-json.log*" \) -delete 2>/dev/null
            echo "  Deleted logs in $BASE_DIR" >> "$LOG_FILE"
        fi
    done
fi

# 3. 最后执行一次 container prune（兜底）
echo "Running docker container prune..." >> "$LOG_FILE"
docker container prune --force >> "$LOG_FILE" 2>&1

# 4. 输出磁盘使用摘要
echo "Disk usage after cleanup:" >> "$LOG_FILE"
df -h /var/lib/docker >> "$LOG_FILE"

sudo chmod +x /usr/local/bin/clean-docker-logs.sh
# 每天凌晨 2:30 执行
echo "30 2 * * * root /usr/local/bin/clean-docker-logs.sh" | sudo tee -a /etc/crontab

server:
  http_listen_port: 9080
  grpc_listen_port: 0
positions:
  filename: /var/lib/promtail/positions.yaml
clients:
  - url: http://loki:3100/loki/api/v1/push
scrape_configs:
- job_name: docker-logs
  static_configs:
  - targets:
      - localhost
    labels:
      job: docker-logs
      __path__: /var/lib/docker/containers/*/*-json.log
  # ✅ 自动提取容器元数据作为 Loki labels
  pipeline_stages:
  - docker: {}
  - labels:
      stream:
      container_id:
      name:
      image:

{job="docker-logs"} |~ "ERROR" | line_format "{{.name}}: {{.log}}"

# 查看大文件（聚焦 /var/lib/docker）
sudo du -sh /var/lib/docker/containers/*/*-json.log* | sort -hr | head -10

# 输出示例：
# 8.2G    /var/lib/docker/containers/abc123.../abc123...-json.log
# 3.1G    /var/lib/docker/containers/def456.../def456...-json.log.1.gz

# 查看该容器 ID 对应的服务
docker ps -a | grep abc123...

# 输出：
# abc123...   my-java-app:1.2.3   ...   Exited (137) 2 days ago   my-java-app

# 安全删除该容器所有日志
sudo rm -f /var/lib/docker/containers/abc123.../abc123...-json.log*
# 执行 prune（清理其他已停止容器）
docker container prune --force

# ❌ 原配置（危险！）
logging:
  level:
    com.example.payment: DEBUG  # 导致每笔支付打 200 行日志
# ✅ 修正后
logging:
  level:
    com.example.payment: INFO
    # 如需调试，临时改为 WARN，并配合采样服务

sudo vim /etc/docker/daemon.json
# 添加轮转配置（前文所述）
sudo systemctl restart docker

# 重新运行容器
docker run -d --log-opt max-size=20m --log-opt max-file=3 my-java-app:1.2.3

# 模拟日志写入
for i in {1..10000}; do echo "DEBUG log line $i"; done | docker exec -i <new-container-id> sh -c "cat >> /dev/stdout"

# 检查日志文件
ls -lh /var/lib/docker/containers/<new-id>/
# 应看到：xxx-json.log（<20M） + xxx-json.log.1.gz（压缩后）