Shell脚本如何配置容器资源预留

本文目录导读：

1. Docker容器资源预留
2. Kubernetes Pod资源预留
3. 资源监控和调整
4. 最佳实践脚本
5. 注意事项

在Shell脚本中配置容器资源预留,主要涉及Docker和Kubernetes两种场景，以下是两种场景下的详细配置方法：

Docker容器资源预留

CPU资源预留

#!/bin/bash
# CPU预留配置示例
docker run -d \
  --cpus="1.5" \              # 限制CPU使用上限为1.5个核心
  --cpu-shares=512 \          # CPU权重（默认1024，值越高优先级越高）
  --cpuset-cpus="0,1" \       # 绑定到特定CPU核心
  --cpu-period=100000 \       # CPU周期（微秒）
  --cpu-quota=50000 \         # CPU配额（周期内最多使用50000微秒）
  --name my_container \
  nginx
# 动态调整已运行容器的CPU限制
docker update --cpus="2" --cpu-shares=1024 my_container

内存资源预留

#!/bin/bash
# 内存预留配置
docker run -d \
  --memory="512m" \           # 内存硬限制
  --memory-reservation="256m" \ # 内存软限制（预留值）
  --memory-swap="1g" \        # 交换空间限制（内存+交换）
  --memory-swappiness=0 \     # 禁用swap倾向
  --name my_container \
  nginx
# OOM优先级设置
docker run -d \
  --oom-kill-disable=false \  # 允许OOM时杀死容器
  --oom-score-adj=-500 \      # OOM分数调整（-1000到1000）
  nginx

完整资源预留脚本

#!/bin/bash
# 容器资源预留配置脚本
configure_container_resources() {
    local container_name=$1
    local cpu_limit=$2
    local mem_limit=$3
    local mem_reserve=$4
    echo "配置容器 ${container_name} 资源预留..."
    docker run -d \
        --name "${container_name}" \
        --cpus="${cpu_limit}" \
        --memory="${mem_limit}" \
        --memory-reservation="${mem_reserve}" \
        --cpu-shares=512 \
        nginx
}
# 使用示例
configure_container_resources "web-server" "1.5" "512m" "256m"

Kubernetes Pod资源预留

YAML配置模板

# pod-resources.yaml
apiVersion: v1
kind: Pod
metadata:
  name: resource-pod
spec:
  containers:
  - name: app-container
    image: nginx
    resources:
      requests:          # 资源预留（保证值）
        memory: "256Mi"
        cpu: "250m"
      limits:            # 资源限制（最大值）
        memory: "512Mi"
        cpu: "500m"

Shell脚本生成K8s配置

#!/bin/bash
# Kubernetes Pod资源预留脚本
create_resource_pod() {
    local pod_name=$1
    local cpu_request=$2
    local mem_request=$3
    local cpu_limit=$4
    local mem_limit=$5
    cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: ${pod_name}
spec:
  containers:
  - name: app
    image: nginx
    resources:
      requests:
        memory: "${mem_request}"
        cpu: "${cpu_request}"
      limits:
        memory: "${mem_limit}"
        cpu: "${cpu_limit}"
EOF
}
# 部署示例
create_resource_pod "web-app" "250m" "256Mi" "500m" "512Mi"

批量部署脚本

#!/bin/bash
# 批量配置多个容器的资源预留
declare -A RESOURCES=(
    ["nginx-web"]="200m:256Mi:400m:512Mi"
    ["api-server"]="500m:512Mi:1:1Gi"
    ["cache-service"]="1:2Gi:2:4Gi"
)
for app_name in "${!RESOURCES[@]}"; do
    IFS=':' read -r cpu_req mem_req cpu_lim mem_lim <<< "${RESOURCES[$app_name]}"
    kubectl run "${app_name}" \
        --image=nginx \
        --requests="cpu=${cpu_req},memory=${mem_req}" \
        --limits="cpu=${cpu_lim},memory=${mem_lim}"
done

资源监控和调整

#!/bin/bash
# 资源使用监控脚本
monitor_resources() {
    local container_name=$1
    echo "监控容器 ${container_name} 资源使用："
    docker stats "${container_name}" --no-stream
    # 获取详细信息
    echo "CPU 限制："
    docker inspect "${container_name}" | jq '.[0].HostConfig.NanoCpus'
    echo "内存限制："
    docker inspect "${container_name}" | jq '.[0].HostConfig.Memory'
}
# 自动调整资源
auto_adjust_resources() {
    local container_name=$1
    local cpu_usage=$(docker stats "${container_name}" --no-stream --format "{{.CPUPerc}}" | sed 's/%//')
    if (( $(echo "$cpu_usage > 80" | bc -l) )); then
        echo "CPU使用率过高，增加资源..."
        docker update --cpus="2" "${container_name}"
    fi
}

最佳实践脚本

#!/bin/bash
# 综合资源管理脚本
set -e
# 配置参数
CONTAINER_NAME="production-app"
BASE_CPU="1"
BASE_MEM="512m"
RESERVE_MEM="256m"
MAX_CPU="2"
MAX_MEM="1g"
# 创建容器并配置资源预留
create_optimized_container() {
    echo "开始配置容器资源预留..."
    # 停止并删除已存在的容器
    docker rm -f "${CONTAINER_NAME}" 2>/dev/null || true
    # 启动容器并配置资源
    docker run -d \
        --name "${CONTAINER_NAME}" \
        --cpus="${BASE_CPU}" \
        --memory="${BASE_MEM}" \
        --memory-reservation="${RESERVE_MEM}" \
        --memory-swap="${MAX_MEM}" \
        --cpu-shares=512 \
        --restart=unless-stopped \
        --log-opt max-size=10m \
        --log-opt max-file=3 \
        nginx
    echo "容器 ${CONTAINER_NAME} 配置完成："
    echo "  CPU 基础限制: ${BASE_CPU}"
    echo "  内存限制: ${BASE_MEM}"
    echo "  内存预留: ${RESERVE_MEM}"
}
# 验证配置
verify_configuration() {
    echo "验证资源配置..."
    docker inspect "${CONTAINER_NAME}" | jq '{
        "容器名称": .[0].Name,
        "CPU限制": (.[0].HostConfig.NanoCpus / 1e9 | tostring) + " 核心",
        "内存限制": (.[0].HostConfig.Memory | tostring) + " 字节",
        "内存预留": (.[0].HostConfig.MemoryReservation | tostring) + " 字节"
    }'
}
# 执行
create_optimized_container
verify_configuration

注意事项

1. 资源预留不是隔离：--memory-reservation 是软限制，当主机内存充足时才保证
2. CPU预留技巧：使用 --cpu-shares 设置权重，而不是绝对限制
3. 监控很重要：定期检查实际使用情况，调整预留值
4. Kubernetes QoS：通过 requests 和 limits 的组合实现不同 QoS 级别：
   • Guaranteed：requests == limits
   • Burstable：requests < limits
   • BestEffort：不设置 requests 和 limits

这些脚本提供了从基础配置到高级管理的完整解决方案,可根据实际场景调整参数。