基于脚本的配置管理：从手动到自动化的过渡阶段

老马啸西风2025/8/31大约 12 分钟

3.2 基于脚本的配置管理

随着IT环境复杂性的增加和服务器数量的增长，纯手动配置的局限性日益显现。为了提高效率和减少错误，系统管理员开始采用基于脚本的配置管理方法。这种方法代表了从完全手动配置向现代自动化配置管理的重要过渡阶段。

脚本化配置管理的优势

基于脚本的配置管理相比纯手动配置具有显著优势：

1. 提高效率

脚本可以重复执行，大大减少了配置时间：

#!/bin/bash
# Web服务器批量配置脚本

# 配置参数
SERVERS=("web01" "web02" "web03" "web04" "web05")
DOMAIN="example.com"
ADMIN_EMAIL="admin@$DOMAIN"

# 日志函数
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a /var/log/web-config.log
}

# 配置单台服务器
configure_server() {
    local server=$1
    log "开始配置服务器: $server.$DOMAIN"
    
    # SSH连接并执行配置
    ssh root@$server.$DOMAIN "
        # 更新系统
        yum update -y
        
        # 安装必要软件包
        yum install -y httpd php mysql-server git
        
        # 配置Apache
        sed -i 's/#ServerName.*/ServerName $server.$DOMAIN/' /etc/httpd/conf/httpd.conf
        
        # 启动服务
        systemctl start httpd
        systemctl start mysqld
        systemctl enable httpd
        systemctl enable mysqld
        
        # 配置防火墙
        firewall-cmd --permanent --add-service=http
        firewall-cmd --permanent --add-service=https
        firewall-cmd --reload
    "
    
    log "服务器 $server.$DOMAIN 配置完成"
}

# 批量配置所有服务器
log "开始批量配置Web服务器"
for server in \"${SERVERS[@]}\"; do
    configure_server $server
done
log "所有Web服务器配置完成"

2. 减少错误

脚本执行减少了人为输入错误：

# Windows服务器配置脚本
param(
    [string[]]$Servers = @("web01", "web02", "web03"),
    [string]$Domain = "example.com",
    [int]$MaxMemory = 4096
)

function Write-Log {
    param([string]$Message)
    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    Write-Host "[$Timestamp] $Message"
    "$Timestamp $Message" | Out-File -FilePath "C:\config.log" -Append
}

function Configure-WindowsServer {
    param([string]$Server)
    
    Write-Log "开始配置服务器: $Server.$Domain"
    
    try {
        # 使用PowerShell远程会话配置服务器
        $session = New-PSSession -ComputerName "$Server.$Domain" -Credential (Get-Credential)
        
        Invoke-Command -Session $session -ScriptBlock {
            param($MaxMemory)
            
            # 安装IIS
            Import-Module ServerManager
            Add-WindowsFeature Web-Server -IncludeManagementTools
            
            # 配置应用程序池
            Set-ItemProperty -Path "IIS:\AppPools\DefaultAppPool" -Name "managedRuntimeVersion" -Value "v4.0"
            Set-ItemProperty -Path "IIS:\AppPools\DefaultAppPool" -Name "managedPipelineMode" -Value "Integrated"
            
            # 配置内存限制
            $WebConfigPath = "C:\inetpub\wwwroot\web.config"
            if (Test-Path $WebConfigPath) {
                $WebConfig = [xml](Get-Content $WebConfigPath)
                $WebConfig.configuration.'system.web'.compilation.debug = "false"
                $WebConfig.Save($WebConfigPath)
            }
            
            # 配置Windows防火墙
            New-NetFirewallRule -DisplayName "允许HTTP" -Direction Inbound -Protocol TCP -LocalPort 80 -Action Allow
            New-NetFirewallRule -DisplayName "允许HTTPS" -Direction Inbound -Protocol TCP -LocalPort 443 -Action Allow
            
            # 启动相关服务
            Start-Service W3SVC
            Set-Service W3SVC -StartupType Automatic
            
        } -ArgumentList $MaxMemory
        
        Remove-PSSession $session
        Write-Log "服务器 $Server.$Domain 配置成功"
    }
    catch {
        Write-Log "服务器 $Server.$Domain 配置失败: $($_.Exception.Message)"
    }
}

# 批量配置所有服务器
Write-Log "开始批量配置Windows服务器"
foreach ($server in $Servers) {
    Configure-WindowsServer -Server $server
}
Write-Log "Windows服务器批量配置完成"

3. 提高一致性

脚本确保所有服务器使用相同的配置：

# 配置一致性检查脚本
import paramiko
import json

class ConfigurationConsistencyChecker:
    def __init__(self, servers, ssh_key_path):
        self.servers = servers
        self.ssh_key_path = ssh_key_path
        self.configurations = {}
    
    def collect_configurations(self):
        """收集所有服务器的配置信息"""
        for server in self.servers:
            try:
                config = self.get_server_configuration(server)
                self.configurations[server] = config
            except Exception as e:
                print(f"收集服务器 {server} 配置失败: {e}")
    
    def get_server_configuration(self, server):
        """获取单台服务器的配置信息"""
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        
        # 使用SSH密钥连接
        ssh.connect(server, username='root', key_filename=self.ssh_key_path)
        
        # 收集配置信息
        config = {}
        
        # 获取操作系统信息
        stdin, stdout, stderr = ssh.exec_command('cat /etc/os-release')
        config['os'] = stdout.read().decode().strip()
        
        # 获取Apache版本
        stdin, stdout, stderr = ssh.exec_command('httpd -v')
        config['apache_version'] = stdout.read().decode().strip()
        
        # 获取PHP配置
        stdin, stdout, stderr = ssh.exec_command('php -r "echo ini_get(\'memory_limit\');"')
        config['php_memory_limit'] = stdout.read().decode().strip()
        
        # 获取网络配置
        stdin, stdout, stderr = ssh.exec_command('ip addr show')
        config['network'] = stdout.read().decode().strip()
        
        ssh.close()
        return config
    
    def check_consistency(self):
        """检查配置一致性"""
        if not self.configurations:
            self.collect_configurations()
        
        inconsistencies = []
        
        # 以第一台服务器为基准
        baseline = list(self.configurations.values())[0]
        
        for server, config in self.configurations.items():
            for key, value in config.items():
                if key in baseline and baseline[key] != value:
                    inconsistencies.append({
                        'server': server,
                        'config_item': key,
                        'expected': baseline[key],
                        'actual': value
                    })
        
        return inconsistencies
    
    def generate_report(self):
        """生成一致性报告"""
        inconsistencies = self.check_consistency()
        
        report = {
            'total_servers': len(self.servers),
            'checked_servers': len(self.configurations),
            'inconsistencies_found': len(inconsistencies),
            'details': inconsistencies
        }
        
        return report

# 使用示例
servers = ['web01.example.com', 'web02.example.com', 'web03.example.com']
checker = ConfigurationConsistencyChecker(servers, '/root/.ssh/id_rsa')
report = checker.generate_report()

print("配置一致性检查报告:")
print(json.dumps(report, indent=2, ensure_ascii=False))

Bash脚本配置管理

在Linux/Unix环境下，Bash脚本是最常用的配置管理工具。

基础脚本结构

#!/bin/bash
# 标准化的Bash配置脚本结构

# 脚本信息
SCRIPT_NAME="Web服务器配置脚本"
SCRIPT_VERSION="1.0.0"
SCRIPT_AUTHOR="系统管理员"

# 配置参数
CONFIG_FILE="/etc/web-config.conf"
LOG_FILE="/var/log/web-config.log"

# 默认配置值
DEFAULT_APACHE_PORT=80
DEFAULT_PHP_MEMORY="512M"
DEFAULT_MYSQL_POOL="1G"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# 日志函数
log() {
    local level=$1
    local message=$2
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    case $level in
        "INFO")
            echo -e "${GREEN}[INFO]${NC} [$timestamp] $message" | tee -a $LOG_FILE
            ;;
        "WARN")
            echo -e "${YELLOW}[WARN]${NC} [$timestamp] $message" | tee -a $LOG_FILE
            ;;
        "ERROR")
            echo -e "${RED}[ERROR]${NC} [$timestamp] $message" | tee -a $LOG_FILE
            ;;
        *)
            echo "[$timestamp] $message" | tee -a $LOG_FILE
            ;;
    esac
}

# 错误处理函数
error_exit() {
    log "ERROR" "$1"
    exit 1
}

# 检查是否以root权限运行
check_root() {
    if [[ $EUID -ne 0 ]]; then
        error_exit "此脚本需要root权限运行"
    fi
}

# 加载配置文件
load_config() {
    if [[ -f $CONFIG_FILE ]]; then
        source $CONFIG_FILE
        log "INFO" "配置文件加载成功: $CONFIG_FILE"
    else
        log "WARN" "配置文件不存在，使用默认配置: $CONFIG_FILE"
    fi
}

# 验证配置参数
validate_config() {
    # 验证端口
    if ! [[ $APACHE_PORT =~ ^[0-9]+$ ]] || [[ $APACHE_PORT -lt 1 ]] || [[ $APACHE_PORT -gt 65535 ]]; then
        APACHE_PORT=$DEFAULT_APACHE_PORT
        log "WARN" "Apache端口配置无效，使用默认值: $APACHE_PORT"
    fi
    
    # 验证内存限制
    if [[ ! $PHP_MEMORY =~ ^[0-9]+[MG]$ ]]; then
        PHP_MEMORY=$DEFAULT_PHP_MEMORY
        log "WARN" "PHP内存限制配置无效，使用默认值: $PHP_MEMORY"
    fi
}

# 主函数
main() {
    log "INFO" "开始执行 $SCRIPT_NAME v$SCRIPT_VERSION"
    
    # 检查权限
    check_root
    
    # 加载配置
    load_config
    
    # 验证配置
    validate_config
    
    # 执行配置任务
    configure_system
    
    log "INFO" "$SCRIPT_NAME 执行完成"
}

# 配置系统函数
configure_system() {
    log "INFO" "开始系统配置..."
    
    # 更新系统
    log "INFO" "更新系统软件包..."
    yum update -y >> $LOG_FILE 2>&1 || error_exit "系统更新失败"
    
    # 安装必要软件包
    log "INFO" "安装必要软件包..."
    yum install -y httpd php mysql-server git >> $LOG_FILE 2>&1 || error_exit "软件包安装失败"
    
    # 配置Apache
    configure_apache
    
    # 配置PHP
    configure_php
    
    # 配置MySQL
    configure_mysql
    
    # 启动服务
    start_services
    
    # 配置防火墙
    configure_firewall
    
    # 验证配置
    verify_configuration
}

# 配置Apache
configure_apache() {
    log "INFO" "配置Apache..."
    
    # 备份原配置
    cp /etc/httpd/conf/httpd.conf /etc/httpd/conf/httpd.conf.backup
    
    # 设置基本配置
    sed -i "s/#ServerName.*/ServerName $(hostname)/" /etc/httpd/conf/httpd.conf
    sed -i "s/Listen 80/Listen $APACHE_PORT/" /etc/httpd/conf/httpd.conf
    
    log "INFO" "Apache配置完成"
}

# 配置PHP
configure_php() {
    log "INFO" "配置PHP..."
    
    # 备份原配置
    cp /etc/php.ini /etc/php.ini.backup
    
    # 设置内存限制
    sed -i "s/memory_limit.*/memory_limit = $PHP_MEMORY/" /etc/php.ini
    
    log "INFO" "PHP配置完成"
}

# 配置MySQL
configure_mysql() {
    log "INFO" "配置MySQL..."
    
    # 备份原配置
    cp /etc/my.cnf /etc/my.cnf.backup
    
    # 设置缓冲池大小
    echo "[mysqld]" > /etc/my.cnf
    echo "innodb_buffer_pool_size = $MYSQL_POOL" >> /etc/my.cnf
    
    log "INFO" "MySQL配置完成"
}

# 启动服务
start_services() {
    log "INFO" "启动服务..."
    
    systemctl start httpd
    systemctl start mysqld
    systemctl enable httpd
    systemctl enable mysqld
    
    log "INFO" "服务启动完成"
}

# 配置防火墙
configure_firewall() {
    log "INFO" "配置防火墙..."
    
    firewall-cmd --permanent --add-service=http >> $LOG_FILE 2>&1
    firewall-cmd --permanent --add-service=https >> $LOG_FILE 2>&1
    firewall-cmd --reload >> $LOG_FILE 2>&1
    
    log "INFO" "防火墙配置完成"
}

# 验证配置
verify_configuration() {
    log "INFO" "验证配置..."
    
    # 检查服务状态
    if ! systemctl is-active --quiet httpd; then
        error_exit "Apache服务启动失败"
    fi
    
    if ! systemctl is-active --quiet mysqld; then
        error_exit "MySQL服务启动失败"
    fi
    
    # 测试Web服务
    if ! curl -s http://localhost:$APACHE_PORT | grep -q "Apache"; then
        error_exit "Web服务测试失败"
    fi
    
    log "INFO" "配置验证通过"
}

# 执行主函数
main "$@"

高级脚本功能

# 高级配置脚本示例：支持多环境配置

# 环境配置文件
declare -A ENV_CONFIGS=(
    ["development"]="dev-config.conf"
    ["testing"]="test-config.conf"
    ["production"]="prod-config.conf"
)

# 加载环境配置
load_environment_config() {
    local environment=$1
    local config_file=${ENV_CONFIGS[$environment]}
    
    if [[ -z $config_file ]]; then
        error_exit "不支持的环境: $environment"
    fi
    
    if [[ -f $config_file ]]; then
        source $config_file
        log "INFO" "加载环境配置: $environment ($config_file)"
    else
        log "WARN" "环境配置文件不存在: $config_file"
    fi
}

# 交互式配置
interactive_configuration() {
    echo "=== 交互式配置 ==="
    
    read -p "请输入服务器名称 (默认: $(hostname)): " server_name
    server_name=${server_name:-$(hostname)}
    
    read -p "请输入Apache端口 (默认: 80): " apache_port
    apache_port=${apache_port:-80}
    
    read -p "请输入PHP内存限制 (默认: 512M): " php_memory
    php_memory=${php_memory:-"512M"}
    
    echo "配置确认:"
    echo "  服务器名称: $server_name"
    echo "  Apache端口: $apache_port"
    echo "  PHP内存限制: $php_memory"
    
    read -p "确认配置? (y/N): " confirm
    if [[ ! $confirm =~ ^[Yy]$ ]]; then
        error_exit "用户取消配置"
    fi
}

# 命令行参数处理
show_help() {
    echo "用法: $0 [选项]"
    echo "选项:"
    echo "  -e, --environment ENV  指定环境 (development|testing|production)"
    echo "  -i, --interactive      交互式配置"
    echo "  -c, --config FILE      指定配置文件"
    echo "  -h, --help             显示帮助信息"
    echo "  -v, --version          显示版本信息"
}

# 参数解析
while [[ $# -gt 0 ]]; do
    case $1 in
        -e|--environment)
            ENVIRONMENT="$2"
            shift 2
            ;;
        -i|--interactive)
            INTERACTIVE=true
            shift
            ;;
        -c|--config)
            CONFIG_FILE="$2"
            shift 2
            ;;
        -h|--help)
            show_help
            exit 0
            ;;
        -v|--version)
            echo "$SCRIPT_NAME v$SCRIPT_VERSION"
            exit 0
            ;;
        *)
            echo "未知选项: $1"
            show_help
            exit 1
            ;;
    esac
done

PowerShell脚本配置管理

在Windows环境下，PowerShell提供了强大的配置管理能力。

基础PowerShell脚本

# 标准化的PowerShell配置脚本结构

# 脚本信息
param(
    [string]$Environment = "development",
    [string]$ConfigFile = "config.json",
    [switch]$Interactive,
    [switch]$Help
)

# 全局变量
$Script:ScriptName = "Windows服务器配置脚本"
$Script:ScriptVersion = "1.0.0"
$Script:LogPath = "C:\config.log"

# 颜色定义
$Script:Colors = @{
    Red = [System.ConsoleColor]::Red
    Green = [System.ConsoleColor]::Green
    Yellow = [System.ConsoleColor]::Yellow
    White = [System.ConsoleColor]::White
}

# 日志函数
function Write-Log {
    param(
        [string]$Level,
        [string]$Message
    )
    
    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $LogMessage = "[$Timestamp] [$Level] $Message"
    
    # 输出到控制台
    switch ($Level) {
        "INFO" { Write-Host $LogMessage -ForegroundColor $Script:Colors.Green }
        "WARN" { Write-Host $LogMessage -ForegroundColor $Script:Colors.Yellow }
        "ERROR" { Write-Host $LogMessage -ForegroundColor $Script:Colors.Red }
        default { Write-Host $LogMessage -ForegroundColor $Script:Colors.White }
    }
    
    # 写入日志文件
    $LogMessage | Out-File -FilePath $Script:LogPath -Append
}

# 错误处理函数
function Stop-OnError {
    param([string]$Message)
    Write-Log "ERROR" $Message
    exit 1
}

# 检查管理员权限
function Test-Administrator {
    $CurrentUser = [Security.Principal.WindowsIdentity]::GetCurrent()
    return (New-Object Security.Principal.WindowsPrincipal $CurrentUser).IsInRole([Security.Principal.WindowsBuiltinRole]::Administrator)
}

# 加载配置文件
function Load-Configuration {
    param([string]$ConfigPath)
    
    if (Test-Path $ConfigPath) {
        try {
            $Config = Get-Content $ConfigPath | ConvertFrom-Json
            Write-Log "INFO" "配置文件加载成功: $ConfigPath"
            return $Config
        }
        catch {
            Write-Log "WARN" "配置文件解析失败，使用默认配置: $ConfigPath"
            return $null
        }
    }
    else {
        Write-Log "WARN" "配置文件不存在: $ConfigPath"
        return $null
    }
}

# 验证配置参数
function Validate-Configuration {
    param($Config)
    
    # 如果没有配置，使用默认值
    if (-not $Config) {
        $Config = @{
            ServerName = $env:COMPUTERNAME
            MaxMemory = 4096
            Port = 80
        }
    }
    
    # 验证参数
    if ($Config.MaxMemory -lt 512 -or $Config.MaxMemory -gt 65536) {
        $Config.MaxMemory = 4096
        Write-Log "WARN" "内存配置无效，使用默认值: $($Config.MaxMemory)MB"
    }
    
    if ($Config.Port -lt 1 -or $Config.Port -gt 65535) {
        $Config.Port = 80
        Write-Log "WARN" "端口配置无效，使用默认值: $($Config.Port)"
    }
    
    return $Config
}

# 配置IIS
function Configure-IIS {
    param($Config)
    
    Write-Log "INFO" "配置IIS..."
    
    try {
        # 安装IIS
        Import-Module ServerManager
        Add-WindowsFeature Web-Server -IncludeManagementTools -ErrorAction Stop
        
        # 配置网站
        Set-ItemProperty -Path "IIS:\Sites\Default Web Site" -Name "bindings" -Value @{
            protocol="http"
            bindingInformation="*:$($Config.Port):$($Config.ServerName)"
        }
        
        # 配置应用程序池
        Set-ItemProperty -Path "IIS:\AppPools\DefaultAppPool" -Name "managedRuntimeVersion" -Value "v4.0"
        Set-ItemProperty -Path "IIS:\AppPools\DefaultAppPool" -Name "managedPipelineMode" -Value "Integrated"
        
        Write-Log "INFO" "IIS配置完成"
    }
    catch {
        Stop-OnError "IIS配置失败: $($_.Exception.Message)"
    }
}

# 配置防火墙
function Configure-Firewall {
    param($Config)
    
    Write-Log "INFO" "配置防火墙..."
    
    try {
        # 允许HTTP和HTTPS
        New-NetFirewallRule -DisplayName "允许HTTP" -Direction Inbound -Protocol TCP -LocalPort $Config.Port -Action Allow -ErrorAction Stop
        New-NetFirewallRule -DisplayName "允许HTTPS" -Direction Inbound -Protocol TCP -LocalPort 443 -Action Allow -ErrorAction Stop
        
        Write-Log "INFO" "防火墙配置完成"
    }
    catch {
        Stop-OnError "防火墙配置失败: $($_.Exception.Message)"
    }
}

# 启动服务
function Start-Services {
    Write-Log "INFO" "启动服务..."
    
    try {
        Start-Service W3SVC -ErrorAction Stop
        Set-Service W3SVC -StartupType Automatic -ErrorAction Stop
        
        Write-Log "INFO" "服务启动完成"
    }
    catch {
        Stop-OnError "服务启动失败: $($_.Exception.Message)"
    }
}

# 验证配置
function Test-Configuration {
    param($Config)
    
    Write-Log "INFO" "验证配置..."
    
    try {
        # 测试端口监听
        $PortTest = Test-NetConnection -ComputerName localhost -Port $Config.Port -ErrorAction Stop
        if (-not $PortTest.TcpTestSucceeded) {
            Stop-OnError "端口测试失败: $($Config.Port)"
        }
        
        Write-Log "INFO" "配置验证通过"
    }
    catch {
        Stop-OnError "配置验证失败: $($_.Exception.Message)"
    }
}

# 主函数
function Main {
    Write-Log "INFO" "开始执行 $Script:ScriptName v$Script:ScriptVersion"
    
    # 检查管理员权限
    if (-not (Test-Administrator)) {
        Stop-OnError "此脚本需要管理员权限运行"
    }
    
    # 显示帮助
    if ($Help) {
        Show-Help
        return
    }
    
    # 加载配置
    $Config = Load-Configuration -ConfigPath $ConfigFile
    
    # 验证配置
    $Config = Validate-Configuration -Config $Config
    
    # 交互式配置
    if ($Interactive) {
        $Config = Invoke-InteractiveConfiguration -Config $Config
    }
    
    # 执行配置
    Configure-System -Config $Config
    
    Write-Log "INFO" "$Script:ScriptName 执行完成"
}

# 执行主函数
Main

脚本化配置管理的局限性

尽管脚本化配置管理相比纯手动配置有了显著改进，但仍存在一些局限性：

1. 脚本维护复杂

# 脚本维护复杂性的示例

# 问题1: 脚本逻辑复杂
configure_complex_system() {
    # 复杂的条件判断
    if [[ $OS_TYPE == "centos" ]]; then
        if [[ $OS_VERSION == "7" ]]; then
            # CentOS 7特定配置
            configure_centos7
        elif [[ $OS_VERSION == "8" ]]; then
            # CentOS 8特定配置
            configure_centos8
        fi
    elif [[ $OS_TYPE == "ubuntu" ]]; then
        if [[ $OS_VERSION == "18.04" ]]; then
            # Ubuntu 18.04特定配置
            configure_ubuntu1804
        elif [[ $OS_VERSION == "20.04" ]]; then
            # Ubuntu 20.04特定配置
            configure_ubuntu2004
        fi
    fi
    
    # 更多复杂逻辑...
}

# 问题2: 错误处理不完善
configure_service() {
    # 简单的错误处理
    systemctl start myservice || echo "启动失败"
    
    # 更好的错误处理应该是:
    if ! systemctl start myservice; then
        log "ERROR" "服务启动失败，尝试重启..."
        systemctl restart myservice || {
            log "ERROR" "服务重启失败"
            return 1
        }
    fi
}

2. 环境依赖性强

# 环境依赖性示例

# 问题: 脚本依赖特定环境
function Configure-Application {
    param($Config)
    
    # 假设特定路径存在
    $AppPath = "C:\Program Files\MyApp"
    
    # 假设特定用户存在
    $ServiceUser = "MyAppUser"
    
    # 假设特定端口可用
    $Port = 8080
    
    # 这些假设在不同环境中可能不成立
    # 需要添加环境检查
    if (-not (Test-Path $AppPath)) {
        Stop-OnError "应用程序路径不存在: $AppPath"
    }
    
    if (-not (Get-LocalUser -Name $ServiceUser -ErrorAction SilentlyContinue)) {
        Stop-OnError "服务用户不存在: $ServiceUser"
    }
    
    if (Get-NetTCPConnection -LocalPort $Port -ErrorAction SilentlyContinue) {
        Stop-OnError "端口已被占用: $Port"
    }
}

3. 缺乏状态管理

# 缺乏状态管理的示例

# 问题: 脚本无法知道系统当前状态
reconfigure_system() {
    # 总是执行完整配置，即使只需要部分变更
    stop_services
    update_config_files
    start_services
    
    # 更好的做法应该是检查当前状态
    if ! is_service_running "myservice"; then
        start_service "myservice"
    fi
    
    if has_config_changed "/etc/myapp.conf"; then
        reload_service "myservice"
    fi
}

# 状态检查函数
is_service_running() {
    local service=$1
    systemctl is-active --quiet $service
}

has_config_changed() {
    local config_file=$1
    # 检查配置文件是否发生变化
    # 可以使用checksum或mtime比较
    local current_checksum=$(md5sum $config_file | cut -d' ' -f1)
    local saved_checksum=$(cat "$config_file.checksum" 2>/dev/null || echo "")
    
    if [[ $current_checksum != $saved_checksum ]]; then
        echo $current_checksum > "$config_file.checksum"
        return 0  # 配置已更改
    else
        return 1  # 配置未更改
    fi
}

总结

基于脚本的配置管理是配置管理发展的重要阶段，它通过脚本化执行显著提高了配置效率，减少了人为错误，并改善了配置一致性。然而，脚本化方法仍然存在维护复杂、环境依赖性强、缺乏状态管理等局限性。

这些局限性推动了更高级的自动化配置管理工具的发展，如Ansible、Chef、Puppet等。在下一节中，我们将探讨文档驱动的配置管理方法，了解如何通过文档化来进一步规范配置管理流程。