Shell脚本如何配置容器优化策略

本文目录导读：

1. 镜像构建优化脚本
2. 容器资源限制配置
3. 存储与IO优化
4. 网络与安全优化
5. 完整的优化启动脚本
6. 性能监控与动态调整
7. 配置文件化策略
8. 总结的关键优化点

为Shell脚本配置容器优化策略,可以从镜像构建、运行时配置和资源限制三个层面入手，以下是具体的Shell脚本实现方案：

镜像构建优化脚本

#!/bin/bash
# container_optimize_build.sh - 容器镜像构建优化
# 多阶段构建示例
cat > Dockerfile << 'EOF'
# 第一阶段：构建阶段
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o myapp .
# 第二阶段：运行阶段
FROM alpine:3.19
RUN apk --no-cache add ca-certificates tzdata
WORKDIR /app
COPY --from=builder /app/myapp .
COPY --from=builder /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
EXPOSE 8080
USER 1000:1000
CMD ["./myapp"]
EOF
# 优化构建参数
docker build \
  --build-arg BUILDKIT_INLINE_CACHE=1 \
  --cache-from myapp:cache \
  --tag myapp:latest \
  --compress \
  --squash \
  .

容器资源限制配置

#!/bin/bash
# container_resource_limit.sh - 资源限制管理
container_name="myapp_container"
# CPU限制（使用CFS调度器）
CPU_LIMIT="2"  # 核心数
CPU_SHARES="512"  # CPU权重（默认1024）
CPU_QUOTA="100000"  # 每100ms周期内最多使用100ms
# 内存限制
MEMORY_LIMIT="2g"
MEMORY_SWAP="4g"  # 包含swap的总内存限制
MEMORY_RESERVATION="1g"  # 预留内存
# 运行容器并设置资源限制
docker run -d \
  --name "$container_name" \
  --cpus="$CPU_LIMIT" \
  --cpu-shares="$CPU_SHARES" \
  --cpu-quota="$CPU_QUOTA" \
  --memory="$MEMORY_LIMIT" \
  --memory-swap="$MEMORY_SWAP" \
  --memory-reservation="$MEMORY_RESERVATION" \
  --oom-kill-disable=false \
  --pids-limit=100 \
  myapp:latest
# 验证资源限制
echo "Container resource limits:"
docker inspect "$container_name" --format='{{.HostConfig.CpuShares}} {{.HostConfig.Memory}}'

存储与IO优化

#!/bin/bash
# container_storage_optimize.sh - 存储优化
# 使用overlay2存储驱动，配置存储驱动参数
DOCKER_STORAGE_OPTS="--storage-driver=overlay2 \
  --storage-opt overlay2.size=10G \
  --storage-opt overlay2.override_kernel_check=1"
# 配置挂载点优化
MOUNTS=(
  "-v /data/logs:/app/logs:ro"  # 只读日志目录
  "-v /data/data:/app/data:rw,z"  # 共享数据卷
  "--mount type=tmpfs,destination=/tmp,tmpfs-size=1G"  # 临时内存文件系统
)
# 限制blkio
BLOCK_IO_OPTS="--blkio-weight=500 \
  --device-read-bps=/dev/sda:100mb \
  --device-write-bps=/dev/sda:50mb"
# 运行优化后的容器
docker run -d \
  --name optimized_container \
  ${MOUNTS[@]} \
  $BLOCK_IO_OPTS \
  --read-only \
  --tmpfs /run \
  --tmpfs /tmp \
  myapp:latest

网络与安全优化

#!/bin/bash
# container_network_security.sh - 网络与安全策略
# 网络优化参数
NETWORK_OPTS="\
  --network=host \
  --dns 8.8.8.8 \
  --dns 114.114.114.114 \
  --sysctl net.core.somaxconn=65535 \
  --sysctl net.ipv4.tcp_tw_reuse=1 \
  --sysctl net.ipv4.ip_local_port_range=1024 65535"
# 安全策略
SECURITY_OPTS="\
  --security-opt no-new-privileges:true \
  --security-opt apparmor=default \
  --cap-drop=ALL \
  --cap-add=NET_BIND_SERVICE \
  --read-only-rootfs"
# 运行安全加固的容器
docker run -d \
  --name secure_container \
  $NETWORK_OPTS \
  $SECURITY_OPTS \
  --user 1000:1000 \
  --group-add 1001 \
  myapp:latest

完整的优化启动脚本

#!/bin/bash
# container_optimized_runner.sh - 综合优化启动
set -euo pipefail
# 配置参数
IMAGE_NAME="myapp:latest"
CONTAINER_NAME="myapp_optimized"
NETWORK_NAME="myapp_network"
VOLUME_NAME="myapp_data"
# 健康检查函数
healthcheck() {
  docker run --rm --network container:$CONTAINER_NAME \
    curlimages/curl:latest \
    --connect-timeout 5 \
    --max-time 10 \
    http://localhost:8080/health
}
# 创建网络（如果不存在）
docker network inspect "$NETWORK_NAME" >/dev/null 2>&1 || \
  docker network create "$NETWORK_NAME"
# 创建数据卷
docker volume inspect "$VOLUME_NAME" >/dev/null 2>&1 || \
  docker volume create "$VOLUME_NAME"
# 停止并删除旧容器
docker stop "$CONTAINER_NAME" 2>/dev/null || true
docker rm "$CONTAINER_NAME" 2>/dev/null || true
# 启动优化后的容器
docker run -d \
  --name "$CONTAINER_NAME" \
  --network "$NETWORK_NAME" \
  --restart unless-stopped \
  --cpus="2.5" \
  --memory="4g" \
  --memory-reservation="2g" \
  --memory-swap="6g" \
  --oom-kill-disable=false \
  --pids-limit="200" \
  --ulimit nofile=65535:65535 \
  --ulimit nproc=4096:4096 \
  --read-only \
  --tmpfs /tmp:size=500M \
  --tmpfs /run:size=100M \
  -v "$VOLUME_NAME:/app/data" \
  -v /etc/localtime:/etc/localtime:ro \
  -p 8080:8080 \
  -e "JAVA_OPTS=-Xms1g -Xmx2g -XX:+UseG1GC" \
  -e "NODE_OPTIONS=--max-old-space-size=2048" \
  --label "traefik.enable=true" \
  --label "traefik.http.routers.myapp.rule=Host(\`example.com\`)" \
  "$IMAGE_NAME"
# 等待容器就绪
echo "Waiting for container to be healthy..."
for i in {1..30}; do
  if healthcheck; then
    echo "Container is healthy!"
    break
  fi
  sleep 2
done
# 输出容器状态
echo "Container status:"
docker ps --filter "name=$CONTAINER_NAME" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
echo "Resource usage:"
docker stats --no-stream "$CONTAINER_NAME"

性能监控与动态调整

#!/bin/bash
# container_perf_adjust.sh - 动态性能调整
CONTAINER_NAME="myapp_optimized"
# 监控函数
monitor_resources() {
  local cpu_usage
  local mem_usage
  cpu_usage=$(docker stats --no-stream --format "{{.CPUPerc}}" "$CONTAINER_NAME" | sed 's/%//')
  mem_usage=$(docker stats --no-stream --format "{{.MemPerc}}" "$CONTAINER_NAME" | sed 's/%//')
  echo "CPU: ${cpu_usage}% | Memory: ${mem_usage}%"
  # 自动调整策略
  if (( $(echo "$cpu_usage > 80" | bc -l) )); then
    echo "High CPU detected, adjusting limits..."
    docker update --cpus="4" "$CONTAINER_NAME"
  elif (( $(echo "$cpu_usage < 20" | bc -l) )); then
    echo "Low CPU usage, reducing limits..."
    docker update --cpus="1" "$CONTAINER_NAME"
  fi
}
# 定期执行监控
while true; do
  monitor_resources
  sleep 60
done

配置文件化策略

#!/bin/bash
# container_policy_config.sh - 策略配置管理
# 创建策略配置文件
cat > /etc/container-policies.d/myapp.conf << 'POLICY'
# 应用优化策略
APP_NAME="myapp"
ENVIRONMENT="production"
# 资源限制
CPU_LIMIT="2.5"
MEMORY_LIMIT="4g"
MEMORY_RESERVATION="2g"
# 存储优化
LOG_ROTATION="daily"
LOG_RETENTION_DAYS="7"
DATA_VOLUME_DRIVER="local"
DATA_VOLUME_OPTS="type=ext4,device=/dev/sdb1"
# 网络优化
MTU_SIZE="9000"
TCP_CONGESTION="bbr"
NETWORK_PRIORITY="high"
# 安全策略
APPARMOR_PROFILE="docker-default"
SECCOMP_PROFILE="default.json"
SELINUX_TYPE="container_t"
# 日志策略
LOG_MAX_SIZE="100m"
LOG_MAX_FILES="3"
LOGGING_DRIVER="json-file"
# 更新策略
UPDATE_STRATEGY="rolling"
UPDATE_PARALLELISM="2"
MAX_UNAVAILABLE="1"
POLICY
# 应用配置
source /etc/container-policies.d/myapp.conf
# 加载配置并启动容器
docker run -d \
  --name "$APP_NAME" \
  --cpus="$CPU_LIMIT" \
  --memory="$MEMORY_LIMIT" \
  --memory-reservation="$MEMORY_RESERVATION" \
  --log-driver "$LOGGING_DRIVER" \
  --log-opt max-size="$LOG_MAX_SIZE" \
  --log-opt max-file="$LOG_MAX_FILES" \
  --mount "type=volume,source=${APP_NAME}_data,target=/app/data" \
  --security-opt "apparmor=$APPARMOR_PROFILE" \
  myapp:latest

总结的关键优化点

1. 资源限制：合理设置CPU、内存、PID限制
2. 存储优化：使用Overlay2驱动，配置挂载点
3. 网络调优：调整内核参数，使用Host模式
4. 安全加固：最小权限原则，AppArmor/SELinux
5. 日志管理：限制日志大小，使用logrotate
6. 健康检查：配置liveness/readiness探针
7. 动态调整：基于监控指标自动调整限制
8. 多阶段构建：减小镜像体积
9. 只读根文件系统：提高安全性
10. 限制容器能力：使用cap-drop/cap-add

这些脚本可以集成到CI/CD流水线中，实现容器优化的自动化管理。