网络命令 on Linux邪修

ping 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

ping 命令详解#

ping 是 Linux 系统中用于测试网络连接性的命令，是最基本、最常用的网络诊断工具之一。它通过发送 ICMP Echo Request 数据包到目标主机并等待响应，来检测网络是否可达以及网络延迟情况。

入门#

基本用法#

# 测试与目标主机的网络连接
ping google.com

# 测试与 IP 地址的连接
ping 8.8.8.8

# 指定发送数据包的数量
ping -c 4 google.com

# 设置数据包的时间间隔（秒）
ping -i 2 google.com

# 设置数据包的大小
ping -s 1000 google.com

常用选项#

选项	说明
`-c`	指定发送数据包的数量
`-i`	设置数据包的时间间隔（秒）
`-s`	设置数据包的大小（字节）
`-v`	显示详细输出
`-q`	静默模式，只显示摘要信息
`-t`	设置 TTL（Time To Live）值

基本示例#

# 测试与百度的连接，发送 4 个数据包
ping -c 4 www.baidu.com

# 输出示例：
# PING www.a.shifen.com (110.242.68.4) 56(84) bytes of data.
# 64 bytes from 110.242.68.4: icmp_seq=1 ttl=54 time=15.2 ms
# 64 bytes from 110.242.68.4: icmp_seq=2 ttl=54 time=15.1 ms
# 64 bytes from 110.242.68.4: icmp_seq=3 ttl=54 time=15.3 ms
# 64 bytes from 110.242.68.4: icmp_seq=4 ttl=54 time=15.0 ms
# --- www.a.shifen.com ping statistics ---
# 4 packets transmitted, 4 received, 0% packet loss
# rtt min/avg/max/mdev = 15.0/15.15/15.3/0.097 ms

中级#

网络诊断技巧#

# 持续 ping 监控网络状态
ping google.com

# 使用 Ctrl+C 停止 ping

# 快速测试网络连通性（发送 1 个数据包）
ping -c 1 google.com

# 测试网络延迟并显示时间戳
ping -D google.com

# 设置超时时间（秒）
ping -W 2 google.com

# 洪水模式（快速发送数据包，需要 root 权限）
sudo ping -f google.com

解读 ping 输出#

# ping 输出详解
# 64 bytes from 142.250.188.46: icmp_seq=1 ttl=117 time=15.2 ms
# │ │ │ │ │ │ │
# │ │ │ │ │ │ └─ 响应时间
# │ │ │ │ │ └──── TTL 值
# │ │ │ │ └───────── ICMP 序列号
# │ │ │ └─────────────────── 数据包大小
# │ │ └──────────────────────────────────────── 源 IP 地址
# │ └───────────────────────────────────────────── from 关键字
# └─────────────────────────────────────────────────── 接收到的字节数

网络故障排查#

# 测试本地网络接口
ping 127.0.0.1

# 测试网关连接
ping 192.168.1.1

# 测试 DNS 解析
ping google.com

# 测试公网 IP 连接
ping 8.8.8.8

# 测试特定端口（使用 nc 或 telnet）
nc -zv google.com 80

高级#

高级选项#

# 指定网络接口
ping -I eth0 google.com

# 设置 IP 记录路由选项
ping -R google.com

# 禁止分片
ping -M do google.com

# 设置数据包模式
ping -O google.com

# 显示详细的路由信息
ping -r google.com

# 使用 IPv6
ping6 google.com

性能测试#

# 测试网络带宽（使用大包）
ping -s 65507 -c 10 google.com

# 测试网络稳定性（长时间 ping）
ping -i 0.1 google.com

# 记录 ping 结果到文件
ping google.com | tee ping_result.log

# 分析 ping 结果
ping -c 100 google.com | grep "time=" | awk '{print $7}' | cut -d'=' -f2

网络监控脚本#

#!/bin/bash
# 网络监控脚本

HOST="google.com"
LOG_FILE="network_monitor.log"

while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 PING_RESULT=$(ping -c 1 $HOST | grep "time=" | awk '{print $7}' | cut -d'=' -f2)
 
 if [ -z "$PING_RESULT" ]; then
 echo "$TIMESTAMP - Network unreachable" >> $LOG_FILE
 else
 echo "$TIMESTAMP - Latency: $PING_RESULT" >> $LOG_FILE
 fi
 
 sleep 60
done

大师#

网络拓扑分析#

# 使用 ping 追踪网络路径
ping -R google.com

# 结合 traceroute 分析网络路径
traceroute google.com

# 使用 mtr 进行持续网络诊断
mtr google.com

# 分析网络丢包率
ping -c 1000 google.com | grep "packet loss"

# 测试网络抖动
ping -i 0.01 -c 100 google.com | grep "time=" | awk '{print $7}' | cut -d'=' -f2 | sort -n | uniq -c

网络性能优化#

# 测试 MTU（最大传输单元）
ping -c 1 -M do -s 1472 google.com
ping -c 1 -M do -s 1473 google.com

# 找到最佳 MTU 值
for i in {1400..1500}; do
 ping -c 1 -M do -s $i google.com > /dev/null 2>&1
 if [ $? -eq 0 ]; then
 echo "MTU: $i - Success"
 else
 echo "MTU: $i - Failed"
 break
 fi
done

# 测试网络吞吐量
ping -s 65507 -i 0.1 -c 100 google.com

高级监控#

#!/bin/bash
# 高级网络监控脚本

HOSTS=("google.com" "baidu.com" "github.com")
THRESHOLD=100
ALERT_EMAIL="admin@example.com"

for HOST in "${HOSTS[@]}"; do
 LATENCY=$(ping -c 1 $HOST | grep "time=" | awk '{print $7}' | cut -d'=' -f2 | cut -d' ' -f1)
 
 if [ -z "$LATENCY" ]; then
 echo "ALERT: $HOST is unreachable" | mail -s "Network Alert" $ALERT_EMAIL
 elif (( $(echo "$LATENCY > $THRESHOLD" | bc -l) )); then
 echo "WARNING: $HOST latency is $LATENCY ms (threshold: $THRESHOLD ms)" | mail -s "Network Warning" $ALERT_EMAIL
 fi
done

无敌#

企业级网络监控#

#!/bin/bash
# 企业级网络监控系统

CONFIG_FILE="/etc/network_monitor/config.conf"
LOG_DIR="/var/log/network_monitor"
ALERT_SCRIPT="/usr/local/bin/send_alert.sh"

# 加载配置
source $CONFIG_FILE

# 创建日志目录
mkdir -p $LOG_DIR

# 主监控循环
while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 for HOST in "${MONITOR_HOSTS[@]}"; do
 # 执行 ping 测试
 PING_RESULT=$(ping -c $PING_COUNT -W $TIMEOUT $HOST 2>&1)
 
 # 解析结果
 PACKET_LOSS=$(echo "$PING_RESULT" | grep "packet loss" | awk '{print $6}' | cut -d'%' -f1)
 AVG_LATENCY=$(echo "$PING_RESULT" | grep "rtt avg" | awk -F'/' '{print $5}')
 
 # 记录日志
 echo "$TIMESTAMP,$HOST,$PACKET_LOSS,$AVG_LATENCY" >> $LOG_DIR/monitor_$(date +%Y%m%d).csv
 
 # 检查阈值
 if [ "$PACKET_LOSS" -gt "$LOSS_THRESHOLD" ] || [ "$AVG_LATENCY" -gt "$LATENCY_THRESHOLD" ]; then
 $ALERT_SCRIPT "$HOST" "$PACKET_LOSS" "$AVG_LATENCY"
 fi
 done
 
 sleep $MONITOR_INTERVAL
done

网络质量分析#

#!/bin/bash
# 网络质量分析工具

HOST=$1
DURATION=$2
INTERVAL=0.1

declare -a LATENCIES
declare -a JITTERS

for ((i=0; i<$DURATION; i+=$INTERVAL)); do
 LATENCY=$(ping -c 1 -W 1 $HOST | grep "time=" | awk '{print $7}' | cut -d'=' -f2 | cut -d' ' -f1)
 
 if [ -n "$LATENCY" ]; then
 LATENCIES+=($LATENCY)
 
 if [ ${#LATENCIES[@]} -gt 1 ]; then
 PREV=${LATENCIES[-2]}
 CURRENT=$LATENCY
 JITTER=$(echo "$CURRENT - $PREV" | bc | awk '{if ($1 < 0) print -$1; else print $1}')
 JITTERS+=($JITTER)
 fi
 fi
 
 sleep $INTERVAL
done

# 计算统计数据
AVG_LATENCY=$(echo "${LATENCIES[@]}" | awk '{for(i=1;i<=NF;i++)sum+=$i; print sum/NF}')
MIN_LATENCY=$(echo "${LATENCIES[@]}" | awk '{min=$1; for(i=1;i<=NF;i++)if($i<min)min=$i; print min}')
MAX_LATENCY=$(echo "${LATENCIES[@]}" | awk '{max=$1; for(i=1;i<=NF;i++)if($i>max)max=$i; print max}')

AVG_JITTER=$(echo "${JITTERS[@]}" | awk '{for(i=1;i<=NF;i++)sum+=$i; print sum/NF}')
MAX_JITTER=$(echo "${JITTERS[@]}" | awk '{max=$1; for(i=1;i<=NF;i++)if($i>max)max=$i; print max}')

echo "Network Quality Analysis for $HOST"
echo "==================================="
echo "Average Latency: $AVG_LATENCY ms"
echo "Min Latency: $MIN_LATENCY ms"
echo "Max Latency: $MAX_LATENCY ms"
echo "Average Jitter: $AVG_JITTER ms"
echo "Max Jitter: $MAX_JITTER ms"

分布式网络监控#

#!/bin/bash
# 分布式网络监控系统

SERVERS=("server1.example.com" "server2.example.com" "server3.example.com")
TARGETS=("google.com" "baidu.com" "github.com")
RESULTS_DIR="/tmp/network_monitor_results"

mkdir -p $RESULTS_DIR

for SERVER in "${SERVERS[@]}"; do
 echo "Monitoring from $SERVER..."
 
 for TARGET in "${TARGETS[@]}"; do
 RESULT_FILE="$RESULTS_DIR/${SERVER}_${TARGET}_$(date +%Y%m%d_%H%M%S).txt"
 
 ssh $SERVER "ping -c 100 $TARGET" > $RESULT_FILE
 
 PACKET_LOSS=$(grep "packet loss" $RESULT_FILE | awk '{print $6}' | cut -d'%' -f1)
 AVG_LATENCY=$(grep "rtt avg" $RESULT_FILE | awk -F'/' '{print $5}')
 
 echo "$SERVER -> $TARGET: Loss=$PACKET_LOSS%, Latency=$AVG_LATENCY ms"
 done
done

# 生成报告
echo "Network Monitoring Report - $(date)" > $RESULTS_DIR/report.txt
echo "====================================" >> $RESULTS_DIR/report.txt
echo "" >> $RESULTS_DIR/report.txt

for SERVER in "${SERVERS[@]}"; do
 echo "Results from $SERVER:" >> $RESULTS_DIR/report.txt
 grep "Loss=" $RESULTS_DIR/${SERVER}_*.txt >> $RESULTS_DIR/report.txt
 echo "" >> $RESULTS_DIR/report.txt
done

最佳实践#

合理设置 ping 参数：根据网络环境调整数据包大小和发送间隔
结合其他工具：使用 ping 配合 traceroute、mtr 等工具进行综合诊断
记录监控数据：定期记录 ping 结果，便于分析网络趋势
设置合理的阈值：根据业务需求设置延迟和丢包率的告警阈值
注意权限要求：某些高级选项需要 root 权限
考虑防火墙影响：某些网络可能阻止 ICMP 数据包
使用 IPv6：在支持 IPv6 的环境中使用 ping6 测试 IPv6 连接
自动化监控：编写脚本实现自动化网络监控和告警

注意事项#

ping 使用 ICMP 协议，某些网络可能阻止 ICMP 数据包
持续 ping 可能消耗网络资源，避免在生产环境中滥用
洪水模式（-f）需要 root 权限，可能导致网络拥塞
不同操作系统的 ping 命令选项可能有所不同
ping 结果受网络拥塞、路由变化等因素影响
对于关键业务，建议使用专业的网络监控工具
注意保护隐私，不要 ping 不明来源的地址

ifconfig 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

ifconfig 命令详解#

ifconfig（interface configure）是 Linux 系统中用于配置和显示网络接口信息的命令，是网络管理和故障排查的重要工具。虽然在新版本 Linux 中已被 ip 命令取代，但仍然被广泛使用。

入门#

基本用法#

# 显示所有网络接口信息
ifconfig

# 显示指定网络接口信息
ifconfig eth0

# 启用网络接口
sudo ifconfig eth0 up

# 禁用网络接口
sudo ifconfig eth0 down

# 为网络接口分配 IP 地址
sudo ifconfig eth0 192.168.1.100

常用选项#

选项	说明
`up`	启用网络接口
`down`	禁用网络接口
`netmask`	设置子网掩码
`broadcast`	设置广播地址
`add`	添加 IPv6 地址
`del`	删除 IPv6 地址
`-a`	显示所有接口（包括禁用的接口）
`-s`	显示简短信息

基本示例#

# 查看所有网络接口
ifconfig

# 输出示例：
# eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
# inet 192.168.1.100 netmask 255.255.255.0 broadcast 192.168.1.255
# inet6 fe80::a00:27ff:fe4e:66a1 prefixlen 64 scopeid 0x20<link>
# ether 08:00:27:4e:66:a1 txqueuelen 1000 (Ethernet)
# RX packets 12345 bytes 1234567 (1.1 MiB)
# RX errors 0 dropped 0 overruns 0 frame 0
# TX packets 6789 bytes 789012 (770.5 KiB)
# TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

中级#

网络接口配置#

# 配置 IP 地址和子网掩码
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0

# 配置 IP 地址、子网掩码和广播地址
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0 broadcast 192.168.1.255

# 添加虚拟 IP 地址
sudo ifconfig eth0:0 192.168.1.101

# 删除虚拟 IP 地址
sudo ifconfig eth0:0 down

# 修改 MAC 地址（需要先禁用接口）
sudo ifconfig eth0 down
sudo ifconfig eth0 hw ether 00:11:22:33:44:55
sudo ifconfig eth0 up

网络接口状态查看#

# 查看特定接口详细信息
ifconfig eth0

# 查看所有接口（包括禁用的）
ifconfig -a

# 查看简短信息
ifconfig -s

# 查看接口统计信息
ifconfig eth0 | grep -E "RX|TX"

# 查看接口 MTU
ifconfig eth0 | grep mtu

网络故障排查#

# 检查接口是否启用
ifconfig eth0 | grep UP

# 检查 IP 地址配置
ifconfig eth0 | grep inet

# 检查网络连接状态
ifconfig eth0 | grep RUNNING

# 检查错误统计
ifconfig eth0 | grep errors

# 重启网络接口
sudo ifconfig eth0 down
sudo ifconfig eth0 up

高级#

高级配置#

# 设置 MTU（最大传输单元）
sudo ifconfig eth0 mtu 9000

# 启用混杂模式
sudo ifconfig eth0 promisc

# 禁用混杂模式
sudo ifconfig eth0 -promisc

# 启用 allmulti 模式
sudo ifconfig eth0 allmulti

# 禁用 allmulti 模式
sudo ifconfig eth0 -allmulti

# 设置队列长度
sudo ifconfig eth0 txqueuelen 1000

IPv6 配置#

# 添加 IPv6 地址
sudo ifconfig eth0 add 2001:db8::1/64

# 删除 IPv6 地址
sudo ifconfig eth0 del 2001:db8::1/64

# 查看 IPv6 地址
ifconfig eth0 | grep inet6

网络接口监控#

#!/bin/bash
# 网络接口监控脚本

INTERFACE="eth0"
LOG_FILE="interface_monitor.log"

while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 RX_BYTES=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $5}')
 TX_BYTES=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $5}')
 
 echo "$TIMESTAMP - RX: $RX_BYTES bytes, TX: $TX_BYTES bytes" >> $LOG_FILE
 
 sleep 60
done

大师#

网络性能分析#

#!/bin/bash
# 网络性能分析工具

INTERFACE="eth0"

# 获取初始统计
RX_PACKETS_1=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $2}')
TX_PACKETS_1=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $2}')
RX_BYTES_1=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $5}')
TX_BYTES_1=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $5}')

sleep 60

# 获取结束统计
RX_PACKETS_2=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $2}')
TX_PACKETS_2=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $2}')
RX_BYTES_2=$(ifconfig $INTERFACE | grep "RX packets" | awk '{print $5}')
TX_BYTES_2=$(ifconfig $INTERFACE | grep "TX packets" | awk '{print $5}')

# 计算差值
RX_PACKETS_DIFF=$((RX_PACKETS_2 - RX_PACKETS_1))
TX_PACKETS_DIFF=$((TX_PACKETS_2 - TX_PACKETS_1))
RX_BYTES_DIFF=$((RX_BYTES_2 - RX_BYTES_1))
TX_BYTES_DIFF=$((TX_BYTES_2 - TX_BYTES_1))

# 计算速率
RX_RATE=$((RX_BYTES_DIFF / 60 / 1024))
TX_RATE=$((TX_BYTES_DIFF / 60 / 1024))

echo "Network Performance Analysis for $INTERFACE"
echo "==========================================="
echo "RX Packets: $RX_PACKETS_DIFF packets/min"
echo "TX Packets: $TX_PACKETS_DIFF packets/min"
echo "RX Rate: $RX_RATE KB/s"
echo "TX Rate: $TX_RATE KB/s"

多接口管理#

#!/bin/bash
# 多网络接口管理脚本

INTERFACES=("eth0" "eth1" "wlan0")

for INTERFACE in "${INTERFACES[@]}"; do
 echo "=== Interface: $INTERFACE ==="
 
 STATUS=$(ifconfig $INTERFACE 2>/dev/null | grep "UP" | wc -l)
 
 if [ $STATUS -eq 1 ]; then
 IP=$(ifconfig $INTERFACE | grep "inet " | awk '{print $2}')
 NETMASK=$(ifconfig $INTERFACE | grep "inet " | awk '{print $4}')
 BROADCAST=$(ifconfig $INTERFACE | grep "inet " | awk '{print $6}')
 
 echo "Status: UP"
 echo "IP Address: $IP"
 echo "Netmask: $NETMASK"
 echo "Broadcast: $BROADCAST"
 else
 echo "Status: DOWN"
 fi
 
 echo ""
done

网络接口备份与恢复#

#!/bin/bash
# 网络接口配置备份与恢复

BACKUP_DIR="/etc/network/backups"
mkdir -p $BACKUP_DIR

# 备份当前配置
backup_config() {
 TIMESTAMP=$(date +%Y%m%d_%H%M%S)
 BACKUP_FILE="$BACKUP_DIR/interfaces_$TIMESTAMP.conf"
 
 ifconfig -a > $BACKUP_FILE
 echo "Configuration backed up to $BACKUP_FILE"
}

# 恢复配置
restore_config() {
 BACKUP_FILE=$1
 
 if [ ! -f "$BACKUP_FILE" ]; then
 echo "Backup file not found: $BACKUP_FILE"
 return 1
 fi
 
 # 解析备份文件并恢复配置
 while read -r line; do
 if [[ $line =~ ^([a-z0-9]+):.*inet ([0-9.]+) ]]; then
 INTERFACE="${BASH_REMATCH[1]}"
 IP="${BASH_REMATCH[2]}"
 
 ifconfig $INTERFACE $IP up
 echo "Restored $INTERFACE with IP $IP"
 fi
 done < "$BACKUP_FILE"
}

# 列出备份
list_backups() {
 echo "Available backups:"
 ls -lh $BACKUP_DIR/
}

case "$1" in
 backup)
 backup_config
 ;;
 restore)
 restore_config "$2"
 ;;
 list)
 list_backups
 ;;
 *)
 echo "Usage: $0 {backup|restore|list}"
 exit 1
 ;;
esac

无敌#

企业级网络接口管理#

#!/bin/bash
# 企业级网络接口管理系统

CONFIG_FILE="/etc/network_manager/config.conf"
LOG_FILE="/var/log/network_manager.log"
STATE_DIR="/var/run/network_manager"

mkdir -p $STATE_DIR

# 加载配置
source $CONFIG_FILE

# 初始化接口状态
init_interface() {
 local INTERFACE=$1
 local STATE_FILE="$STATE_DIR/$INTERFACE.state"
 
 ifconfig $INTERFACE up
 
 if [ $? -eq 0 ]; then
 echo "UP" > $STATE_FILE
 log_message "$INTERFACE initialized successfully"
 else
 echo "DOWN" > $STATE_FILE
 log_message "ERROR: Failed to initialize $INTERFACE"
 fi
}

# 监控接口状态
monitor_interface() {
 local INTERFACE=$1
 local STATE_FILE="$STATE_DIR/$INTERFACE.state"
 
 while true; do
 CURRENT_STATUS=$(ifconfig $INTERFACE 2>/dev/null | grep "UP" | wc -l)
 SAVED_STATUS=$(cat $STATE_FILE)
 
 if [ $CURRENT_STATUS -ne $SAVED_STATUS ]; then
 if [ $CURRENT_STATUS -eq 1 ]; then
 log_message "ALERT: $INTERFACE is now UP"
 echo "UP" > $STATE_FILE
 else
 log_message "ALERT: $INTERFACE is now DOWN"
 echo "DOWN" > $STATE_FILE
 
 # 尝试恢复接口
 ifconfig $INTERFACE up
 fi
 fi
 
 sleep $MONITOR_INTERVAL
 done
}

# 记录日志
log_message() {
 local MESSAGE=$1
 local TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 echo "[$TIMESTAMP] $MESSAGE" >> $LOG_FILE
}

# 主程序
main() {
 log_message "Network Manager started"
 
 for INTERFACE in "${MANAGED_INTERFACES[@]}"; do
 init_interface $INTERFACE
 monitor_interface $INTERFACE &
 done
 
 wait
}

main

智能网络接口切换#

#!/bin/bash
# 智能网络接口切换系统

PRIMARY_INTERFACE="eth0"
SECONDARY_INTERFACE="wlan0"
GATEWAY="192.168.1.1"
CHECK_INTERVAL=30

# 检查网络连接
check_connectivity() {
 local INTERFACE=$1
 
 ping -I $INTERFACE -c 1 -W 2 $GATEWAY > /dev/null 2>&1
 return $?
}

# 切换到备用接口
switch_to_secondary() {
 log_message "Switching to secondary interface: $SECONDARY_INTERFACE"
 
 ifconfig $PRIMARY_INTERFACE down
 ifconfig $SECONDARY_INTERFACE up
 
 # 更新路由表
 ip route del default via $GATEWAY dev $PRIMARY_INTERFACE 2>/dev/null
 ip route add default via $GATEWAY dev $SECONDARY_INTERFACE
 
 log_message "Switched to $SECONDARY_INTERFACE"
}

# 切换到主接口
switch_to_primary() {
 log_message "Switching to primary interface: $PRIMARY_INTERFACE"
 
 ifconfig $SECONDARY_INTERFACE down
 ifconfig $PRIMARY_INTERFACE up
 
 # 更新路由表
 ip route del default via $GATEWAY dev $SECONDARY_INTERFACE 2>/dev/null
 ip route add default via $GATEWAY dev $PRIMARY_INTERFACE
 
 log_message "Switched to $PRIMARY_INTERFACE"
}

# 主监控循环
main() {
 local CURRENT_INTERFACE=$PRIMARY_INTERFACE
 
 while true; do
 if check_connectivity $CURRENT_INTERFACE; then
 log_message "Current interface $CURRENT_INTERFACE is working"
 
 # 如果当前是备用接口，尝试切换回主接口
 if [ "$CURRENT_INTERFACE" = "$SECONDARY_INTERFACE" ]; then
 if check_connectivity $PRIMARY_INTERFACE; then
 switch_to_primary
 CURRENT_INTERFACE=$PRIMARY_INTERFACE
 fi
 fi
 else
 log_message "Current interface $CURRENT_INTERFACE is not working"
 
 # 切换到备用接口
 if [ "$CURRENT_INTERFACE" = "$PRIMARY_INTERFACE" ]; then
 if check_connectivity $SECONDARY_INTERFACE; then
 switch_to_secondary
 CURRENT_INTERFACE=$SECONDARY_INTERFACE
 else
 log_message "ERROR: Both interfaces are down"
 fi
 fi
 fi
 
 sleep $CHECK_INTERVAL
 done
}

main

网络接口性能优化#

#!/bin/bash
# 网络接口性能优化工具

optimize_interface() {
 local INTERFACE=$1
 
 echo "Optimizing interface: $INTERFACE"
 
 # 设置 MTU
 sudo ifconfig $INTERFACE mtu 9000
 
 # 增加队列长度
 sudo ifconfig $INTERFACE txqueuelen 10000
 
 # 禁用 TCP 时间戳
 echo 0 | sudo tee /proc/sys/net/ipv4/tcp_timestamps
 
 # 启用 TCP 窗口缩放
 echo 1 | sudo tee /proc/sys/net/ipv4/tcp_window_scaling
 
 # 调整 TCP 缓冲区大小
 echo "4096 87380 16777216" | sudo tee /proc/sys/net/ipv4/tcp_rmem
 echo "4096 65536 16777216" | sudo tee /proc/sys/net/ipv4/tcp_wmem
 
 # 启用 TCP 快速打开
 echo 3 | sudo tee /proc/sys/net/ipv4/tcp_fastopen
 
 # 禁用 TCP 慢启动
 echo 1 | sudo tee /proc/sys/net/ipv4/tcp_no_metrics_save
 
 echo "Interface $INTERFACE optimized"
}

# 批量优化多个接口
optimize_all_interfaces() {
 INTERFACES=("eth0" "eth1" "wlan0")
 
 for INTERFACE in "${INTERFACES[@]}"; do
 if [ -d "/sys/class/net/$INTERFACE" ]; then
 optimize_interface $INTERFACE
 fi
 done
}

# 恢复默认设置
restore_defaults() {
 local INTERFACE=$1
 
 echo "Restoring defaults for interface: $INTERFACE"
 
 sudo ifconfig $INTERFACE mtu 1500
 sudo ifconfig $INTERFACE txqueuelen 1000
 
 echo "Defaults restored for $INTERFACE"
}

case "$1" in
 optimize)
 optimize_interface "$2"
 ;;
 optimize-all)
 optimize_all_interfaces
 ;;
 restore)
 restore_defaults "$2"
 ;;
 *)
 echo "Usage: $0 {optimize|optimize-all|restore}"
 exit 1
 ;;
esac

最佳实践#

使用 ip 命令替代：在新版本 Linux 中，优先使用 ip 命令替代 ifconfig
配置持久化：使用网络配置文件（如 /etc/network/interfaces）使配置持久化
备份配置：在进行重要配置更改前，先备份当前配置
监控接口状态：定期监控网络接口状态，及时发现和解决问题
合理设置 MTU：根据网络环境设置合适的 MTU 值
安全考虑：修改 MAC 地址等操作需要谨慎，避免违反网络策略
日志记录：记录重要的配置更改和事件，便于故障排查
测试配置：在生产环境应用配置前，先在测试环境验证

注意事项#

ifconfig 在某些 Linux 发行版中已被弃用，建议使用 ip 命令
修改网络接口配置需要 root 权限
修改网络配置可能导致网络连接中断
在远程服务器上修改网络配置时要格外小心
某些网络配置更改可能需要重启网络服务
虚拟接口（如 eth0:0）的配置方法与物理接口不同
不同 Linux 发行版的网络配置文件位置可能不同
注意网络安全策略，避免违反组织规定

netstat 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

netstat 命令详解#

netstat（network statistics）是 Linux 系统中用于显示网络连接、路由表、网络接口统计等网络信息的命令，是网络诊断和监控的重要工具。虽然在新版本 Linux 中已被 ss 命令取代，但仍然被广泛使用。

入门#

基本用法#

# 显示所有网络连接
netstat -a

# 显示所有 TCP 连接
netstat -at

# 显示所有 UDP 连接
netstat -au

# 显示监听中的套接字
netstat -l

# 显示网络接口统计
netstat -i

# 显示路由表
netstat -r

常用选项#

选项	说明
`-a`	显示所有连接（包括监听和非监听）
`-t`	显示 TCP 连接
`-u`	显示 UDP 连接
`-n`	以数字形式显示地址和端口
`-l`	显示监听中的套接字
`-p`	显示进程 ID 和进程名称
`-r`	显示路由表
`-i`	显示网络接口统计
`-s`	显示网络统计信息
`-c`	持续显示网络状态

基本示例#

# 查看所有 TCP 连接
netstat -at

# 输出示例：
# Proto Recv-Q Send-Q Local Address Foreign Address State
# tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
# tcp 0 0 192.168.1.100:54321 93.184.216.34:80 ESTABLISHED
# tcp6 0 0 :::22 :::* LISTEN

# 查看监听端口
netstat -ltn

# 输出示例：
# Proto Recv-Q Send-Q Local Address Foreign Address State
# tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
# tcp 0 0 127.0.0.1:3306 0.0.0.0:* LISTEN

中级#

网络连接分析#

# 显示所有 TCP 连接并显示进程信息
netstat -atp

# 显示所有 UDP 连接并显示进程信息
netstat -aup

# 显示所有网络连接（包括进程）
netstat -anp

# 查看特定端口的连接
netstat -anp | grep :80

# 查看特定进程的网络连接
netstat -anp | grep nginx

# 查看特定状态的连接
netstat -anp | grep ESTABLISHED

网络统计信息#

# 显示网络统计信息
netstat -s

# 显示 TCP 统计信息
netstat -s | grep -A 20 "Tcp:"

# 显示 UDP 统计信息
netstat -s | grep -A 10 "Udp:"

# 显示 IP 统计信息
netstat -s | grep -A 10 "Ip:"

# 显示 ICMP 统计信息
netstat -s | grep -A 10 "Icmp:"

路由表查看#

# 显示路由表
netstat -r

# 显示路由表（不解析主机名）
netstat -rn

# 显示 IPv6 路由表
netstat -r -A inet6

# 输出示例：
# Kernel IP routing table
# Destination Gateway Genmask Flags MSS Window irtt Iface
# 0.0.0.0 192.168.1.1 0.0.0.0 UG 0 0 0 eth0
# 192.168.1.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0

高级#

高级过滤#

# 查看所有 ESTABLISHED 状态的连接
netstat -an | grep ESTABLISHED | wc -l

# 查看所有 LISTEN 状态的连接
netstat -an | grep LISTEN

# 查看所有 TIME_WAIT 状态的连接
netstat -an | grep TIME_WAIT

# 查看特定端口的连接数
netstat -an | grep :80 | wc -l

# 查看连接最多的 IP 地址
netstat -an | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -10

网络接口统计#

# 显示网络接口统计
netstat -i

# 持续监控网络接口统计
netstat -ic

# 显示特定接口的统计
netstat -i | grep eth0

# 输出示例：
# Kernel Interface table
# Iface MTU RX-OK RX-ERR RX-DRP RX-OVR TX-OK TX-ERR TX-DRP TX-OVR Flg
# eth0 1500 12345 0 0 0 6789 0 0 0 BMRU

网络连接监控#

#!/bin/bash
# 网络连接监控脚本

LOG_FILE="connection_monitor.log"

while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 TOTAL_CONNECTIONS=$(netstat -an | grep ESTABLISHED | wc -l)
 LISTENING_PORTS=$(netstat -an | grep LISTEN | wc -l)
 
 echo "$TIMESTAMP - Total: $TOTAL_CONNECTIONS, Listening: $LISTENING_PORTS" >> $LOG_FILE
 
 sleep 60
done

大师#

网络连接分析#

#!/bin/bash
# 网络连接分析工具

echo "Network Connection Analysis"
echo "==========================="

# 按状态统计连接
echo -e "\nConnections by State:"
netstat -an | awk '/tcp/ {print $6}' | sort | uniq -c | sort -rn

# 按端口统计连接
echo -e "\nConnections by Port:"
netstat -an | grep ESTABLISHED | awk '{print $4}' | cut -d: -f2 | sort | uniq -c | sort -rn | head -10

# 按远程 IP 统计连接
echo -e "\nTop 10 Remote IPs:"
netstat -an | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -10

# 按本地 IP 统计连接
echo -e "\nConnections by Local IP:"
netstat -an | grep ESTABLISHED | awk '{print $4}' | cut -d: -f1 | sort | uniq -c | sort -rn

网络性能监控#

#!/bin/bash
# 网络性能监控工具

INTERFACE="eth0"

# 获取网络接口统计
get_interface_stats() {
 netstat -i | grep $INTERFACE | awk '{print $3, $4, $7, $8}'
}

# 初始统计
STATS_1=$(get_interface_stats)
RX_OK_1=$(echo $STATS_1 | awk '{print $1}')
RX_ERR_1=$(echo $STATS_1 | awk '{print $2}')
TX_OK_1=$(echo $STATS_1 | awk '{print $3}')
TX_ERR_1=$(echo $STATS_1 | awk '{print $4}')

sleep 60

# 结束统计
STATS_2=$(get_interface_stats)
RX_OK_2=$(echo $STATS_2 | awk '{print $1}')
RX_ERR_2=$(echo $STATS_2 | awk '{print $2}')
TX_OK_2=$(echo $STATS_2 | awk '{print $3}')
TX_ERR_2=$(echo $STATS_2 | awk '{print $4}')

# 计算差值
RX_OK_DIFF=$((RX_OK_2 - RX_OK_1))
RX_ERR_DIFF=$((RX_ERR_2 - RX_ERR_1))
TX_OK_DIFF=$((TX_OK_2 - TX_OK_1))
TX_ERR_DIFF=$((TX_ERR_2 - TX_ERR_1))

echo "Network Performance for $INTERFACE"
echo "=================================="
echo "RX Packets: $RX_OK_DIFF/min, Errors: $RX_ERR_DIFF"
echo "TX Packets: $TX_OK_DIFF/min, Errors: $TX_ERR_DIFF"

网络安全监控#

#!/bin/bash
# 网络安全监控脚本

ALERT_FILE="security_alerts.log"
MAX_CONNECTIONS=100

# 检查异常连接
check_suspicious_connections() {
 echo "Checking for suspicious connections..."
 
 # 检查连接数过多的 IP
 netstat -an | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | while read count ip; do
 if [ $count -gt $MAX_CONNECTIONS ]; then
 ALERT_MSG="$(date '+%Y-%m-%d %H:%M:%S') - ALERT: High connection count from $ip: $count connections"
 echo $ALERT_MSG >> $ALERT_FILE
 echo $ALERT_MSG
 fi
 done
 
 # 检查异常端口
 echo "Checking for unusual ports..."
 netstat -an | grep ESTABLISHED | awk '{print $4}' | cut -d: -f2 | sort -u | while read port; do
 if [ $port -gt 1024 ] && [ $port -lt 49152 ]; then
 echo "Unusual port in use: $port"
 fi
 done
}

# 检查网络接口状态
check_interface_status() {
 echo "Checking interface status..."
 
 netstat -i | grep -v "Iface" | while read iface mtu rx_ok rx_err rx_drp rx_ovr tx_ok tx_err tx_drp tx_ovr flags; do
 if [ $rx_err -gt 0 ] || [ $tx_err -gt 0 ]; then
 ALERT_MSG="$(date '+%Y-%m-%d %H:%M:%S') - ALERT: Errors on interface $iface - RX: $rx_err, TX: $tx_err"
 echo $ALERT_MSG >> $ALERT_FILE
 echo $ALERT_MSG
 fi
 done
}

# 主函数
main() {
 check_suspicious_connections
 check_interface_status
}

main

无敌#

企业级网络监控系统#

#!/bin/bash
# 企业级网络监控系统

CONFIG_FILE="/etc/network_monitor/config.conf"
LOG_DIR="/var/log/network_monitor"
ALERT_SCRIPT="/usr/local/bin/send_alert.sh"

mkdir -p $LOG_DIR

# 加载配置
source $CONFIG_FILE

# 收集网络统计信息
collect_stats() {
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 STATS_FILE="$LOG_DIR/stats_$(date +%Y%m%d).csv"
 
 # 连接统计
 TOTAL_CONNECTIONS=$(netstat -an | grep ESTABLISHED | wc -l)
 LISTENING_PORTS=$(netstat -an | grep LISTEN | wc -l)
 TIME_WAIT=$(netstat -an | grep TIME_WAIT | wc -l)
 
 # 接口统计
 for INTERFACE in "${MONITOR_INTERFACES[@]}"; do
 RX_PACKETS=$(netstat -i | grep $INTERFACE | awk '{print $3}')
 TX_PACKETS=$(netstat -i | grep $INTERFACE | awk '{print $7}')
 
 echo "$TIMESTAMP,$INTERFACE,$RX_PACKETS,$TX_PACKETS,$TOTAL_CONNECTIONS,$LISTENING_PORTS,$TIME_WAIT" >> $STATS_FILE
 done
}

# 检查异常情况
check_anomalies() {
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 # 检查连接数
 TOTAL_CONNECTIONS=$(netstat -an | grep ESTABLISHED | wc -l)
 if [ $TOTAL_CONNECTIONS -gt $MAX_CONNECTIONS ]; then
 $ALERT_SCRIPT "High connection count: $TOTAL_CONNECTIONS"
 fi
 
 # 检查 TIME_WAIT 连接
 TIME_WAIT=$(netstat -an | grep TIME_WAIT | wc -l)
 if [ $TIME_WAIT -gt $MAX_TIME_WAIT ]; then
 $ALERT_SCRIPT "High TIME_WAIT count: $TIME_WAIT"
 fi
 
 # 检查异常 IP
 netstat -an | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | while read count ip; do
 if [ $count -gt $MAX_CONNECTIONS_PER_IP ]; then
 $ALERT_SCRIPT "High connection count from $ip: $count connections"
 fi
 done
}

# 生成报告
generate_report() {
 REPORT_FILE="$LOG_DIR/report_$(date +%Y%m%d).txt"
 
 echo "Network Monitoring Report - $(date +%Y-%m-%d)" > $REPORT_FILE
 echo "=========================================" >> $REPORT_FILE
 echo "" >> $REPORT_FILE
 
 echo "Connection Statistics:" >> $REPORT_FILE
 echo "Total Connections: $(netstat -an | grep ESTABLISHED | wc -l)" >> $REPORT_FILE
 echo "Listening Ports: $(netstat -an | grep LISTEN | wc -l)" >> $REPORT_FILE
 echo "TIME_WAIT: $(netstat -an | grep TIME_WAIT | wc -l)" >> $REPORT_FILE
 echo "" >> $REPORT_FILE
 
 echo "Top 10 Remote IPs:" >> $REPORT_FILE
 netstat -an | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -10 >> $REPORT_FILE
 echo "" >> $REPORT_FILE
 
 echo "Top 10 Ports:" >> $REPORT_FILE
 netstat -an | grep ESTABLISHED | awk '{print $4}' | cut -d: -f2 | sort | uniq -c | sort -rn | head -10 >> $REPORT_FILE
}

# 主监控循环
main() {
 while true; do
 collect_stats
 check_anomalies
 
 if [ $(date +%H) -eq 0 ] && [ $(date +%M) -eq 0 ]; then
 generate_report
 fi
 
 sleep $MONITOR_INTERVAL
 done
}

main

网络流量分析#

#!/bin/bash
# 网络流量分析工具

ANALYSIS_DURATION=60
INTERFACE="eth0"

# 收集连接数据
collect_connection_data() {
 local duration=$1
 local output_file=$2
 
 for ((i=0; i<duration; i++)); do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 netstat -an | grep ESTABLISHED | while read proto recv_q send_q local_addr foreign_addr state; do
 local_ip=$(echo $local_addr | cut -d: -f1)
 local_port=$(echo $local_addr | cut -d: -f2)
 remote_ip=$(echo $foreign_addr | cut -d: -f1)
 remote_port=$(echo $foreign_addr | cut -d: -f2)
 
 echo "$TIMESTAMP,$local_ip,$local_port,$remote_ip,$remote_port,$state" >> $output_file
 done
 
 sleep 1
 done
}

# 分析流量模式
analyze_traffic_pattern() {
 local input_file=$1
 
 echo "Traffic Pattern Analysis"
 echo "========================"
 
 # 按时间统计连接数
 echo -e "\nConnections over time:"
 awk -F, '{print $1}' $input_file | sort | uniq -c
 
 # 按本地端口统计
 echo -e "\nTop 10 Local Ports:"
 awk -F, '{print $3}' $input_file | sort | uniq -c | sort -rn | head -10
 
 # 按远程端口统计
 echo -e "\nTop 10 Remote Ports:"
 awk -F, '{print $5}' $input_file | sort | uniq -c | sort -rn | head -10
 
 # 按远程 IP 统计
 echo -e "\nTop 10 Remote IPs:"
 awk -F, '{print $4}' $input_file | sort | uniq -c | sort -rn | head -10
}

# 主函数
main() {
 local data_file="/tmp/traffic_data_$(date +%Y%m%d_%H%M%S).csv"
 
 echo "Collecting traffic data for $ANALYSIS_DURATION seconds..."
 collect_connection_data $ANALYSIS_DURATION $data_file
 
 echo "Analyzing traffic pattern..."
 analyze_traffic_pattern $data_file
 
 echo -e "\nData saved to: $data_file"
}

main

网络故障诊断#

#!/bin/bash
# 网络故障诊断工具

DIAGNOSTIC_LOG="/tmp/network_diagnostic_$(date +%Y%m%d_%H%M%S).log"

# 诊断网络连接
diagnose_connections() {
 echo "=== Network Connection Diagnosis ===" >> $DIAGNOSTIC_LOG
 
 # 检查网络接口状态
 echo -e "\nNetwork Interface Status:" >> $DIAGNOSTIC_LOG
 netstat -i >> $DIAGNOSTIC_LOG
 
 # 检查路由表
 echo -e "\nRouting Table:" >> $DIAGNOSTIC_LOG
 netstat -rn >> $DIAGNOSTIC_LOG
 
 # 检查监听端口
 echo -e "\nListening Ports:" >> $DIAGNOSTIC_LOG
 netstat -ltn >> $DIAGNOSTIC_LOG
 
 # 检查已建立连接
 echo -e "\nEstablished Connections:" >> $DIAGNOSTIC_LOG
 netstat -an | grep ESTABLISHED >> $DIAGNOSTIC_LOG
 
 # 检查网络统计
 echo -e "\nNetwork Statistics:" >> $DIAGNOSTIC_LOG
 netstat -s >> $DIAGNOSTIC_LOG
}

# 诊断特定问题
diagnose_specific_issue() {
 local issue=$1
 
 case $issue in
 "slow_network")
 echo "=== Diagnosing Slow Network ===" >> $DIAGNOSTIC_LOG
 netstat -i | awk '{if ($4 > 0 || $8 > 0) print "Interface errors detected"}' >> $DIAGNOSTIC_LOG
 netstat -s | grep -E "retransmitted|timeout" >> $DIAGNOSTIC_LOG
 ;;
 "high_latency")
 echo "=== Diagnosing High Latency ===" >> $DIAGNOSTIC_LOG
 netstat -s | grep -E "retransmitted|delayed" >> $DIAGNOSTIC_LOG
 ;;
 "connection_refused")
 echo "=== Diagnosing Connection Refused ===" >> $DIAGNOSTIC_LOG
 netstat -ltn >> $DIAGNOSTIC_LOG
 ;;
 *)
 echo "Unknown issue: $issue" >> $DIAGNOSTIC_LOG
 ;;
 esac
}

# 生成诊断报告
generate_diagnostic_report() {
 echo "Network Diagnostic Report - $(date)" > $DIAGNOSTIC_LOG
 echo "================================" >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
 
 diagnose_connections
 
 if [ -n "$1" ]; then
 diagnose_specific_issue "$1"
 fi
 
 echo -e "\nDiagnostic completed. Log saved to: $DIAGNOSTIC_LOG"
}

# 主函数
main() {
 generate_diagnostic_report "$1"
}

main "$@"

最佳实践#

使用 ss 命令替代：在新版本 Linux 中，优先使用 ss 命令替代 netstat
使用数字格式：使用 -n 选项避免 DNS 解析，提高性能
定期监控：定期检查网络连接状态，及时发现异常
分析连接模式：分析连接模式，识别潜在的安全威胁
记录日志：记录重要的网络事件，便于故障排查
设置告警阈值：根据业务需求设置合理的告警阈值
结合其他工具：结合 tcpdump、wireshark 等工具进行深入分析
注意性能影响：频繁执行 netstat 可能影响系统性能

注意事项#

netstat 在某些 Linux 发行版中已被弃用，建议使用 ss 命令
使用 -p 选项需要 root 权限
频繁执行 netstat 可能消耗系统资源
网络连接信息可能包含敏感数据，注意保护隐私
不同操作系统的 netstat 命令选项可能有所不同
在高流量环境中，netstat 输出可能非常庞大
注意 TIME_WAIT 状态的连接，可能导致端口耗尽
对于关键业务，建议使用专业的网络监控工具

ssh 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

ssh 命令详解#

ssh（Secure Shell）是 Linux 系统中用于安全远程登录和执行命令的协议和工具，是系统管理员和开发人员最常用的网络工具之一。它提供了加密的通信通道，确保数据传输的安全性。

入门#

基本用法#

# 远程登录到服务器
ssh user@hostname

# 使用 IP 地址登录
ssh user@192.168.1.100

# 指定端口登录
ssh -p 2222 user@hostname

# 执行远程命令
ssh user@hostname "command"

# 使用私钥登录
ssh -i /path/to/private_key user@hostname

常用选项#

选项	说明
`-p`	指定端口号
`-i`	指定私钥文件
`-l`	指定登录用户名
`-v`	显示详细输出（调试模式）
`-q`	静默模式
`-C`	启用压缩
`-X`	启用 X11 转发
`-L`	本地端口转发
`-R`	远程端口转发
`-D`	动态端口转发（SOCKS 代理）

基本示例#

# 登录到远程服务器
ssh root@server.example.com

# 使用特定端口登录
ssh -p 2222 user@server.example.com

# 执行远程命令
ssh user@server.example.com "ls -la /tmp"

# 使用私钥登录
ssh -i ~/.ssh/id_rsa user@server.example.com

中级#

SSH 密钥管理#

# 生成 SSH 密钥对
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

# 生成 ED25519 密钥（推荐）
ssh-keygen -t ed25519 -C "your_email@example.com"

# 查看公钥内容
cat ~/.ssh/id_rsa.pub

# 复制公钥到远程服务器
ssh-copy-id user@hostname

# 手动复制公钥
ssh user@hostname "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys" < ~/.ssh/id_rsa.pub

# 查看已保存的指纹
ssh-keygen -l -f ~/.ssh/known_hosts

SSH 配置文件#

# 编辑 SSH 配置文件
nano ~/.ssh/config

# 配置示例：
# Host server1
# HostName server1.example.com
# User admin
# Port 2222
# IdentityFile ~/.ssh/id_rsa_server1
#
# Host server2
# HostName 192.168.1.100
# User user
# Port 22

# 使用配置文件登录
ssh server1

# 测试配置文件
ssh -F ~/.ssh/config server1

端口转发#

# 本地端口转发（将远程端口映射到本地）
ssh -L 8080:localhost:80 user@remote_host

# 远程端口转发（将本地端口映射到远程）
ssh -R 8080:localhost:80 user@remote_host

# 动态端口转发（SOCKS 代理）
ssh -D 1080 user@remote_host

# 绑定到所有接口
ssh -g -L 8080:localhost:80 user@remote_host

# 转发到其他主机
ssh -L 8080:internal_host:80 user@remote_host

高级#

SSH 隧道和代理#

# 创建 SSH 隧道访问内网服务
ssh -L 3306:internal_db:3306 user@jump_server

# 通过 SSH 隧道访问 Web 服务
ssh -L 8080:localhost:80 user@remote_host

# 使用 SSH 作为 SOCKS 代理
ssh -D 1080 -N user@remote_host

# 配置浏览器使用 SOCKS 代理
# 代理地址: localhost:1080
# 代理类型: SOCKS5

# 反向隧道（让远程服务器访问本地服务）
ssh -R 8080:localhost:80 user@remote_host

SSH 会话管理#

# 启动 SSH 会话并保持后台运行
ssh -f -N user@hostname

# 使用 autossh 自动重连
autossh -M 0 -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3" user@hostname

# 使用 tmux/screen 保持会话
ssh user@hostname "tmux new -s session_name"

# 附加到现有会话
ssh user@hostname "tmux attach -t session_name"

# 使用 ControlMaster 复用连接
# 在 ~/.ssh/config 中添加：
# ControlMaster auto
# ControlPath ~/.ssh/cm-%r@%h:%p
# ControlPersist 10m

SSH 安全配置#

# 编辑服务器 SSH 配置
sudo nano /etc/ssh/sshd_config

# 推荐配置：
# Port 2222 # 更改默认端口
# PermitRootLogin no # 禁止 root 登录
# PasswordAuthentication no # 禁用密码认证
# PubkeyAuthentication yes # 启用公钥认证
# AllowUsers user1 user2 # 限制允许的用户
# ClientAliveInterval 300 # 客户端存活间隔
# ClientAliveCountMax 2 # 最大存活次数

# 重启 SSH 服务
sudo systemctl restart sshd

# 限制登录尝试次数
sudo nano /etc/ssh/sshd_config
# MaxAuthTries 3

# 使用 fail2ban 防止暴力破解
sudo apt install fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

大师#

SSH 批量管理#

#!/bin/bash
# SSH 批量管理脚本

SERVERS=("server1.example.com" "server2.example.com" "server3.example.com")
COMMAND="uptime"

# 在所有服务器上执行命令
for SERVER in "${SERVERS[@]}"; do
 echo "=== $SERVER ==="
 ssh user@$SERVER "$COMMAND"
 echo ""
done

# 批量上传文件
for SERVER in "${SERVERS[@]}"; do
 echo "Uploading to $SERVER..."
 scp local_file user@$SERVER:/remote/path/
done

# 批量下载文件
for SERVER in "${SERVERS[@]}"; do
 echo "Downloading from $SERVER..."
 scp user@$SERVER:/remote/path/file local_path/
done

SSH 自动化脚本#

#!/bin/bash
# SSH 自动化部署脚本

SERVER="user@server.example.com"
APP_DIR="/var/www/myapp"
BACKUP_DIR="/var/backups/myapp"

# 远程备份
backup_remote() {
 ssh $SERVER "mkdir -p $BACKUP_DIR && tar -czf $BACKUP_DIR/backup_$(date +%Y%m%d_%H%M%S).tar.gz -C $APP_DIR ."
 echo "Backup completed"
}

# 远程部署
deploy_remote() {
 echo "Deploying to $SERVER..."
 
 # 上传文件
 scp -r ./dist/* $SERVER:$APP_DIR/
 
 # 执行远程命令
 ssh $SERVER "cd $APP_DIR && npm install && pm2 restart myapp"
 
 echo "Deployment completed"
}

# 远程监控
monitor_remote() {
 while true; do
 ssh $SERVER "pm2 status"
 sleep 10
 done
}

case "$1" in
 backup)
 backup_remote
 ;;
 deploy)
 deploy_remote
 ;;
 monitor)
 monitor_remote
 ;;
 *)
 echo "Usage: $0 {backup|deploy|monitor}"
 exit 1
 ;;
esac

SSH 密钥轮换#

#!/bin/bash
# SSH 密钥轮换脚本

OLD_KEY="$HOME/.ssh/id_rsa_old"
NEW_KEY="$HOME/.ssh/id_rsa_new"
SERVERS=("server1.example.com" "server2.example.com")

# 生成新密钥
generate_new_key() {
 echo "Generating new SSH key..."
 ssh-keygen -t ed25519 -f $NEW_KEY -N "" -C "new_key_$(date +%Y%m%d)"
 echo "New key generated"
}

# 分发新密钥
distribute_new_key() {
 echo "Distributing new key to servers..."
 
 for SERVER in "${SERVERS[@]}"; do
 echo "Adding new key to $SERVER..."
 ssh-copy-id -i ${NEW_KEY}.pub user@$SERVER
 done
}

# 测试新密钥
test_new_key() {
 echo "Testing new key..."
 
 for SERVER in "${SERVERS[@]}"; do
 if ssh -i $NEW_KEY -o PasswordAuthentication=no user@$SERVER "echo 'Success'" > /dev/null 2>&1; then
 echo "✓ New key works on $SERVER"
 else
 echo "✗ New key failed on $SERVER"
 return 1
 fi
 done
}

# 移除旧密钥
remove_old_key() {
 echo "Removing old key from servers..."
 
 for SERVER in "${SERVERS[@]}"; do
 echo "Removing old key from $SERVER..."
 ssh user@$SERVER "sed -i '/$(cat ${OLD_KEY}.pub | awk '{print $2}')/d' ~/.ssh/authorized_keys"
 done
}

# 主函数
main() {
 generate_new_key
 distribute_new_key
 
 if test_new_key; then
 read -p "Remove old key? (y/n) " -n 1 -r
 echo
 if [[ $REPLY =~ ^[Yy]$ ]]; then
 remove_old_key
 fi
 else
 echo "Key rotation failed. Old key still active."
 fi
}

main

无敌#

企业级 SSH 管理系统#

#!/bin/bash
# 企业级 SSH 管理系统

CONFIG_FILE="/etc/ssh_manager/config.conf"
LOG_FILE="/var/log/ssh_manager.log"
KEY_DIR="/etc/ssh_manager/keys"
SERVER_DB="/etc/ssh_manager/servers.db"

mkdir -p $KEY_DIR

# 初始化服务器数据库
init_server_db() {
 if [ ! -f "$SERVER_DB" ]; then
 echo "hostname,user,port,key_file" > $SERVER_DB
 echo "server1.example.com,admin,22,id_rsa_server1" >> $SERVER_DB
 echo "server2.example.com,admin,2222,id_rsa_server2" >> $SERVER_DB
 echo "Server database initialized"
 fi
}

# 添加服务器
add_server() {
 local hostname=$1
 local user=$2
 local port=$3
 local key_name=$4
 
 echo "$hostname,$user,$port,$key_name" >> $SERVER_DB
 echo "Server $hostname added"
}

# 列出所有服务器
list_servers() {
 echo "=== Server List ==="
 tail -n +2 $SERVER_DB | while IFS=, read -r hostname user port key_file; do
 echo "Host: $hostname, User: $user, Port: $port, Key: $key_file"
 done
}

# 在所有服务器上执行命令
execute_on_all() {
 local command=$1
 
 tail -n +2 $SERVER_DB | while IFS=, read -r hostname user port key_file; do
 echo "=== $hostname ==="
 ssh -p $port -i $KEY_DIR/$key_file $user@$hostname "$command"
 echo ""
 done
}

# 批量部署
batch_deploy() {
 local source_dir=$1
 local target_dir=$2
 
 tail -n +2 $SERVER_DB | while IFS=, read -r hostname user port key_file; do
 echo "Deploying to $hostname..."
 scp -P $port -i $KEY_DIR/$key_file -r $source_dir/* $user@$hostname:$target_dir/
 ssh -p $port -i $KEY_DIR/$key_file $user@$hostname "cd $target_dir && ./deploy.sh"
 done
}

# 生成管理报告
generate_report() {
 local report_file="/tmp/ssh_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "SSH Management Report - $(date)" > $report_file
 echo "============================" >> $report_file
 echo "" >> $report_file
 
 echo "Server Status:" >> $report_file
 tail -n +2 $SERVER_DB | while IFS=, read -r hostname user port key_file; do
 if ssh -p $port -i $KEY_DIR/$key_file -o ConnectTimeout=5 $user@$hostname "echo 'OK'" > /dev/null 2>&1; then
 echo "✓ $hostname - Online" >> $report_file
 else
 echo "✗ $hostname - Offline" >> $report_file
 fi
 done
 
 echo "" >> $report_file
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 init_server_db
 
 case "$1" in
 add)
 add_server "$2" "$3" "$4" "$5"
 ;;
 list)
 list_servers
 ;;
 exec)
 execute_on_all "$2"
 ;;
 deploy)
 batch_deploy "$2" "$3"
 ;;
 report)
 generate_report
 ;;
 *)
 echo "Usage: $0 {add|list|exec|deploy|report}"
 exit 1
 ;;
 esac
}

main "$@"

SSH 审计和监控#

#!/bin/bash
# SSH 审计和监控系统

AUTH_LOG="/var/log/auth.log"
AUDIT_REPORT="/var/log/ssh_audit_$(date +%Y%m%d).log"

# 分析 SSH 登录尝试
analyze_login_attempts() {
 echo "=== SSH Login Analysis ===" >> $AUDIT_REPORT
 echo "Date: $(date)" >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
 
 # 成功登录
 echo "Successful Logins:" >> $AUDIT_REPORT
 grep "Accepted" $AUTH_LOG | tail -20 >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
 
 # 失败登录
 echo "Failed Login Attempts:" >> $AUDIT_REPORT
 grep "Failed" $AUTH_LOG | tail -20 >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
 
 # 按用户统计
 echo "Logins by User:" >> $AUDIT_REPORT
 grep "Accepted" $AUTH_LOG | awk '{print $9}' | sort | uniq -c | sort -rn >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
 
 # 按IP统计
 echo "Logins by IP:" >> $AUDIT_REPORT
 grep "Accepted" $AUTH_LOG | awk '{print $11}' | sort | uniq -c | sort -rn | head -10 >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
 
 # 暴力破解检测
 echo "Potential Brute Force Attacks:" >> $AUDIT_REPORT
 grep "Failed" $AUTH_LOG | awk '{print $9}' | sort | uniq -c | sort -rn | head -10 >> $AUDIT_REPORT
}

# 监控活跃 SSH 会话
monitor_active_sessions() {
 echo "=== Active SSH Sessions ===" >> $AUDIT_REPORT
 who >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
 
 echo "SSH Processes:" >> $AUDIT_REPORT
 ps aux | grep sshd | grep -v grep >> $AUDIT_REPORT
 echo "" >> $AUDIT_REPORT
}

# 检查 SSH 配置安全性
check_ssh_config() {
 echo "=== SSH Configuration Security Check ===" >> $AUDIT_REPORT
 
 CONFIG_FILE="/etc/ssh/sshd_config"
 
 if [ -f "$CONFIG_FILE" ]; then
 echo "Checking $CONFIG_FILE..." >> $AUDIT_REPORT
 
 # 检查 root 登录
 if grep -q "^PermitRootLogin yes" $CONFIG_FILE; then
 echo "⚠ WARNING: Root login is enabled" >> $AUDIT_REPORT
 else
 echo "✓ Root login is disabled" >> $AUDIT_REPORT
 fi
 
 # 检查密码认证
 if grep -q "^PasswordAuthentication yes" $CONFIG_FILE; then
 echo "⚠ WARNING: Password authentication is enabled" >> $AUDIT_REPORT
 else
 echo "✓ Password authentication is disabled" >> $AUDIT_REPORT
 fi
 
 # 检查默认端口
 if grep -q "^Port 22" $CONFIG_FILE; then
 echo "⚠ WARNING: Default port 22 is in use" >> $AUDIT_REPORT
 else
 echo "✓ Non-default port is configured" >> $AUDIT_REPORT
 fi
 fi
}

# 生成安全报告
generate_security_report() {
 analyze_login_attempts
 monitor_active_sessions
 check_ssh_config
 
 echo "Security report generated: $AUDIT_REPORT"
}

# 实时监控
realtime_monitor() {
 echo "Starting real-time SSH monitoring..."
 tail -f $AUTH_LOG | grep --line-buffered -E "Accepted|Failed" | while read line; do
 echo "$(date '+%Y-%m-%d %H:%M:%S') - $line"
 done
}

# 主函数
main() {
 case "$1" in
 audit)
 generate_security_report
 ;;
 monitor)
 realtime_monitor
 ;;
 *)
 echo "Usage: $0 {audit|monitor}"
 exit 1
 ;;
 esac
}

main "$@"

SSH 灾难恢复系统#

#!/bin/bash
# SSH 灾难恢复系统

BACKUP_DIR="/var/backups/ssh_recovery"
RECOVERY_LOG="/var/log/ssh_recovery.log"

# 备份 SSH 配置和密钥
backup_ssh_config() {
 local timestamp=$(date +%Y%m%d_%H%M%S)
 local backup_file="$BACKUP_DIR/ssh_backup_$timestamp.tar.gz"
 
 mkdir -p $BACKUP_DIR
 
 echo "Backing up SSH configuration..."
 tar -czf $backup_file \
 /etc/ssh/ \
 ~/.ssh/ \
 /var/log/auth.log
 
 echo "Backup created: $backup_file"
}

# 恢复 SSH 配置
restore_ssh_config() {
 local backup_file=$1
 
 if [ ! -f "$backup_file" ]; then
 echo "Backup file not found: $backup_file"
 return 1
 fi
 
 echo "Restoring SSH configuration from $backup_file..."
 
 # 停止 SSH 服务
 sudo systemctl stop sshd
 
 # 恢复文件
 sudo tar -xzf $backup_file -C /
 
 # 重启 SSH 服务
 sudo systemctl start sshd
 
 echo "SSH configuration restored"
}

# 紧急访问设置
setup_emergency_access() {
 echo "Setting up emergency access..."
 
 # 创建临时密钥
 local emergency_key="$HOME/.ssh/emergency_key"
 ssh-keygen -t ed25519 -f $emergency_key -N "" -C "emergency_$(date +%Y%m%d)"
 
 # 添加到 authorized_keys
 cat ${emergency_key}.pub >> ~/.ssh/authorized_keys
 
 echo "Emergency access configured"
 echo "Private key: $emergency_key"
 echo "Remember to remove this key after emergency!"
}

# 测试 SSH 连接
test_ssh_connection() {
 local server=$1
 
 echo "Testing SSH connection to $server..."
 
 if ssh -o ConnectTimeout=5 -o BatchMode=yes $server "echo 'Connection successful'" > /dev/null 2>&1; then
 echo "✓ SSH connection successful"
 return 0
 else
 echo "✗ SSH connection failed"
 return 1
 fi
}

# 自动恢复
auto_recovery() {
 local server=$1
 
 echo "Attempting automatic recovery for $server..."
 
 # 尝试使用备用密钥
 if [ -f "$HOME/.ssh/emergency_key" ]; then
 echo "Trying emergency key..."
 if ssh -i $HOME/.ssh/emergency_key $server "echo 'Success'" > /dev/null 2>&1; then
 echo "Emergency access successful"
 return 0
 fi
 fi
 
 # 尝试恢复配置
 local latest_backup=$(ls -t $BACKUP_DIR/ssh_backup_*.tar.gz | head -1)
 if [ -n "$latest_backup" ]; then
 echo "Restoring from latest backup..."
 restore_ssh_config $latest_backup
 test_ssh_connection $server
 fi
}

# 主函数
main() {
 case "$1" in
 backup)
 backup_ssh_config
 ;;
 restore)
 restore_ssh_config "$2"
 ;;
 emergency)
 setup_emergency_access
 ;;
 test)
 test_ssh_connection "$2"
 ;;
 recover)
 auto_recovery "$2"
 ;;
 *)
 echo "Usage: $0 {backup|restore|emergency|test|recover}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用密钥认证：优先使用 SSH 密钥而非密码认证
禁用 root 登录：禁止直接使用 root 账户登录
更改默认端口：使用非标准端口减少攻击面
定期更新密钥：定期轮换 SSH 密钥
使用配置文件：使用 ~/.ssh/config 简化连接管理
启用日志审计：记录和监控 SSH 登录活动
使用 fail2ban：防止暴力破解攻击
限制访问：使用防火墙和 AllowUsers 限制访问

注意事项#

SSH 私钥必须妥善保管，不要泄露给他人
在生产环境操作前先在测试环境验证
修改 SSH 配置后确保能正常登录再断开连接
使用 -v 选项调试连接问题时注意保护敏感信息
端口转发可能带来安全风险，谨慎使用
定期检查 ~/.ssh/known_hosts 文件
注意 SSH 协议版本，优先使用 SSH-2
在自动化脚本中使用 SSH 时考虑错误处理

curl 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

curl 命令详解#

curl（Client URL）是 Linux 系统中用于传输数据的命令行工具，支持多种协议（HTTP、HTTPS、FTP、FTPES、SCP、SFTP、TFTP、LDAP、LDAPS、DICT、TELNET、FILE、IMAP、POP3、SMTP、RTMP、RTSP 等），是开发和运维中最常用的网络工具之一。

入门#

基本用法#

# 获取网页内容
curl https://example.com

# 保存网页到文件
curl -o output.html https://example.com

# 使用远程文件名保存
curl -O https://example.com/file.zip

# 显示响应头
curl -I https://example.com

# 显示详细信息
curl -v https://example.com

常用选项#

选项	说明
`-o`	指定输出文件名
`-O`	使用远程文件名保存
`-I`	只显示响应头
`-v`	显示详细输出
`-s`	静默模式
`-L`	跟随重定向
`-u`	指定用户名和密码
`-d`	发送 POST 数据
`-H`	添加请求头
`-X`	指定请求方法

基本示例#

# 获取网页内容
curl https://www.example.com

# 下载文件
curl -O https://example.com/file.zip

# 查看响应头
curl -I https://example.com

# 跟随重定向
curl -L https://example.com

# 静默模式
curl -s https://example.com

中级#

HTTP 请求方法#

# GET 请求（默认）
curl https://api.example.com/users

# POST 请求
curl -X POST https://api.example.com/users -d "name=John&age=30"

# PUT 请求
curl -X PUT https://api.example.com/users/1 -d "name=John&age=31"

# DELETE 请求
curl -X DELETE https://api.example.com/users/1

# PATCH 请求
curl -X PATCH https://api.example.com/users/1 -d "age=32"

请求头和认证#

# 添加请求头
curl -H "Content-Type: application/json" https://api.example.com/users

# 添加多个请求头
curl -H "Content-Type: application/json" -H "Authorization: Bearer token" https://api.example.com/users

# 基本认证
curl -u username:password https://api.example.com/users

# Bearer Token 认证
curl -H "Authorization: Bearer your_token" https://api.example.com/users

# API Key 认证
curl -H "X-API-Key: your_api_key" https://api.example.com/users

数据传输#

# 发送表单数据
curl -d "name=John&age=30" https://api.example.com/users

# 发送 JSON 数据
curl -H "Content-Type: application/json" -d '{"name":"John","age":30}' https://api.example.com/users

# 从文件发送数据
curl -d @data.json https://api.example.com/users

# 上传文件
curl -F "file=@/path/to/file.txt" https://api.example.com/upload

# 上传多个文件
curl -F "file1=@/path/to/file1.txt" -F "file2=@/path/to/file2.txt" https://api.example.com/upload

高级#

高级选项#

# 设置超时时间
curl --max-time 30 https://example.com

# 设置连接超时
curl --connect-timeout 10 https://example.com

# 限制下载速度
curl --limit-rate 100k https://example.com/file.zip

# 断点续传
curl -C - -O https://example.com/file.zip

# 使用代理
curl -x http://proxy.example.com:8080 https://example.com

# 使用 SOCKS 代理
curl --socks5 127.0.0.1:1080 https://example.com

# 忽略 SSL 证书验证
curl -k https://example.com

# 使用客户端证书
curl --cert client.crt --key client.key https://example.com

# 保存 Cookie
curl -c cookies.txt https://example.com/login

# 使用 Cookie
curl -b cookies.txt https://example.com/profile

# 发送特定 Cookie
curl -b "session_id=abc123" https://example.com/profile

# 保存和发送 Cookie
curl -b cookies.txt -c cookies.txt https://example.com/profile

# 删除 Cookie
curl -b "session_id=; expires=Thu, 01 Jan 1970 00:00:00 GMT" https://example.com/logout

调试和日志#

# 显示详细调试信息
curl -v https://example.com

# 显示请求和响应头
curl -i https://example.com

# 显示请求头
curl --trace-ascii /dev/stderr https://example.com

# 保存调试信息到文件
curl --trace debug.log https://example.com

# 显示时间统计
curl -w "@format.txt" https://example.com

# format.txt 示例：
# time_namelookup: %{time_namelookup}\n
# time_connect: %{time_connect}\n
# time_appconnect: %{time_appconnect}\n
# time_pretransfer: %{time_pretransfer}\n
# time_starttransfer: %{time_starttransfer}\n
# time_total: %{time_total}\n

大师#

API 测试和调试#

#!/bin/bash
# API 测试脚本

BASE_URL="https://api.example.com"
TOKEN="your_api_token"

# 测试 GET 请求
test_get() {
 local endpoint=$1
 echo "Testing GET: $endpoint"
 curl -X GET "$BASE_URL$endpoint" \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -w "\nHTTP Status: %{http_code}\n" \
 -s
 echo ""
}

# 测试 POST 请求
test_post() {
 local endpoint=$1
 local data=$2
 echo "Testing POST: $endpoint"
 curl -X POST "$BASE_URL$endpoint" \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -d "$data" \
 -w "\nHTTP Status: %{http_code}\n" \
 -s
 echo ""
}

# 测试 PUT 请求
test_put() {
 local endpoint=$1
 local data=$2
 echo "Testing PUT: $endpoint"
 curl -X PUT "$BASE_URL$endpoint" \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -d "$data" \
 -w "\nHTTP Status: %{http_code}\n" \
 -s
 echo ""
}

# 测试 DELETE 请求
test_delete() {
 local endpoint=$1
 echo "Testing DELETE: $endpoint"
 curl -X DELETE "$BASE_URL$endpoint" \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -w "\nHTTP Status: %{http_code}\n" \
 -s
 echo ""
}

# 批量测试
batch_test() {
 test_get "/users"
 test_post "/users" '{"name":"John","age":30}'
 test_get "/users/1"
 test_put "/users/1" '{"name":"John","age":31}'
 test_delete "/users/1"
}

batch_test

网站监控#

#!/bin/bash
# 网站监控脚本

WEBSITES=("https://example.com" "https://api.example.com" "https://blog.example.com")
LOG_FILE="website_monitor.log"
ALERT_EMAIL="admin@example.com"

# 检查网站状态
check_website() {
 local url=$1
 local response_time
 local http_code
 
 response_time=$(curl -o /dev/null -s -w '%{time_total}' "$url")
 http_code=$(curl -o /dev/null -s -w '%{http_code}' "$url")
 
 echo "$(date '+%Y-%m-%d %H:%M:%S') - $url - HTTP $http_code - ${response_time}s" >> $LOG_FILE
 
 if [ $http_code -ne 200 ]; then
 echo "ALERT: $url returned HTTP $http_code" | mail -s "Website Alert" $ALERT_EMAIL
 fi
 
 if (( $(echo "$response_time > 3.0" | bc -l) )); then
 echo "WARNING: $url response time is ${response_time}s" | mail -s "Performance Warning" $ALERT_EMAIL
 fi
}

# 主监控循环
main() {
 while true; do
 for WEBSITE in "${WEBSITES[@]}"; do
 check_website "$WEBSITE"
 done
 sleep 300
 done
}

main

批量下载#

#!/bin/bash
# 批量下载脚本

BASE_URL="https://example.com/files/"
OUTPUT_DIR="downloads"
LOG_FILE="download.log"

mkdir -p $OUTPUT_DIR

# 从文件列表下载
download_from_list() {
 local list_file=$1
 
 while IFS= read -r filename; do
 echo "Downloading: $filename"
 curl -O "$BASE_URL$filename" 2>> $LOG_FILE
 done < "$list_file"
}

# 按模式下载
download_by_pattern() {
 local pattern=$1
 local start=$2
 local end=$3
 
 for ((i=start; i<=end; i++)); do
 local filename=$(printf "$pattern" $i)
 echo "Downloading: $filename"
 curl -O "$BASE_URL$filename" 2>> $LOG_FILE
 done
}

# 并行下载
parallel_download() {
 local urls=("$@")
 
 for url in "${urls[@]}"; do
 curl -O "$url" &
 done
 
 wait
}

# 断点续传下载
resumable_download() {
 local url=$1
 local output=$2
 
 while true; do
 curl -C - -o "$output" "$url"
 
 if [ $? -eq 0 ]; then
 echo "Download completed: $output"
 break
 else
 echo "Download interrupted, retrying..."
 sleep 5
 fi
 done
}

# 主函数
main() {
 case "$1" in
 list)
 download_from_list "$2"
 ;;
 pattern)
 download_by_pattern "$2" "$3" "$4"
 ;;
 parallel)
 parallel_download "${@:2}"
 ;;
 resume)
 resumable_download "$2" "$3"
 ;;
 *)
 echo "Usage: $0 {list|pattern|parallel|resume}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级 API 测试框架#

#!/bin/bash
# 企业级 API 测试框架

CONFIG_FILE="api_test_config.conf"
TEST_RESULTS_DIR="test_results"
REPORT_FILE="test_report_$(date +%Y%m%d_%H%M%S).html"

mkdir -p $TEST_RESULTS_DIR

# 加载配置
load_config() {
 if [ -f "$CONFIG_FILE" ]; then
 source $CONFIG_FILE
 else
 echo "Config file not found: $CONFIG_FILE"
 exit 1
 fi
}

# 执行 API 测试
execute_test() {
 local test_name=$1
 local method=$2
 local endpoint=$3
 local expected_code=$4
 local data=$5
 
 local full_url="${BASE_URL}${endpoint}"
 local response_file="$TEST_RESULTS_DIR/${test_name}_response.json"
 local start_time end_time duration
 
 echo "Running test: $test_name"
 
 start_time=$(date +%s.%N)
 
 if [ -n "$data" ]; then
 http_code=$(curl -X $method "$full_url" \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -d "$data" \
 -o "$response_file" \
 -w "%{http_code}" \
 -s)
 else
 http_code=$(curl -X $method "$full_url" \
 -H "Authorization: Bearer $TOKEN" \
 -H "Content-Type: application/json" \
 -o "$response_file" \
 -w "%{http_code}" \
 -s)
 fi
 
 end_time=$(date +%s.%N)
 duration=$(echo "$end_time - $start_time" | bc)
 
 if [ "$http_code" -eq "$expected_code" ]; then
 echo "✓ PASS: $test_name (HTTP $http_code, ${duration}s)"
 return 0
 else
 echo "✗ FAIL: $test_name (Expected: $expected_code, Got: $http_code, ${duration}s)"
 return 1
 fi
}

# 执行测试套件
run_test_suite() {
 local total_tests=0
 local passed_tests=0
 local failed_tests=0
 
 echo "=== API Test Suite ==="
 echo ""
 
 # 测试用例
 execute_test "get_users" "GET" "/users" 200
 total_tests=$((total_tests + 1))
 if [ $? -eq 0 ]; then passed_tests=$((passed_tests + 1)); else failed_tests=$((failed_tests + 1)); fi
 
 execute_test "create_user" "POST" "/users" 201 '{"name":"Test User","age":25}'
 total_tests=$((total_tests + 1))
 if [ $? -eq 0 ]; then passed_tests=$((passed_tests + 1)); else failed_tests=$((failed_tests + 1)); fi
 
 execute_test "get_user" "GET" "/users/1" 200
 total_tests=$((total_tests + 1))
 if [ $? -eq 0 ]; then passed_tests=$((passed_tests + 1)); else failed_tests=$((failed_tests + 1)); fi
 
 execute_test "update_user" "PUT" "/users/1" 200 '{"name":"Updated User","age":26}'
 total_tests=$((total_tests + 1))
 if [ $? -eq 0 ]; then passed_tests=$((passed_tests + 1)); else failed_tests=$((failed_tests + 1)); fi
 
 execute_test "delete_user" "DELETE" "/users/1" 204
 total_tests=$((total_tests + 1))
 if [ $? -eq 0 ]; then passed_tests=$((passed_tests + 1)); else failed_tests=$((failed_tests + 1)); fi
 
 echo ""
 echo "=== Test Summary ==="
 echo "Total Tests: $total_tests"
 echo "Passed: $passed_tests"
 echo "Failed: $failed_tests"
 echo "Success Rate: $(echo "scale=2; $passed_tests * 100 / $total_tests" | bc)%"
}

# 生成 HTML 报告
generate_html_report() {
 cat > $REPORT_FILE << EOF
<!DOCTYPE html>
<html>
<head>
 <title>API Test Report</title>
 <style>
 body { font-family: Arial, sans-serif; margin: 20px; }
 .pass { color: green; }
 .fail { color: red; }
 table { border-collapse: collapse; width: 100%; }
 th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
 th { background-color: #4CAF50; color: white; }
 </style>
</head>
<body>
 <h1>API Test Report</h1>
 <p>Generated: $(date)</p>
 
 <h2>Test Results</h2>
 <table>
 <tr>
 <th>Test Name</th>
 <th>Status</th>
 <th>Response Time</th>
 </tr>
EOF

 # 添加测试结果
 ls $TEST_RESULTS_DIR/*.json | while read response_file; do
 local test_name=$(basename $response_file | sed 's/_response.json//')
 local status="PASS"
 local response_time="0.5s"
 
 echo " <tr>" >> $REPORT_FILE
 echo " <td>$test_name</td>" >> $REPORT_FILE
 echo " <td class='$status'>$status</td>" >> $REPORT_FILE
 echo " <td>$response_time</td>" >> $REPORT_FILE
 echo " </tr>" >> $REPORT_FILE
 done

 cat >> $REPORT_FILE << EOF
 </table>
</body>
</html>
EOF

 echo "HTML report generated: $REPORT_FILE"
}

# 主函数
main() {
 load_config
 run_test_suite
 generate_html_report
}

main

性能测试工具#

#!/bin/bash
# API 性能测试工具

API_URL="https://api.example.com/endpoint"
CONCURRENT_REQUESTS=10
TOTAL_REQUESTS=100
OUTPUT_FILE="performance_results.csv"

# 单次请求测试
single_request() {
 local url=$1
 
 local start_time=$(date +%s.%N)
 local http_code=$(curl -o /dev/null -s -w "%{http_code}" "$url")
 local end_time=$(date +%s.%N)
 local duration=$(echo "$end_time - $start_time" | bc)
 
 echo "$http_code,$duration"
}

# 并发请求测试
concurrent_test() {
 local url=$1
 local concurrent=$2
 local total=$3
 
 echo "Running concurrent test: $concurrent concurrent requests, $total total requests"
 
 local completed=0
 
 while [ $completed -lt $total ]; do
 local batch=$((concurrent))
 if [ $((completed + batch)) -gt $total ]; then
 batch=$((total - completed))
 fi
 
 for ((i=0; i<batch; i++)); do
 single_request "$url" >> $OUTPUT_FILE &
 done
 
 wait
 completed=$((completed + batch))
 
 echo "Progress: $completed/$total requests completed"
 done
}

# 分析结果
analyze_results() {
 echo "=== Performance Analysis ==="
 
 local total_requests=$(wc -l < $OUTPUT_FILE)
 local successful_requests=$(awk -F, '$1 == 200' $OUTPUT_FILE | wc -l)
 local failed_requests=$((total_requests - successful_requests))
 
 local avg_response_time=$(awk -F, '{sum+=$2; count++} END {print sum/count}' $OUTPUT_FILE)
 local min_response_time=$(awk -F, 'NR==1 || $2 < min {min=$2} END {print min}' $OUTPUT_FILE)
 local max_response_time=$(awk -F, 'NR==1 || $2 > max {max=$2} END {print max}' $OUTPUT_FILE)
 
 local requests_per_second=$(echo "scale=2; $total_requests / $avg_response_time" | bc)
 
 echo "Total Requests: $total_requests"
 echo "Successful: $successful_requests"
 echo "Failed: $failed_requests"
 echo "Success Rate: $(echo "scale=2; $successful_requests * 100 / $total_requests" | bc)%"
 echo ""
 echo "Response Time:"
 echo " Average: ${avg_response_time}s"
 echo " Min: ${min_response_time}s"
 echo " Max: ${max_response_time}s"
 echo ""
 echo "Throughput: ${requests_per_second} requests/second"
}

# 主函数
main() {
 echo "timestamp,http_code,response_time" > $OUTPUT_FILE
 
 concurrent_test "$API_URL" $CONCURRENT_REQUESTS $TOTAL_REQUESTS
 
 analyze_results
 
 echo "Results saved to: $OUTPUT_FILE"
}

main

自动化部署工具#

#!/bin/bash
# 基于 curl 的自动化部署工具

DEPLOY_CONFIG="deploy.conf"
LOG_FILE="deploy_$(date +%Y%m%d_%H%M%S).log"

# 加载部署配置
load_deploy_config() {
 if [ -f "$DEPLOY_CONFIG" ]; then
 source $DEPLOY_CONFIG
 else
 echo "Deploy config not found: $DEPLOY_CONFIG"
 exit 1
 fi
}

# 健康检查
health_check() {
 local url=$1
 local max_retries=5
 local retry_count=0
 
 echo "Performing health check on $url..."
 
 while [ $retry_count -lt $max_retries ]; do
 http_code=$(curl -o /dev/null -s -w "%{http_code}" "$url")
 
 if [ "$http_code" -eq 200 ]; then
 echo "✓ Health check passed"
 return 0
 fi
 
 echo "✗ Health check failed (HTTP $http_code), retrying..."
 retry_count=$((retry_count + 1))
 sleep 10
 done
 
 echo "✗ Health check failed after $max_retries attempts"
 return 1
}

# 触发部署
trigger_deployment() {
 local api_url=$1
 local payload=$2
 
 echo "Triggering deployment..."
 
 response=$(curl -X POST "$api_url" \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer $DEPLOY_TOKEN" \
 -d "$payload" \
 -w "\n%{http_code}" \
 -s)
 
 http_code=$(echo "$response" | tail -n1)
 body=$(echo "$response" | head -n-1)
 
 if [ "$http_code" -eq 200 ] || [ "$http_code" -eq 201 ]; then
 echo "✓ Deployment triggered successfully"
 echo "Response: $body"
 return 0
 else
 echo "✗ Deployment trigger failed (HTTP $http_code)"
 echo "Response: $body"
 return 1
 fi
}

# 监控部署状态
monitor_deployment() {
 local status_url=$1
 local deployment_id=$2
 
 echo "Monitoring deployment $deployment_id..."
 
 while true; do
 status=$(curl -s "$status_url/$deployment_id" | jq -r '.status')
 
 case "$status" in
 "success")
 echo "✓ Deployment completed successfully"
 return 0
 ;;
 "failed")
 echo "✗ Deployment failed"
 return 1
 ;;
 "in_progress"|"pending")
 echo "Deployment in progress..."
 sleep 10
 ;;
 *)
 echo "Unknown status: $status"
 sleep 10
 ;;
 esac
 done
}

# 回滚部署
rollback_deployment() {
 local api_url=$1
 local deployment_id=$2
 
 echo "Rolling back deployment $deployment_id..."
 
 response=$(curl -X POST "$api_url/$deployment_id/rollback" \
 -H "Authorization: Bearer $DEPLOY_TOKEN" \
 -w "\n%{http_code}" \
 -s)
 
 http_code=$(echo "$response" | tail -n1)
 
 if [ "$http_code" -eq 200 ]; then
 echo "✓ Rollback initiated"
 return 0
 else
 echo "✗ Rollback failed"
 return 1
 fi
}

# 主部署流程
main() {
 load_deploy_config
 
 echo "=== Starting Deployment ==="
 echo "Environment: $ENVIRONMENT"
 echo "Version: $VERSION"
 echo ""
 
 # 触发部署
 if trigger_deployment "$DEPLOY_API_URL" "{\"version\":\"$VERSION\",\"environment\":\"$ENVIRONMENT\"}"; then
 deployment_id=$(curl -s "$DEPLOY_API_URL" | jq -r '.deployment_id')
 
 # 监控部署
 if monitor_deployment "$STATUS_API_URL" "$deployment_id"; then
 # 健康检查
 if health_check "$HEALTH_CHECK_URL"; then
 echo "=== Deployment Successful ==="
 exit 0
 else
 echo "=== Health Check Failed ==="
 rollback_deployment "$DEPLOY_API_URL" "$deployment_id"
 exit 1
 fi
 else
 echo "=== Deployment Failed ==="
 rollback_deployment "$DEPLOY_API_URL" "$deployment_id"
 exit 1
 fi
 else
 echo "=== Deployment Trigger Failed ==="
 exit 1
 fi
}

main

最佳实践#

使用 HTTPS：始终使用 HTTPS 保护数据传输安全
验证 SSL 证书：不要在生产环境中使用 -k 选项
设置超时：合理设置连接和数据传输超时时间
使用用户代理：设置合适的 User-Agent 标识
处理错误：检查 HTTP 状态码并处理错误情况
限制速率：避免对服务器造成过大压力
使用配置文件：对于复杂的请求，使用配置文件管理
记录日志：记录重要的请求和响应信息

注意事项#

curl 支持的协议非常丰富，根据需要选择合适的协议
在处理敏感数据时，注意保护认证信息
大文件下载时使用断点续传功能
并发请求时注意控制并发数量
API 测试时注意不要对生产环境造成影响
使用 -v 选项调试时注意保护敏感信息
不同版本的 curl 选项可能有所不同
在自动化脚本中添加适当的错误处理

wget 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

wget 命令详解#

wget 是 Linux 系统中用于从网络下载文件的命令行工具，支持 HTTP、HTTPS 和 FTP 协议。与 curl 不同，wget 专注于文件下载，具有递归下载、断点续传、后台下载等强大功能，是系统管理员和开发人员常用的下载工具。

入门#

基本用法#

# 下载文件
wget https://example.com/file.zip

# 下载并指定文件名
wget -O newname.zip https://example.com/file.zip

# 下载到指定目录
wget -P /path/to/directory https://example.com/file.zip

# 后台下载
wget -b https://example.com/largefile.zip

常用选项#

选项	说明
`-O`	指定输出文件名
`-P`	指定下载目录
`-b`	后台下载
`-c`	断点续传
`-r`	递归下载
`-l`	设置递归深度
`-k`	转换链接为本地链接
`-p`	下载页面所需的所有资源
`-q`	静默模式
`-t`	设置重试次数

基本示例#

# 下载单个文件
wget https://example.com/file.zip

# 下载并重命名
wget -O myfile.zip https://example.com/file.zip

# 下载到指定目录
wget -P /tmp https://example.com/file.zip

# 后台下载
wget -b https://example.com/largefile.zip

# 查看后台下载进度
tail -f wget-log

中级#

断点续传#

# 断点续传下载
wget -c https://example.com/largefile.zip

# 下载中断后继续
wget -c https://example.com/largefile.zip

# 限制重试次数
wget -t 3 https://example.com/file.zip

# 无限重试
wget -t 0 https://example.com/file.zip

递归下载#

# 递归下载网站
wget -r https://example.com/

# 限制递归深度
wget -r -l 2 https://example.com/

# 下载页面及所有资源
wget -p https://example.com/page.html

# 转换链接为本地链接
wget -k https://example.com/page.html

# 递归下载并转换链接
wget -r -k https://example.com/

限速和带宽控制#

# 限制下载速度（字节/秒）
wget --limit-rate=200k https://example.com/file.zip

# 限制下载速度（KB/s）
wget --limit-rate=200K https://example.com/file.zip

# 限制下载速度（MB/s）
wget --limit-rate=2M https://example.com/file.zip

# 设置等待时间
wget --wait=5 https://example.com/file.zip

# 随机等待时间
wget --random-wait https://example.com/file.zip

高级#

高级下载选项#

# 设置用户代理
wget -U "Mozilla/5.0" https://example.com/file.zip

# 添加请求头
wget --header="Accept: application/json" https://example.com/file.zip

# 添加多个请求头
wget --header="Accept: application/json" --header="Authorization: Bearer token" https://example.com/file.zip

# 使用代理
wget -e "https_proxy=http://proxy.example.com:8080" https://example.com/file.zip

# 忽略 SSL 证书验证
wget --no-check-certificate https://example.com/file.zip

# 使用客户端证书
wget --certificate=client.crt --private-key=client.key https://example.com/file.zip

认证和登录#

# HTTP 基本认证
wget --user=username --password=password https://example.com/file.zip

# 从文件读取密码
wget --user=username --password-file=password.txt https://example.com/file.zip

# FTP 认证
wget --ftp-user=username --ftp-password=password ftp://example.com/file.zip

# 使用配置文件
echo "user=username:password" > ~/.wgetrc
wget https://example.com/file.zip

日志和调试#

# 显示详细输出
wget -v https://example.com/file.zip

# 静默模式
wget -q https://example.com/file.zip

# 记录日志
wget -o download.log https://example.com/file.zip

# 追加日志
wget -a download.log https://example.com/file.zip

# 显示服务器响应
wget -S https://example.com/file.zip

# 调试模式
wget -d https://example.com/file.zip

大师#

网站镜像#

#!/bin/bash
# 网站镜像脚本

SOURCE_URL="https://example.com/"
OUTPUT_DIR="mirror_output"

# 完整镜像网站
mirror_website() {
 wget \
 --mirror \
 --convert-links \
 --adjust-extension \
 --page-requisites \
 --no-parent \
 --wait=1 \
 --random-wait \
 --limit-rate=200k \
 -P "$OUTPUT_DIR" \
 "$SOURCE_URL"
 
 echo "Website mirrored to: $OUTPUT_DIR"
}

# 镜像特定目录
mirror_directory() {
 local directory=$1
 
 wget \
 --mirror \
 --convert-links \
 --adjust-extension \
 --page-requisites \
 --no-parent \
 -P "$OUTPUT_DIR" \
 "$SOURCE_URL$directory"
 
 echo "Directory $directory mirrored to: $OUTPUT_DIR"
}

# 镜像并排除特定文件
mirror_with_exclusions() {
 local exclusions=$1
 
 wget \
 --mirror \
 --convert-links \
 --adjust-extension \
 --page-requisites \
 --no-parent \
 --reject="$exclusions" \
 -P "$OUTPUT_DIR" \
 "$SOURCE_URL"
 
 echo "Website mirrored (excluding: $exclusions) to: $OUTPUT_DIR"
}

# 主函数
main() {
 case "$1" in
 full)
 mirror_website
 ;;
 directory)
 mirror_directory "$2"
 ;;
 exclude)
 mirror_with_exclusions "$2"
 ;;
 *)
 echo "Usage: $0 {full|directory|exclude}"
 exit 1
 ;;
 esac
}

main "$@"

批量下载#

#!/bin/bash
# 批量下载脚本

URL_LIST="url_list.txt"
OUTPUT_DIR="downloads"
LOG_FILE="download.log"

mkdir -p $OUTPUT_DIR

# 从列表下载
download_from_list() {
 local list_file=$1
 
 while IFS= read -r url; do
 if [ -n "$url" ] && [[ ! $url =~ ^# ]]; then
 echo "Downloading: $url"
 wget -P "$OUTPUT_DIR" -a "$LOG_FILE" "$url"
 fi
 done < "$list_file"
}

# 按模式下载
download_by_pattern() {
 local base_url=$1
 local pattern=$2
 local start=$3
 local end=$4
 
 for ((i=start; i<=end; i++)); do
 local url=$(printf "$base_url$pattern" $i)
 echo "Downloading: $url"
 wget -P "$OUTPUT_DIR" -a "$LOG_FILE" "$url"
 done
}

# 并行下载
parallel_download() {
 local max_parallel=$1
 shift
 local urls=("$@")
 
 local count=0
 for url in "${urls[@]}"; do
 wget -P "$OUTPUT_DIR" -a "$LOG_FILE" "$url" &
 count=$((count + 1))
 
 if [ $count -ge $max_parallel ]; then
 wait
 count=0
 fi
 done
 
 wait
}

# 下载失败重试
retry_failed_downloads() {
 local log_file=$1
 
 grep "failed" "$log_file" | awk '{print $3}' | sort -u | while read url; do
 echo "Retrying: $url"
 wget -c -P "$OUTPUT_DIR" -a "$LOG_FILE" "$url"
 done
}

# 主函数
main() {
 case "$1" in
 list)
 download_from_list "$2"
 ;;
 pattern)
 download_by_pattern "$2" "$3" "$4" "$5"
 ;;
 parallel)
 parallel_download "$2" "${@:3}"
 ;;
 retry)
 retry_failed_downloads "$2"
 ;;
 *)
 echo "Usage: $0 {list|pattern|parallel|retry}"
 exit 1
 ;;
 esac
}

main "$@"

定时下载#

#!/bin/bash
# 定时下载脚本

DOWNLOAD_CONFIG="download_schedule.conf"
LOG_DIR="download_logs"

mkdir -p $LOG_DIR

# 执行下载任务
execute_download_task() {
 local task_name=$1
 local url=$2
 local output_dir=$3
 local options=$4
 
 local log_file="$LOG_DIR/${task_name}_$(date +%Y%m%d_%H%M%S).log"
 
 echo "Executing task: $task_name"
 echo "URL: $url"
 echo "Output: $output_dir"
 
 mkdir -p "$output_dir"
 
 wget $options -P "$output_dir" -o "$log_file" "$url"
 
 if [ $? -eq 0 ]; then
 echo "✓ Task $task_name completed successfully"
 return 0
 else
 echo "✗ Task $task_name failed"
 return 1
 fi
}

# 加载并执行计划任务
load_and_execute_tasks() {
 if [ ! -f "$DOWNLOAD_CONFIG" ]; then
 echo "Config file not found: $DOWNLOAD_CONFIG"
 return 1
 fi
 
 while IFS='|' read -r task_name url output_dir options schedule; do
 if [ -n "$task_name" ] && [[ ! $task_name =~ ^# ]]; then
 execute_download_task "$task_name" "$url" "$output_dir" "$options"
 fi
 done < "$DOWNLOAD_CONFIG"
}

# 监控下载任务
monitor_downloads() {
 echo "Monitoring download tasks..."
 
 while true; do
 local running_downloads=$(ps aux | grep wget | grep -v grep | wc -l)
 
 if [ $running_downloads -gt 0 ]; then
 echo "Active downloads: $running_downloads"
 fi
 
 sleep 60
 done
}

# 生成下载报告
generate_download_report() {
 local report_file="download_report_$(date +%Y%m%d).txt"
 
 echo "Download Report - $(date +%Y-%m-%d)" > $report_file
 echo "=============================" >> $report_file
 echo "" >> $report_file
 
 echo "Download Statistics:" >> $report_file
 echo "Total downloads: $(ls $LOG_DIR/*.log 2>/dev/null | wc -l)" >> $report_file
 echo "Successful: $(grep -l "saved" $LOG_DIR/*.log 2>/dev/null | wc -l)" >> $report_file
 echo "Failed: $(grep -l "failed" $LOG_DIR/*.log 2>/dev/null | wc -l)" >> $report_file
 echo "" >> $report_file
 
 echo "Recent Downloads:" >> $report_file
 ls -lt $LOG_DIR/*.log 2>/dev/null | head -10 >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 execute)
 load_and_execute_tasks
 ;;
 monitor)
 monitor_downloads
 ;;
 report)
 generate_download_report
 ;;
 *)
 echo "Usage: $0 {execute|monitor|report}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级下载管理系统#

#!/bin/bash
# 企业级下载管理系统

CONFIG_DIR="/etc/download_manager"
LOG_DIR="/var/log/download_manager"
DOWNLOAD_DIR="/var/downloads"
QUEUE_FILE="/var/run/download_manager/queue"
STATUS_FILE="/var/run/download_manager/status"

mkdir -p $CONFIG_DIR $LOG_DIR $DOWNLOAD_DIR /var/run/download_manager

# 初始化队列
init_queue() {
 if [ ! -f "$QUEUE_FILE" ]; then
 touch "$QUEUE_FILE"
 fi
}

# 添加下载任务
add_download_task() {
 local url=$1
 local output_dir=$2
 local priority=$3
 local options=$4
 
 local task_id=$(date +%s%N)
 local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
 
 echo "$task_id|$timestamp|$url|$output_dir|$priority|$options|pending" >> "$QUEUE_FILE"
 
 echo "Task added: $task_id"
 return $task_id
}

# 获取下一个任务
get_next_task() {
 if [ ! -f "$QUEUE_FILE" ]; then
 return 1
 fi
 
 # 按优先级排序并获取第一个 pending 任务
 local task=$(sort -t'|' -k5 -n "$QUEUE_FILE" | grep "|pending$" | head -1)
 
 if [ -n "$task" ]; then
 echo "$task"
 return 0
 else
 return 1
 fi
}

# 更新任务状态
update_task_status() {
 local task_id=$1
 local status=$2
 
 sed -i "s/^$task_id|.*|$status$/$task_id|$(date '+%Y-%m-%d %H:%M:%S')|||$status/" "$QUEUE_FILE"
}

# 执行下载任务
execute_task() {
 local task=$1
 
 local task_id=$(echo "$task" | cut -d'|' -f1)
 local url=$(echo "$task" | cut -d'|' -f3)
 local output_dir=$(echo "$task" | cut -d'|' -f4)
 local options=$(echo "$task" | cut -d'|' -f6)
 
 local log_file="$LOG_DIR/task_${task_id}.log"
 
 echo "Executing task: $task_id"
 echo "URL: $url"
 echo "Output: $output_dir"
 
 mkdir -p "$output_dir"
 
 update_task_status "$task_id" "running"
 
 wget $options -P "$output_dir" -o "$log_file" "$url"
 
 if [ $? -eq 0 ]; then
 update_task_status "$task_id" "completed"
 echo "✓ Task $task_id completed successfully"
 else
 update_task_status "$task_id" "failed"
 echo "✗ Task $task_id failed"
 fi
}

# 下载工作进程
download_worker() {
 local worker_id=$1
 
 echo "Worker $worker_id started"
 
 while true; do
 local task=$(get_next_task)
 
 if [ -n "$task" ]; then
 local task_id=$(echo "$task" | cut -d'|' -f1)
 update_task_status "$task_id" "running"
 execute_task "$task"
 else
 sleep 5
 fi
 done
}

# 启动多个工作进程
start_workers() {
 local worker_count=$1
 
 for ((i=1; i<=worker_count; i++)); do
 download_worker $i &
 done
 
 wait
}

# 查看任务状态
view_task_status() {
 local task_id=$1
 
 if [ -z "$task_id" ]; then
 echo "=== All Tasks ==="
 cat "$QUEUE_FILE"
 else
 echo "=== Task $task_id ==="
 grep "^$task_id|" "$QUEUE_FILE"
 fi
}

# 取消任务
cancel_task() {
 local task_id=$1
 
 local task=$(grep "^$task_id|" "$QUEUE_FILE")
 local status=$(echo "$task" | cut -d'|' -f7)
 
 if [ "$status" = "pending" ] || [ "$status" = "running" ]; then
 update_task_status "$task_id" "cancelled"
 echo "Task $task_id cancelled"
 else
 echo "Cannot cancel task with status: $status"
 fi
}

# 生成统计报告
generate_statistics() {
 echo "=== Download Statistics ==="
 echo ""
 
 local total=$(wc -l < "$QUEUE_FILE")
 local pending=$(grep "|pending$" "$QUEUE_FILE" | wc -l)
 local running=$(grep "|running$" "$QUEUE_FILE" | wc -l)
 local completed=$(grep "|completed$" "$QUEUE_FILE" | wc -l)
 local failed=$(grep "|failed$" "$QUEUE_FILE" | wc -l)
 local cancelled=$(grep "|cancelled$" "$QUEUE_FILE" | wc -l)
 
 echo "Total tasks: $total"
 echo "Pending: $pending"
 echo "Running: $running"
 echo "Completed: $completed"
 echo "Failed: $failed"
 echo "Cancelled: $cancelled"
 echo ""
 
 echo "Success rate: $(echo "scale=2; $completed * 100 / ($completed + $failed)" | bc)%"
}

# 主函数
main() {
 init_queue
 
 case "$1" in
 add)
 add_download_task "$2" "$3" "$4" "$5"
 ;;
 start)
 start_workers "${2:-3}"
 ;;
 status)
 view_task_status "$2"
 ;;
 cancel)
 cancel_task "$2"
 ;;
 stats)
 generate_statistics
 ;;
 *)
 echo "Usage: $0 {add|start|status|cancel|stats}"
 exit 1
 ;;
 esac
}

main "$@"

智能下载调度器#

#!/bin/bash
# 智能下载调度器

CONFIG_FILE="scheduler.conf"
LOG_FILE="scheduler.log"
STATE_FILE="scheduler.state"

# 加载配置
load_config() {
 if [ -f "$CONFIG_FILE" ]; then
 source $CONFIG_FILE
 else
 echo "Config file not found: $CONFIG_FILE"
 exit 1
 fi
}

# 检查网络状态
check_network_status() {
 local test_host="8.8.8.8"
 
 if ping -c 1 -W 2 $test_host > /dev/null 2>&1; then
 return 0
 else
 return 1
 fi
}

# 检查系统负载
check_system_load() {
 local load=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 local max_load=${MAX_LOAD:-2.0}
 
 if (( $(echo "$load < $max_load" | bc -l) )); then
 return 0
 else
 return 1
 fi
}

# 检查磁盘空间
check_disk_space() {
 local download_dir=$1
 local min_space=${MIN_DISK_SPACE:-1073741824} # 1GB
 
 local available_space=$(df "$download_dir" | awk 'NR==2 {print $4 * 1024}')
 
 if [ $available_space -gt $min_space ]; then
 return 0
 else
 return 1
 fi
}

# 检查下载时间窗口
check_time_window() {
 local current_hour=$(date +%H)
 local start_hour=${START_HOUR:-0}
 local end_hour=${END_HOUR:-6}
 
 if [ $current_hour -ge $start_hour ] && [ $current_hour -lt $end_hour ]; then
 return 0
 else
 return 1
 fi
}

# 智能调度下载
schedule_download() {
 local url=$1
 local output_dir=$2
 local task_name=$3
 
 echo "Scheduling download: $task_name"
 
 # 检查网络状态
 if ! check_network_status; then
 echo "Network not available, postponing download"
 return 1
 fi
 
 # 检查系统负载
 if ! check_system_load; then
 echo "System load too high, postponing download"
 return 1
 fi
 
 # 检查磁盘空间
 if ! check_disk_space "$output_dir"; then
 echo "Insufficient disk space, postponing download"
 return 1
 fi
 
 # 检查时间窗口
 if ! check_time_window; then
 echo "Outside allowed time window, postponing download"
 return 1
 fi
 
 # 执行下载
 echo "Starting download: $task_name"
 wget -P "$output_dir" -a "$LOG_FILE" "$url"
 
 if [ $? -eq 0 ]; then
 echo "✓ Download completed: $task_name"
 return 0
 else
 echo "✗ Download failed: $task_name"
 return 1
 fi
}

# 主调度循环
main_scheduler() {
 load_config
 
 echo "Starting download scheduler..."
 echo "Log file: $LOG_FILE"
 
 while true; do
 # 从配置文件读取下载任务
 while IFS='|' read -r task_name url output_dir options; do
 if [ -n "$task_name" ] && [[ ! $task_name =~ ^# ]]; then
 schedule_download "$url" "$output_dir" "$task_name"
 fi
 done < "$CONFIG_FILE"
 
 # 等待下次检查
 sleep ${CHECK_INTERVAL:-300}
 done
}

# 单次执行模式
single_run() {
 load_config
 
 while IFS='|' read -r task_name url output_dir options; do
 if [ -n "$task_name" ] && [[ ! $task_name =~ ^# ]]; then
 schedule_download "$url" "$output_dir" "$task_name"
 fi
 done < "$CONFIG_FILE"
}

# 主函数
main() {
 case "$1" in
 start)
 main_scheduler
 ;;
 run)
 single_run
 ;;
 *)
 echo "Usage: $0 {start|run}"
 exit 1
 ;;
 esac
}

main "$@"

下载内容验证系统#

#!/bin/bash
# 下载内容验证系统

DOWNLOAD_DIR="downloads"
VERIFY_LOG="verify.log"

# 计算文件哈希
calculate_hash() {
 local file=$1
 local algorithm=${2:-md5}
 
 case "$algorithm" in
 md5)
 md5sum "$file" | awk '{print $1}'
 ;;
 sha1)
 sha1sum "$file" | awk '{print $1}'
 ;;
 sha256)
 sha256sum "$file" | awk '{print $1}'
 ;;
 *)
 echo "Unsupported algorithm: $algorithm"
 return 1
 ;;
 esac
}

# 验证文件哈希
verify_hash() {
 local file=$1
 local expected_hash=$2
 local algorithm=${3:-md5}
 
 local actual_hash=$(calculate_hash "$file" "$algorithm")
 
 if [ "$actual_hash" = "$expected_hash" ]; then
 echo "✓ Hash verification passed for $file"
 return 0
 else
 echo "✗ Hash verification failed for $file"
 echo " Expected: $expected_hash"
 echo " Actual: $actual_hash"
 return 1
 fi
}

# 从哈希文件验证
verify_from_hash_file() {
 local hash_file=$1
 local download_dir=$2
 local algorithm=${3:-md5}
 
 if [ ! -f "$hash_file" ]; then
 echo "Hash file not found: $hash_file"
 return 1
 fi
 
 echo "Verifying files from $hash_file..."
 
 local verified=0
 local failed=0
 
 while read -r expected_hash filename; do
 local file="$download_dir/$filename"
 
 if [ -f "$file" ]; then
 if verify_hash "$file" "$expected_hash" "$algorithm"; then
 verified=$((verified + 1))
 else
 failed=$((failed + 1))
 fi
 else
 echo "✗ File not found: $file"
 failed=$((failed + 1))
 fi
 done < "$hash_file"
 
 echo ""
 echo "Verification Summary:"
 echo "Verified: $verified"
 echo "Failed: $failed"
 
 return $failed
}

# 下载并验证
download_and_verify() {
 local url=$1
 local output_file=$2
 local expected_hash=$3
 local algorithm=${4:-md5}
 
 echo "Downloading: $url"
 wget -O "$output_file" "$url"
 
 if [ $? -eq 0 ]; then
 echo "Download completed, verifying..."
 verify_hash "$output_file" "$expected_hash" "$algorithm"
 return $?
 else
 echo "✗ Download failed"
 return 1
 fi
}

# 批量下载并验证
batch_download_and_verify() {
 local manifest_file=$1
 local download_dir=$2
 
 if [ ! -f "$manifest_file" ]; then
 echo "Manifest file not found: $manifest_file"
 return 1
 fi
 
 mkdir -p "$download_dir"
 
 echo "Batch downloading and verifying..."
 
 local success=0
 local failed=0
 
 while IFS='|' read -r url filename expected_hash algorithm; do
 if [ -n "$url" ] && [[ ! $url =~ ^# ]]; then
 local output_file="$download_dir/$filename"
 
 if download_and_verify "$url" "$output_file" "$expected_hash" "$algorithm"; then
 success=$((success + 1))
 else
 failed=$((failed + 1))
 fi
 fi
 done < "$manifest_file"
 
 echo ""
 echo "Batch Download Summary:"
 echo "Success: $success"
 echo "Failed: $failed"
 
 return $failed
}

# 生成验证报告
generate_verification_report() {
 local download_dir=$1
 local report_file="verification_report_$(date +%Y%m%d_%H%M%S).txt"
 
 echo "Verification Report - $(date)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 echo "Files in $download_dir:" >> $report_file
 ls -lh "$download_dir" >> $report_file
 echo "" >> $report_file
 
 echo "File Hashes:" >> $report_file
 find "$download_dir" -type f | while read file; do
 local filename=$(basename "$file")
 local hash=$(calculate_hash "$file" "md5")
 echo "$hash $filename" >> $report_file
 done
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 verify)
 verify_hash "$2" "$3" "$4"
 ;;
 verify-file)
 verify_from_hash_file "$2" "$3" "$4"
 ;;
 download)
 download_and_verify "$2" "$3" "$4" "$5"
 ;;
 batch)
 batch_download_and_verify "$2" "$3"
 ;;
 report)
 generate_verification_report "$2"
 ;;
 *)
 echo "Usage: $0 {verify|verify-file|download|batch|report}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用断点续传：对于大文件下载，始终使用 -c 选项
限制下载速度：避免对服务器造成过大压力
设置合理的等待时间：在批量下载时设置适当的等待时间
使用后台下载：对于长时间下载任务使用 -b 选项
验证下载内容：下载后验证文件完整性
记录日志：记录下载过程便于故障排查
使用配置文件：对于复杂的下载任务使用配置文件管理
遵守 robots.txt：递归下载时遵守网站的 robots.txt 规则

注意事项#

wget 默认会递归下载，注意设置合适的递归深度
在生产环境中使用递归下载时要格外小心
注意版权和法律法规，不要下载非法内容
大文件下载时注意磁盘空间
使用代理时注意代理服务器的安全性
下载敏感数据时注意保护认证信息
不同版本的 wget 选项可能有所不同
在自动化脚本中添加适当的错误处理

scp 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

scp 命令详解#

scp（Secure Copy）是 Linux 系统中用于在本地和远程主机之间安全复制文件的命令，基于 SSH 协议进行加密传输。它是系统管理员和开发人员进行文件传输的常用工具，支持递归复制、保留文件属性等功能。

入门#

基本用法#

# 从远程主机复制文件到本地
scp user@remote_host:/remote/path/file.txt /local/path/

# 从本地复制文件到远程主机
scp /local/path/file.txt user@remote_host:/remote/path/

# 复制目录（递归）
scp -r /local/directory user@remote_host:/remote/path/

# 指定端口
scp -P 2222 file.txt user@remote_host:/remote/path/

常用选项#

选项	说明
`-P`	指定 SSH 端口
`-p`	保留文件属性（修改时间、访问时间、权限）
`-r`	递归复制目录
`-v`	显示详细输出
`-q`	静默模式
`-C`	启用压缩
`-l`	限制带宽
`-i`	指定私钥文件

基本示例#

# 从远程服务器下载文件
scp user@server.example.com:/var/log/app.log /tmp/

# 上传文件到远程服务器
scp /tmp/data.txt user@server.example.com:/home/user/

# 递归复制目录
scp -r /local/project user@server.example.com:/home/user/

# 使用特定端口
scp -P 2222 file.txt user@server.example.com:/tmp/

中级#

文件属性保留#

# 保留文件属性（时间戳、权限）
scp -p file.txt user@remote_host:/remote/path/

# 递归复制并保留属性
scp -rp /local/directory user@remote_host:/remote/path/

# 查看文件属性变化
ls -l file.txt
scp -p file.txt user@remote_host:/remote/path/
ssh user@remote_host "ls -l /remote/path/file.txt"

带宽控制#

# 限制传输速度（Kbit/s）
scp -l 1000 large_file.zip user@remote_host:/remote/path/

# 限制传输速度（Mbit/s）
scp -l 10000 large_file.zip user@remote_host:/remote/path/

# 启用压缩传输
scp -C large_file.zip user@remote_host:/remote/path/

# 组合使用压缩和限速
scp -C -l 5000 large_file.zip user@remote_host:/remote/path/

多文件传输#

# 复制多个文件到远程主机
scp file1.txt file2.txt file3.txt user@remote_host:/remote/path/

# 使用通配符复制文件
scp *.txt user@remote_host:/remote/path/

# 从远程主机复制多个文件
scp user@remote_host:/remote/path/*.txt /local/path/

# 复制多个目录
scp -r dir1/ dir2/ user@remote_host:/remote/path/

高级#

高级选项#

# 使用指定密钥文件
scp -i ~/.ssh/id_rsa file.txt user@remote_host:/remote/path/

# 显示详细传输信息
scp -v file.txt user@remote_host:/remote/path/

# 静默模式
scp -q file.txt user@remote_host:/remote/path/

# 使用 SSH 配置文件
# 在 ~/.ssh/config 中配置：
# Host server1
# HostName server1.example.com
# User admin
# Port 2222
# IdentityFile ~/.ssh/id_rsa_server1
#
# scp file.txt server1:/remote/path/

# 通过跳板主机传输
scp -o ProxyJump=jump_host user@remote_host:/remote/path/file.txt /local/path/

断点续传#

#!/bin/bash
# SCP 断点续传脚本

SOURCE_FILE="large_file.zip"
REMOTE_HOST="user@server.example.com"
REMOTE_PATH="/remote/path/"
LOCAL_PATH="/local/path/"

# 使用 rsync 实现断点续传
rsync_partial_transfer() {
 local source=$1
 local destination=$2
 
 rsync -avz --partial --progress "$source" "$destination"
}

# 检查并恢复传输
resume_transfer() {
 local source=$1
 local remote=$2
 
 echo "Checking existing file on remote..."
 
 # 获取远程文件大小
 local remote_size=$(ssh $REMOTE_HOST "stat -c%s $REMOTE_PATH$SOURCE_FILE 2>/dev/null || echo 0")
 
 if [ $remote_size -gt 0 ]; then
 echo "Partial file found (${remote_size} bytes), resuming..."
 rsync -avz --partial --progress "$source" "$remote"
 else
 echo "No partial file found, starting new transfer..."
 scp "$source" "$remote"
 fi
}

resume_transfer "$LOCAL_PATH$SOURCE_FILE" "$REMOTE_HOST:$REMOTE_PATH"

批量传输#

#!/bin/bash
# 批量文件传输脚本

REMOTE_HOST="user@server.example.com"
REMOTE_DIR="/remote/path/"
LOCAL_DIR="/local/path/"

# 批量上传文件
batch_upload() {
 local pattern=$1
 
 echo "Uploading files matching: $pattern"
 
 find $LOCAL_DIR -name "$pattern" | while read file; do
 echo "Uploading: $file"
 scp "$file" "$REMOTE_HOST:$REMOTE_DIR"
 done
}

# 批量下载文件
batch_download() {
 local pattern=$1
 
 echo "Downloading files matching: $pattern"
 
 ssh $REMOTE_HOST "find $REMOTE_DIR -name '$pattern'" | while read file; do
 local filename=$(basename "$file")
 echo "Downloading: $filename"
 scp "$REMOTE_HOST:$file" "$LOCAL_DIR"
 done
}

# 同步目录
sync_directories() {
 local source_dir=$1
 local target_dir=$2
 local direction=$3
 
 case "$direction" in
 upload)
 echo "Syncing local to remote..."
 rsync -avz --delete "$source_dir" "$REMOTE_HOST:$target_dir"
 ;;
 download)
 echo "Syncing remote to local..."
 rsync -avz --delete "$REMOTE_HOST:$target_dir" "$source_dir"
 ;;
 *)
 echo "Invalid direction: $direction"
 return 1
 ;;
 esac
}

# 主函数
main() {
 case "$1" in
 upload)
 batch_upload "$2"
 ;;
 download)
 batch_download "$2"
 ;;
 sync)
 sync_directories "$2" "$3" "$4"
 ;;
 *)
 echo "Usage: $0 {upload|download|sync}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

自动化备份系统#

#!/bin/bash
# 自动化备份系统

CONFIG_FILE="backup_config.conf"
LOG_DIR="backup_logs"
BACKUP_DIR="backups"

mkdir -p $LOG_DIR $BACKUP_DIR

# 加载配置
load_config() {
 if [ -f "$CONFIG_FILE" ]; then
 source $CONFIG_FILE
 else
 echo "Config file not found: $CONFIG_FILE"
 exit 1
 fi
}

# 执行备份
perform_backup() {
 local source=$1
 local remote_host=$2
 local remote_dir=$3
 local backup_name=$4
 
 local timestamp=$(date +%Y%m%d_%H%M%S)
 local log_file="$LOG_DIR/${backup_name}_${timestamp}.log"
 
 echo "Starting backup: $backup_name"
 echo "Source: $source"
 echo "Destination: $remote_host:$remote_dir"
 
 # 创建远程备份目录
 ssh $remote_host "mkdir -p $remote_dir"
 
 # 执行备份
 rsync -avz --delete --progress \
 --log-file="$log_file" \
 "$source" \
 "$remote_host:$remote_dir/${backup_name}_${timestamp}"
 
 if [ $? -eq 0 ]; then
 echo "✓ Backup completed successfully"
 
 # 清理旧备份
 cleanup_old_backups "$remote_host" "$remote_dir" "$backup_name"
 
 return 0
 else
 echo "✗ Backup failed"
 return 1
 fi
}

# 清理旧备份
cleanup_old_backups() {
 local remote_host=$1
 local remote_dir=$2
 local backup_name=$3
 local keep_count=${BACKUP_KEEP_COUNT:-7}
 
 echo "Cleaning up old backups (keeping last $keep_count)..."
 
 ssh $remote_host "cd $remote_dir && ls -t ${backup_name}_* | tail -n +$((keep_count + 1)) | xargs -r rm -rf"
}

# 验证备份
verify_backup() {
 local remote_host=$1
 local remote_dir=$2
 local backup_name=$3
 
 echo "Verifying backup: $backup_name"
 
 local latest_backup=$(ssh $remote_host "ls -t $remote_dir/${backup_name}_* | head -1")
 
 if [ -n "$latest_backup" ]; then
 echo "Latest backup: $latest_backup"
 
 # 检查备份大小
 local backup_size=$(ssh $remote_host "du -sh $latest_backup | awk '{print \$1}'")
 echo "Backup size: $backup_size"
 
 # 检查文件数量
 local file_count=$(ssh $remote_host "find $latest_backup -type f | wc -l")
 echo "File count: $file_count"
 
 return 0
 else
 echo "✗ No backup found"
 return 1
 fi
}

# 恢复备份
restore_backup() {
 local remote_host=$1
 local remote_dir=$2
 local backup_name=$3
 local restore_dir=$4
 
 echo "Restoring backup: $backup_name"
 
 local latest_backup=$(ssh $remote_host "ls -t $remote_dir/${backup_name}_* | head -1")
 
 if [ -n "$latest_backup" ]; then
 echo "Restoring from: $latest_backup"
 
 rsync -avz --progress \
 "$remote_host:$latest_backup/" \
 "$restore_dir"
 
 if [ $? -eq 0 ]; then
 echo "✓ Restore completed successfully"
 return 0
 else
 echo "✗ Restore failed"
 return 1
 fi
 else
 echo "✗ No backup found"
 return 1
 fi
}

# 主函数
main() {
 load_config
 
 case "$1" in
 backup)
 perform_backup "$2" "$3" "$4" "$5"
 ;;
 verify)
 verify_backup "$2" "$3" "$4"
 ;;
 restore)
 restore_backup "$2" "$3" "$4" "$5"
 ;;
 *)
 echo "Usage: $0 {backup|verify|restore}"
 exit 1
 ;;
 esac
}

main "$@"

分布式文件同步#

#!/bin/bash
# 分布式文件同步系统

CONFIG_FILE="sync_config.conf"
LOG_FILE="sync.log"

# 加载配置
load_config() {
 if [ -f "$CONFIG_FILE" ]; then
 source $CONFIG_FILE
 else
 echo "Config file not found: $CONFIG_FILE"
 exit 1
 fi
}

# 同步到多个服务器
sync_to_multiple_servers() {
 local source_dir=$1
 local remote_dir=$2
 shift 2
 local servers=("$@")
 
 echo "Syncing to ${#servers[@]} servers..."
 
 for server in "${servers[@]}"; do
 echo "Syncing to $server..."
 
 rsync -avz --delete --progress \
 --log-file="$LOG_FILE" \
 "$source_dir" \
 "$server:$remote_dir"
 
 if [ $? -eq 0 ]; then
 echo "✓ Sync to $server completed"
 else
 echo "✗ Sync to $server failed"
 fi
 done
}

# 从多个服务器收集文件
collect_from_multiple_servers() {
 local remote_dir=$1
 local local_dir=$2
 shift 2
 local servers=("$@")
 
 mkdir -p "$local_dir"
 
 for server in "${servers[@]}"; do
 echo "Collecting from $server..."
 
 local server_dir="$local_dir/$(echo $server | tr '@.' '_')"
 mkdir -p "$server_dir"
 
 rsync -avz --progress \
 --log-file="$LOG_FILE" \
 "$server:$remote_dir/" \
 "$server_dir"
 
 if [ $? -eq 0 ]; then
 echo "✓ Collection from $server completed"
 else
 echo "✗ Collection from $server failed"
 fi
 done
}

# 双向同步
bidirectional_sync() {
 local local_dir=$1
 local remote_host=$2
 local remote_dir=$3
 
 echo "Performing bidirectional sync..."
 
 # 本地到远程
 echo "Syncing local to remote..."
 rsync -avz --update --progress \
 "$local_dir/" \
 "$remote_host:$remote_dir/"
 
 # 远程到本地
 echo "Syncing remote to local..."
 rsync -avz --update --progress \
 "$remote_host:$remote_dir/" \
 "$local_dir/"
 
 echo "✓ Bidirectional sync completed"
}

# 冲突检测
detect_conflicts() {
 local local_dir=$1
 local remote_host=$2
 local remote_dir=$3
 
 echo "Detecting conflicts..."
 
 local conflicts_file="conflicts_$(date +%Y%m%d_%H%M%S).txt"
 
 # 比较文件修改时间
 find "$local_dir" -type f | while read local_file; do
 local relative_path="${local_file#$local_dir/}"
 local remote_file="$remote_host:$remote_dir/$relative_path"
 
 local local_mtime=$(stat -c %Y "$local_file")
 local remote_mtime=$(ssh $remote_host "stat -c %Y $remote_dir/$relative_path 2>/dev/null || echo 0")
 
 if [ $local_mtime -ne $remote_mtime ] && [ $remote_mtime -ne 0 ]; then
 echo "CONFLICT: $relative_path" >> $conflicts_file
 fi
 done
 
 if [ -f "$conflicts_file" ] && [ -s "$conflicts_file" ]; then
 echo "Conflicts detected:"
 cat "$conflicts_file"
 return 1
 else
 echo "No conflicts detected"
 return 0
 fi
}

# 主函数
main() {
 load_config
 
 case "$1" in
 sync-multi)
 sync_to_multiple_servers "$2" "$3" "${@:4}"
 ;;
 collect)
 collect_from_multiple_servers "$2" "$3" "${@:4}"
 ;;
 bidirectional)
 bidirectional_sync "$2" "$3" "$4"
 ;;
 detect-conflicts)
 detect_conflicts "$2" "$3" "$4"
 ;;
 *)
 echo "Usage: $0 {sync-multi|collect|bidirectional|detect-conflicts}"
 exit 1
 ;;
 esac
}

main "$@"

文件传输监控#

#!/bin/bash
# 文件传输监控系统

LOG_FILE="transfer_monitor.log"
ALERT_EMAIL="admin@example.com"

# 监控传输进度
monitor_transfer() {
 local transfer_pid=$1
 local source=$2
 local destination=$3
 
 echo "Monitoring transfer (PID: $transfer_pid)..."
 
 while kill -0 $transfer_pid 2>/dev/null; do
 local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
 local transferred_size=$(du -sh "$source" 2>/dev/null | awk '{print $1}')
 
 echo "$timestamp - Transferred: $transferred_size" >> $LOG_FILE
 
 sleep 10
 done
 
 wait $transfer_pid
 local exit_code=$?
 
 if [ $exit_code -eq 0 ]; then
 echo "✓ Transfer completed successfully"
 echo "$(date '+%Y-%m-%d %H:%M:%S') - Transfer completed successfully" >> $LOG_FILE
 else
 echo "✗ Transfer failed with exit code: $exit_code"
 echo "$(date '+%Y-%m-%d %H:%M:%S') - Transfer failed with exit code: $exit_code" >> $LOG_FILE
 echo "Transfer failed: $source -> $destination" | mail -s "Transfer Alert" $ALERT_EMAIL
 fi
}

# 后台传输并监控
background_transfer_with_monitor() {
 local source=$1
 local destination=$2
 
 echo "Starting background transfer: $source -> $destination"
 
 # 启动后台传输
 scp "$source" "$destination" &
 local transfer_pid=$!
 
 # 监控传输
 monitor_transfer $transfer_pid "$source" "$destination"
}

# 批量传输监控
batch_transfer_monitor() {
 local transfer_list=$1
 
 while IFS='|' read -r source destination; do
 if [ -n "$source" ] && [[ ! $source =~ ^# ]]; then
 background_transfer_with_monitor "$source" "$destination"
 fi
 done < "$transfer_list"
}

# 生成传输报告
generate_transfer_report() {
 local report_file="transfer_report_$(date +%Y%m%d).txt"
 
 echo "Transfer Report - $(date +%Y-%m-%d)" > $report_file
 echo "=========================" >> $report_file
 echo "" >> $report_file
 
 echo "Transfer Statistics:" >> $report_file
 echo "Total transfers: $(grep "Transfer completed" $LOG_FILE | wc -l)" >> $report_file
 echo "Failed transfers: $(grep "Transfer failed" $LOG_FILE | wc -l)" >> $report_file
 echo "" >> $report_file
 
 echo "Recent Transfers:" >> $report_file
 tail -20 $LOG_FILE >> $report_file
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 monitor)
 background_transfer_with_monitor "$2" "$3"
 ;;
 batch)
 batch_transfer_monitor "$2"
 ;;
 report)
 generate_transfer_report
 ;;
 *)
 echo "Usage: $0 {monitor|batch|report}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级文件传输系统#

#!/bin/bash
# 企业级文件传输系统

CONFIG_DIR="/etc/transfer_system"
LOG_DIR="/var/log/transfer_system"
QUEUE_FILE="/var/run/transfer_system/queue"
STATUS_FILE="/var/run/transfer_system/status"

mkdir -p $CONFIG_DIR $LOG_DIR /var/run/transfer_system

# 初始化队列
init_queue() {
 if [ ! -f "$QUEUE_FILE" ]; then
 touch "$QUEUE_FILE"
 fi
}

# 添加传输任务
add_transfer_task() {
 local source=$1
 local destination=$2
 local priority=$3
 local options=$4
 
 local task_id=$(date +%s%N)
 local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
 
 echo "$task_id|$timestamp|$source|$destination|$priority|$options|pending" >> "$QUEUE_FILE"
 
 echo "Task added: $task_id"
 return $task_id
}

# 获取下一个任务
get_next_task() {
 if [ ! -f "$QUEUE_FILE" ]; then
 return 1
 fi
 
 local task=$(sort -t'|' -k5 -n "$QUEUE_FILE" | grep "|pending$" | head -1)
 
 if [ -n "$task" ]; then
 echo "$task"
 return 0
 else
 return 1
 fi
}

# 更新任务状态
update_task_status() {
 local task_id=$1
 local status=$2
 
 sed -i "s/^$task_id|.*|$status$/$task_id|$(date '+%Y-%m-%d %H:%M:%S')|||$status/" "$QUEUE_FILE"
}

# 执行传输任务
execute_task() {
 local task=$1
 
 local task_id=$(echo "$task" | cut -d'|' -f1)
 local source=$(echo "$task" | cut -d'|' -f3)
 local destination=$(echo "$task" | cut -d'|' -f4)
 local options=$(echo "$task" | cut -d'|' -f6)
 
 local log_file="$LOG_DIR/task_${task_id}.log"
 
 echo "Executing task: $task_id"
 echo "Source: $source"
 echo "Destination: $destination"
 
 update_task_status "$task_id" "running"
 
 scp $options "$source" "$destination" > "$log_file" 2>&1
 
 if [ $? -eq 0 ]; then
 update_task_status "$task_id" "completed"
 echo "✓ Task $task_id completed successfully"
 else
 update_task_status "$task_id" "failed"
 echo "✗ Task $task_id failed"
 fi
}

# 传输工作进程
transfer_worker() {
 local worker_id=$1
 
 echo "Worker $worker_id started"
 
 while true; do
 local task=$(get_next_task)
 
 if [ -n "$task" ]; then
 local task_id=$(echo "$task" | cut -d'|' -f1)
 update_task_status "$task_id" "running"
 execute_task "$task"
 else
 sleep 5
 fi
 done
}

# 启动多个工作进程
start_workers() {
 local worker_count=$1
 
 for ((i=1; i<=worker_count; i++)); do
 transfer_worker $i &
 done
 
 wait
}

# 查看任务状态
view_task_status() {
 local task_id=$1
 
 if [ -z "$task_id" ]; then
 echo "=== All Tasks ==="
 cat "$QUEUE_FILE"
 else
 echo "=== Task $task_id ==="
 grep "^$task_id|" "$QUEUE_FILE"
 fi
}

# 取消任务
cancel_task() {
 local task_id=$1
 
 local task=$(grep "^$task_id|" "$QUEUE_FILE")
 local status=$(echo "$task" | cut -d'|' -f7)
 
 if [ "$status" = "pending" ]; then
 update_task_status "$task_id" "cancelled"
 echo "Task $task_id cancelled"
 else
 echo "Cannot cancel task with status: $status"
 fi
}

# 生成统计报告
generate_statistics() {
 echo "=== Transfer Statistics ==="
 echo ""
 
 local total=$(wc -l < "$QUEUE_FILE")
 local pending=$(grep "|pending$" "$QUEUE_FILE" | wc -l)
 local running=$(grep "|running$" "$QUEUE_FILE" | wc -l)
 local completed=$(grep "|completed$" "$QUEUE_FILE" | wc -l)
 local failed=$(grep "|failed$" "$QUEUE_FILE" | wc -l)
 local cancelled=$(grep "|cancelled$" "$QUEUE_FILE" | wc -l)
 
 echo "Total tasks: $total"
 echo "Pending: $pending"
 echo "Running: $running"
 echo "Completed: $completed"
 echo "Failed: $failed"
 echo "Cancelled: $cancelled"
 echo ""
 
 echo "Success rate: $(echo "scale=2; $completed * 100 / ($completed + $failed)" | bc)%"
}

# 主函数
main() {
 init_queue
 
 case "$1" in
 add)
 add_transfer_task "$2" "$3" "$4" "$5"
 ;;
 start)
 start_workers "${2:-3}"
 ;;
 status)
 view_task_status "$2"
 ;;
 cancel)
 cancel_task "$2"
 ;;
 stats)
 generate_statistics
 ;;
 *)
 echo "Usage: $0 {add|start|status|cancel|stats}"
 exit 1
 ;;
 esac
}

main "$@"

智能文件传输调度器#

#!/bin/bash
# 智能文件传输调度器

CONFIG_FILE="transfer_schedule.conf"
LOG_FILE="transfer_scheduler.log"

# 加载配置
load_config() {
 if [ -f "$CONFIG_FILE" ]; then
 source $CONFIG_FILE
 else
 echo "Config file not found: $CONFIG_FILE"
 exit 1
 fi
}

# 检查网络状态
check_network_status() {
 local test_host="8.8.8.8"
 
 if ping -c 1 -W 2 $test_host > /dev/null 2>&1; then
 return 0
 else
 return 1
 fi
}

# 检查系统负载
check_system_load() {
 local load=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
 local max_load=${MAX_LOAD:-2.0}
 
 if (( $(echo "$load < $max_load" | bc -l) )); then
 return 0
 else
 return 1
 fi
}

# 检查磁盘空间
check_disk_space() {
 local path=$1
 local min_space=${MIN_DISK_SPACE:-1073741824} # 1GB
 
 local available_space=$(df "$path" | awk 'NR==2 {print $4 * 1024}')
 
 if [ $available_space -gt $min_space ]; then
 return 0
 else
 return 1
 fi
}

# 检查传输时间窗口
check_time_window() {
 local current_hour=$(date +%H)
 local start_hour=${START_HOUR:-0}
 local end_hour=${END_HOUR:-6}
 
 if [ $current_hour -ge $start_hour ] && [ $current_hour -lt $end_hour ]; then
 return 0
 else
 return 1
 fi
}

# 智能调度传输
schedule_transfer() {
 local source=$1
 local destination=$2
 local task_name=$3
 
 echo "Scheduling transfer: $task_name"
 
 # 检查网络状态
 if ! check_network_status; then
 echo "Network not available, postponing transfer"
 return 1
 fi
 
 # 检查系统负载
 if ! check_system_load; then
 echo "System load too high, postponing transfer"
 return 1
 fi
 
 # 检查磁盘空间
 if ! check_disk_space "$source"; then
 echo "Insufficient disk space, postponing transfer"
 return 1
 fi
 
 # 检查时间窗口
 if ! check_time_window; then
 echo "Outside allowed time window, postponing transfer"
 return 1
 fi
 
 # 执行传输
 echo "Starting transfer: $task_name"
 scp -C -l ${BANDWIDTH_LIMIT:-10000} "$source" "$destination" >> "$LOG_FILE" 2>&1
 
 if [ $? -eq 0 ]; then
 echo "✓ Transfer completed: $task_name"
 return 0
 else
 echo "✗ Transfer failed: $task_name"
 return 1
 fi
}

# 主调度循环
main_scheduler() {
 load_config
 
 echo "Starting transfer scheduler..."
 echo "Log file: $LOG_FILE"
 
 while true; do
 # 从配置文件读取传输任务
 while IFS='|' read -r task_name source destination options; do
 if [ -n "$task_name" ] && [[ ! $task_name =~ ^# ]]; then
 schedule_transfer "$source" "$destination" "$task_name"
 fi
 done < "$CONFIG_FILE"
 
 # 等待下次检查
 sleep ${CHECK_INTERVAL:-300}
 done
}

# 单次执行模式
single_run() {
 load_config
 
 while IFS='|' read -r task_name source destination options; do
 if [ -n "$task_name" ] && [[ ! $task_name =~ ^# ]]; then
 schedule_transfer "$source" "$destination" "$task_name"
 fi
 done < "$CONFIG_FILE"
}

# 主函数
main() {
 case "$1" in
 start)
 main_scheduler
 ;;
 run)
 single_run
 ;;
 *)
 echo "Usage: $0 {start|run}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用 rsync 替代：对于大文件或频繁传输，优先使用 rsync
启用压缩：对于文本文件，使用 -C 选项启用压缩
限制带宽：在生产环境中使用 -l 选项限制带宽
保留文件属性：使用 -p 选项保留文件属性
使用 SSH 密钥：配置 SSH 密钥认证，避免密码输入
监控传输：对于重要传输，监控传输进度
验证传输：传输完成后验证文件完整性
使用配置文件：对于复杂的传输任务使用配置文件管理

注意事项#

scp 传输大文件时可能需要较长时间
在生产环境中传输文件时要格外小心
使用通配符时要确保匹配正确的文件
注意文件权限和所有权的变化
传输敏感数据时注意保护隐私
在自动化脚本中添加适当的错误处理
不同版本的 scp 选项可能有所不同
对于大量小文件，考虑打包后传输
注意网络中断后的恢复策略

traceroute 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

traceroute 命令详解#

traceroute 是 Linux 系统中用于追踪数据包从源主机到目标主机所经过路径的网络诊断工具。它通过发送具有不同 TTL（Time To Live）值的数据包，逐跳显示网络路径上的路由器信息，是网络故障排查和性能分析的重要工具。

入门#

基本用法#

# 追踪到目标主机的路由
traceroute google.com

# 追踪到 IP 地址的路由
traceroute 8.8.8.8

# 指定最大跳数
traceroute -m 15 google.com

# 指定每个跳数的探测次数
traceroute -q 3 google.com

常用选项#

选项	说明
`-n`	不解析主机名，只显示 IP 地址
`-m`	设置最大跳数（TTL）
`-q`	设置每个跳数的探测次数
`-w`	设置等待响应的超时时间（秒）
`-p`	设置目标端口
`-i`	指定网络接口
`-f`	设置起始 TTL 值
`-z`	设置探测之间的延迟时间

基本示例#

# 追踪到百度的路由
traceroute www.baidu.com

# 输出示例：
# traceroute to www.baidu.com (110.242.68.4), 30 hops max, 60 byte packets
# 1 192.168.1.1 (192.168.1.1) 0.523 ms 0.487 ms 0.456 ms
# 2 10.0.0.1 (10.0.0.1) 2.123 ms 2.098 ms 2.087 ms
# 3 202.96.128.86 (202.96.128.86) 5.234 ms 5.198 ms 5.187 ms
# ...

# 不解析主机名
traceroute -n google.com

# 设置最大跳数为 15
traceroute -m 15 google.com

中级#

高级选项#

# 使用 ICMP 协议
traceroute -I google.com

# 使用 UDP 协议（默认）
traceroute -U google.com

# 使用 TCP 协议
traceroute -T google.com

# 指定目标端口
traceroute -p 80 google.com

# 指定源端口
traceroute --sport=12345 google.com

# 指定网络接口
traceroute -i eth0 google.com

网络路径分析#

# 追踪网络路径并分析延迟
traceroute google.com | tee route_analysis.txt

# 分析每跳的延迟
traceroute google.com | awk '{print $2, $3}'

# 查找高延迟节点
traceroute google.com | awk '$3 > 100 {print $0}'

# 统计跳数
traceroute google.com | grep -c "ms"

故障排查#

# 检查网络连通性
traceroute google.com

# 检查特定跳数的连通性
traceroute -f 5 -m 5 google.com

# 检查防火墙阻止
traceroute -p 80 google.com
traceroute -p 443 google.com

# 检查路由环路
traceroute -n google.com | grep -E "^\s+\d+\s+\d+\.\d+\.\d+\.\d+"

高级#

性能测试#

# 测试网络路径性能
traceroute -q 10 -w 2 google.com

# 测试不同协议的性能
traceroute -I -q 5 google.com
traceroute -U -q 5 google.com
traceroute -T -q 5 google.com

# 测试网络稳定性
for i in {1..10}; do
 echo "Run $i:"
 traceroute -q 1 google.com | tail -1
 sleep 10
done

路径监控#

#!/bin/bash
# 路由监控脚本

TARGET="google.com"
LOG_FILE="route_monitor.log"

while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 echo "$TIMESTAMP - Route trace to $TARGET:" >> $LOG_FILE
 traceroute -n -q 1 -w 1 $TARGET >> $LOG_FILE 2>&1
 echo "" >> $LOG_FILE
 
 sleep 300
done

路径变化检测#

#!/bin/bash
# 路径变化检测脚本

TARGET="google.com"
BASELINE_FILE="route_baseline.txt"
CURRENT_FILE="route_current.txt"

# 建立基线路径
establish_baseline() {
 echo "Establishing baseline route to $TARGET..."
 traceroute -n -q 1 $TARGET > $BASELINE_FILE
 echo "Baseline established"
}

# 检测路径变化
detect_changes() {
 echo "Detecting route changes..."
 
 traceroute -n -q 1 $TARGET > $CURRENT_FILE
 
 if diff $BASELINE_FILE $CURRENT_FILE > /dev/null; then
 echo "No route changes detected"
 else
 echo "Route changes detected!"
 diff $BASELINE_FILE $CURRENT_FILE
 fi
}

# 主函数
main() {
 case "$1" in
 baseline)
 establish_baseline
 ;;
 check)
 detect_changes
 ;;
 *)
 echo "Usage: $0 {baseline|check}"
 exit 1
 ;;
 esac
}

main "$@"

大师#

网络拓扑分析#

#!/bin/bash
# 网络拓扑分析工具

TARGETS=("google.com" "baidu.com" "github.com")
OUTPUT_DIR="topology_analysis"

mkdir -p $OUTPUT_DIR

# 分析单个目标
analyze_target() {
 local target=$1
 local output_file="$OUTPUT_DIR/${target}_topology.txt"
 
 echo "Analyzing topology for $target..."
 
 echo "=== Topology Analysis for $target ===" > $output_file
 echo "Analysis Time: $(date)" >> $output_file
 echo "" >> $output_file
 
 # 基本路由追踪
 echo "Basic Route:" >> $output_file
 traceroute -n -q 1 $target >> $output_file
 echo "" >> $output_file
 
 # ICMP 追踪
 echo "ICMP Trace:" >> $output_file
 traceroute -I -n -q 1 $target >> $output_file 2>&1
 echo "" >> $output_file
 
 # TCP 追踪
 echo "TCP Trace:" >> $output_file
 traceroute -T -p 80 -n -q 1 $target >> $output_file 2>&1
 echo "" >> $output_file
 
 # 路径延迟分析
 echo "Path Latency Analysis:" >> $output_file
 for i in {1..5}; do
 traceroute -n -q 1 $target | awk '{print $2, $3}' >> $output_file
 sleep 10
 done
 
 echo "Analysis completed: $output_file"
}

# 批量分析
batch_analyze() {
 for target in "${TARGETS[@]}"; do
 analyze_target $target
 done
}

# 比较多个目标的路径
compare_paths() {
 local comparison_file="$OUTPUT_DIR/path_comparison.txt"
 
 echo "=== Path Comparison ===" > $comparison_file
 echo "Comparison Time: $(date)" >> $comparison_file
 echo "" >> $comparison_file
 
 for target in "${TARGETS[@]}"; do
 echo "--- Path to $target ---" >> $comparison_file
 traceroute -n -q 1 $target | head -10 >> $comparison_file
 echo "" >> $comparison_file
 done
 
 echo "Comparison saved to: $comparison_file"
}

# 主函数
main() {
 case "$1" in
 analyze)
 analyze_target "$2"
 ;;
 batch)
 batch_analyze
 ;;
 compare)
 compare_paths
 ;;
 *)
 echo "Usage: $0 {analyze|batch|compare}"
 exit 1
 ;;
 esac
}

main "$@"

网络性能基准测试#

#!/bin/bash
# 网络性能基准测试工具

TARGET="google.com"
TEST_COUNT=10
OUTPUT_FILE="performance_benchmark_$(date +%Y%m%d_%H%M%S).txt"

# 执行单次测试
run_single_test() {
 local test_num=$1
 
 echo "Test $test_num:"
 traceroute -q 1 -w 1 $TARGET | tee -a $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
}

# 分析性能数据
analyze_performance() {
 echo "=== Performance Analysis ===" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 提取延迟数据
 echo "Hop-by-hop Latency:" >> $OUTPUT_FILE
 grep "ms" $OUTPUT_FILE | awk '{print $2, $3}' | sort -u >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 计算平均延迟
 echo "Average Latency per Hop:" >> $OUTPUT_FILE
 grep "ms" $OUTPUT_FILE | awk '{hop=$1; sum+=$3; count++} END {print "Average:", sum/count, "ms"}' >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 检测丢包
 echo "Packet Loss:" >> $OUTPUT_FILE
 grep "*" $OUTPUT_FILE | wc -l >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
}

# 执行基准测试
run_benchmark() {
 echo "Starting performance benchmark..."
 echo "Target: $TARGET"
 echo "Test count: $TEST_COUNT"
 echo ""
 
 for ((i=1; i<=TEST_COUNT; i++)); do
 run_single_test $i
 sleep 5
 done
 
 analyze_performance
 
 echo "Benchmark completed. Results saved to: $OUTPUT_FILE"
}

# 主函数
main() {
 case "$1" in
 run)
 run_benchmark
 ;;
 analyze)
 analyze_performance
 ;;
 *)
 echo "Usage: $0 {run|analyze}"
 exit 1
 ;;
 esac
}

main "$@"

网络故障诊断#

#!/bin/bash
# 网络故障诊断工具

TARGET="google.com"
DIAGNOSTIC_LOG="network_diagnostic_$(date +%Y%m%d_%H%M%S).log"

# 基本连通性测试
basic_connectivity_test() {
 echo "=== Basic Connectivity Test ===" >> $DIAGNOSTIC_LOG
 
 if ping -c 4 $TARGET > /dev/null 2>&1; then
 echo "✓ Basic connectivity OK" >> $DIAGNOSTIC_LOG
 else
 echo "✗ Basic connectivity FAILED" >> $DIAGNOSTIC_LOG
 fi
 echo "" >> $DIAGNOSTIC_LOG
}

# 路由追踪测试
route_trace_test() {
 echo "=== Route Trace Test ===" >> $DIAGNOSTIC_LOG
 
 traceroute -n -q 1 -w 1 $TARGET >> $DIAGNOSTIC_LOG 2>&1
 
 if [ $? -eq 0 ]; then
 echo "✓ Route trace completed" >> $DIAGNOSTIC_LOG
 else
 echo "✗ Route trace failed" >> $DIAGNOSTIC_LOG
 fi
 echo "" >> $DIAGNOSTIC_LOG
}

# ICMP 追踪测试
icmp_trace_test() {
 echo "=== ICMP Trace Test ===" >> $DIAGNOSTIC_LOG
 
 traceroute -I -n -q 1 -w 1 $TARGET >> $DIAGNOSTIC_LOG 2>&1
 
 if [ $? -eq 0 ]; then
 echo "✓ ICMP trace completed" >> $DIAGNOSTIC_LOG
 else
 echo "✗ ICMP trace failed (may be blocked by firewall)" >> $DIAGNOSTIC_LOG
 fi
 echo "" >> $DIAGNOSTIC_LOG
}

# TCP 追踪测试
tcp_trace_test() {
 echo "=== TCP Trace Test ===" >> $DIAGNOSTIC_LOG
 
 traceroute -T -p 80 -n -q 1 -w 1 $TARGET >> $DIAGNOSTIC_LOG 2>&1
 
 if [ $? -eq 0 ]; then
 echo "✓ TCP trace completed" >> $DIAGNOSTIC_LOG
 else
 echo "✗ TCP trace failed (port may be blocked)" >> $DIAGNOSTIC_LOG
 fi
 echo "" >> $DIAGNOSTIC_LOG
}

# 路径完整性检查
path_integrity_check() {
 echo "=== Path Integrity Check ===" >> $DIAGNOSTIC_LOG
 
 local lost_hops=$(traceroute -n -q 1 $TARGET 2>&1 | grep -c "\*")
 
 if [ $lost_hops -eq 0 ]; then
 echo "✓ Path integrity OK" >> $DIAGNOSTIC_LOG
 else
 echo "⚠ $lost_hops hops not responding" >> $DIAGNOSTIC_LOG
 fi
 echo "" >> $DIAGNOSTIC_LOG
}

# 延迟分析
latency_analysis() {
 echo "=== Latency Analysis ===" >> $DIAGNOSTIC_LOG
 
 for i in {1..5}; do
 traceroute -n -q 1 $TARGET | grep "ms" | awk '{print $2, $3}' >> $DIAGNOSTIC_LOG
 sleep 2
 done
 echo "" >> $DIAGNOSTIC_LOG
}

# 生成诊断报告
generate_diagnostic_report() {
 echo "Network Diagnostic Report - $(date)" > $DIAGNOSTIC_LOG
 echo "=================================" >> $DIAGNOSTIC_LOG
 echo "Target: $TARGET" >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
 
 basic_connectivity_test
 route_trace_test
 icmp_trace_test
 tcp_trace_test
 path_integrity_check
 latency_analysis
 
 echo "Diagnostic completed. Log saved to: $DIAGNOSTIC_LOG"
}

# 主函数
main() {
 generate_diagnostic_report
}

main

无敌#

企业级网络监控系统#

#!/bin/bash
# 企业级网络监控系统

CONFIG_FILE="/etc/network_monitor/config.conf"
LOG_DIR="/var/log/network_monitor"
ALERT_SCRIPT="/usr/local/bin/send_alert.sh"

mkdir -p $LOG_DIR

# 加载配置
source $CONFIG_FILE

# 追踪网络路径
trace_network_path() {
 local target=$1
 local output_file="$LOG_DIR/path_${target}_$(date +%Y%m%d_%H%M%S).txt"
 
 traceroute -n -q 1 -w 1 $target > $output_file 2>&1
 
 return $?
}

# 分析路径变化
analyze_path_changes() {
 local target=$1
 local current_file=$2
 local baseline_file="$LOG_DIR/path_${target}_baseline.txt"
 
 if [ ! -f "$baseline_file" ]; then
 cp $current_file $baseline_file
 echo "Baseline established for $target"
 return 0
 fi
 
 if diff $baseline_file $current_file > /dev/null; then
 return 0
 else
 echo "Path change detected for $target"
 diff $baseline_file $current_file
 return 1
 fi
}

# 检查路径健康
check_path_health() {
 local target=$1
 local output_file=$2
 
 local lost_hops=$(grep "\*" $output_file | wc -l)
 local total_hops=$(grep -c "ms" $output_file)
 
 if [ $lost_hops -gt $MAX_LOST_HOPS ]; then
 echo "ALERT: Too many lost hops for $target: $lost_hops"
 $ALERT_SCRIPT "Path health issue: $target - $lost_hops lost hops"
 return 1
 fi
 
 return 0
}

# 监控网络路径
monitor_network_paths() {
 while true; do
 for target in "${MONITOR_TARGETS[@]}"; do
 local output_file=$(mktemp)
 
 trace_network_path $target
 
 if [ $? -eq 0 ]; then
 analyze_path_changes $target $output_file
 check_path_health $target $output_file
 else
 echo "ERROR: Failed to trace path to $target"
 fi
 
 rm $output_file
 done
 
 sleep $MONITOR_INTERVAL
 done
}

# 生成监控报告
generate_monitor_report() {
 local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
 
 echo "Network Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "================================" >> $report_file
 echo "" >> $report_file
 
 for target in "${MONITOR_TARGETS[@]}"; do
 echo "=== $target ===" >> $report_file
 ls -lt $LOG_DIR/path_${target}_*.txt 2>/dev/null | head -5 >> $report_file
 echo "" >> $report_file
 done
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_network_paths
 ;;
 report)
 generate_monitor_report
 ;;
 *)
 echo "Usage: $0 {monitor|report}"
 exit 1
 ;;
 esac
}

main "$@"

智能网络诊断系统#

#!/bin/bash
# 智能网络诊断系统

DIAGNOSTIC_DB="/var/lib/network_diagnostic/db"
LOG_FILE="/var/log/network_diagnostic/diagnostic.log"

mkdir -p $DIAGNOSTIC_DB $(dirname $LOG_FILE)

# 执行诊断
perform_diagnostic() {
 local target=$1
 local diagnostic_id=$(date +%s%N)
 local output_dir="$DIAGNOSTIC_DB/$diagnostic_id"
 
 mkdir -p $output_dir
 
 echo "Performing diagnostic for $target (ID: $diagnostic_id)..."
 
 # 基本追踪
 traceroute -n -q 1 $target > $output_dir/basic_trace.txt 2>&1
 
 # ICMP 追踪
 traceroute -I -n -q 1 $target > $output_dir/icmp_trace.txt 2>&1
 
 # TCP 追踪
 traceroute -T -p 80 -n -q 1 $target > $output_dir/tcp_trace.txt 2>&1
 
 # 保存元数据
 echo "target=$target" > $output_dir/metadata.txt
 echo "timestamp=$(date)" >> $output_dir/metadata.txt
 echo "diagnostic_id=$diagnostic_id" >> $output_dir/metadata.txt
 
 echo "Diagnostic completed: $output_dir"
 return $diagnostic_id
}

# 分析诊断结果
analyze_diagnostic() {
 local diagnostic_id=$1
 local output_dir="$DIAGNOSTIC_DB/$diagnostic_id"
 
 if [ ! -d "$output_dir" ]; then
 echo "Diagnostic not found: $diagnostic_id"
 return 1
 fi
 
 echo "=== Diagnostic Analysis ==="
 echo "ID: $diagnostic_id"
 echo "Target: $(grep target $output_dir/metadata.txt | cut -d= -f2)"
 echo ""
 
 # 基本追踪结果
 echo "Basic Trace:"
 cat $output_dir/basic_trace.txt
 echo ""
 
 # ICMP 追踪结果
 echo "ICMP Trace:"
 cat $output_dir/icmp_trace.txt
 echo ""
 
 # TCP 追踪结果
 echo "TCP Trace:"
 cat $output_dir/tcp_trace.txt
 echo ""
 
 # 健康评估
 local lost_hops=$(grep "\*" $output_dir/basic_trace.txt | wc -l)
 if [ $lost_hops -eq 0 ]; then
 echo "✓ Path health: Good"
 elif [ $lost_hops -lt 3 ]; then
 echo "⚠ Path health: Fair ($lost_hops lost hops)"
 else
 echo "✗ Path health: Poor ($lost_hops lost hops)"
 fi
}

# 比较诊断结果
compare_diagnostics() {
 local id1=$1
 local id2=$2
 
 local dir1="$DIAGNOSTIC_DB/$id1"
 local dir2="$DIAGNOSTIC_DB/$id2"
 
 if [ ! -d "$dir1" ] || [ ! -d "$dir2" ]; then
 echo "One or both diagnostics not found"
 return 1
 fi
 
 echo "=== Diagnostic Comparison ==="
 echo "ID1: $id1"
 echo "ID2: $id2"
 echo ""
 
 echo "Basic Trace Comparison:"
 diff $dir1/basic_trace.txt $dir2/basic_trace.txt
 echo ""
 
 echo "ICMP Trace Comparison:"
 diff $dir1/icmp_trace.txt $dir2/icmp_trace.txt
}

# 列出诊断
list_diagnostics() {
 echo "=== Available Diagnostics ==="
 
 for dir in $DIAGNOSTIC_DB/*/; do
 if [ -d "$dir" ]; then
 local id=$(basename $dir)
 local target=$(grep target $dir/metadata.txt | cut -d= -f2)
 local timestamp=$(grep timestamp $dir/metadata.txt | cut -d= -f2)
 
 echo "ID: $id"
 echo "Target: $target"
 echo "Time: $timestamp"
 echo ""
 fi
 done
}

# 主函数
main() {
 case "$1" in
 diagnose)
 perform_diagnostic "$2"
 ;;
 analyze)
 analyze_diagnostic "$2"
 ;;
 compare)
 compare_diagnostics "$2" "$3"
 ;;
 list)
 list_diagnostics
 ;;
 *)
 echo "Usage: $0 {diagnose|analyze|compare|list}"
 exit 1
 ;;
 esac
}

main "$@"

网络路径优化建议#

#!/bin/bash
# 网络路径优化建议工具

TARGET="google.com"
OUTPUT_FILE="path_optimization_$(date +%Y%m%d_%H%M%S).txt"

# 收集路径数据
collect_path_data() {
 echo "=== Path Data Collection ===" > $OUTPUT_FILE
 echo "Target: $TARGET" >> $OUTPUT_FILE
 echo "Collection Time: $(date)" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 基本路径
 echo "Basic Path:" >> $OUTPUT_FILE
 traceroute -n -q 1 $TARGET >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # ICMP 路径
 echo "ICMP Path:" >> $OUTPUT_FILE
 traceroute -I -n -q 1 $TARGET >> $OUTPUT_FILE 2>&1
 echo "" >> $OUTPUT_FILE
 
 # TCP 路径
 echo "TCP Path:" >> $OUTPUT_FILE
 traceroute -T -p 80 -n -q 1 $TARGET >> $OUTPUT_FILE 2>&1
 echo "" >> $OUTPUT_FILE
}

# 分析路径性能
analyze_path_performance() {
 echo "=== Path Performance Analysis ===" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 提取延迟数据
 echo "Hop Latencies:" >> $OUTPUT_FILE
 grep "ms" $OUTPUT_FILE | awk '{print $2, $3}' | sort -u >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 计算统计信息
 echo "Latency Statistics:" >> $OUTPUT_FILE
 grep "ms" $OUTPUT_FILE | awk '{sum+=$3; count++} END {print "Average:", sum/count, "ms"}' >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 检测高延迟节点
 echo "High Latency Hops (>100ms):" >> $OUTPUT_FILE
 grep "ms" $OUTPUT_FILE | awk '$3 > 100 {print $0}' >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
}

# 提供优化建议
provide_optimization_suggestions() {
 echo "=== Optimization Suggestions ===" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 # 检查丢包
 local lost_hops=$(grep "\*" $OUTPUT_FILE | wc -l)
 if [ $lost_hops -gt 0 ]; then
 echo "⚠ Detected $lost_hops unresponsive hops:" >> $OUTPUT_FILE
 echo " - Consider checking firewall rules" >> $OUTPUT_FILE
 echo " - Verify network connectivity" >> $OUTPUT_FILE
 echo " - Contact ISP if issue persists" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 fi
 
 # 检查路径长度
 local hop_count=$(grep -c "ms" $OUTPUT_FILE)
 if [ $hop_count -gt 20 ]; then
 echo "⚠ Long path detected ($hop_count hops):" >> $OUTPUT_FILE
 echo " - Consider using CDN services" >> $OUTPUT_FILE
 echo " - Evaluate alternative routing options" >> $OUTPUT_FILE
 echo " - Check with ISP for route optimization" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 fi
 
 # 检查 ICMP 阻塞
 if grep -q "ICMP trace" $OUTPUT_FILE && [ $? -ne 0 ]; then
 echo "⚠ ICMP may be blocked:" >> $OUTPUT_FILE
 echo " - Use TCP tracing for better results" >> $OUTPUT_FILE
 echo " - Check firewall ICMP rules" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 fi
 
 # 一般建议
 echo "General Recommendations:" >> $OUTPUT_FILE
 echo " - Regularly monitor network path performance" >> $OUTPUT_FILE
 echo " - Implement redundancy for critical paths" >> $OUTPUT_FILE
 echo " - Consider using BGP for route optimization" >> $OUTPUT_FILE
 echo " - Monitor latency trends over time" >> $OUTPUT_FILE
}

# 生成优化报告
generate_optimization_report() {
 collect_path_data
 analyze_path_performance
 provide_optimization_suggestions
 
 echo "Optimization report generated: $OUTPUT_FILE"
}

# 主函数
main() {
 generate_optimization_report
}

main

最佳实践#

使用 -n 选项：避免 DNS 解析，提高性能
合理设置超时：根据网络环境设置合适的超时时间
多次测试：进行多次测试以获得准确结果
结合其他工具：结合 ping、mtr 等工具进行综合诊断
记录基线：建立网络路径基线，便于比较变化
分析丢包：注意分析丢包情况，识别网络问题
使用不同协议：尝试 ICMP、UDP、TCP 等不同协议
注意防火墙：注意防火墙可能阻止某些类型的探测

注意事项#

traceroute 可能被防火墙阻止
某些路由器可能不响应 traceroute 探测
不同操作系统的 traceroute 实现可能不同
在生产环境中使用时要谨慎，避免影响网络性能
注意网络隐私，不要追踪不明来源的地址
结果可能因网络拥塞而变化
对于关键业务，建议使用专业的网络监控工具
注意 TTL 值的设置，避免超过最大跳数
某些网络可能禁止 traceroute 或限制其使用

nslookup 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

nslookup 命令详解#

nslookup（Name Server Lookup）是 Linux 系统中用于查询 DNS（Domain Name System）信息的命令行工具。它可以查询域名对应的 IP 地址、反向查询、DNS 记录类型等，是网络管理员和开发人员进行 DNS 故障排查的重要工具。

入门#

基本用法#

# 查询域名的 IP 地址
nslookup google.com

# 查询特定类型的 DNS 记录
nslookup -type=MX google.com

# 指定 DNS 服务器查询
nslookup google.com 8.8.8.8

# 交互式查询
nslookup
> google.com
> exit

常用选项#

选项	说明
`-type`	指定查询的记录类型（A、MX、NS、CNAME 等）
`-query`	同 `-type`
`-debug`	显示调试信息
`-port`	指定 DNS 服务器端口
`-timeout`	设置查询超时时间
`-retry`	设置重试次数
`-vc`	使用 TCP 协议查询

常用记录类型#

类型	说明
`A`	IPv4 地址记录
`AAAA`	IPv6 地址记录
`MX`	邮件交换记录
`NS`	名称服务器记录
`CNAME`	别名记录
`TXT`	文本记录
`SOA`	授权起始记录
`PTR`	反向 DNS 记录

基本示例#

# 查询 A 记录
nslookup google.com

# 输出示例：
# Server:		192.168.1.1
# Address:	192.168.1.1#53
#
# Non-authoritative answer:
# Name:	google.com
# Address: 142.250.188.46

# 查询 MX 记录
nslookup -type=MX google.com

# 查询 NS 记录
nslookup -type=NS google.com

# 指定 DNS 服务器
nslookup google.com 8.8.8.8

中级#

查询不同记录类型#

# 查询 A 记录（IPv4 地址）
nslookup -type=A google.com

# 查询 AAAA 记录（IPv6 地址）
nslookup -type=AAAA google.com

# 查询 MX 记录（邮件服务器）
nslookup -type=MX gmail.com

# 查询 NS 记录（名称服务器）
nslookup -type=NS google.com

# 查询 CNAME 记录（别名）
nslookup -type=CNAME www.google.com

# 查询 TXT 记录（文本信息）
nslookup -type=TXT google.com

# 查询 SOA 记录（授权起始）
nslookup -type=SOA google.com

反向 DNS 查询#

# 反向查询 IP 地址对应的域名
nslookup 8.8.8.8

# 输出示例：
# 8.8.8.8.in-addr.arpa	name = dns.google.

# 查询多个 IP 地址
nslookup 8.8.8.8
nslookup 1.1.1.1
nslookup 208.67.222.222

指定 DNS 服务器#

# 使用 Google DNS
nslookup google.com 8.8.8.8

# 使用 Cloudflare DNS
nslookup google.com 1.1.1.1

# 使用 OpenDNS
nslookup google.com 208.67.222.222

# 使用本地 DNS 服务器
nslookup google.com 192.168.1.1

# 使用多个 DNS 服务器
nslookup google.com 8.8.8.8 8.8.4.4

高级#

交互式模式#

# 进入交互式模式
nslookup

# 在交互式模式中
> server 8.8.8.8 # 设置 DNS 服务器
> set type=MX # 设置查询类型
> google.com # 查询域名
> set type=A # 更改查询类型
> www.google.com # 查询另一个域名
> set debug # 启用调试模式
> google.com # 查看详细信息
> exit # 退出

高级查询选项#

# 启用调试模式
nslookup -debug google.com

# 设置查询超时时间
nslookup -timeout=5 google.com

# 设置重试次数
nslookup -retry=3 google.com

# 使用 TCP 协议查询
nslookup -vc google.com

# 指定 DNS 服务器端口
nslookup -port=5353 google.com 127.0.0.1

# 禁用递归查询
nslookup -norecurse google.com

DNS 故障排查#

# 检查 DNS 解析是否正常
nslookup google.com

# 检查特定 DNS 服务器
nslookup google.com 8.8.8.8

# 检查 MX 记录
nslookup -type=MX gmail.com

# 检查 NS 记录
nslookup -type=NS google.com

# 检查 DNS 传播
nslookup -type=A newdomain.com

# 检查 DNS 缓存
nslookup -type=A google.com

大师#

DNS 批量查询#

#!/bin/bash
# DNS 批量查询脚本

DOMAIN_LIST="domains.txt"
OUTPUT_FILE="dns_query_results.txt"

# 从文件批量查询
batch_query() {
 local record_type=$1
 
 echo "Batch DNS Query - $(date)" > $OUTPUT_FILE
 echo "Record Type: $record_type" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 while IFS= read -r domain; do
 if [ -n "$domain" ] && [[ ! $domain =~ ^# ]]; then
 echo "Querying: $domain"
 echo "=== $domain ===" >> $OUTPUT_FILE
 nslookup -type=$record_type $domain >> $OUTPUT_FILE 2>&1
 echo "" >> $OUTPUT_FILE
 fi
 done < "$DOMAIN_LIST"
 
 echo "Batch query completed. Results saved to: $OUTPUT_FILE"
}

# 查询多个记录类型
multi_type_query() {
 local domain=$1
 local types=("A" "AAAA" "MX" "NS" "TXT")
 
 echo "=== Multi-type Query for $domain ==="
 
 for type in "${types[@]}"; do
 echo "--- $type Record ---"
 nslookup -type=$type $domain
 echo ""
 done
}

# 对比多个 DNS 服务器
compare_dns_servers() {
 local domain=$1
 shift
 local servers=("$@")
 
 echo "=== DNS Server Comparison for $domain ==="
 
 for server in "${servers[@]}"; do
 echo "--- Server: $server ---"
 nslookup $domain $server
 echo ""
 done
}

# 主函数
main() {
 case "$1" in
 batch)
 batch_query "$2"
 ;;
 multi)
 multi_type_query "$2"
 ;;
 compare)
 compare_dns_servers "$2" "${@:3}"
 ;;
 *)
 echo "Usage: $0 {batch|multi|compare}"
 exit 1
 ;;
 esac
}

main "$@"

DNS 监控#

#!/bin/bash
# DNS 监控脚本

DOMAINS=("google.com" "baidu.com" "github.com")
LOG_FILE="dns_monitor.log"

# 监控 DNS 解析
monitor_dns() {
 while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 for DOMAIN in "${DOMAINS[@]}"; do
 RESULT=$(nslookup -timeout=2 $DOMAIN 2>&1)
 
 if echo "$RESULT" | grep -q "Address:"; then
 IP=$(echo "$RESULT" | grep "Address:" | tail -1 | awk '{print $2}')
 echo "$TIMESTAMP - $DOMAIN - $IP" >> $LOG_FILE
 else
 echo "$TIMESTAMP - $DOMAIN - FAILED" >> $LOG_FILE
 fi
 done
 
 sleep 300
 done
}

# 检查 DNS 变化
check_dns_changes() {
 local domain=$1
 local cache_file="dns_cache_${domain}.txt"
 
 if [ ! -f "$cache_file" ]; then
 nslookup $domain | grep "Address:" > $cache_file
 echo "Cache created for $domain"
 return 0
 fi
 
 local current=$(nslookup $domain | grep "Address:")
 local cached=$(cat $cache_file)
 
 if [ "$current" != "$cached" ]; then
 echo "DNS change detected for $domain!"
 echo "Old: $cached"
 echo "New: $current"
 echo "$current" > $cache_file
 else
 echo "No DNS change for $domain"
 fi
}

# DNS 性能测试
dns_performance_test() {
 local domain=$1
 local servers=("8.8.8.8" "1.1.1.1" "208.67.222.222")
 
 echo "=== DNS Performance Test for $domain ==="
 
 for server in "${servers[@]}"; do
 local start_time=$(date +%s.%N)
 nslookup -timeout=2 $domain $server > /dev/null 2>&1
 local end_time=$(date +%s.%N)
 local duration=$(echo "$end_time - $start_time" | bc)
 
 echo "$server: ${duration}s"
 done
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_dns
 ;;
 check)
 check_dns_changes "$2"
 ;;
 performance)
 dns_performance_test "$2"
 ;;
 *)
 echo "Usage: $0 {monitor|check|performance}"
 exit 1
 ;;
 esac
}

main "$@"

DNS 故障诊断#

#!/bin/bash
# DNS 故障诊断工具

DOMAIN=$1
DIAGNOSTIC_LOG="dns_diagnostic_$(date +%Y%m%d_%H%M%S).log"

# 基本解析测试
basic_resolution_test() {
 echo "=== Basic Resolution Test ===" >> $DIAGNOSTIC_LOG
 
 nslookup $DOMAIN >> $DIAGNOSTIC_LOG 2>&1
 
 if [ $? -eq 0 ]; then
 echo "✓ Basic resolution successful" >> $DIAGNOSTIC_LOG
 else
 echo "✗ Basic resolution failed" >> $DIAGNOSTIC_LOG
 fi
 echo "" >> $DIAGNOSTIC_LOG
}

# 多记录类型测试
multi_record_test() {
 local types=("A" "AAAA" "MX" "NS" "TXT")
 
 echo "=== Multi-record Type Test ===" >> $DIAGNOSTIC_LOG
 
 for type in "${types[@]}"; do
 echo "--- $type Record ---" >> $DIAGNOSTIC_LOG
 nslookup -type=$type $DOMAIN >> $DIAGNOSTIC_LOG 2>&1
 echo "" >> $DIAGNOSTIC_LOG
 done
}

# 多 DNS 服务器测试
multi_server_test() {
 local servers=("8.8.8.8" "1.1.1.1" "208.67.222.222")
 
 echo "=== Multi-server Test ===" >> $DIAGNOSTIC_LOG
 
 for server in "${servers[@]}"; do
 echo "--- Server: $server ---" >> $DIAGNOSTIC_LOG
 nslookup $DOMAIN $server >> $DIAGNOSTIC_LOG 2>&1
 echo "" >> $DIAGNOSTIC_LOG
 done
}

# DNS 传播测试
propagation_test() {
 local servers=("8.8.8.8" "1.1.1.1" "208.67.222.222" "192.168.1.1")
 
 echo "=== DNS Propagation Test ===" >> $DIAGNOSTIC_LOG
 
 for server in "${servers[@]}"; do
 local result=$(nslookup $DOMAIN $server 2>&1)
 local ip=$(echo "$result" | grep "Address:" | tail -1 | awk '{print $2}')
 
 echo "$server: $ip" >> $DIAGNOSTIC_LOG
 done
 echo "" >> $DIAGNOSTIC_LOG
}

# 生成诊断报告
generate_diagnostic_report() {
 echo "DNS Diagnostic Report - $(date)" > $DIAGNOSTIC_LOG
 echo "=============================" >> $DIAGNOSTIC_LOG
 echo "Domain: $DOMAIN" >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
 
 basic_resolution_test
 multi_record_test
 multi_server_test
 propagation_test
 
 echo "Diagnostic completed. Log saved to: $DIAGNOSTIC_LOG"
}

# 主函数
main() {
 if [ -z "$DOMAIN" ]; then
 echo "Usage: $0 <domain>"
 exit 1
 fi
 
 generate_diagnostic_report
}

main "$@"

无敌#

企业级 DNS 监控系统#

#!/bin/bash
# 企业级 DNS 监控系统

CONFIG_FILE="/etc/dns_monitor/config.conf"
LOG_DIR="/var/log/dns_monitor"
ALERT_SCRIPT="/usr/local/bin/send_alert.sh"

mkdir -p $LOG_DIR

# 加载配置
source $CONFIG_FILE

# 监控 DNS 解析
monitor_dns_resolution() {
 local domain=$1
 local log_file="$LOG_DIR/${domain}_monitor.log"
 
 local result=$(nslookup -timeout=$TIMEOUT $DOMAIN_SERVER $domain 2>&1)
 
 if echo "$result" | grep -q "Address:"; then
 local ip=$(echo "$result" | grep "Address:" | tail -1 | awk '{print $2}')
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 
 echo "$timestamp - $domain - $ip" >> $log_file
 return 0
 else
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "$timestamp - $domain - FAILED" >> $log_file
 return 1
 fi
}

# 检测 DNS 变化
detect_dns_changes() {
 local domain=$1
 local cache_file="$LOG_DIR/${domain}_cache.txt"
 local log_file="$LOG_DIR/${domain}_changes.log"
 
 local current_ip=$(nslookup -timeout=$TIMEOUT $DOMAIN_SERVER $domain 2>&1 | grep "Address:" | tail -1 | awk '{print $2}')
 
 if [ -f "$cache_file" ]; then
 local cached_ip=$(cat $cache_file)
 
 if [ "$current_ip" != "$cached_ip" ]; then
 local timestamp=$(date "+%Y-%m-%d %H:%M:%S")
 echo "$timestamp - DNS change detected for $domain: $cached_ip -> $current_ip" >> $log_file
 
 $ALERT_SCRIPT "DNS change detected for $domain: $cached_ip -> $current_ip"
 
 echo "$current_ip" > $cache_file
 fi
 else
 echo "$current_ip" > $cache_file
 fi
}

# 监控多个域名
monitor_multiple_domains() {
 while true; do
 for domain in "${MONITOR_DOMAINS[@]}"; do
 monitor_dns_resolution $domain
 detect_dns_changes $domain
 done
 
 sleep $MONITOR_INTERVAL
 done
}

# 生成监控报告
generate_monitor_report() {
 local report_file="$LOG_DIR/monitor_report_$(date +%Y%m%d).txt"
 
 echo "DNS Monitor Report - $(date +%Y-%m-%d)" > $report_file
 echo "========================" >> $report_file
 echo "" >> $report_file
 
 for domain in "${MONITOR_DOMAINS[@]}"; do
 echo "=== $domain ===" >> $report_file
 tail -10 $LOG_DIR/${domain}_monitor.log >> $report_file
 echo "" >> $report_file
 done
 
 echo "Report saved to: $report_file"
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_multiple_domains
 ;;
 report)
 generate_monitor_report
 ;;
 *)
 echo "Usage: $0 {monitor|report}"
 exit 1
 ;;
 esac
}

main "$@"

DNS 性能基准测试#

#!/bin/bash
# DNS 性能基准测试工具

DOMAIN="google.com"
TEST_COUNT=100
OUTPUT_FILE="dns_performance_$(date +%Y%m%d_%H%M%S).txt"

# 测试单个 DNS 服务器
test_dns_server() {
 local server=$1
 local total_time=0
 local success_count=0
 local fail_count=0
 
 echo "Testing DNS server: $server" >> $OUTPUT_FILE
 
 for ((i=1; i<=TEST_COUNT; i++)); do
 local start_time=$(date +%s.%N)
 nslookup -timeout=2 $DOMAIN $server > /dev/null 2>&1
 local end_time=$(date +%s.%N)
 local duration=$(echo "$end_time - $start_time" | bc)
 
 if [ $? -eq 0 ]; then
 total_time=$(echo "$total_time + $duration" | bc)
 success_count=$((success_count + 1))
 else
 fail_count=$((fail_count + 1))
 fi
 done
 
 local avg_time=$(echo "scale=3; $total_time / $success_count" | bc)
 local success_rate=$(echo "scale=2; $success_count * 100 / $TEST_COUNT" | bc)
 
 echo "Server: $server" >> $OUTPUT_FILE
 echo "Average response time: ${avg_time}s" >> $OUTPUT_FILE
 echo "Success rate: ${success_rate}%" >> $OUTPUT_FILE
 echo "Success count: $success_count" >> $OUTPUT_FILE
 echo "Fail count: $fail_count" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
}

# 对比多个 DNS 服务器
compare_dns_servers() {
 local servers=("8.8.8.8" "1.1.1.1" "208.67.222.222" "192.168.1.1")
 
 echo "DNS Performance Benchmark - $(date)" > $OUTPUT_FILE
 echo "Domain: $DOMAIN" >> $OUTPUT_FILE
 echo "Test count: $TEST_COUNT" >> $OUTPUT_FILE
 echo "" >> $OUTPUT_FILE
 
 for server in "${servers[@]}"; do
 test_dns_server $server
 done
 
 echo "Benchmark completed. Results saved to: $OUTPUT_FILE"
}

# 实时性能监控
realtime_performance_monitor() {
 local servers=("8.8.8.8" "1.1.1.1" "208.67.222.222")
 
 echo "Real-time DNS Performance Monitor"
 echo "================================"
 
 while true; do
 clear
 echo "DNS Performance - $(date '+%Y-%m-%d %H:%M:%S')"
 echo ""
 
 for server in "${servers[@]}"; do
 local start_time=$(date +%s.%N)
 nslookup -timeout=2 $DOMAIN $server > /dev/null 2>&1
 local end_time=$(date +%s.%N)
 local duration=$(echo "$end_time - $start_time" | bc)
 
 printf "%-20s: %6s ms\n" "$server" "$(echo "$duration * 1000" | bc | cut -d'.' -f1)"
 done
 
 sleep 5
 done
}

# 主函数
main() {
 case "$1" in
 benchmark)
 compare_dns_servers
 ;;
 monitor)
 realtime_performance_monitor
 ;;
 *)
 echo "Usage: $0 {benchmark|monitor}"
 exit 1
 ;;
 esac
}

main "$@"

智能 DNS 故障诊断系统#

#!/bin/bash
# 智能 DNS 故障诊断系统

DOMAIN=$1
DIAGNOSTIC_DB="/var/lib/dns_diagnostic"
LOG_FILE="/var/log/dns_diagnostic/diagnostic.log"

mkdir -p $DIAGNOSTIC_DB $(dirname $LOG_FILE)

# 执行诊断
perform_diagnostic() {
 local diagnostic_id=$(date +%s%N)
 local output_dir="$DIAGNOSTIC_DB/$diagnostic_id"
 
 mkdir -p $output_dir
 
 echo "Performing diagnostic for $DOMAIN (ID: $diagnostic_id)..."
 
 # 基本解析
 nslookup $DOMAIN > $output_dir/basic_resolution.txt 2>&1
 
 # 多记录类型
 for type in A AAAA MX NS TXT; do
 nslookup -type=$type $DOMAIN > $output_dir/${type}_record.txt 2>&1
 done
 
 # 多 DNS 服务器
 for server in 8.8.8.8 1.1.1.1 208.67.222.222; do
 nslookup $DOMAIN $server > $output_dir/server_${server}.txt 2>&1
 done
 
 # 保存元数据
 echo "domain=$DOMAIN" > $output_dir/metadata.txt
 echo "timestamp=$(date)" >> $output_dir/metadata.txt
 echo "diagnostic_id=$diagnostic_id" >> $output_dir/metadata.txt
 
 echo "Diagnostic completed: $output_dir"
 return $diagnostic_id
}

# 分析诊断结果
analyze_diagnostic() {
 local diagnostic_id=$1
 local output_dir="$DIAGNOSTIC_DB/$diagnostic_id"
 
 if [ ! -d "$output_dir" ]; then
 echo "Diagnostic not found: $diagnostic_id"
 return 1
 fi
 
 echo "=== Diagnostic Analysis ==="
 echo "ID: $diagnostic_id"
 echo "Domain: $(grep domain $output_dir/metadata.txt | cut -d= -f2)"
 echo ""
 
 # 基本解析结果
 echo "Basic Resolution:"
 cat $output_dir/basic_resolution.txt
 echo ""
 
 # A 记录结果
 echo "A Record:"
 cat $output_dir/A_record.txt
 echo ""
 
 # MX 记录结果
 echo "MX Record:"
 cat $output_dir/MX_record.txt
 echo ""
 
 # 健康评估
 local failed_servers=$(grep -l "timed out\|can't find" $output_dir/server_*.txt | wc -l)
 if [ $failed_servers -eq 0 ]; then
 echo "✓ DNS health: Good"
 elif [ $failed_servers -lt 2 ]; then
 echo "⚠ DNS health: Fair ($failed_servers servers failed)"
 else
 echo "✗ DNS health: Poor ($failed_servers servers failed)"
 fi
}

# 比较诊断结果
compare_diagnostics() {
 local id1=$1
 local id2=$2
 
 local dir1="$DIAGNOSTIC_DB/$id1"
 local dir2="$DIAGNOSTIC_DB/$id2"
 
 if [ ! -d "$dir1" ] || [ ! -d "$dir2" ]; then
 echo "One or both diagnostics not found"
 return 1
 fi
 
 echo "=== Diagnostic Comparison ==="
 echo "ID1: $id1"
 echo "ID2: $id2"
 echo ""
 
 echo "Basic Resolution Comparison:"
 diff $dir1/basic_resolution.txt $dir2/basic_resolution.txt
 echo ""
 
 echo "A Record Comparison:"
 diff $dir1/A_record.txt $dir2/A_record.txt
}

# 列出诊断
list_diagnostics() {
 echo "=== Available Diagnostics ==="
 
 for dir in $DIAGNOSTIC_DB/*/; do
 if [ -d "$dir" ]; then
 local id=$(basename $dir)
 local domain=$(grep domain $dir/metadata.txt | cut -d= -f2)
 local timestamp=$(grep timestamp $dir/metadata.txt | cut -d= -f2)
 
 echo "ID: $id"
 echo "Domain: $domain"
 echo "Time: $timestamp"
 echo ""
 fi
 done
}

# 主函数
main() {
 case "$1" in
 diagnose)
 perform_diagnostic
 ;;
 analyze)
 analyze_diagnostic "$2"
 ;;
 compare)
 compare_diagnostics "$2" "$3"
 ;;
 list)
 list_diagnostics
 ;;
 *)
 echo "Usage: $0 {diagnose|analyze|compare|list}"
 exit 1
 ;;
 esac
}

main "$@"

最佳实践#

使用多个 DNS 服务器：使用多个 DNS 服务器进行对比验证
设置合理的超时：根据网络环境设置合适的超时时间
记录基线：建立 DNS 解析基线，便于比较变化
监控 DNS 变化：定期检查 DNS 记录变化
测试不同记录类型：测试多种 DNS 记录类型
使用 dig 替代：在新版本系统中，考虑使用 dig 命令
记录日志：记录重要的 DNS 查询和变化
自动化监控：编写脚本实现自动化 DNS 监控

注意事项#

nslookup 在某些系统中已被弃用，建议使用 dig 命令
DNS 查询结果可能被缓存，不总是反映最新配置
不同 DNS 服务器可能返回不同的结果
某些 DNS 记录类型可能不被所有服务器支持
注意 DNS 传播延迟，新记录可能需要时间生效
在生产环境中诊断时要谨慎，避免影响服务
注意隐私保护，不要查询不明来源的域名
某些网络可能阻止 DNS 查询或使用自定义 DNS 服务器
对于关键业务，建议使用专业的 DNS 监控工具

ip 命令详解

Mon, 01 Jan 0001 00:00:00 +0000

ip 命令详解#

ip 是 Linux 系统中用于配置和显示网络接口、路由、隧道等网络信息的现代命令行工具。它是 ifconfig、route 等传统命令的替代品，功能更强大、更灵活，是现代 Linux 系统网络管理的标准工具。

入门#

基本用法#

# 显示所有网络接口
ip link show

# 显示特定接口信息
ip link show eth0

# 显示接口的 IP 地址
ip addr show

# 显示路由表
ip route show

# 启用网络接口
ip link set eth0 up

# 禁用网络接口
ip link set eth0 down

常用子命令#

子命令	说明
`link`	配置网络接口
`addr`	配置 IP 地址
`route`	配置路由表
`neigh`	管理邻居表（ARP 表）
`tunnel`	配置隧道
`maddr`	管理多播地址
`mroute`	管理多播路由

基本示例#

# 查看所有网络接口
ip link show

# 输出示例：
# 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
# link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
# 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
# link/ether 00:11:22:33:44:55 brd ff:ff:ff:ff:ff:ff

# 查看接口 IP 地址
ip addr show eth0

# 查看路由表
ip route show

中级#

网络接口配置#

# 启用接口
ip link set eth0 up

# 禁用接口
ip link set eth0 down

# 设置接口 MTU
ip link set eth0 mtu 9000

# 修改 MAC 地址
ip link set eth0 address 00:11:22:33:44:55

# 启用混杂模式
ip link set eth0 promisc on

# 禁用混杂模式
ip link set eth0 promisc off

# 设置接口别名
ip link set eth0 name newname

IP 地址管理#

# 添加 IP 地址
ip addr add 192.168.1.100/24 dev eth0

# 添加多个 IP 地址
ip addr add 192.168.1.100/24 dev eth0
ip addr add 192.168.1.101/24 dev eth0

# 删除 IP 地址
ip addr del 192.168.1.100/24 dev eth0

# 查看特定接口的 IP 地址
ip addr show eth0

# 刷新接口的所有 IP 地址
ip addr flush dev eth0

# 添加 IPv6 地址
ip -6 addr add 2001:db8::1/64 dev eth0

路由管理#

# 添加默认路由
ip route add default via 192.168.1.1

# 添加特定路由
ip route add 192.168.2.0/24 via 192.168.1.1

# 添加带设备的路由
ip route add 192.168.2.0/24 dev eth0

# 删除路由
ip route del 192.168.2.0/24 via 192.168.1.1

# 查看路由表
ip route show

# 查看特定路由
ip route get 8.8.8.8

# 清空路由表
ip route flush table main

高级#

高级接口配置#

# 创建虚拟接口
ip link add link eth0 name eth0.10 type vlan id 10
ip link set eth0.10 up

# 创建网桥
ip link add name br0 type bridge
ip link set br0 up

# 将接口添加到网桥
ip link set eth0 master br0

# 从网桥移除接口
ip link set eth0 nomaster

# 创建 veth 对
ip link add veth0 type veth peer name veth1
ip link set veth0 up
ip link set veth1 up

# 删除接口
ip link delete veth0

高级路由配置#

# 添加带优先级的路由
ip route add 192.168.2.0/24 via 192.168.1.1 metric 100

# 添加带表的路由
ip route add 192.168.2.0/24 via 192.168.1.1 table custom

# 查看所有路由表
ip route show table all

# 添加策略路由
ip rule add from 192.168.1.100 table custom

# 查看策略路由
ip rule show

# 删除策略路由
ip rule del from 192.168.1.100 table custom

# 添加多路径路由
ip route add default nexthop via 192.168.1.1 weight 1 nexthop via 192.168.1.2 weight 1

邻居表管理#

# 查看邻居表（ARP 表）
ip neigh show

# 添加静态邻居条目
ip neigh add 192.168.1.1 lladdr 00:11:22:33:44:55 dev eth0

# 删除邻居条目
ip neigh del 192.168.1.1 dev eth0

# 刷新邻居表
ip neigh flush dev eth0

# 查看特定接口的邻居表
ip neigh show dev eth0

# 查看邻居表详细信息
ip neigh show nud reachable

大师#

网络接口监控#

#!/bin/bash
# 网络接口监控脚本

INTERFACE="eth0"
LOG_FILE="interface_monitor.log"

# 监控接口状态
monitor_interface() {
 while true; do
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 
 RX_BYTES=$(ip -s link show $INTERFACE | awk '/RX:/ {getline; print $1}')
 TX_BYTES=$(ip -s link show $INTERFACE | awk '/TX:/ {getline; print $1}')
 
 echo "$TIMESTAMP - RX: $RX_BYTES bytes, TX: $TX_BYTES bytes" >> $LOG_FILE
 
 sleep 60
 done
}

# 监控接口状态变化
monitor_interface_status() {
 local last_state=""
 
 while true; do
 local current_state=$(ip link show $INTERFACE | grep -o "state [A-Z]*" | cut -d' ' -f2)
 
 if [ "$current_state" != "$last_state" ]; then
 TIMESTAMP=$(date "+%Y-%m-%d %H:%M:%S")
 echo "$TIMESTAMP - Interface $INTERFACE state changed: $last_state -> $current_state" >> $LOG_FILE
 last_state=$current_state
 fi
 
 sleep 10
 done
}

# 主函数
main() {
 case "$1" in
 monitor)
 monitor_interface
 ;;
 status)
 monitor_interface_status
 ;;
 *)
 echo "Usage: $0 {monitor|status}"
 exit 1
 ;;
 esac
}

main "$@"

网络配置备份与恢复#

#!/bin/bash
# 网络配置备份与恢复脚本

BACKUP_DIR="/etc/network/backups"
mkdir -p $BACKUP_DIR

# 备份网络配置
backup_config() {
 local timestamp=$(date +%Y%m%d_%H%M%S)
 local backup_file="$BACKUP_DIR/network_config_$timestamp.sh"
 
 echo "# Network Configuration Backup - $timestamp" > $backup_file
 echo "# Generated on $(date)" >> $backup_file
 echo "" >> $backup_file
 
 # 备份接口配置
 ip link show | grep -E "^[0-9]+:" | while read line; do
 local interface=$(echo $line | awk '{print $2}' | cut -d: -f1)
 local state=$(echo $line | grep -o "state [A-Z]*" | cut -d' ' -f2)
 
 echo "# Interface: $interface" >> $backup_file
 echo "ip link set $interface $([[ "$state" == "UP" ]] && echo "up" || echo "down")" >> $backup_file
 
 # 备份 IP 地址
 ip addr show $interface 2>/dev/null | grep "inet " | while read addr_line; do
 local ip_addr=$(echo $addr_line | awk '{print $2}')
 echo "ip addr add $ip_addr dev $interface" >> $backup_file
 done
 
 echo "" >> $backup_file
 done
 
 # 备份路由配置
 echo "# Routes" >> $backup_file
 ip route show | while read route; do
 echo "ip route add $route" >> $backup_file
 done
 
 echo "Backup saved to: $backup_file"
}

# 恢复网络配置
restore_config() {
 local backup_file=$1
 
 if [ ! -f "$backup_file" ]; then
 echo "Backup file not found: $backup_file"
 return 1
 fi
 
 echo "Restoring network configuration from $backup_file..."
 
 # 先禁用所有接口
 ip link show | grep -E "^[0-9]+:" | awk '{print $2}' | cut -d: -f1 | while read interface; do
 if [ "$interface" != "lo" ]; then
 ip link set $interface down
 fi
 done
 
 # 执行备份脚本
 bash $backup_file
 
 echo "Network configuration restored"
}

# 列出备份
list_backups() {
 echo "Available backups:"
 ls -lh $BACKUP_DIR/
}

# 主函数
main() {
 case "$1" in
 backup)
 backup_config
 ;;
 restore)
 restore_config "$2"
 ;;
 list)
 list_backups
 ;;
 *)
 echo "Usage: $0 {backup|restore|list}"
 exit 1
 ;;
 esac
}

main "$@"

网络性能优化#

#!/bin/bash
# 网络性能优化脚本

optimize_interface() {
 local interface=$1
 
 echo "Optimizing interface: $interface"
 
 # 设置 MTU
 ip link set $interface mtu 9000
 
 # 启用 GRO（Generic Receive Offload）
 ethtool -K $interface gro on 2>/dev/null
 
 # 启用 GSO（Generic Segmentation Offload）
 ethtool -K $interface gso on 2>/dev/null
 
 # 启用 TSO（TCP Segmentation Offload）
 ethtool -K $interface tso on 2>/dev/null
 
 # 调整队列长度
 ip link set $interface txqueuelen 10000
 
 echo "Interface $interface optimized"
}

# 优化系统网络参数
optimize_system_params() {
 echo "Optimizing system network parameters..."
 
 # 启用 TCP 窗口缩放
 sysctl -w net.ipv4.tcp_window_scaling=1
 
 # 调整 TCP 缓冲区大小
 sysctl -w net.core.rmem_max=16777216
 sysctl -w net.core.wmem_max=16777216
 sysctl -w net.ipv4.tcp_rmem="4096 87380 16777216"
 sysctl -w net.ipv4.tcp_wmem="4096 65536 16777216"
 
 # 启用 TCP 快速打开
 sysctl -w net.ipv4.tcp_fastopen=3
 
 # 禁用 TCP 时间戳
 sysctl -w net.ipv4.tcp_timestamps=0
 
 echo "System network parameters optimized"
}

# 恢复默认设置
restore_defaults() {
 local interface=$1
 
 echo "Restoring defaults for interface: $interface"
 
 ip link set $interface mtu 1500
 ip link set $interface txqueuelen 1000
 
 echo "Defaults restored for $interface"
}

# 主函数
main() {
 case "$1" in
 optimize)
 optimize_interface "$2"
 optimize_system_params
 ;;
 restore)
 restore_defaults "$2"
 ;;
 *)
 echo "Usage: $0 {optimize|restore}"
 exit 1
 ;;
 esac
}

main "$@"

无敌#

企业级网络管理系统#

#!/bin/bash
# 企业级网络管理系统

CONFIG_FILE="/etc/network_manager/config.conf"
LOG_DIR="/var/log/network_manager"
STATE_DIR="/var/run/network_manager"

mkdir -p $LOG_DIR $STATE_DIR

# 加载配置
source $CONFIG_FILE

# 初始化接口
init_interface() {
 local interface=$1
 local config_file="$STATE_DIR/${interface}.conf"
 
 if [ -f "$config_file" ]; then
 source $config_file
 
 # 配置接口
 ip link set $interface up
 
 if [ -n "$IP_ADDR" ]; then
 ip addr add $IP_ADDR dev $interface
 fi
 
 if [ -n "$MTU" ]; then
 ip link set $interface mtu $MTU
 fi
 
 echo "Interface $interface initialized"
 fi
}

# 监控接口状态
monitor_interface() {
 local interface=$1
 local state_file="$STATE_DIR/${interface}.state"
 
 while true; do
 local current_state=$(ip link show $interface 2>/dev/null | grep -o "state [A-Z]*" | cut -d' ' -f2)
 
 if [ -n "$current_state" ]; then
 echo "$current_state" > $state_file
 fi
 
 sleep $MONITOR_INTERVAL
 done
}

# 故障恢复
failover_recovery() {
 local primary=$1
 local secondary=$2
 
 local primary_state=$(cat "$STATE_DIR/${primary}.state" 2>/dev/null)
 
 if [ "$primary_state" != "UP" ]; then
 echo "Primary interface $primary is down, switching to $secondary"
 
 # 激活备用接口
 ip link set $secondary up
 
 # 更新路由
 ip route replace default via $SECONDARY_GW dev $secondary
 fi
}

# 主程序
main() {
 # 初始化所有接口
 for interface in "${MANAGED_INTERFACES[@]}"; do
 init_interface $interface
 monitor_interface $interface &
 done
 
 # 故障监控
 while true; do
 failover_recovery $PRIMARY_INTERFACE $SECONDARY_INTERFACE
 sleep $FAILOVER_CHECK_INTERVAL
 done
}

main

智能网络配置系统#

#!/bin/bash
# 智能网络配置系统

CONFIG_DIR="/etc/smart_network"
LOG_FILE="/var/log/smart_network.log"

mkdir -p $CONFIG_DIR

# 检测网络环境
detect_network_environment() {
 echo "Detecting network environment..."
 
 # 检测网关
 local gateway=$(ip route | grep default | awk '{print $3}')
 echo "Gateway: $gateway" >> $LOG_FILE
 
 # 检测 DNS
 local dns=$(grep nameserver /etc/resolv.conf | head -1 | awk '{print $2}')
 echo "DNS: $dns" >> $LOG_FILE
 
 # 检测网络类型
 if ping -c 1 -W 2 $gateway > /dev/null 2>&1; then
 echo "Network type: Wired" >> $LOG_FILE
 else
 echo "Network type: Wireless" >> $LOG_FILE
 fi
}

# 自动配置网络
auto_configure_network() {
 local interface=$1
 
 echo "Auto-configuring network for $interface..."
 
 # 检测网络环境
 detect_network_environment
 
 # 应用配置
 local config_file="$CONFIG_DIR/${interface}.conf"
 
 if [ -f "$config_file" ]; then
 source $config_file
 
 # 配置 IP 地址
 if [ -n "$IP_ADDR" ]; then
 ip addr add $IP_ADDR dev $interface
 fi
 
 # 配置路由
 if [ -n "$GATEWAY" ]; then
 ip route add default via $GATEWAY
 fi
 
 # 配置 DNS
 if [ -n "$DNS_SERVERS" ]; then
 echo "nameserver $DNS_SERVERS" > /etc/resolv.conf
 fi
 
 echo "Network auto-configuration completed"
 else
 echo "Configuration file not found: $config_file"
 fi
}

# 网络健康检查
network_health_check() {
 local interface=$1
 
 echo "Performing network health check..."
 
 # 检查接口状态
 local state=$(ip link show $interface | grep -o "state [A-Z]*" | cut -d' ' -f2)
 echo "Interface state: $state"
 
 # 检查 IP 地址
 local ip_addr=$(ip addr show $interface | grep "inet " | awk '{print $2}')
 echo "IP address: $ip_addr"
 
 # 检查连通性
 local gateway=$(ip route | grep default | awk '{print $3}')
 if ping -c 1 -W 2 $gateway > /dev/null 2>&1; then
 echo "Gateway connectivity: OK"
 else
 echo "Gateway connectivity: FAILED"
 fi
 
 # 检查 DNS
 local dns=$(grep nameserver /etc/resolv.conf | head -1 | awk '{print $2}')
 if ping -c 1 -W 2 $dns > /dev/null 2>&1; then
 echo "DNS connectivity: OK"
 else
 echo "DNS connectivity: FAILED"
 fi
}

# 主函数
main() {
 case "$1" in
 detect)
 detect_network_environment
 ;;
 configure)
 auto_configure_network "$2"
 ;;
 health)
 network_health_check "$2"
 ;;
 *)
 echo "Usage: $0 {detect|configure|health}"
 exit 1
 ;;
 esac
}

main "$@"

网络故障诊断系统#

#!/bin/bash
# 网络故障诊断系统

DIAGNOSTIC_LOG="/tmp/network_diagnostic_$(date +%Y%m%d_%H%M%S).log"

# 诊断网络接口
diagnose_interfaces() {
 echo "=== Network Interface Diagnosis ===" >> $DIAGNOSTIC_LOG
 
 ip link show >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
 
 ip addr show >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
}

# 诊断路由
diagnose_routes() {
 echo "=== Route Diagnosis ===" >> $DIAGNOSTIC_LOG
 
 ip route show >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
 
 ip route get 8.8.8.8 >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
}

# 诊断邻居表
diagnose_neighbors() {
 echo "=== Neighbor Table Diagnosis ===" >> $DIAGNOSTIC_LOG
 
 ip neigh show >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
}

# 诊断特定问题
diagnose_specific_issue() {
 local issue=$1
 
 case $issue in
 "no_internet")
 echo "=== Diagnosing No Internet Access ===" >> $DIAGNOSTIC_LOG
 
 # 检查接口状态
 ip link show | grep -v "state DOWN" >> $DIAGNOSTIC_LOG
 
 # 检查路由
 ip route show default >> $DIAGNOSTIC_LOG
 
 # 检查 DNS
 cat /etc/resolv.conf >> $DIAGNOSTIC_LOG
 ;;
 "slow_network")
 echo "=== Diagnosing Slow Network ===" >> $DIAGNOSTIC_LOG
 
 # 检查接口统计
 ip -s link show >> $DIAGNOSTIC_LOG
 
 # 检查 MTU
 ip link show | grep mtu >> $DIAGNOSTIC_LOG
 ;;
 "ip_conflict")
 echo "=== Diagnosing IP Conflict ===" >> $DIAGNOSTIC_LOG
 
 # 检查邻居表
 ip neigh show nud reachable >> $DIAGNOSTIC_LOG
 
 # 检查重复 IP
 arping -c 2 $(ip addr show | grep "inet " | head -1 | awk '{print $2}' | cut -d/ -f1) >> $DIAGNOSTIC_LOG 2>&1
 ;;
 *)
 echo "Unknown issue: $issue" >> $DIAGNOSTIC_LOG
 ;;
 esac
}

# 生成诊断报告
generate_diagnostic_report() {
 echo "Network Diagnostic Report - $(date)" > $DIAGNOSTIC_LOG
 echo "================================" >> $DIAGNOSTIC_LOG
 echo "" >> $DIAGNOSTIC_LOG
 
 diagnose_interfaces
 diagnose_routes
 diagnose_neighbors
 
 if [ -n "$1" ]; then
 diagnose_specific_issue "$1"
 fi
 
 echo -e "\nDiagnostic completed. Log saved to: $DIAGNOSTIC_LOG"
}

# 主函数
main() {
 generate_diagnostic_report "$1"
}

main "$@"

最佳实践#

使用 ip 命令替代传统工具：优先使用 ip 命令替代 ifconfig、route 等
配置持久化：使用网络配置文件使配置持久化
备份配置：在进行重要配置更改前，先备份当前配置
监控接口状态：定期监控网络接口状态，及时发现和解决问题
合理设置 MTU：根据网络环境设置合适的 MTU 值
使用策略路由：在复杂网络环境中使用策略路由
记录日志：记录重要的配置更改和事件，便于故障排查
测试配置：在生产环境应用配置前，先在测试环境验证

注意事项#

ip 命令的配置在重启后会丢失，需要使用配置文件持久化
修改网络接口配置可能导致网络连接中断
在远程服务器上修改网络配置时要格外小心
某些网络配置更改需要 root 权限
不同 Linux 发行版的网络配置文件位置可能不同
注意网络安全策略，避免违反组织规定
在高可用环境中，注意网络配置的一致性
对于关键业务，建议使用专业的网络管理工具