Shell脚本如何基准测试镜像性能

本文目录导读：

1. 拉取速度测试
2. 构建速度测试
3. 综合性能测试脚本
4. 实时监控脚本
5. 使用方法

我来介绍几种Shell脚本中基准测试镜像性能的方法，主要包括拉取速度、构建速度和磁盘性能测试。

拉取速度测试

#!/bin/bash
# 镜像拉取性能测试脚本
test_image_pull() {
    local image=$1
    local test_count=3
    echo "测试镜像: $image"
    echo "- 清除已有镜像"
    docker rmi $image 2>/dev/null
    echo "- 拉取测试..."
    for i in $(seq 1 $test_count); do
        echo "  测试 #$i"
        # 记录开始时间
        start_time=$(date +%s%N)
        # 拉取镜像
        docker pull $image
        # 记录结束时间
        end_time=$(date +%s%N)
        # 计算耗时（毫秒）
        duration=$(( (end_time - start_time) / 1000000 ))
        # 获取镜像大小
        size=$(docker images $image --format "{{.Size}}" | sed 's/GB//;s/MB//')
        # 计算速度（如果大小包含GB转换为MB）
        if [[ $size == *"GB"* ]]; then
            size_mb=$(echo "$size * 1024" | bc)
        else
            size_mb=$size
        fi
        speed=$(( size_mb * 1000 / duration ))
        echo "  耗时: ${duration}ms"
        echo "  大小: ${size_mb}MB"
        echo "  速度: ${speed}MB/s"
        # 清除镜像以便下次测试
        docker rmi $image 2>/dev/null
    done
}
# 测试不同镜像
test_image_pull "nginx:latest"
test_image_pull "alpine:latest"
test_image_pull "node:16-alpine"

构建速度测试

#!/bin/bash
# Docker构建性能测试
test_build_performance() {
    local test_dir="/tmp/docker_build_test"
    echo "测试Docker构建性能..."
    # 创建测试文件
    mkdir -p $test_dir
    cat > $test_dir/Dockerfile << 'EOF'
FROM alpine:3.18
RUN apk add --no-cache curl wget git bash
COPY test.txt /test.txt
RUN echo "Build test" > /test.txt && cat /test.txt
EOF
    echo "test content" > $test_dir/test.txt
    # 测试不同构建策略
    echo "1. 普通构建"
    start_time=$(date +%s%N)
    docker build -t test-build:latest $test_dir 2>&1 | grep -v "^Step\|^ --->"
    end_time=$(date +%s%N)
    echo "$(( (end_time - start_time) / 1000000 ))ms"
    # 测试缓存
    echo "2. 缓存构建"
    start_time=$(date +%s%N)
    docker build -t test-build:latest $test_dir 2>&1 | grep -v "^Step\|^ --->"
    end_time=$(date +%s%N)
    echo "$(( (end_time - start_time) / 1000000 ))ms"
    # 测试多阶段构建
    cat > $test_dir/Dockerfile << 'EOF'
FROM alpine:3.18 AS builder
RUN echo "Building..." > /output.txt
FROM alpine:3.18
COPY --from=builder /output.txt /
CMD ["cat", "/output.txt"]
EOF
    echo "3. 多阶段构建"
    start_time=$(date +%s%N)
    docker build -t test-build:multi $test_dir 2>&1 | grep -v "^Step\|^ --->"
    end_time=$(date +%s%N)
    echo "$(( (end_time - start_time) / 1000000 ))ms"
    # 清理
    docker rmi test-build:latest test-build:multi 2>/dev/null
    rm -rf $test_dir
}
test_build_performance

综合性能测试脚本

#!/bin/bash
# 完整的镜像性能测试套件
PERFORMANCE_LOG="docker_performance_$(date +%Y%m%d_%H%M%S).log"
log_result() {
    echo "$1" >> "$PERFORMANCE_LOG"
    echo "$1"
}
# 系统信息
log_result "=== Docker 性能测试报告 ==="
log_result "测试时间: $(date)"
log_result "Docker版本: $(docker version --format '{{.Server.Version}}')"
log_result "系统信息: $(uname -a)"
log_result ""
# 1. 磁盘IO测试
test_disk_io() {
    log_result "=== 磁盘IO测试 ==="
    # 测试Docker数据目录
    docker_root=$(docker info | grep "Docker Root Dir" | awk '{print $4}')
    log_result "Docker数据目录: $docker_root"
    # 创建测试文件
    dd if=/dev/zero of=/tmp/test_write bs=1M count=1024 2>&1 | tail -1
    log_result "顺序写入测试完成"
    # 使用fio测试（如果安装）
    if command -v fio &> /dev/null; then
        fio --randrepeat=1 --ioengine=libaio --direct=1 --gtod_reduce=1 \
            --name=test --bs=4k --iodepth=64 --size=1G --readwrite=randrw \
            --rwmixread=75 --directory=$docker_root 2>&1 | grep "IOPS\|BW="
    fi
    rm -f /tmp/test_write
}
# 2. 网络延迟测试
test_network_latency() {
    log_result "=== 网络延迟测试 ==="
    # 测试不同镜像仓库
    registries=("docker.io" "registry.hub.docker.com" "gcr.io" "quay.io")
    for registry in "${registries[@]}"; do
        latency=$(ping -c 3 -q $registry 2>&1 | tail -1 | awk -F'/' '{print $5}')
        log_result "  $registry: ${latency}ms"
    done
}
# 3. 并发拉取测试
test_concurrent_pull() {
    log_result "=== 并发拉取测试 ==="
    local images=(
        "nginx:alpine"
        "python:3.11-alpine"
        "node:18-alpine"
        "alpine:latest"
        "busybox:latest"
    )
    echo "测试同时拉取 ${#images[@]} 个镜像..."
    start_time=$(date +%s%N)
    # 后台并行拉取
    for image in "${images[@]}"; do
        (docker pull $image 2>&1) &
    done
    # 等待所有完成
    wait
    end_time=$(date +%s%N)
    duration=$(( (end_time - start_time) / 1000000 ))
    log_result "并发拉取完成: ${duration}ms"
    log_result ""
}
# 4. 镜像层缓存测试
test_layer_caching() {
    log_result "=== 镜像层缓存测试 ==="
    local test_dir="/tmp/docker_layer_test"
    mkdir -p $test_dir
    # 创建基础Dockerfile
    cat > $test_dir/Dockerfile << 'EOF'
FROM alpine:3.18
RUN apk update
RUN apk add nginx
RUN echo "Layer 1" > /layer1.txt
RUN echo "Layer 2" > /layer2.txt
RUN echo "Layer 3" > /layer3.txt
EOF
    log_result "初始构建:"
    start_time=$(date +%s%N)
    docker build -t layer-test:1 $test_dir 2>&1 | grep "Step\|Successfully"
    end_time=$(date +%s%N)
    log_result "  耗时: $(( (end_time - start_time) / 1000000 ))ms"
    # 修改最后一行
    sed -i '$d' $test_dir/Dockerfile
    echo 'RUN echo "Layer 4" > /layer4.txt' >> $test_dir/Dockerfile
    log_result "变更后构建（应使用缓存）:"
    start_time=$(date +%s%N)
    docker build -t layer-test:2 $test_dir 2>&1 | grep "Using cache\|CACHED\|Step\|Successfully"
    end_time=$(date +%s%N)
    log_result "  耗时: $(( (end_time - start_time) / 1000000 ))ms"
    # 清理
    docker rmi layer-test:1 layer-test:2 2>/dev/null
    rm -rf $test_dir
}
# 5. 生成报告
generate_report() {
    log_result "=== 测试总结 ==="
    # 计算平均值和统计信息
    echo "统计信息生成中..."
    log_result "详细报告已保存到: $PERFORMANCE_LOG"
}
# 运行所有测试
main() {
    log_result "开始Docker性能测试..."
    log_result ""
    test_disk_io
    test_network_latency
    test_concurrent_pull
    test_layer_caching
    generate_report
    log_result ""
    log_result "测试完成!"
}
main

实时监控脚本

#!/bin/bash
# 实时监控Docker性能
monitor_docker_performance() {
    local interval=1
    local duration=${1:-60}  # 默认60秒
    echo "监控Docker性能 (${duration}秒)..."
    echo "时间,CPU%,内存%,磁盘IO(读),磁盘IO(写),网络RX,网络TX"
    end_time=$((SECONDS + duration))
    while [ $SECONDS -lt $end_time ]; do
        timestamp=$(date +%H:%M:%S)
        # Docker统计信息
        stats=$(docker stats --no-stream --format \
            "table {{.CPUPerc}}\t{{.MemPerc}}\t{{.NetIO}}" 2>/dev/null | tail -2)
        # 系统IO统计
        io_stats=$(iostat -d 1 2 | tail -3 | head -1 | awk '{print $3","$4}')
        echo "$timestamp,$stats,$io_stats"
        sleep $interval
    done
}
monitor_docker_performance 30

使用方法

# 赋予执行权限
chmod +x docker_benchmark.sh
# 运行测试
./docker_benchmark.sh
# 查看报告
cat docker_performance_*.log
# 实时监控
./monitor_performance.sh 120  # 监控120秒

这些脚本涵盖了镜像性能测试的主要方面：拉取速度、构建性能、缓存效率、并发处理能力和磁盘IO,可以根据具体需求选择使用或组合测试。