Alpine Linux脚本编程从入门到精通 轻量级系统下的高效自动化实践指南

威震华夏关云长

1. 介绍Alpine Linux及其脚本编程的特点

Alpine Linux是一个基于musl libc和BusyBox的轻量级Linux发行版，以其小巧、安全和高效率而闻名。与传统的Linux发行版相比，Alpine Linux的镜像大小通常只有几MB，这使得它特别适合容器化环境和资源受限的系统。

在Alpine Linux中进行脚本编程有几个显著特点：

1. 资源占用小：Alpine Linux使用BusyBox代替了GNU核心工具集，这意味着大多数标准Unix工具都以更小的体积提供。
2. 安全性高：默认情况下，Alpine Linux采用了多种安全加固措施，如地址空间布局随机化（ASLR）和栈粉碎保护（SSP）。
3. 兼容性考虑：由于使用musl libc而不是glibc，一些在传统Linux发行版上工作的脚本可能需要调整。
4. 包管理系统：Alpine Linux使用APK（Alpine Package Keeper）作为其包管理器，与传统的apt或yum不同。

这些特点使得Alpine Linux成为Docker容器、嵌入式系统和边缘计算设备的理想选择，同时也为脚本编程带来了一些独特的考虑因素。

2. Alpine Linux脚本编程基础

Shell环境介绍

Alpine Linux默认使用Ash shell（Almquist shell）作为其/bin/sh，而不是更常见的Bash。Ash是一个轻量级的POSIX兼容shell，它比Bash小得多，但功能也相对有限。这意味着在Alpine Linux中编写脚本时，需要更加注重POSIX兼容性，避免使用Bash特有的功能。

要检查当前使用的shell，可以运行以下命令：

2. echo $SHELL

复制代码

在Alpine Linux中，输出通常是/bin/sh，指向Ash。

如果你需要Bash功能，可以通过APK安装：

2. apk add bash

复制代码

安装后，可以通过#!/bin/bash来指定使用Bash解释器运行脚本。

基本语法

Alpine Linux中的脚本遵循标准的shell脚本语法，但需要注意与Ash的兼容性。以下是一个基本的”Hello World”脚本：

2. #!/bin/sh
4. echo "Hello, Alpine Linux!"

复制代码

保存为hello.sh后，需要赋予执行权限：

2. chmod +x hello.sh

复制代码

然后运行：

2. ./hello.sh

复制代码

变量和数据类型

在Ash中，变量不需要显式声明类型，所有变量本质上都是字符串。以下是变量使用的基本示例：

2. #!/bin/sh
4. # 变量赋值（注意：等号两边不能有空格）
5. name="Alpine Linux"
6. version="3.15"
8. # 变量使用
9. echo "Welcome to $name version $version"
11. # 命令替换（使用反引号或$()）
12. current_dir=$(pwd)
13. echo "Current directory: $current_dir"
15. # 环境变量
16. echo "Home directory: $HOME"
17. echo "Path: $PATH"
19. # 只读变量
20. readonly constant="This cannot be changed"
21. echo "Constant: $constant"
23. # 尝试修改只读变量（会报错）
24. constant="New value"

复制代码

控制结构

Ash支持标准的控制结构，如条件判断和循环。以下是一些示例：

2. #!/bin/sh
4. # if-else结构
5. count=10
6. if [ $count -gt 5 ]; then
7.     echo "Count is greater than 5"
8. else
9.     echo "Count is not greater than 5"
10. fi
12. # case结构
13. option="start"
14. case $option in
15.     start)
16.         echo "Starting service"
17.         ;;
18.     stop)
19.         echo "Stopping service"
20.         ;;
21.     restart)
22.         echo "Restarting service"
23.         ;;
24.     *)
25.         echo "Usage: $0 {start|stop|restart}"
26.         exit 1
27.         ;;
28. esac

复制代码

2. #!/bin/sh
4. # for循环
5. echo "Counting with for loop:"
6. for i in 1 2 3 4 5; do
7.     echo "Number: $i"
8. done
10. # while循环
11. echo "Counting with while loop:"
12. counter=1
13. while [ $counter -le 5 ]; do
14.     echo "Counter: $counter"
15.     counter=$((counter + 1))
16. done
18. # until循环
19. echo "Counting with until loop:"
20. counter=1
21. until [ $counter -gt 5 ]; do
22.     echo "Counter: $counter"
23.     counter=$((counter + 1))
24. done

复制代码

3. Alpine Linux脚本编程进阶

函数和模块化编程

在Alpine Linux脚本中，函数可以帮助你组织代码，使其更加模块化和可重用。以下是如何在Ash中定义和使用函数：

2. #!/bin/sh
4. # 定义函数
5. greet() {
6.     echo "Hello, $1!"
7. }
9. # 调用函数
10. greet "World"
12. # 带返回值的函数
13. add() {
14.     local sum=$(( $1 + $2 ))
15.     echo $sum
16. }
18. result=$(add 5 3)
19. echo "5 + 3 = $result"
21. # 使用全局变量
22. global_var="I'm global"
24. show_global() {
25.     echo "Global variable: $global_var"
26. }
28. show_global
30. # 使用局部变量
31. show_local() {
32.     local local_var="I'm local"
33.     echo "Local variable: $local_var"
34. }
36. show_local
38. # 尝试访问局部变量（会失败）
39. echo "Trying to access local variable: $local_var"

复制代码

文本处理工具

Alpine Linux提供了多种文本处理工具，虽然它们通常是BusyBox的简化版本，但功能仍然强大。以下是一些常用的文本处理工具及其示例：

2. #!/bin/sh
4. # 在文件中搜索模式
5. echo "Searching for 'root' in /etc/passwd:"
6. grep "root" /etc/passwd
8. # 使用正则表达式
9. echo "Searching for lines starting with 'r' in /etc/passwd:"
10. grep "^r" /etc/passwd
12. # 反向匹配
13. echo "Searching for lines not containing 'nologin' in /etc/passwd:"
14. grep -v "nologin" /etc/passwd
16. # 计数匹配行
17. echo "Counting lines containing 'root' in /etc/passwd:"
18. grep -c "root" /etc/passwd

复制代码

2. #!/bin/sh
4. # 创建测试文件
5. cat > test.txt <<EOF
6. Line 1
7. Line 2
8. Line 3
9. Line 4
10. Line 5
11. EOF
13. # 替换文本
14. echo "Replacing 'Line' with 'Row':"
15. sed 's/Line/Row/g' test.txt
17. # 删除行
18. echo "Deleting line 3:"
19. sed '3d' test.txt
21. # 插入行
22. echo "Inserting a line after line 2:"
23. sed '2a\Inserted Line' test.txt
25. # 只显示特定行
26. echo "Showing only lines 2-4:"
27. sed -n '2,4p' test.txt
29. # 清理测试文件
30. rm test.txt

复制代码

2. #!/bin/sh
4. # 创建测试文件
5. cat > data.csv <<EOF
6. Name,Age,City
7. Alice,30,New York
8. Bob,25,Los Angeles
9. Charlie,35,Chicago
10. EOF
12. # 打印特定列
13. echo "Printing names and cities:"
14. awk -F, '{print $1 " lives in " $3}' data.csv
16. # 过滤行
17. echo "Filtering people older than 30:"
18. awk -F, '$2 > 30 {print $1 " is " $2 " years old"}' data.csv
20. # 计算总和
21. echo "Calculating total age:"
22. awk -F, 'NR>1 {sum+=$2} END {print "Total age: " sum}' data.csv
24. # 清理测试文件
25. rm data.csv

复制代码

系统管理脚本

Alpine Linux的轻量级特性使其成为系统管理脚本的理想平台。以下是一些常见的系统管理任务脚本示例：

2. #!/bin/sh
4. # 服务管理脚本
5. SERVICE_NAME="nginx"
6. SERVICE_PID="/var/run/$SERVICE_NAME.pid"
8. start() {
9.     if [ -f $SERVICE_PID ]; then
10.         echo "$SERVICE_NAME is already running."
11.         return 1
12.     fi
13.     echo "Starting $SERVICE_NAME..."
14.     /usr/sbin/nginx
15.     if [ $? -eq 0 ]; then
16.         echo "$SERVICE_NAME started successfully."
17.     else
18.         echo "Failed to start $SERVICE_NAME."
19.         return 1
20.     fi
21. }
23. stop() {
24.     if [ ! -f $SERVICE_PID ]; then
25.         echo "$SERVICE_NAME is not running."
26.         return 1
27.     fi
28.     echo "Stopping $SERVICE_NAME..."
29.     kill $(cat $SERVICE_PID)
30.     if [ $? -eq 0 ]; then
31.         rm -f $SERVICE_PID
32.         echo "$SERVICE_NAME stopped successfully."
33.     else
34.         echo "Failed to stop $SERVICE_NAME."
35.         return 1
36.     fi
37. }
39. status() {
40.     if [ -f $SERVICE_PID ]; then
41.         echo "$SERVICE_NAME is running with PID $(cat $SERVICE_PID)."
42.     else
43.         echo "$SERVICE_NAME is not running."
44.     fi
45. }
47. restart() {
48.     stop
49.     sleep 2
50.     start
51. }
53. case "$1" in
54.     start)
55.         start
56.         ;;
57.     stop)
58.         stop
59.         ;;
60.     status)
61.         status
62.         ;;
63.     restart)
64.         restart
65.         ;;
66.     *)
67.         echo "Usage: $0 {start|stop|status|restart}"
68.         exit 1
69.         ;;
70. esac
72. exit 0

复制代码

2. #!/bin/sh
4. # 日志管理脚本
5. LOG_DIR="/var/log"
6. LOG_FILES="messages auth.log kern.log"
7. MAX_SIZE=10485760  # 10MB
8. MAX_FILES=5
10. rotate_logs() {
11.     for log_file in $LOG_FILES; do
12.         log_path="$LOG_DIR/$log_file"
13.         if [ -f "$log_path" ]; then
14.             size=$(stat -c%s "$log_path")
15.             if [ $size -gt $MAX_SIZE ]; then
16.                 echo "Rotating $log_path..."
17.                
18.                 # 删除最旧的归档
19.                 if [ -f "${log_path}.${MAX_FILES}" ]; then
20.                     rm -f "${log_path}.${MAX_FILES}"
21.                 fi
22.                
23.                 # 移动现有归档
24.                 i=$((MAX_FILES - 1))
25.                 while [ $i -gt 0 ]; do
26.                     if [ -f "${log_path}.${i}" ]; then
27.                         mv "${log_path}.${i}" "${log_path}.$((i + 1))"
28.                     fi
29.                     i=$((i - 1))
30.                 done
31.                
32.                 # 移动当前日志
33.                 mv "$log_path" "${log_path}.1"
34.                
35.                 # 创建新日志文件
36.                 touch "$log_path"
37.                 chmod 640 "$log_path"
38.                
39.                 echo "Log rotation completed for $log_path."
40.             fi
41.         fi
42.     done
43. }
45. compress_old_logs() {
46.     for log_file in $LOG_FILES; do
47.         log_path="$LOG_DIR/$log_file"
48.         # 压缩除最新归档外的所有归档
49.         for i in $(seq 2 $MAX_FILES); do
50.             if [ -f "${log_path}.${i}" ] && [ ! -f "${log_path}.${i}.gz" ]; then
51.                 echo "Compressing ${log_path}.${i}..."
52.                 gzip "${log_path}.${i}"
53.             fi
54.         done
55.     done
56. }
58. case "$1" in
59.     rotate)
60.         rotate_logs
61.         ;;
62.     compress)
63.         compress_old_logs
64.         ;;
65.     *)
66.         echo "Usage: $0 {rotate|compress}"
67.         exit 1
68.         ;;
69. esac
71. exit 0

复制代码

2. #!/bin/sh
4. # 系统监控脚本
5. ALERT_EMAIL="admin@example.com"
6. ALERT_SUBJECT="System Alert: $(hostname)"
7. TEMP_THRESHOLD=80  # CPU温度阈值（摄氏度）
8. DISK_THRESHOLD=90  # 磁盘使用率阈值（百分比）
9. MEM_THRESHOLD=90   # 内存使用率阈值（百分比）
11. send_alert() {
12.     local message="$1"
13.     echo "$message" | mail -s "$ALERT_SUBJECT" "$ALERT_EMAIL"
14.     echo "Alert sent: $message"
15. }
17. check_cpu_temp() {
18.     if [ -f /sys/class/thermal/thermal_zone0/temp ]; then
19.         temp=$(cat /sys/class/thermal/thermal_zone0/temp)
20.         temp=$((temp / 1000))  # 转换为摄氏度
21.         
22.         if [ $temp -gt $TEMP_THRESHOLD ]; then
23.             message="WARNING: CPU temperature is ${temp}°C, exceeding threshold of ${TEMP_THRESHOLD}°C"
24.             echo "$message"
25.             send_alert "$message"
26.         else
27.             echo "CPU temperature is ${temp}°C, within normal range."
28.         fi
29.     else
30.         echo "CPU temperature sensor not available."
31.     fi
32. }
34. check_disk_usage() {
35.     df -h | grep -vE '^Filesystem|tmpfs|cdrom' | while read -r line; do
36.         usage=$(echo "$line" | awk '{print $5}' | sed 's/%//')
37.         partition=$(echo "$line" | awk '{print $6}')
38.         
39.         if [ "$usage" -gt "$DISK_THRESHOLD" ]; then
40.             message="WARNING: Disk usage on $partition is ${usage}%, exceeding threshold of ${DISK_THRESHOLD}%"
41.             echo "$message"
42.             send_alert "$message"
43.         else
44.             echo "Disk usage on $partition is ${usage}%, within normal range."
45.         fi
46.     done
47. }
49. check_memory_usage() {
50.     if [ -f /proc/meminfo ]; then
51.         total_mem=$(grep MemTotal /proc/meminfo | awk '{print $2}')
52.         free_mem=$(grep MemAvailable /proc/meminfo | awk '{print $2}')
53.         used_mem=$((total_mem - free_mem))
54.         usage=$((used_mem * 100 / total_mem))
55.         
56.         if [ "$usage" -gt "$MEM_THRESHOLD" ]; then
57.             message="WARNING: Memory usage is ${usage}%, exceeding threshold of ${MEM_THRESHOLD}%"
58.             echo "$message"
59.             send_alert "$message"
60.         else
61.             echo "Memory usage is ${usage}%, within normal range."
62.         fi
63.     else
64.         echo "Memory information not available."
65.     fi
66. }
68. # 主监控函数
69. monitor() {
70.     echo "===== System Monitoring Report ====="
71.     echo "Date: $(date)"
72.     echo "Hostname: $(hostname)"
73.     echo
74.    
75.     echo "=== CPU Temperature Check ==="
76.     check_cpu_temp
77.     echo
78.    
79.     echo "=== Disk Usage Check ==="
80.     check_disk_usage
81.     echo
82.    
83.     echo "=== Memory Usage Check ==="
84.     check_memory_usage
85.     echo
86.    
87.     echo "===== Monitoring Complete ====="
88. }
90. # 执行监控
91. monitor

复制代码

4. 实际应用案例

系统维护脚本

以下是一个系统维护脚本，用于定期清理系统、更新软件包和备份重要文件：

2. #!/bin/sh
4. # 系统维护脚本
5. BACKUP_DIR="/var/backups"
6. LOG_FILE="/var/log/system_maintenance.log"
7. TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
9. # 创建日志函数
10. log() {
11.     echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" | tee -a "$LOG_FILE"
12. }
14. # 检查并创建备份目录
15. check_backup_dir() {
16.     if [ ! -d "$BACKUP_DIR" ]; then
17.         log "Creating backup directory: $BACKUP_DIR"
18.         mkdir -p "$BACKUP_DIR"
19.     fi
20. }
22. # 清理临时文件
23. clean_temp() {
24.     log "Cleaning temporary files..."
25.    
26.     # 清理/tmp目录中超过7天的文件
27.     find /tmp -type f -mtime +7 -delete 2>/dev/null
28.     log "Cleaned files in /tmp older than 7 days"
29.    
30.     # 清理/var/tmp目录中超过30天的文件
31.     find /var/tmp -type f -mtime +30 -delete 2>/dev/null
32.     log "Cleaned files in /var/tmp older than 30 days"
33.    
34.     # 清理日志文件
35.     find /var/log -type f -name "*.log.*" -mtime +30 -delete 2>/dev/null
36.     log "Cleaned log files older than 30 days"
37. }
39. # 更新系统
40. update_system() {
41.     log "Updating system packages..."
42.    
43.     # 更新包索引
44.     apk update
45.    
46.     # 升级所有包
47.     if apk upgrade; then
48.         log "System packages updated successfully"
49.     else
50.         log "ERROR: Failed to update system packages"
51.         return 1
52.     fi
53. }
55. # 清理未使用的包
56. cleanup_packages() {
57.     log "Cleaning up unused packages..."
58.    
59.     # 删除缓存
60.     rm -rf /var/cache/apk/*
61.     log "Cleaned APK cache"
62. }
64. # 备份重要配置文件
65. backup_configs() {
66.     log "Backing up important configuration files..."
67.    
68.     backup_file="${BACKUP_DIR}/config_backup_${TIMESTAMP}.tar.gz"
69.    
70.     # 创建备份
71.     tar -czf "$backup_file" \
72.         /etc/passwd \
73.         /etc/group \
74.         /etc/shadow \
75.         /etc/hosts \
76.         /etc/fstab \
77.         /etc/network/interfaces \
78.         /etc/apk/repositories \
79.         2>/dev/null
80.    
81.     if [ $? -eq 0 ]; then
82.         log "Configuration backup created: $backup_file"
83.         
84.         # 删除超过30天的备份
85.         find "$BACKUP_DIR" -name "config_backup_*.tar.gz" -mtime +30 -delete
86.         log "Cleaned old configuration backups"
87.     else
88.         log "ERROR: Failed to create configuration backup"
89.         return 1
90.     fi
91. }
93. # 备份用户数据
94. backup_userdata() {
95.     log "Backing up user data..."
96.    
97.     backup_file="${BACKUP_DIR}/userdata_backup_${TIMESTAMP}.tar.gz"
98.    
99.     # 创建备份
100.     tar -czf "$backup_file" \
101.         /home \
102.         /root \
103.         2>/dev/null
104.    
105.     if [ $? -eq 0 ]; then
106.         log "User data backup created: $backup_file"
107.         
108.         # 删除超过7天的备份
109.         find "$BACKUP_DIR" -name "userdata_backup_*.tar.gz" -mtime +7 -delete
110.         log "Cleaned old user data backups"
111.     else
112.         log "ERROR: Failed to create user data backup"
113.         return 1
114.     fi
115. }
117. # 检查磁盘空间
118. check_disk_space() {
119.     log "Checking disk space..."
120.    
121.     df -h | grep -vE '^Filesystem|tmpfs|cdrom' | while read -r line; do
122.         usage=$(echo "$line" | awk '{print $5}' | sed 's/%//')
123.         partition=$(echo "$line" | awk '{print $6}')
124.         
125.         if [ "$usage" -gt 90 ]; then
126.             log "WARNING: Disk usage on $partition is ${usage}%, exceeding 90% threshold"
127.         else
128.             log "Disk usage on $partition is ${usage}%, within normal range"
129.         fi
130.     done
131. }
133. # 主函数
134. main() {
135.     log "===== Starting System Maintenance ====="
136.    
137.     check_backup_dir
138.    
139.     clean_temp
140.     update_system
141.     cleanup_packages
142.     backup_configs
143.     backup_userdata
144.     check_disk_space
145.    
146.     log "===== System Maintenance Complete ====="
147. }
149. # 执行主函数
150. main

复制代码

网络管理脚本

以下是一个网络管理脚本，用于监控网络状态、配置网络接口和进行网络诊断：

2. #!/bin/sh
4. # 网络管理脚本
5. CONFIG_DIR="/etc/network"
6. LOG_FILE="/var/log/network_management.log"
7. HOSTS_TO_PING="8.8.8.8 1.1.1.1"
9. # 创建日志函数
10. log() {
11.     echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" | tee -a "$LOG_FILE"
12. }
14. # 检查网络接口状态
15. check_interfaces() {
16.     log "Checking network interfaces..."
17.    
18.     # 列出所有网络接口
19.     interfaces=$(ip link show | grep -E '^[0-9]+:' | awk '{print $2}' | sed 's/://')
20.    
21.     for interface in $interfaces; do
22.         status=$(ip link show "$interface" | grep -o 'state [A-Z]*' | awk '{print $2}')
23.         log "Interface $interface: state $status"
24.         
25.         # 如果接口状态为UP，则显示IP地址
26.         if [ "$status" = "UP" ]; then
27.             ip_addr=$(ip addr show "$interface" | grep -o 'inet [0-9]*\.[0-9]*\.[0-9]*\.[0-9]*' | awk '{print $2}')
28.             if [ -n "$ip_addr" ]; then
29.                 log "  IP Address: $ip_addr"
30.             fi
31.         fi
32.     done
33. }
35. # 配置网络接口
36. configure_interface() {
37.     local interface="$1"
38.     local ip_address="$2"
39.     local netmask="$3"
40.     local gateway="$4"
41.    
42.     log "Configuring interface $interface with IP $ip_address..."
43.    
44.     # 检查接口是否存在
45.     if ! ip link show "$interface" >/dev/null 2>&1; then
46.         log "ERROR: Interface $interface does not exist"
47.         return 1
48.     fi
49.    
50.     # 启用接口
51.     ip link set "$interface" up
52.    
53.     # 配置IP地址
54.     ip addr add "$ip_address/$netmask" dev "$interface"
55.    
56.     # 如果提供了网关，则设置默认路由
57.     if [ -n "$gateway" ]; then
58.         ip route add default via "$gateway"
59.     fi
60.    
61.     log "Interface $interface configured successfully"
62. }
64. # 测试网络连接
65. test_connectivity() {
66.     log "Testing network connectivity..."
67.    
68.     for host in $HOSTS_TO_PING; do
69.         log "Pinging $host..."
70.         if ping -c 3 -W 2 "$host" >/dev/null 2>&1; then
71.             log "  Successfully pinged $host"
72.         else
73.             log "  ERROR: Failed to ping $host"
74.         fi
75.     done
76. }
78. # 显示网络统计信息
79. show_stats() {
80.     log "Displaying network statistics..."
81.    
82.     # 显示接口统计
83.     interfaces=$(ip link show | grep -E '^[0-9]+:' | awk '{print $2}' | sed 's/://')
84.    
85.     for interface in $interfaces; do
86.         log "Statistics for $interface:"
87.         ip -s link show "$interface" | grep -E 'RX|TX' | while read -r line; do
88.             log "  $line"
89.         done
90.     done
91.    
92.     # 显示连接统计
93.     log "Active connections:"
94.     netstat -an | grep ESTABLISHED | wc -l | xargs -I{} log "  {} established connections"
95.    
96.     # 显示路由表
97.     log "Routing table:"
98.     ip route show | while read -r line; do
99.         log "  $line"
100.     done
101. }
103. # 重启网络服务
104. restart_network() {
105.     log "Restarting network services..."
106.    
107.     # 重启网络服务（在Alpine Linux中通常是networking服务）
108.     if rc-service networking restart; then
109.         log "Network services restarted successfully"
110.     else
111.         log "ERROR: Failed to restart network services"
112.         return 1
113.     fi
114. }
116. # 设置静态DNS
117. set_dns() {
118.     local dns_servers="$1"
119.    
120.     log "Setting DNS servers to $dns_servers..."
121.    
122.     # 备份当前resolv.conf
123.     cp /etc/resolv.conf /etc/resolv.conf.bak
124.    
125.     # 创建新的resolv.conf
126.     echo "# Generated by network management script" > /etc/resolv.conf
127.    
128.     # 添加DNS服务器
129.     for dns in $dns_servers; do
130.         echo "nameserver $dns" >> /etc/resolv.conf
131.     done
132.    
133.     log "DNS servers updated successfully"
134. }
136. # 诊断网络问题
137. diagnose_issues() {
138.     log "Diagnosing network issues..."
139.    
140.     # 检查默认路由
141.     default_route=$(ip route show | grep default)
142.     if [ -n "$default_route" ]; then
143.         log "Default route found: $default_route"
144.     else
145.         log "WARNING: No default route found"
146.     fi
147.    
148.     # 检查DNS解析
149.     log "Testing DNS resolution..."
150.     if nslookup google.com >/dev/null 2>&1; then
151.         log "DNS resolution working correctly"
152.     else
153.         log "ERROR: DNS resolution failed"
154.     fi
155.    
156.     # 检查关键端口
157.     log "Checking critical ports..."
158.     ports="22 80 443"
159.     for port in $ports; do
160.         log "Checking port $port..."
161.         if netstat -tuln | grep -q ":$port "; then
162.             log "  Port $port is open"
163.         else
164.             log "  Port $port is closed or not listening"
165.         fi
166.     done
167. }
169. # 主函数
170. main() {
171.     case "$1" in
172.         check)
173.             log "===== Network Check Started ====="
174.             check_interfaces
175.             test_connectivity
176.             log "===== Network Check Complete ====="
177.             ;;
178.         configure)
179.             if [ $# -ne 5 ]; then
180.                 echo "Usage: $0 configure <interface> <ip_address> <netmask> <gateway>"
181.                 exit 1
182.             fi
183.             log "===== Network Configuration Started ====="
184.             configure_interface "$2" "$3" "$4" "$5"
185.             log "===== Network Configuration Complete ====="
186.             ;;
187.         stats)
188.             log "===== Network Statistics ====="
189.             show_stats
190.             log "===== Statistics Display Complete ====="
191.             ;;
192.         restart)
193.             log "===== Network Restart Started ====="
194.             restart_network
195.             log "===== Network Restart Complete ====="
196.             ;;
197.         dns)
198.             if [ $# -ne 2 ]; then
199.                 echo "Usage: $0 dns <dns_servers>"
200.                 exit 1
201.             fi
202.             log "===== DNS Configuration Started ====="
203.             set_dns "$2"
204.             log "===== DNS Configuration Complete ====="
205.             ;;
206.         diagnose)
207.             log "===== Network Diagnostics Started ====="
208.             diagnose_issues
209.             log "===== Network Diagnostics Complete ====="
210.             ;;
211.         *)
212.             echo "Usage: $0 {check|configure|stats|restart|dns|diagnose}"
213.             echo "  check - Check network interfaces and connectivity"
214.             echo "  configure <interface> <ip_address> <netmask> <gateway> - Configure network interface"
215.             echo "  stats - Display network statistics"
216.             echo "  restart - Restart network services"
217.             echo "  dns <dns_servers> - Set DNS servers (space-separated)"
218.             echo "  diagnose - Diagnose network issues"
219.             exit 1
220.             ;;
221.     esac
222. }
224. # 执行主函数
225. main "$@"

复制代码

容器环境脚本

以下是一个容器环境管理脚本，用于在Alpine Linux上管理Docker容器：

2. #!/bin/sh
4. # 容器环境管理脚本
5. DATA_DIR="/var/lib/docker-containers"
6. LOG_DIR="/var/log/docker-containers"
7. COMPOSE_FILE="$DATA_DIR/docker-compose.yml"
9. # 创建日志函数
10. log() {
11.     echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" | tee -a "$LOG_DIR/management.log"
12. }
14. # 检查并创建必要目录
15. check_dirs() {
16.     if [ ! -d "$DATA_DIR" ]; then
17.         log "Creating data directory: $DATA_DIR"
18.         mkdir -p "$DATA_DIR"
19.     fi
20.    
21.     if [ ! -d "$LOG_DIR" ]; then
22.         log "Creating log directory: $LOG_DIR"
23.         mkdir -p "$LOG_DIR"
24.     fi
25. }
27. # 检查Docker是否安装
28. check_docker() {
29.     if ! command -v docker >/dev/null 2>&1; then
30.         log "ERROR: Docker is not installed"
31.         return 1
32.     fi
33.    
34.     if ! docker info >/dev/null 2>&1; then
35.         log "ERROR: Docker daemon is not running"
36.         return 1
37.     fi
38.    
39.     log "Docker is installed and running"
40.     return 0
41. }
43. # 安装Docker
44. install_docker() {
45.     log "Installing Docker..."
46.    
47.     # 安装必要的包
48.     apk add docker docker-cli-compose
49.    
50.     # 启动Docker服务
51.     rc-update add docker boot
52.     service docker start
53.    
54.     # 验证安装
55.     if docker info >/dev/null 2>&1; then
56.         log "Docker installed and started successfully"
57.         return 0
58.     else
59.         log "ERROR: Failed to start Docker after installation"
60.         return 1
61.     fi
62. }
64. # 创建Docker Compose文件
65. create_compose_file() {
66.     log "Creating Docker Compose file..."
67.    
68.     cat > "$COMPOSE_FILE" <<EOF
69. version: '3'
71. services:
72.   nginx:
73.     image: nginx:alpine
74.     container_name: nginx
75.     ports:
76.       - "80:80"
77.       - "443:443"
78.     volumes:
79.       - $DATA_DIR/nginx/conf:/etc/nginx/conf.d
80.       - $DATA_DIR/nginx/html:/usr/share/nginx/html
81.       - $DATA_DIR/nginx/logs:/var/log/nginx
82.     restart: unless-stopped
83.    
84.   mysql:
85.     image: mysql:5.7
86.     container_name: mysql
87.     environment:
88.       MYSQL_ROOT_PASSWORD: your_root_password
89.       MYSQL_DATABASE: your_database
90.       MYSQL_USER: your_user
91.       MYSQL_PASSWORD: your_password
92.     volumes:
93.       - $DATA_DIR/mysql/data:/var/lib/mysql
94.       - $DATA_DIR/mysql/conf:/etc/mysql/conf.d
95.     restart: unless-stopped
96.    
97.   php:
98.     image: php:7.4-fpm-alpine
99.     container_name: php
100.     volumes:
101.       - $DATA_DIR/nginx/html:/var/www/html
102.     restart: unless-stopped
103. EOF
105.     log "Docker Compose file created: $COMPOSE_FILE"
106. }
108. # 启动容器
109. start_containers() {
110.     log "Starting containers..."
111.    
112.     if [ ! -f "$COMPOSE_FILE" ]; then
113.         log "ERROR: Docker Compose file not found: $COMPOSE_FILE"
114.         return 1
115.     fi
116.    
117.     cd "$DATA_DIR"
118.    
119.     if docker-compose up -d; then
120.         log "Containers started successfully"
121.         return 0
122.     else
123.         log "ERROR: Failed to start containers"
124.         return 1
125.     fi
126. }
128. # 停止容器
129. stop_containers() {
130.     log "Stopping containers..."
131.    
132.     if [ ! -f "$COMPOSE_FILE" ]; then
133.         log "ERROR: Docker Compose file not found: $COMPOSE_FILE"
134.         return 1
135.     fi
136.    
137.     cd "$DATA_DIR"
138.    
139.     if docker-compose down; then
140.         log "Containers stopped successfully"
141.         return 0
142.     else
143.         log "ERROR: Failed to stop containers"
144.         return 1
145.     fi
146. }
148. # 重启容器
149. restart_containers() {
150.     log "Restarting containers..."
151.    
152.     stop_containers
153.     sleep 2
154.     start_containers
155. }
157. # 显示容器状态
158. show_status() {
159.     log "Displaying container status..."
160.    
161.     cd "$DATA_DIR"
162.    
163.     echo "===== Container Status ====="
164.     docker-compose ps
165.    
166.     echo ""
167.     echo "===== Resource Usage ====="
168.     docker stats --no-stream
169. }
171. # 备份容器数据
172. backup_data() {
173.     log "Backing up container data..."
174.    
175.     backup_file="$DATA_DIR/backup_$(date +"%Y%m%d_%H%M%S").tar.gz"
176.    
177.     # 创建备份
178.     tar -czf "$backup_file" -C "$DATA_DIR" .
179.    
180.     if [ $? -eq 0 ]; then
181.         log "Container data backed up to: $backup_file"
182.         
183.         # 删除超过7天的备份
184.         find "$DATA_DIR" -name "backup_*.tar.gz" -mtime +7 -delete
185.         log "Cleaned old backups"
186.     else
187.         log "ERROR: Failed to backup container data"
188.         return 1
189.     fi
190. }
192. # 恢复容器数据
193. restore_data() {
194.     local backup_file="$1"
195.    
196.     if [ -z "$backup_file" ]; then
197.         log "ERROR: No backup file specified"
198.         return 1
199.     fi
200.    
201.     if [ ! -f "$backup_file" ]; then
202.         log "ERROR: Backup file not found: $backup_file"
203.         return 1
204.     fi
205.    
206.     log "Restoring container data from: $backup_file"
207.    
208.     # 停止容器
209.     stop_containers
210.    
211.     # 备份当前数据
212.     if [ -d "$DATA_DIR" ]; then
213.         current_backup="$DATA_DIR/pre_restore_$(date +"%Y%m%d_%H%M%S")"
214.         mv "$DATA_DIR" "$current_backup"
215.         log "Current data backed up to: $current_backup"
216.     fi
217.    
218.     # 创建新目录
219.     mkdir -p "$DATA_DIR"
220.    
221.     # 恢复数据
222.     tar -xzf "$backup_file" -C "$DATA_DIR"
223.    
224.     if [ $? -eq 0 ]; then
225.         log "Container data restored successfully"
226.         
227.         # 启动容器
228.         start_containers
229.     else
230.         log "ERROR: Failed to restore container data"
231.         return 1
232.     fi
233. }
235. # 更新容器镜像
236. update_images() {
237.     log "Updating container images..."
238.    
239.     cd "$DATA_DIR"
240.    
241.     # 拉取最新镜像
242.     if docker-compose pull; then
243.         log "Container images updated successfully"
244.         
245.         # 重启容器以使用新镜像
246.         restart_containers
247.     else
248.         log "ERROR: Failed to update container images"
249.         return 1
250.     fi
251. }
253. # 清理未使用的Docker资源
254. cleanup_docker() {
255.     log "Cleaning up unused Docker resources..."
256.    
257.     # 删除停止的容器
258.     stopped_containers=$(docker ps -q -f status=exited)
259.     if [ -n "$stopped_containers" ]; then
260.         log "Removing stopped containers..."
261.         echo "$stopped_containers" | xargs docker rm
262.     fi
263.    
264.     # 删除未使用的镜像
265.     dangling_images=$(docker images -q -f dangling=true)
266.     if [ -n "$dangling_images" ]; then
267.         log "Removing dangling images..."
268.         echo "$dangling_images" | xargs docker rmi
269.     fi
270.    
271.     # 删除未使用的网络
272.     unused_networks=$(docker network ls -q -f dangling=true)
273.     if [ -n "$unused_networks" ]; then
274.         log "Removing unused networks..."
275.         echo "$unused_networks" | xargs docker network rm
276.     fi
277.    
278.     # 删除未使用的卷
279.     unused_volumes=$(docker volume ls -q -f dangling=true)
280.     if [ -n "$unused_volumes" ]; then
281.         log "Removing unused volumes..."
282.         echo "$unused_volumes" | xargs docker volume rm
283.     fi
284.    
285.     log "Docker cleanup completed"
286. }
288. # 主函数
289. main() {
290.     check_dirs
291.    
292.     case "$1" in
293.         install)
294.             log "===== Docker Installation Started ====="
295.             install_docker
296.             log "===== Docker Installation Complete ====="
297.             ;;
298.         setup)
299.             log "===== Container Setup Started ====="
300.             check_docker || install_docker
301.             create_compose_file
302.             start_containers
303.             log "===== Container Setup Complete ====="
304.             ;;
305.         start)
306.             log "===== Container Start Started ====="
307.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
308.             start_containers
309.             log "===== Container Start Complete ====="
310.             ;;
311.         stop)
312.             log "===== Container Stop Started ====="
313.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
314.             stop_containers
315.             log "===== Container Stop Complete ====="
316.             ;;
317.         restart)
318.             log "===== Container Restart Started ====="
319.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
320.             restart_containers
321.             log "===== Container Restart Complete ====="
322.             ;;
323.         status)
324.             log "===== Container Status ====="
325.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
326.             show_status
327.             log "===== Status Display Complete ====="
328.             ;;
329.         backup)
330.             log "===== Container Backup Started ====="
331.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
332.             backup_data
333.             log "===== Container Backup Complete ====="
334.             ;;
335.         restore)
336.             if [ $# -ne 2 ]; then
337.                 echo "Usage: $0 restore <backup_file>"
338.                 exit 1
339.             fi
340.             log "===== Container Restore Started ====="
341.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
342.             restore_data "$2"
343.             log "===== Container Restore Complete ====="
344.             ;;
345.         update)
346.             log "===== Container Update Started ====="
347.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
348.             update_images
349.             log "===== Container Update Complete ====="
350.             ;;
351.         cleanup)
352.             log "===== Docker Cleanup Started ====="
353.             check_docker || { log "ERROR: Docker is not available"; exit 1; }
354.             cleanup_docker
355.             log "===== Docker Cleanup Complete ====="
356.             ;;
357.         *)
358.             echo "Usage: $0 {install|setup|start|stop|restart|status|backup|restore|update|cleanup}"
359.             echo "  install - Install Docker"
360.             echo "  setup - Set up containers with default configuration"
361.             echo "  start - Start containers"
362.             echo "  stop - Stop containers"
363.             echo "  restart - Restart containers"
364.             echo "  status - Display container status and resource usage"
365.             echo "  backup - Backup container data"
366.             echo "  restore <backup_file> - Restore container data from backup"
367.             echo "  update - Update container images and restart containers"
368.             echo "  cleanup - Clean up unused Docker resources"
369.             exit 1
370.             ;;
371.     esac
372. }
374. # 执行主函数
375. main "$@"

复制代码

5. 高级技巧和最佳实践

性能优化

在Alpine Linux中编写高效脚本需要考虑其资源限制和轻量级特性。以下是一些性能优化的技巧：

2. #!/bin/sh
4. # 不好的做法：使用外部命令
5. count=$(wc -l < file.txt)
7. # 好的做法：使用内置命令
8. count=0
9. while IFS= read -r line; do
10.     count=$((count + 1))
11. done < file.txt
13. echo "File has $count lines"

复制代码

2. #!/bin/sh
4. # 不好的做法：创建不必要的子shell
5. result=$(echo "text" | grep "pattern")
7. # 好的做法：使用内置字符串操作
8. text="text with pattern"
9. if [ "${text#*pattern}" != "$text" ]; then
10.     result="pattern found"
11. else
12.     result="pattern not found"
13. fi
15. echo "$result"

复制代码

2. #!/bin/sh
4. # 处理大文件时，使用流式处理而不是全部加载到内存
6. # 不好的做法：将整个文件加载到内存
7. content=$(cat large_file.txt)
8. processed_content=$(echo "$content" | sed 's/old/new/g')
9. echo "$processed_content" > processed_file.txt
11. # 好的做法：使用流式处理
12. sed 's/old/new/g' large_file.txt > processed_file.txt

复制代码

2. #!/bin/sh
4. # 不好的做法：在循环中重复调用外部命令
5. files="file1.txt file2.txt file3.txt"
6. for file in $files; do
7.     gzip "$file"
8. done
10. # 好的做法：使用xargs批量处理
11. echo "$files" | xargs gzip

复制代码

错误处理

健壮的脚本应该能够优雅地处理错误。以下是一些错误处理的最佳实践：

2. #!/bin/sh
4. # 检查命令是否成功执行
5. update_system() {
6.     echo "Updating system..."
7.     if apk update && apk upgrade; then
8.         echo "System updated successfully"
9.         return 0
10.     else
11.         echo "ERROR: Failed to update system" >&2
12.         return 1
13.     fi
14. }
16. # 使用错误处理
17. if ! update_system; then
18.     echo "Cannot proceed without updated system. Exiting." >&2
19.     exit 1
20. fi

复制代码

2. #!/bin/sh
4. # 在脚本开头设置这些选项
5. set -e  # 任何命令返回非零状态时立即退出
6. set -u  # 使用未定义变量时视为错误
8. # 或者使用组合
9. set -eu
11. # 如果需要处理某些命令可能失败的情况，可以使用 || true
12. command_that_might_fail || true
14. # 或者使用子shell
15. (command_that_might_fail) || echo "Command failed, but continuing..."

复制代码

2. #!/bin/sh
4. # 错误处理函数
5. error_exit() {
6.     echo "ERROR: $1" >&2
7.     exit "${2:-1}"
8. }
10. # 使用错误处理函数
11. check_file() {
12.     local file="$1"
13.    
14.     if [ ! -f "$file" ]; then
15.         error_exit "File not found: $file"
16.     fi
17.    
18.     if [ ! -r "$file" ]; then
19.         error_exit "Cannot read file: $file"
20.     fi
21.    
22.     echo "File check passed: $file"
23. }
25. # 使用错误处理函数
26. check_file "/etc/passwd"

复制代码

2. #!/bin/sh
4. # 定义清理函数
5. cleanup() {
6.     echo "Cleaning up..."
7.     # 删除临时文件
8.     rm -f /tmp/temp_file_$$
9.     # 停止后台进程
10.     if [ -n "$background_pid" ]; then
11.         kill "$background_pid" 2>/dev/null
12.     fi
13.     echo "Cleanup complete"
14. }
16. # 设置trap，在脚本退出时执行清理
17. trap cleanup EXIT INT TERM
19. # 创建临时文件
20. temp_file="/tmp/temp_file_$$"
21. echo "Creating temporary file: $temp_file"
22. touch "$temp_file"
24. # 启动后台进程
25. some_long_running_process &
26. background_pid=$!
28. # 脚本主要逻辑
29. echo "Script is running..."
30. sleep 5
31. echo "Script completed"
33. # 退出时会自动调用cleanup

复制代码

调试技巧

调试脚本时，以下技巧可以帮助你快速定位问题：

2. #!/bin/sh
4. # 启用命令跟踪
5. set -x
7. # 你的代码
8. echo "This will be printed with a + prefix"
9. name="World"
10. echo "Hello, $name!"
12. # 禁用命令跟踪
13. set +x
15. echo "This will be printed normally"

复制代码

2. #!/bin/sh
4. # 日志级别
5. LOG_LEVEL_DEBUG=0
6. LOG_LEVEL_INFO=1
7. LOG_LEVEL_WARN=2
8. LOG_LEVEL_ERROR=3
10. # 当前日志级别（默认为INFO）
11. LOG_LEVEL=$LOG_LEVEL_INFO
13. # 日志函数
14. log_debug() {
15.     if [ $LOG_LEVEL -le $LOG_LEVEL_DEBUG ]; then
16.         echo "DEBUG: $1" >&2
17.     fi
18. }
20. log_info() {
21.     if [ $LOG_LEVEL -le $LOG_LEVEL_INFO ]; then
22.         echo "INFO: $1" >&2
23.     fi
24. }
26. log_warn() {
27.     if [ $LOG_LEVEL -le $LOG_LEVEL_WARN ]; then
28.         echo "WARN: $1" >&2
29.     fi
30. }
32. log_error() {
33.     if [ $LOG_LEVEL -le $LOG_LEVEL_ERROR ]; then
34.         echo "ERROR: $1" >&2
35.     fi
36. }
38. # 使用日志函数
39. log_debug "This is a debug message"
40. log_info "This is an info message"
41. log_warn "This is a warning message"
42. log_error "This is an error message"

复制代码

2. #!/bin/sh
4. # 调试标志
5. DEBUG=false
7. # 调试函数
8. debug() {
9.     if [ "$DEBUG" = "true" ]; then
10.         echo "DEBUG: $1" >&2
11.     fi
12. }
14. # 使用调试函数
15. debug "Starting script processing"
17. # 你的代码
18. name="World"
19. debug "Variable name set to: $name"
20. echo "Hello, $name!"
22. debug "Script processing completed"

复制代码

2. #!/bin/sh
4. # 创建临时调试文件
5. DEBUG_FILE="/tmp/debug_$$"
7. # 调试函数
8. debug() {
9.     echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" >> "$DEBUG_FILE"
10. }
12. # 使用调试函数
13. debug "Script started"
15. # 你的代码
16. name="World"
17. debug "Processing name: $name"
18. echo "Hello, $name!"
20. debug "Script completed"
22. # 如果脚本成功执行，删除调试文件
23. rm -f "$DEBUG_FILE"

复制代码

6. 结论和资源

Alpine Linux的轻量级特性使其成为自动化脚本和容器化环境的理想选择。通过掌握Alpine Linux脚本编程的基础知识和高级技巧，你可以创建高效、可靠的自动化解决方案。

关键要点总结

1. 了解Alpine Linux的特点：Alpine Linux使用Ash shell和BusyBox工具集，与传统的Linux发行版有所不同。
2. 注重POSIX兼容性：避免使用Bash特有的功能，确保脚本在Ash环境中正常运行。
3. 优化资源使用：利用Alpine Linux的轻量级特性，编写高效的脚本。
4. 错误处理：实现健壮的错误处理机制，确保脚本在遇到问题时能够优雅地处理。
5. 调试技巧：使用适当的调试工具和技术，快速定位和解决问题。

有用资源

1. Alpine Linux官方文档：https://wiki.alpinelinux.org/
2. Ash shell文档：https://linux.die.net/man/1/ash
3. BusyBox文档：https://busybox.net/
4. POSIX Shell标准：https://pubs.opengroup.org/onlinepubs/9699919799/
5. Alpine Linux包仓库：https://pkgs.alpinelinux.org/

示例脚本仓库

以下是一些包含Alpine Linux脚本示例的有用仓库：

1. Alpine Linux Scripts：https://github.com/alpinelinux/alpine-scripts
2. Docker Alpine Images：https://github.com/docker-library/alpine
3. Alpine Linux Wiki Scripts：https://wiki.alpinelinux.org/wiki/Category:Scripts

通过掌握这些知识和资源，你将能够在Alpine Linux环境中创建高效、可靠的自动化脚本，充分发挥这个轻量级系统的潜力。