Compare commits

...

3 Commits

24 changed files with 3898 additions and 0 deletions

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
.idea/

6
src/metric/.gitignore vendored Normal file
View File

@ -0,0 +1,6 @@
/prometheus/data/
/client-plugins/dcgm-exporter-installer/
/client-plugins/demo-all-in-one/artifact/
/client-plugins/demo-all-in-one/publish/
/client-plugins/demo-all-in-one/checklist
/client-plugins/demo-all-in-one/VERSION

View File

@ -0,0 +1 @@
1.29.0

View File

@ -0,0 +1,3 @@
# 组件名称 目录路径 版本号 [依赖组件] [安装顺序]
dcgm-exporter-installer /Users/sundapeng/Project/nlp/aiops/client-plugins/dcgm-exporter-installer 1.1.0
node-exporter-installer /Users/sundapeng/Project/nlp/aiops/client-plugins/node-exporter-installer 1.1.0

View File

@ -0,0 +1,61 @@
# 客户侧组件安装包构建、发布流程
## 第一步:配置版本和组件
首先搞定配置文件:
1. 把 `.checklist.example` 重命名成 `checklist`
2. 把 `.VERSION.example` 重命名成 `VERSION`
### checklist 文件格式
```
# 组件名称 目录路径 版本号 [依赖组件] [安装顺序]
dcgm-exporter-installer /path/to/dcgm-exporter-installer 1.1.0
node-exporter-installer /path/to/node-exporter-installer 1.1.0
```
### VERSION 文件
设置需要发布的版本号,比如 `1.29.0`
> 建议用 `version-manager.sh` 来管理版本
## 第二步:构建安装包
直接跑脚本:
```bash
./package_artifact.sh
```
构建完的东西会放在 `artifact/` 目录下,按版本分文件夹。
如果版本已经存在了,想要覆盖重新构建:
```bash
./package_artifact.sh --force
```
构建完可以手工测试安装包。
## 第三步:发布安装包
用这个脚本发布:
```bash
./publish_artifact.sh
```
发布后的内容在 `publish/` 目录里,包含:
- 压缩版本的安装包
- 一键安装的bash脚本
## 第四步部署到FTP服务器详见 FTP 搭建)
把发布的内容上传到FTP服务器客户端就可以通过一键命令安装
```bash
curl -u user:passwd ftp://server_ip/setup.sh -o setup.sh
chmod +x setup.sh
sudo ./setup.sh --server server_ip --user user --password passwd
```
这样客户就能直接从FTP服务器下载并安装组件了。

View File

@ -0,0 +1,204 @@
#!/bin/bash
# 整体健康检查脚本,调用各个组件的健康检查并将结果写入 .health_log 文件
set -e
# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
HEALTH_LOG_FILE="$SCRIPT_DIR/.health_log"
INSTALL_RECORD_FILE="$SCRIPT_DIR/.install_record"
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数 - 输出到 stderr 避免影响 JSON 结果
log_info() {
echo -e "${BLUE}[INFO]${NC} $1" >&2
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1" >&2
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1" >&2
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1" >&2
}
# 检查单个组件健康状态
check_component() {
local component_name="$1"
local check_script_path="$2"
log_info "检查 $component_name 健康状态..."
if [[ ! -f "$check_script_path" ]]; then
log_error "健康检查脚本不存在: $check_script_path"
echo "{\"name\": \"$component_name\", \"status\": \"unhealth\", \"reason\": \"健康检查脚本不存在: $check_script_path\"}"
return 1
fi
if [[ ! -x "$check_script_path" ]]; then
log_error "健康检查脚本无执行权限: $check_script_path"
echo "{\"name\": \"$component_name\", \"status\": \"unhealth\", \"reason\": \"健康检查脚本无执行权限: $check_script_path\"}"
return 1
fi
# 执行健康检查脚本,只捕获 stdoutstderr 输出到终端
local result
if result=$("$check_script_path" 2>/dev/null); then
log_success "$component_name 健康检查通过"
echo "$result"
return 0
else
log_warning "$component_name 健康检查失败"
echo "$result"
return 1
fi
}
# 生成时间戳
get_timestamp() {
date '+%Y-%m-%d %H:%M:%S'
}
# 从安装记录文件中读取组件安装目录
read_install_record() {
local install_record_file="$1"
if [[ ! -f "$install_record_file" ]]; then
log_error "安装记录文件不存在: $install_record_file"
return 1
fi
# 检查是否有 jq 命令来解析 JSON
if command -v jq &> /dev/null; then
# 使用 jq 解析 JSON
local components_json
if components_json=$(jq -r '.components | to_entries[] | "\(.key):\(.value.install_dir)"' "$install_record_file" 2>/dev/null); then
echo "$components_json"
return 0
else
log_error "无法解析安装记录文件 JSON 格式: $install_record_file"
return 1
fi
else
# 如果没有 jq尝试简单的文本解析
log_warning "jq 命令不可用,尝试简单文本解析"
# 查找所有 install_dir 行
local components=()
while IFS= read -r line; do
if [[ "$line" =~ \"install_dir\":[[:space:]]*\"([^\"]+)\" ]]; then
local install_dir="${BASH_REMATCH[1]}"
# 从路径中提取组件名称
local component_name=$(basename "$install_dir")
components+=("$component_name:$install_dir")
fi
done < "$install_record_file"
if [[ ${#components[@]} -gt 0 ]]; then
printf '%s\n' "${components[@]}"
return 0
else
log_error "无法从安装记录文件中提取组件信息"
return 1
fi
fi
}
# 主函数
main() {
echo "==========================================" >&2
echo " 整体健康检查脚本" >&2
echo "==========================================" >&2
echo >&2
# 记录健康检查开始时间
local start_time=$(get_timestamp)
log_info "健康检查开始时间: $start_time"
# 从安装记录文件中读取组件信息
log_info "从安装记录文件读取组件信息: $INSTALL_RECORD_FILE"
local components_info
if ! components_info=$(read_install_record "$INSTALL_RECORD_FILE"); then
log_error "无法读取安装记录文件,健康检查终止"
exit 1
fi
# 存储所有检查结果
local all_results=()
local overall_status="health"
# 逐个检查组件
while IFS= read -r component_info; do
if [[ -n "$component_info" ]]; then
IFS=':' read -r component_name install_dir <<< "$component_info"
local check_script_path="$install_dir/check_health.sh"
local result
if result=$(check_component "$component_name" "$check_script_path"); then
all_results+=("$result")
else
all_results+=("$result")
overall_status="unhealth"
fi
fi
done <<< "$components_info"
# 记录健康检查结束时间
local end_time=$(get_timestamp)
log_info "健康检查结束时间: $end_time"
# 构建完整的健康检查结果 JSON
local health_check_result=$(cat << EOF
{
"start_time": "$start_time",
"end_time": "$end_time",
"overall_status": "$overall_status",
"components": [
$(printf '%s,\n' "${all_results[@]}" | sed '$s/,$//')
]
}
EOF
)
# 写入健康日志文件
log_info "将健康检查结果写入日志文件: $HEALTH_LOG_FILE"
echo "$health_check_result" >> "$HEALTH_LOG_FILE"
# 输出 JSON 结果到 stdout
echo "$health_check_result"
# 显示总结到 stderr
echo >&2
echo "==========================================" >&2
echo " 健康检查总结" >&2
echo "==========================================" >&2
echo "开始时间: $start_time" >&2
echo "结束时间: $end_time" >&2
echo "整体状态: $overall_status" >&2
echo "日志文件: $HEALTH_LOG_FILE" >&2
echo >&2
if [[ "$overall_status" == "health" ]]; then
log_success "所有组件健康检查通过!"
exit 0
else
log_error "部分组件健康检查失败,请查看上述详细信息"
exit 1
fi
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,683 @@
#!/bin/bash
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 配置变量
INSTALL_DIR="${1:-$(pwd)}" # 使用第一个参数作为安装目录,如果没有参数则使用当前目录
TEMP_DIR="/tmp/metrics-install-$$"
VERSION_FILE="version.json"
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本需要 root 权限运行"
log_info "请使用: sudo $0 [安装目录]"
log_info "如果不指定安装目录,将使用当前目录: $(pwd)"
exit 1
fi
}
# 检查系统要求
check_system() {
log_info "检查系统要求..."
# 检查操作系统
if [[ ! -f /etc/os-release ]]; then
log_error "无法检测操作系统版本"
exit 1
fi
source /etc/os-release
log_info "检测到操作系统: $NAME $VERSION"
# 检查系统架构
arch=$(uname -m)
log_info "系统架构: $arch"
# 检查磁盘空间
available_space=$(df / | awk 'NR==2 {print $4}')
if [[ $available_space -lt 10485760 ]]; then # 10GB in KB
log_warning "可用磁盘空间不足 10GB当前可用: $(($available_space / 1024 / 1024))GB"
fi
# 检查内存
total_mem=$(free -m | awk 'NR==2{print $2}')
if [[ $total_mem -lt 4096 ]]; then # 4GB
log_warning "系统内存不足 4GB当前: ${total_mem}MB"
fi
}
# 查找版本文件
find_version_file() {
log_info "查找版本信息文件..."
# 在当前目录查找
if [[ -f "$VERSION_FILE" ]]; then
VERSION_FILE_PATH="$VERSION_FILE"
log_success "找到版本文件: $VERSION_FILE"
return 0
fi
# 在 artifact 目录查找
for version_dir in artifact/*/; do
if [[ -f "${version_dir}${VERSION_FILE}" ]]; then
VERSION_FILE_PATH="${version_dir}${VERSION_FILE}"
log_success "找到版本文件: $VERSION_FILE_PATH"
return 0
fi
done
log_error "未找到版本信息文件 $VERSION_FILE"
exit 1
}
# 解析版本信息
parse_version_info() {
log_info "解析版本信息..."
if [[ ! -f "$VERSION_FILE_PATH" ]]; then
log_error "版本文件不存在: $VERSION_FILE_PATH"
exit 1
fi
# 使用 jq 解析 JSON如果可用
if command -v jq &> /dev/null; then
# 验证JSON文件格式
if ! jq empty "$VERSION_FILE_PATH" 2>/dev/null; then
log_error "JSON文件格式错误请检查 $VERSION_FILE_PATH"
exit 1
fi
VERSION=$(jq -r '.version' "$VERSION_FILE_PATH")
BUILD_TIME=$(jq -r '.build_time' "$VERSION_FILE_PATH")
# 解析 artifact_list
if jq -e '.artifact_list' "$VERSION_FILE_PATH" > /dev/null 2>&1; then
jq -r '.artifact_list | to_entries[] | "\(.key):\(.value)"' "$VERSION_FILE_PATH" > "$TEMP_DIR/components.txt"
else
log_error "version.json 中缺少 artifact_list 字段"
exit 1
fi
# 解析 checksums
if jq -e '.checksums' "$VERSION_FILE_PATH" > /dev/null 2>&1; then
jq -r '.checksums | to_entries[] | "\(.key):\(.value)"' "$VERSION_FILE_PATH" > "$TEMP_DIR/checksums.txt"
else
log_error "version.json 中缺少 checksums 字段"
exit 1
fi
# 解析 install_order现在包含完整的文件名
if jq -e '.install_order' "$VERSION_FILE_PATH" > /dev/null 2>&1; then
jq -r '.install_order[]' "$VERSION_FILE_PATH" > "$TEMP_DIR/install_order.txt"
else
log_error "version.json 中缺少 install_order 字段"
exit 1
fi
else
log_warning "jq 未安装,使用简单的 JSON 解析"
# 简单的 JSON 解析
VERSION=$(grep '"version"' "$VERSION_FILE_PATH" | sed 's/.*"version": *"\([^"]*\)".*/\1/')
BUILD_TIME=$(grep '"build_time"' "$VERSION_FILE_PATH" | sed 's/.*"build_time": *"\([^"]*\)".*/\1/')
# 解析 artifact_list
grep -A 100 '"artifact_list"' "$VERSION_FILE_PATH" | grep -E '^\s*"[^"]+":\s*"[^"]+"' | while read line; do
component=$(echo "$line" | sed 's/.*"\([^"]*\)":\s*"[^"]*".*/\1/')
version=$(echo "$line" | sed 's/.*"[^"]*":\s*"\([^"]*\)".*/\1/')
echo "$component:$version" >> "$TEMP_DIR/components.txt"
done
# 解析 checksums
grep -A 100 '"checksums"' "$VERSION_FILE_PATH" | grep -E '^\s*"[^"]+":\s*"[^"]+"' | while read line; do
component=$(echo "$line" | sed 's/.*"\([^"]*\)":\s*"[^"]*".*/\1/')
checksum=$(echo "$line" | sed 's/.*"[^"]*":\s*"\([^"]*\)".*/\1/')
echo "$component:$checksum" >> "$TEMP_DIR/checksums.txt"
done
# 解析 install_order
grep -A 100 '"install_order"' "$VERSION_FILE_PATH" | grep -E '^\s*"[^"]+"' | while read line; do
component=$(echo "$line" | sed 's/.*"\([^"]*\)".*/\1/')
echo "$component" >> "$TEMP_DIR/install_order.txt"
done
# 验证解析结果
if [[ ! -f "$TEMP_DIR/components.txt" || ! -s "$TEMP_DIR/components.txt" ]]; then
log_error "无法解析 artifact_list请检查 version.json 格式"
exit 1
fi
if [[ ! -f "$TEMP_DIR/checksums.txt" || ! -s "$TEMP_DIR/checksums.txt" ]]; then
log_error "无法解析 checksums请检查 version.json 格式"
exit 1
fi
if [[ ! -f "$TEMP_DIR/install_order.txt" || ! -s "$TEMP_DIR/install_order.txt" ]]; then
log_error "无法解析 install_order请检查 version.json 格式"
exit 1
fi
fi
log_success "版本信息解析完成"
log_info " 版本: $VERSION"
log_info " 构建时间: $BUILD_TIME"
component_count=0
if [[ -f "$TEMP_DIR/components.txt" ]]; then
component_count=$(wc -l < "$TEMP_DIR/components.txt")
log_info " 组件数量: $component_count"
log_info " 组件列表:"
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
version=$(echo "$line" | cut -d':' -f2)
log_info " - $component v$version"
done < "$TEMP_DIR/components.txt"
else
log_error "components.txt 文件不存在"
exit 1
fi
}
# 验证文件完整性
verify_checksums() {
log_info "验证文件完整性..."
artifact_dir=$(dirname "$VERSION_FILE_PATH")
failed_verification=0
if [[ -f "$TEMP_DIR/checksums.txt" ]]; then
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
expected_checksum=$(echo "$line" | cut -d':' -f2-)
# 查找匹配的 tar 文件
actual_file=""
for file in "$artifact_dir/${component}-"*.tar.gz; do
if [[ -f "$file" ]]; then
actual_file="$file"
break
fi
done
if [[ -z "$actual_file" ]]; then
log_error "找不到组件文件: $component"
failed_verification=1
continue
fi
# 计算实际校验和
actual_checksum="sha256:$(sha256sum "$actual_file" | cut -d' ' -f1)"
if [[ "$actual_checksum" == "$expected_checksum" ]]; then
log_success " $component: 校验通过"
else
log_error " $component: 校验失败"
log_error " 期望: $expected_checksum"
log_error " 实际: $actual_checksum"
failed_verification=1
fi
done < "$TEMP_DIR/checksums.txt"
fi
if [[ $failed_verification -eq 1 ]]; then
log_error "文件完整性验证失败"
exit 1
fi
log_success "所有文件校验通过"
}
# 创建安装目录
create_install_dirs() {
log_info "创建安装目录..."
mkdir -p "$INSTALL_DIR"
mkdir -p "$TEMP_DIR"
log_success "安装目录创建完成: $INSTALL_DIR"
}
# 安装系统依赖包
install_system_deps() {
log_info "检查系统依赖包..."
local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
local deps_dir="$script_dir/deps"
# 检查deps目录是否存在
if [[ ! -d "$deps_dir" ]]; then
log_info "deps 目录不存在,跳过系统依赖包安装"
return 0
fi
# 检查是否有tar.gz文件
local deps_count=$(find "$deps_dir" -name "*.tar.gz" | wc -l)
if [[ $deps_count -eq 0 ]]; then
log_info "deps 目录中没有 tar.gz 文件,跳过系统依赖包安装"
return 0
fi
log_info "找到 $deps_count 个系统依赖包,开始安装..."
# 创建临时目录用于解压依赖包
local deps_temp_dir="$TEMP_DIR/deps"
mkdir -p "$deps_temp_dir"
# 处理每个tar.gz文件
find "$deps_dir" -name "*.tar.gz" | while read tar_file; do
local tar_basename=$(basename "$tar_file")
local extract_name="${tar_basename%.tar.gz}"
log_info "处理依赖包: $tar_basename"
# 解压到临时目录
local extract_dir="$deps_temp_dir/$extract_name"
mkdir -p "$extract_dir"
if tar -xzf "$tar_file" -C "$extract_dir" 2>/dev/null; then
log_success " $tar_basename 解压完成"
else
log_error " $tar_basename 解压失败"
continue
fi
# 进入解压目录查找deb包
cd "$extract_dir"
local deb_count=$(find . -name "*.deb" | wc -l)
if [[ $deb_count -gt 0 ]]; then
log_info " 找到 $deb_count 个 deb 包,开始安装..."
# 1. 先尝试安装所有deb包
log_info " 第1步批量安装deb包..."
if dpkg -i *.deb 2>/dev/null; then
log_success " 所有deb包安装成功"
else
log_warning " 部分deb包安装失败可能存在依赖问题"
# 2. 使用apt-get修复依赖
log_info " 第2步修复依赖关系..."
if apt-get install -f -y; then
log_success " 依赖关系修复完成"
else
log_error " 依赖关系修复失败"
# 继续处理其他包,不退出
fi
fi
else
log_info " $tar_basename 中没有找到deb包跳过"
fi
# 返回到依赖临时目录
cd "$deps_temp_dir"
done
# 检查并启动 cron 服务
start_cron_service
log_success "系统依赖包安装完成"
}
# 启动 cron 服务
start_cron_service() {
log_info "检查并启动 cron 服务..."
# 检查 cron 是否已经在运行
if pgrep -x "cron" > /dev/null; then
log_success "cron 服务已在运行"
return 0
fi
# 检查 /usr/sbin/cron 是否存在
if [[ ! -f "/usr/sbin/cron" ]]; then
log_warning "cron 可执行文件不存在,跳过启动"
return 1
fi
# 启动 cron 服务
log_info "启动 cron 服务..."
if /usr/sbin/cron start 2>/dev/null || /usr/sbin/cron 2>/dev/null; then
log_success "cron 服务启动成功"
sleep 2
if pgrep -x "cron" > /dev/null; then
log_success "cron 服务运行正常"
else
log_warning "cron 服务可能未正常启动"
fi
else
log_error "cron 服务启动失败"
return 1
fi
}
# 安装组件
install_components() {
log_info "开始安装组件..."
artifact_dir=$(dirname "$VERSION_FILE_PATH")
install_count=0
total_count=0
if [[ -f "$TEMP_DIR/install_order.txt" ]]; then
total_count=$(wc -l < "$TEMP_DIR/install_order.txt")
fi
if [[ -f "$TEMP_DIR/install_order.txt" ]]; then
while IFS= read -r filename; do
install_count=$((install_count + 1))
# 从文件名中提取组件名(去掉时间戳后缀)
component=$(echo "$filename" | sed 's/-[0-9]\{8\}-[0-9]\{6\}\.tar\.gz$//')
log_info "[$install_count/$total_count] 安装 $component..."
log_info " 文件名: $filename"
# 直接使用完整的文件名
tar_file="$artifact_dir/$filename"
if [[ ! -f "$tar_file" ]]; then
log_error "找不到组件文件: $filename"
log_info " 期望路径: $tar_file"
log_info " 当前目录: $(pwd)"
log_info " 目录内容:"
ls -la "$artifact_dir" | while read line; do
log_info " $line"
done
exit 1
fi
log_info " 找到文件: $tar_file"
# 解压到临时目录
component_temp_dir="$TEMP_DIR/$component"
mkdir -p "$component_temp_dir"
if tar -xzf "$tar_file" -C "$component_temp_dir" 2>/dev/null; then
log_success " $component 解压完成"
else
log_error " $component 解压失败"
exit 1
fi
# 查找解压后的目录
extracted_dir=""
for dir in "$component_temp_dir"/*; do
if [[ -d "$dir" ]]; then
extracted_dir="$dir"
break
fi
done
if [[ -z "$extracted_dir" ]]; then
log_error " $component 解压后未找到目录"
exit 1
fi
# 执行安装脚本
if [[ -f "$extracted_dir/install.sh" ]]; then
log_info " 执行 $component 安装脚本..."
if (cd "$extracted_dir" && ./install.sh); then
log_success " $component 安装完成"
else
log_error " $component 安装失败"
exit 1
fi
else
log_error " $component 缺少 install.sh 文件"
exit 1
fi
# 将解压后的目录移动到安装目录,保留组件目录
component_install_dir="$INSTALL_DIR/$component"
if [[ -d "$component_install_dir" ]]; then
log_info " 组件目录已存在,备份后更新: $component_install_dir"
mv "$component_install_dir" "${component_install_dir}.backup.$(date +%Y%m%d_%H%M%S)"
fi
mv "$extracted_dir" "$component_install_dir"
log_success " 组件目录已保存: $component_install_dir"
# 清理临时文件
rm -rf "$component_temp_dir"
done < "$TEMP_DIR/install_order.txt"
fi
log_success "所有组件安装完成"
}
# 创建安装记录
create_install_record() {
log_info "创建安装记录..."
# 等待一段时间确保所有进程都已启动
log_info "等待进程启动..."
sleep 3
local install_time=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
local install_record_file=".install_record"
# 创建 JSON 格式的安装记录
cat > "$install_record_file" << EOF
{
"version": "$VERSION",
"build_time": "$BUILD_TIME",
"install_time": "$install_time",
"install_dir": "$INSTALL_DIR",
"install_pid": $$,
"components": {
EOF
# 添加组件信息
local first_component=true
if [[ -f "$TEMP_DIR/components.txt" ]]; then
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
version=$(echo "$line" | cut -d':' -f2)
# 获取组件的进程信息
local component_pid=""
# 根据组件名查找进程使用多种方法确保能找到PID
case "$component" in
"node-exporter-installer")
# 尝试多种方式查找node_exporter进程
component_pid=$(pgrep -f "node_exporter" | head -1)
if [[ -z "$component_pid" ]]; then
component_pid=$(pgrep -f "node-exporter" | head -1)
fi
if [[ -z "$component_pid" ]]; then
component_pid=$(ps aux | grep -v grep | grep "node_exporter" | awk '{print $2}' | head -1)
fi
;;
"dcgm-exporter-installer")
# 尝试多种方式查找dcgm-exporter进程
component_pid=$(pgrep -f "dcgm-exporter" | head -1)
if [[ -z "$component_pid" ]]; then
component_pid=$(pgrep -f "dcgm_exporter" | head -1)
fi
if [[ -z "$component_pid" ]]; then
component_pid=$(ps aux | grep -v grep | grep "dcgm-exporter" | awk '{print $2}' | head -1)
fi
;;
esac
# 记录找到的PID信息
if [[ -n "$component_pid" ]]; then
log_info " 找到 $component 进程 PID: $component_pid"
else
log_warning " 未找到 $component 进程"
fi
# 添加逗号分隔符
if [[ "$first_component" == "true" ]]; then
first_component=false
else
echo "," >> "$install_record_file"
fi
# 添加组件信息
cat >> "$install_record_file" << EOF
"$component": {
"version": "$version",
"pid": "$component_pid",
"install_dir": "$INSTALL_DIR/$component"
}
EOF
done < "$TEMP_DIR/components.txt"
fi
# 结束 JSON
cat >> "$install_record_file" << EOF
}
}
EOF
log_success "安装记录已创建: $install_record_file"
}
# 设置健康检查定时任务
setup_health_check_cron() {
log_info "设置健康检查定时任务..."
# 直接使用当前安装目录不依赖current软链接
# INSTALL_DIR 是 /opt/argus-metric/versions/1.34.0
local check_health_script="$INSTALL_DIR/check_health.sh"
# 检查健康检查脚本是否存在
if [[ ! -f "$check_health_script" ]]; then
log_error "健康检查脚本不存在: $check_health_script"
return 1
fi
# 确保脚本有执行权限
chmod +x "$check_health_script"
# 创建临时crontab文件
local temp_cron="/tmp/crontab_$$"
# 获取当前用户的crontab如果存在
crontab -l 2>/dev/null > "$temp_cron" || touch "$temp_cron"
# 检查并删除旧的健康检查任务
if grep -q "check_health.sh" "$temp_cron"; then
log_info "发现旧的健康检查定时任务,正在更新..."
# 删除所有包含check_health.sh的行
grep -v "check_health.sh" "$temp_cron" > "$temp_cron.new"
mv "$temp_cron.new" "$temp_cron"
log_info "旧的健康检查定时任务已删除"
fi
# 添加新的定时任务每5分钟执行一次
echo "# Argus-Metrics 健康检查定时任务" >> "$temp_cron"
echo "*/5 * * * * $check_health_script >> $INSTALL_DIR/.health_cron.log 2>&1" >> "$temp_cron"
# 安装新的crontab
if crontab "$temp_cron"; then
log_success "健康检查定时任务设置成功"
log_info " 执行频率: 每5分钟"
log_info " 日志文件: $INSTALL_DIR/.health_cron.log"
log_info " 查看定时任务: crontab -l"
log_info " 删除定时任务: crontab -e"
else
log_error "健康检查定时任务设置失败"
rm -f "$temp_cron"
return 1
fi
# 清理临时文件
rm -f "$temp_cron"
# 立即执行一次健康检查
log_info "执行首次健康检查..."
if "$check_health_script"; then
log_success "首次健康检查完成"
else
log_warning "首次健康检查失败,但定时任务已设置"
fi
}
# 显示安装信息
show_install_info() {
log_success "Argus-Metrics All-in-One 安装完成!"
echo
echo "安装信息:"
echo " 版本: $VERSION"
echo " 构建时间: $BUILD_TIME"
echo " 安装目录: $INSTALL_DIR"
echo
echo "已安装组件:"
if [[ -f "$TEMP_DIR/components.txt" ]]; then
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
version=$(echo "$line" | cut -d':' -f2)
echo " - $component v$version"
done < "$TEMP_DIR/components.txt"
fi
echo
echo "访问地址:"
echo " Node Exporter: http://localhost:9100"
echo " DCGM Exporter: http://localhost:9400"
echo
echo "健康检查:"
echo " 安装记录: .install_record"
echo " 健康日志: .health_log"
echo " 定时任务日志: .health_cron.log"
echo " 查看定时任务: crontab -l"
echo
}
cleanup() {
if [[ -d "$TEMP_DIR" ]]; then
rm -rf "$TEMP_DIR"
fi
}
trap cleanup EXIT
# 主函数
main() {
echo "=========================================="
echo " Argus-Metrics All-in-One 安装脚本 v1.0"
echo "=========================================="
echo
log_info "安装目录: $INSTALL_DIR"
echo
check_root
check_system
find_version_file
create_install_dirs
parse_version_info
verify_checksums
install_system_deps
install_components
create_install_record
setup_health_check_cron
show_install_info
}
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,433 @@
#!/bin/bash
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 显示帮助信息
show_help() {
echo "AIOps All-in-One 打包脚本"
echo
echo "用法: $0 [选项]"
echo
echo "选项:"
echo " --force 强制重新打包,即使版本已存在"
echo " --help 显示此帮助信息"
echo
echo "示例:"
echo " $0 # 正常打包,跳过已存在的版本"
echo " $0 --force # 强制重新打包"
echo
}
# 解析命令行参数
FORCE_PACKAGE=false
if [[ "$1" == "--force" ]]; then
FORCE_PACKAGE=true
log_info "强制重新打包模式"
elif [[ "$1" == "--help" || "$1" == "-h" ]]; then
show_help
exit 0
fi
# 获取当前目录和版本
CURRENT_DIR=$(pwd)
VERSION=$(cat VERSION 2>/dev/null || echo "1.0.0")
ARTIFACT_DIR="artifact/$VERSION"
log_info "开始打包 AIOps All-in-One 安装包 v$VERSION"
# 检查必要文件
log_info "检查必要文件..."
if [[ ! -f "VERSION" ]]; then
log_error "VERSION 文件不存在"
exit 1
fi
if [[ ! -f "checklist" ]]; then
log_error "checklist 文件不存在"
exit 1
fi
# 检查是否已存在该版本
if [[ -d "$ARTIFACT_DIR" && "$FORCE_PACKAGE" == "false" ]]; then
log_info "检查版本 $VERSION 是否已存在..."
# 检查 version.json 是否存在
if [[ -f "$ARTIFACT_DIR/version.json" ]]; then
log_info "找到已存在的版本信息文件"
# 检查是否所有组件文件都存在
missing_files=0
existing_components=0
# 解析已存在的 version.json 来检查文件
if command -v jq &> /dev/null; then
# 使用 jq 解析
while IFS= read -r component; do
existing_components=$((existing_components + 1))
# 查找对应的 tar 文件
found_file=false
for file in "$ARTIFACT_DIR/${component}-"*.tar.gz; do
if [[ -f "$file" ]]; then
found_file=true
break
fi
done
if [[ "$found_file" == "false" ]]; then
missing_files=$((missing_files + 1))
log_warning " 缺少文件: $component"
fi
done < <(jq -r '.artifact_list | keys[]' "$ARTIFACT_DIR/version.json" 2>/dev/null)
else
# 简单的文件检查
for file in "$ARTIFACT_DIR"/*.tar.gz; do
if [[ -f "$file" ]]; then
existing_components=$((existing_components + 1))
fi
done
fi
# 如果所有文件都存在,则跳过打包
if [[ $missing_files -eq 0 && $existing_components -gt 0 ]]; then
log_success "版本 $VERSION 已完整打包,跳过重复打包"
echo
echo "现有文件:"
ls -la "$ARTIFACT_DIR"
echo
echo "如需强制重新打包,请删除目录: rm -rf $ARTIFACT_DIR"
echo "或使用: ./package.sh --force"
exit 0
else
log_warning "版本 $VERSION 存在但不完整,将重新打包"
log_info " 现有组件: $existing_components"
log_info " 缺少文件: $missing_files"
fi
else
log_warning "版本目录存在但缺少 version.json将重新打包"
fi
fi
# 创建 artifact 目录
mkdir -p "$ARTIFACT_DIR"
log_info "创建输出目录: $ARTIFACT_DIR"
# 创建临时文件存储数据
TEMP_DIR=$(mktemp -d)
COMPONENTS_FILE="$TEMP_DIR/components.txt"
VERSIONS_FILE="$TEMP_DIR/versions.txt"
DEPENDENCIES_FILE="$TEMP_DIR/dependencies.txt"
INSTALL_ORDER_FILE="$TEMP_DIR/install_order.txt"
CHECKSUMS_FILE="$TEMP_DIR/checksums.txt"
ARTIFACT_LIST_FILE="$TEMP_DIR/artifact_list.txt"
# 解析 checklist 文件
log_info "解析组件清单..."
line_num=0
component_count=0
while IFS= read -r line; do
[[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
line_num=$((line_num + 1))
# 解析行: 组件名 目录路径 版本 [依赖组件] [安装顺序]
read -r component component_path version dep_component order <<< "$line"
if [[ -z "$component" || -z "$component_path" || -z "$version" ]]; then
log_warning "跳过无效行 $line_num: $line"
continue
fi
# 存储组件信息
echo "$component" >> "$COMPONENTS_FILE"
echo "$component:$version" >> "$VERSIONS_FILE"
echo "$component:$component_path" >> "$TEMP_DIR/component_paths.txt"
if [[ -n "$dep_component" && "$dep_component" != "$component" ]]; then
echo "$component:$dep_component" >> "$DEPENDENCIES_FILE"
fi
if [[ -n "$order" && "$order" =~ ^[0-9]+$ ]]; then
echo "$order:$component" >> "$INSTALL_ORDER_FILE"
else
# 如果没有指定顺序,按解析顺序分配
echo "$line_num:$component" >> "$INSTALL_ORDER_FILE"
fi
component_count=$((component_count + 1))
log_info " - $component v$version"
done < checklist
if [[ $component_count -eq 0 ]]; then
log_error "没有找到有效的组件"
rm -rf "$TEMP_DIR"
exit 1
fi
log_success "找到 $component_count 个组件"
# 检查组件目录是否存在
log_info "检查组件目录..."
missing_components=()
while IFS= read -r component; do
# 获取组件路径
component_path=$(grep "^$component:" "$TEMP_DIR/component_paths.txt" | cut -d':' -f2-)
if [[ -z "$component_path" ]]; then
log_error "未找到组件 $component 的路径配置"
log_info "请检查 component_paths.txt 文件或添加路径配置"
exit 1
fi
if [[ ! -d "$component_path" ]]; then
missing_components+=("$component:$component_path")
fi
done < "$COMPONENTS_FILE"
if [[ ${#missing_components[@]} -gt 0 ]]; then
log_error "以下组件目录不存在:"
for component_path in "${missing_components[@]}"; do
echo " - $component_path"
done
rm -rf "$TEMP_DIR"
exit 1
fi
# 打包各个组件
log_info "开始打包组件..."
while IFS= read -r component; do
# 获取组件版本和路径
version=$(grep "^$component:" "$VERSIONS_FILE" | cut -d':' -f2)
component_path=$(grep "^$component:" "$TEMP_DIR/component_paths.txt" | cut -d':' -f2-)
if [[ -z "$component_path" ]]; then
log_error "未找到组件 $component 的路径配置"
log_info "请检查 component_paths.txt 文件或添加路径配置"
exit 1
fi
log_info "打包 $component v$version..."
log_info " 组件路径: $component_path"
# 进入组件目录
cd "$component_path"
# 检查组件是否有 package.sh
if [[ ! -f "package.sh" ]]; then
log_error "$component 缺少 package.sh 文件"
cd "$CURRENT_DIR"
rm -rf "$TEMP_DIR"
exit 1
fi
# 执行组件的打包脚本
if ./package.sh; then
# 查找生成的 tar 包
tar_file=$(find . -name "*.tar.gz" -type f | head -1)
if [[ -n "$tar_file" ]]; then
# 移动到 artifact 目录
mv "$tar_file" "$CURRENT_DIR/$ARTIFACT_DIR/"
tar_filename=$(basename "$tar_file")
# 计算校验和
checksum=$(sha256sum "$CURRENT_DIR/$ARTIFACT_DIR/$tar_filename" | cut -d' ' -f1)
echo "$component:sha256:$checksum" >> "$CHECKSUMS_FILE"
echo "$component:$version" >> "$ARTIFACT_LIST_FILE"
# 将完整的文件名存储到安装顺序文件中
echo "$tar_filename" >> "$TEMP_DIR/install_order_files.txt"
log_success " $component 打包完成: $tar_filename"
else
log_error "$component 打包失败,未找到生成的 tar 包"
cd "$CURRENT_DIR"
rm -rf "$TEMP_DIR"
exit 1
fi
else
log_error "$component 打包失败"
cd "$CURRENT_DIR"
rm -rf "$TEMP_DIR"
exit 1
fi
# 返回主目录
cd "$CURRENT_DIR"
done < "$COMPONENTS_FILE"
# 生成 version.json
log_info "生成版本信息文件..."
version_json="$ARTIFACT_DIR/version.json"
# 构建依赖关系 JSON
deps_json=""
if [[ -f "$DEPENDENCIES_FILE" ]]; then
first=true
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
dep=$(echo "$line" | cut -d':' -f2)
if [[ "$first" == "true" ]]; then
deps_json="\"$component\":[\"$dep\"]"
first=false
else
deps_json="$deps_json,\"$component\":[\"$dep\"]"
fi
done < "$DEPENDENCIES_FILE"
fi
# 构建安装顺序数组
order_array=""
if [[ -f "$TEMP_DIR/install_order_files.txt" ]]; then
first=true
while IFS= read -r filename; do
if [[ "$first" == "true" ]]; then
order_array="\"$filename\""
first=false
else
order_array="$order_array,\"$filename\""
fi
done < "$TEMP_DIR/install_order_files.txt"
fi
# 构建 artifact_list JSON
artifact_json=""
if [[ -f "$ARTIFACT_LIST_FILE" ]]; then
first=true
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
version=$(echo "$line" | cut -d':' -f2)
if [[ "$first" == "true" ]]; then
artifact_json="\"$component\":\"$version\""
first=false
else
artifact_json="$artifact_json,\"$component\":\"$version\""
fi
done < "$ARTIFACT_LIST_FILE"
fi
# 构建 checksums JSON
checksums_json=""
if [[ -f "$CHECKSUMS_FILE" ]]; then
first=true
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
checksum=$(echo "$line" | cut -d':' -f2-)
if [[ "$first" == "true" ]]; then
checksums_json="\"$component\":\"$checksum\""
first=false
else
checksums_json="$checksums_json,\"$component\":\"$checksum\""
fi
done < "$CHECKSUMS_FILE"
fi
# 生成完整的 version.json
cat > "$version_json" << EOF
{
"version": "$VERSION",
"build_time": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"artifact_list": {
$artifact_json
},
"checksums": {
$checksums_json
},
"dependencies": {
$deps_json
},
"install_order": [
$order_array
]
}
EOF
log_success "版本信息文件生成完成: $version_json"
# 复制`安装`脚本到 artifact 目录
log_info "复制安装脚本..."
if [[ -f "install_artifact.sh" ]]; then
cp "install_artifact.sh" "$ARTIFACT_DIR/install.sh"
chmod +x "$ARTIFACT_DIR/install.sh"
log_success "安装脚本复制完成: $ARTIFACT_DIR/install.sh"
else
log_warning "install_artifact.sh 文件不存在"
fi
# 复制`卸载`脚本到 artifact 目录
log_info "复制卸载脚本..."
if [[ -f "uninstall_artifact.sh" ]]; then
cp "uninstall_artifact.sh" "$ARTIFACT_DIR/uninstall.sh"
chmod +x "$ARTIFACT_DIR/uninstall.sh"
log_success "卸载脚本复制完成: $ARTIFACT_DIR/uninstall.sh"
else
log_warning "uninstall_artifact.sh 文件不存在"
fi
# 复制`健康检查`脚本到 artifact 目录
log_info "复制健康检查脚本..."
if [[ -f "check_health.sh" ]]; then
cp "check_health.sh" "$ARTIFACT_DIR/check_health.sh"
chmod +x "$ARTIFACT_DIR/check_health.sh"
log_success "健康检查脚本复制完成: $ARTIFACT_DIR/check_health.sh"
else
log_warning "check_health.sh 文件不存在"
fi
# 复制 deps 目录到 artifact 目录
log_info "复制系统依赖包..."
if [[ -d "deps" ]]; then
cp -r "deps" "$ARTIFACT_DIR/"
log_success "系统依赖包复制完成: $ARTIFACT_DIR/deps"
# 显示deps目录内容
log_info " 依赖包列表:"
find "$ARTIFACT_DIR/deps" -name "*.tar.gz" -exec basename {} \; | while read dep_file; do
log_info " - $dep_file"
done
else
log_warning "deps 目录不存在,跳过依赖包复制"
fi
# 显示打包结果
log_success "打包完成!"
echo
echo "版本: $VERSION"
echo "输出目录: $ARTIFACT_DIR"
echo "包含组件:"
if [[ -f "$ARTIFACT_LIST_FILE" ]]; then
while IFS= read -r line; do
component=$(echo "$line" | cut -d':' -f1)
version=$(echo "$line" | cut -d':' -f2)
echo " - $component v$version"
done < "$ARTIFACT_LIST_FILE"
fi
echo
echo "文件列表:"
ls -la "$ARTIFACT_DIR"
echo
# 清理临时文件
rm -rf "$TEMP_DIR"

View File

@ -0,0 +1,149 @@
#!/bin/bash
set -e
# 颜色定义
GREEN='\033[0;32m'
BLUE='\033[0;34m'
RED='\033[0;31m'
NC='\033[0m' # No Color
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 显示帮助信息
show_help() {
echo "Argus-Metric Artifact 发布脚本"
echo
echo "用法: $0 <版本号>"
echo
echo "参数:"
echo " <版本号> 要发布的版本号,对应 artifact 目录中的版本"
echo
echo "示例:"
echo " $0 1.20.0 # 发布 1.20.0 版本"
echo
}
# 检查参数
if [[ $# -ne 1 ]]; then
log_error "请提供版本号参数"
show_help
exit 1
fi
VERSION="$1"
ARTIFACT_DIR="artifact/$VERSION"
PUBLISH_DIR="/srv/ftp/share"
# 检查版本目录是否存在
if [[ ! -d "$ARTIFACT_DIR" ]]; then
log_error "版本目录不存在: $ARTIFACT_DIR"
exit 1
fi
log_info "开始发布版本: $VERSION"
# 确保发布目录存在
log_info "确保发布目录存在: $PUBLISH_DIR"
mkdir -p "$PUBLISH_DIR"
# 创建临时目录用于打包
TEMP_PACKAGE_DIR="/tmp/argus-metric-package-$$"
mkdir -p "$TEMP_PACKAGE_DIR"
# 复制所有 tar.gz 文件到临时目录
log_info "准备 artifact 文件..."
tar_files=$(find "$ARTIFACT_DIR" -name "*.tar.gz" -type f)
if [[ -z "$tar_files" ]]; then
log_error "$ARTIFACT_DIR 中未找到 tar.gz 文件"
exit 1
fi
for file in $tar_files; do
filename=$(basename "$file")
log_info " 准备: $filename"
cp "$file" "$TEMP_PACKAGE_DIR/"
done
# 复制版本信息文件
if [[ -f "$ARTIFACT_DIR/version.json" ]]; then
log_info "复制版本信息文件..."
cp "$ARTIFACT_DIR/version.json" "$TEMP_PACKAGE_DIR/"
fi
# 复制健康检查脚本
if [[ -f "$ARTIFACT_DIR/check_health.sh" ]]; then
log_info "复制健康检查脚本..."
cp "$ARTIFACT_DIR/check_health.sh" "$TEMP_PACKAGE_DIR/"
elif [[ -f "check_health.sh" ]]; then
log_info "复制健康检查脚本 (从当前目录)..."
cp "check_health.sh" "$TEMP_PACKAGE_DIR/"
else
log_warning "未找到 check_health.sh 文件"
fi
# 复制安装脚本并重命名为 install.sh
if [[ -f "install_artifact.sh" ]]; then
log_info "复制安装脚本..."
cp "install_artifact.sh" "$TEMP_PACKAGE_DIR/install.sh"
fi
if [[ -f "uninstall_artifact.sh" ]]; then
log_info "复制卸载脚本..."
cp "uninstall_artifact.sh" "$TEMP_PACKAGE_DIR/uninstall.sh"
fi
# 创建tar包使用新的命名规范
TAR_NAME="argus-metric_$(echo $VERSION | tr '.' '_').tar.gz"
log_info "创建发布包: $TAR_NAME"
cd "$TEMP_PACKAGE_DIR"
tar -czf "$PUBLISH_DIR/$TAR_NAME" *
cd - > /dev/null
# 清理临时目录
rm -rf "$TEMP_PACKAGE_DIR"
# 更新 LATEST_VERSION 文件
log_info "更新 LATEST_VERSION 文件..."
echo "$VERSION" > "$PUBLISH_DIR/LATEST_VERSION"
# 复制 setup.sh 到发布目录
if [[ -f "setup.sh" ]]; then
log_info "复制 setup.sh 到发布目录..."
cp "setup.sh" "$PUBLISH_DIR/"
fi
# 显示发布结果
log_success "版本 $VERSION 发布完成!"
echo
echo "发布目录: $PUBLISH_DIR"
echo "发布包: $PUBLISH_DIR/$TAR_NAME"
echo "包大小: $(du -h "$PUBLISH_DIR/$TAR_NAME" | cut -f1)"
echo "最新版本: $(cat "$PUBLISH_DIR/LATEST_VERSION")"
echo
echo "发布目录中的文件:"
ls -la "$PUBLISH_DIR" | while read line; do
echo " $line"
done
echo
echo "使用方法:"
echo " 1. 确保 /srv/ftp/share 目录可通过 FTP 访问"
echo " 2. 用户首先下载安装脚本:"
echo " curl -u ftpuser:admin1234 ftp://10.211.55.4/setup.sh -o setup.sh"
echo " 3. 然后执行安装 (自动获取最新版本):"
echo " sudo sh setup.sh"
echo " 4. 或者指定版本安装:"
echo " sudo sh setup.sh --version $VERSION"
echo " 5. 或者指定不同的FTP服务器:"
echo " sudo sh setup.sh --server 192.168.1.100 --user myuser --password mypass"

View File

@ -0,0 +1,862 @@
#!/bin/bash
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
FTP_SERVER="${FTP_SERVER}"
FTP_USER="${FTP_USER}"
FTP_PASS="${FTP_PASS}"
FTP_PORT="${FTP_PORT:-21}"
BASE_URL="" # FTP基础URL (将在check_ftp_params中设置)
LATEST_VERSION_URL="" # 版本文件URL (将在check_ftp_params中设置)
TEMP_DIR="/tmp/argus-metric-install-$$"
# 安装目录配置
DEFAULT_INSTALL_DIR="/opt/argus-metric" # 默认安装目录
INSTALL_DIR="${INSTALL_DIR:-$DEFAULT_INSTALL_DIR}" # 可通过环境变量覆盖
VERSIONS_DIR="$INSTALL_DIR/versions" # 版本目录
BACKUPS_DIR="$INSTALL_DIR/backups" # 备份目录
CURRENT_LINK="$INSTALL_DIR/current" # 当前版本软链接
LATEST_VERSION_FILE="$INSTALL_DIR/LATEST_VERSION" # 当前版本记录文件
# 检查必需的FTP参数
check_ftp_params() {
local missing_params=()
if [[ -z "$FTP_SERVER" ]]; then
missing_params+=("FTP_SERVER")
fi
if [[ -z "$FTP_USER" ]]; then
missing_params+=("FTP_USER")
fi
if [[ -z "$FTP_PASS" ]]; then
missing_params+=("FTP_PASS")
fi
if [[ ${#missing_params[@]} -gt 0 ]]; then
log_error "缺少必需的FTP参数: ${missing_params[*]}"
log_error "请通过以下方式之一设置FTP参数:"
log_error " 1. 命令行参数: --server <地址> --user <用户名> --password <密码>"
log_error " 2. 环境变量: FTP_SERVER=<地址> FTP_USER=<用户名> FTP_PASS=<密码>"
log_error ""
log_error "示例:"
log_error " sudo sh setup.sh --server 10.211.55.4 --user ftpuser --password admin1234"
log_error " FTP_SERVER=10.211.55.4 FTP_USER=ftpuser FTP_PASS=admin1234 sudo sh setup.sh"
exit 1
fi
# 设置BASE_URL和LATEST_VERSION_URL
BASE_URL="ftp://${FTP_SERVER}:${FTP_PORT}"
LATEST_VERSION_URL="$BASE_URL/LATEST_VERSION"
log_info "FTP配置:"
log_info " 服务器: $FTP_SERVER:$FTP_PORT"
log_info " 用户: $FTP_USER"
}
# 获取最新版本号的函数
get_latest_version() {
log_info "获取最新版本信息..." >&2
log_info "尝试从URL获取: $LATEST_VERSION_URL" >&2
# 先测试FTP连接
log_info "测试FTP连接..." >&2
if ! curl -u "${FTP_USER}:${FTP_PASS}" -sfI "$LATEST_VERSION_URL" >/dev/null 2>&1; then
log_error "无法连接到FTP服务器或文件不存在" >&2
log_error "URL: $LATEST_VERSION_URL" >&2
log_error "请检查:" >&2
log_error " 1. FTP服务器是否运行: $FTP_SERVER:$FTP_PORT" >&2
log_error " 2. 用户名密码是否正确: $FTP_USER" >&2
log_error " 3. LATEST_VERSION文件是否存在" >&2
log_error "手动测试命令: curl -u ${FTP_USER}:${FTP_PASS} ftp://${FTP_SERVER}/LATEST_VERSION" >&2
exit 1
fi
# 获取文件内容
if ! LATEST_VERSION=$(curl -u "${FTP_USER}:${FTP_PASS}" -sfL "$LATEST_VERSION_URL" 2>/dev/null | tr -d '[:space:]'); then
log_error "下载LATEST_VERSION文件失败" >&2
exit 1
fi
log_info "原始获取内容: '$LATEST_VERSION'" >&2
if [[ -z "$LATEST_VERSION" ]]; then
log_error "获取到的版本信息为空" >&2
log_error "可能的原因:" >&2
log_error " 1. LATEST_VERSION文件为空" >&2
log_error " 2. 文件内容格式不正确" >&2
log_error " 3. 网络传输问题" >&2
log_error "请检查FTP服务器上的 /srv/ftp/share/LATEST_VERSION 文件" >&2
exit 1
fi
log_info "检测到最新版本: $LATEST_VERSION" >&2
echo "$LATEST_VERSION"
}
# 解析参数
ARGUS_VERSION="" # 使用不同的变量名避免与系统VERSION冲突
ACTION="install"
while [[ $# -gt 0 ]]; do
case $1 in
--version)
ARGUS_VERSION="$2"
shift 2
;;
--server)
FTP_SERVER="$2"
shift 2
;;
--user)
FTP_USER="$2"
shift 2
;;
--password)
FTP_PASS="$2"
shift 2
;;
--port)
FTP_PORT="$2"
shift 2
;;
--uninstall)
ACTION="uninstall"
shift
;;
--install-dir)
INSTALL_DIR="$2"
shift 2
;;
--rollback)
ACTION="rollback"
shift
;;
--backup-list)
ACTION="backup-list"
shift
;;
--status)
ACTION="status"
shift
;;
--help)
echo "Argus Metric FTP在线安装脚本"
echo
echo "用法: curl -u <用户名>:<密码> ftp://<服务器>/setup.sh -o setup.sh && sh setup.sh [选项]"
echo
echo "必需参数 (必须通过命令行参数或环境变量设置):"
echo " --server SERVER FTP服务器地址 (必须)"
echo " --user USER FTP用户名 (必须)"
echo " --password PASS FTP密码 (必须)"
echo
echo "可选参数:"
echo " --version VERSION 指定版本 (默认: 自动获取最新版本)"
echo " --port PORT FTP端口 (默认: 21)"
echo " --install-dir DIR 安装目录 (默认: /opt/argus-metric)"
echo " --uninstall 卸载 (自动确认)"
echo " --rollback 回滚到上一个备份版本"
echo " --backup-list 列出所有备份版本"
echo " --status 显示当前安装状态"
echo " --help 显示帮助"
echo
echo "环境变量:"
echo " FTP_SERVER FTP服务器地址 (必须)"
echo " FTP_USER FTP用户名 (必须)"
echo " FTP_PASS FTP密码 (必须)"
echo " FTP_PORT FTP端口 (默认: 21)"
echo
echo "示例:"
echo " # 方式1: 使用命令行参数"
echo " curl -u ftpuser:admin1234 ftp://10.211.55.4/setup.sh -o setup.sh"
echo " sudo sh setup.sh --server 10.211.55.4 --user ftpuser --password admin1234"
echo " "
echo " # 方式2: 使用环境变量"
echo " FTP_SERVER=10.211.55.4 FTP_USER=ftpuser FTP_PASS=admin1234 sudo sh setup.sh"
echo " "
echo " # 指定版本安装"
echo " sudo sh setup.sh --server 10.211.55.4 --user ftpuser --password admin1234 --version 1.30.0"
echo " "
echo " # 卸载"
echo " sudo sh setup.sh --server 10.211.55.4 --user ftpuser --password admin1234 --uninstall"
exit 0
;;
*)
log_error "未知参数: $1"
echo "使用 --help 查看帮助信息"
exit 1
;;
esac
done
# 清理函数
cleanup() {
if [[ -d "$TEMP_DIR" ]]; then
rm -rf "$TEMP_DIR"
fi
}
trap cleanup EXIT
# 创建安装目录结构
create_install_directories() {
log_info "创建安装目录结构..."
# 创建主要目录
mkdir -p "$VERSIONS_DIR"
mkdir -p "$BACKUPS_DIR"
log_success "安装目录结构创建完成: $INSTALL_DIR"
}
# 获取当前安装的版本
get_current_version() {
# 优先从LATEST_VERSION文件读取
if [[ -f "$LATEST_VERSION_FILE" ]]; then
local version_from_file=$(cat "$LATEST_VERSION_FILE" 2>/dev/null | tr -d '[:space:]')
if [[ -n "$version_from_file" ]]; then
# 确保版本号格式一致不带v前缀
echo "$version_from_file"
return 0
fi
fi
# 如果文件不存在或为空,从软链接读取
if [[ -L "$CURRENT_LINK" ]]; then
local current_path=$(readlink "$CURRENT_LINK")
# 从版本目录名中提取版本号现在不带v前缀
basename "$current_path"
else
echo ""
fi
}
# 检查是否已安装
check_installed() {
if [[ -L "$CURRENT_LINK" ]] && [[ -d "$CURRENT_LINK" ]]; then
local current_version=$(get_current_version)
if [[ -n "$current_version" ]]; then
log_info "检测到已安装版本: v$current_version"
return 0
fi
fi
return 1
}
# 更新LATEST_VERSION文件
update_latest_version_file() {
local version="$1"
log_info "更新LATEST_VERSION文件: $version"
if echo "$version" > "$LATEST_VERSION_FILE"; then
log_success "LATEST_VERSION文件已更新"
else
log_error "更新LATEST_VERSION文件失败"
return 1
fi
}
# 备份当前版本
backup_current_version() {
local current_version=$(get_current_version)
if [[ -z "$current_version" ]]; then
log_info "没有当前版本需要备份"
return 0
fi
local backup_name="$current_version"
local backup_path="$BACKUPS_DIR/$backup_name"
log_info "备份当前版本 $current_version 到: $backup_path"
# 如果备份已存在,先删除
if [[ -d "$backup_path" ]]; then
log_info "备份版本已存在,覆盖: $backup_path"
rm -rf "$backup_path"
fi
# 复制当前版本目录
if cp -r "$CURRENT_LINK" "$backup_path"; then
log_success "版本备份完成: $backup_name"
# 清理旧备份只保留最近3个
cleanup_old_backups
else
log_error "版本备份失败"
exit 1
fi
}
# 清理旧备份
cleanup_old_backups() {
log_info "清理旧版本备份..."
# 获取备份目录列表按时间排序保留最近3个
local backup_count=$(ls -1 "$BACKUPS_DIR" 2>/dev/null | wc -l)
if [[ $backup_count -gt 3 ]]; then
local to_remove=$((backup_count - 3))
ls -1t "$BACKUPS_DIR" | tail -n $to_remove | while read backup; do
log_info "删除旧备份: $backup"
rm -rf "$BACKUPS_DIR/$backup"
done
fi
}
# 回滚到备份版本
rollback_to_backup() {
local backup_name="$1"
local backup_path="$BACKUPS_DIR/$backup_name"
if [[ ! -d "$backup_path" ]]; then
log_error "备份不存在: $backup_path"
return 1
fi
log_info "回滚到备份版本: $backup_name"
# 停止当前服务
stop_services
# 恢复软链接(备份目录应该包含版本内容)
if ln -sfn "$backup_path" "$CURRENT_LINK"; then
log_success "版本回滚完成: $backup_name"
# 启动服务
start_services
return 0
else
log_error "版本回滚失败"
return 1
fi
}
# 停止服务
stop_services() {
log_info "停止当前服务..."
# 检查服务是否正在运行
if ! check_services_running; then
log_info "服务未运行,无需停止"
return 0
fi
# 尝试使用卸载脚本停止服务
if [[ -f "$CURRENT_LINK/uninstall.sh" ]]; then
cd "$CURRENT_LINK"
chmod +x uninstall.sh
# 自动确认停止服务(避免交互式确认)
echo "y" | ./uninstall.sh >/dev/null 2>&1
local stop_exit_code=$?
if [[ $stop_exit_code -eq 0 ]]; then
log_success "服务停止完成"
else
log_warning "停止服务时出现警告,尝试手动停止"
manual_stop_services
fi
else
log_warning "未找到卸载脚本,尝试手动停止服务"
manual_stop_services
fi
}
# 手动停止服务
manual_stop_services() {
log_info "手动停止服务..."
# 停止 node_exporter
if pgrep -f "node_exporter" >/dev/null 2>&1; then
pkill -f "node_exporter" && log_info "node_exporter 已停止"
fi
# 停止 dcgm_exporter
if pgrep -f "dcgm_exporter" >/dev/null 2>&1; then
pkill -f "dcgm_exporter" && log_info "dcgm_exporter 已停止"
fi
# 等待进程完全停止
sleep 2
# 检查是否还有残留进程
if pgrep -f "node_exporter\|dcgm_exporter" >/dev/null 2>&1; then
log_warning "仍有服务进程运行,尝试强制停止"
pkill -9 -f "node_exporter\|dcgm_exporter" 2>/dev/null || true
fi
log_success "手动停止服务完成"
}
# 启动服务
start_services() {
log_info "启动服务..."
if [[ -f "$CURRENT_LINK/install.sh" ]]; then
cd "$CURRENT_LINK"
chmod +x install.sh
# 检查服务是否已经在运行
if check_services_running; then
log_info "服务已在运行,跳过启动"
return 0
fi
# 启动服务 - 传递正确的安装目录参数
if ./install.sh "$INSTALL_DIR" 2>/dev/null; then
log_success "服务启动完成"
else
log_error "服务启动失败"
return 1
fi
else
log_error "未找到安装脚本"
return 1
fi
}
# 检查服务是否正在运行
check_services_running() {
# 检查常见的服务端口是否在监听
local ports=(9100 9400) # node-exporter 和 dcgm-exporter 的默认端口
for port in "${ports[@]}"; do
if netstat -tlnp 2>/dev/null | grep -q ":$port "; then
log_info "检测到服务正在端口 $port 上运行"
return 0
fi
done
# 检查相关进程
if pgrep -f "node_exporter\|dcgm_exporter" >/dev/null 2>&1; then
log_info "检测到相关服务进程正在运行"
return 0
fi
return 1
}
# 检查是否为 root 用户
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本需要 root 权限运行"
log_info "请使用: sudo sh setup.sh"
exit 1
fi
}
# 检查系统要求
check_system() {
log_info "检查系统要求..."
# 检查操作系统
if [[ ! -f /etc/os-release ]]; then
log_error "无法检测操作系统版本"
exit 1
fi
# 读取系统信息使用子shell避免污染当前环境变量
local OS_INFO=$(source /etc/os-release && echo "$NAME $VERSION_ID")
log_info "检测到操作系统: $OS_INFO"
# 检查系统架构
arch=$(uname -m)
log_info "系统架构: $arch"
# 检查磁盘空间
available_space=$(df / | awk 'NR==2 {print $4}')
if [[ $available_space -lt 1024 ]]; then
log_warning "可用磁盘空间不足 1GB当前可用: $(($available_space / 1024 / 1024))GB"
fi
}
# 下载并安装
install_argus_metric() {
# 如果没有指定版本,获取最新版本
if [[ -z "$ARGUS_VERSION" ]]; then
ARGUS_VERSION=$(get_latest_version)
fi
log_info "开始安装 Argus Metric v$ARGUS_VERSION..."
log_info "安装目录: $INSTALL_DIR"
# 检查是否已安装
local is_upgrade=false
if check_installed; then
local current_version=$(get_current_version)
if [[ "$current_version" == "$ARGUS_VERSION" ]]; then
log_info "版本 v$ARGUS_VERSION 已安装,无需重复安装"
return 0
fi
log_info "检测到版本升级: v$current_version -> v$ARGUS_VERSION"
is_upgrade=true
# 备份当前版本
backup_current_version
fi
# 创建安装目录结构
create_install_directories
# 创建临时目录
mkdir -p "$TEMP_DIR"
cd "$TEMP_DIR"
# 下载发布包,使用新的命名规范
TAR_NAME="argus-metric_$(echo $ARGUS_VERSION | tr '.' '_').tar.gz"
log_info "下载发布包: $TAR_NAME"
log_info "从FTP服务器下载: $FTP_SERVER:$FTP_PORT, 用户: $FTP_USER"
# 构造curl命令并显示隐藏密码
CURL_CMD="curl -u \"${FTP_USER}:***\" -sfL \"$BASE_URL/$TAR_NAME\" -o \"$TAR_NAME\""
log_info "执行命令: $CURL_CMD"
if ! curl -u "${FTP_USER}:${FTP_PASS}" -sfL "$BASE_URL/$TAR_NAME" -o "$TAR_NAME"; then
log_error "下载发布包失败: $BASE_URL/$TAR_NAME"
log_error "完整命令: curl -u \"${FTP_USER}:${FTP_PASS}\" -sfL \"$BASE_URL/$TAR_NAME\" -o \"$TAR_NAME\""
log_error "请检查FTP服务器连接、用户名密码是否正确"
exit 1
fi
# 解压发布包到当前目录
log_info "解压发布包..."
if ! tar -xzf "$TAR_NAME"; then
log_error "解压发布包失败"
exit 1
fi
# 显示解压后的文件结构
log_info "解压后的文件结构:"
ls -la "$TEMP_DIR"
# 准备版本目录
local version_dir="$VERSIONS_DIR/$ARGUS_VERSION"
log_info "安装到版本目录: $version_dir"
# 如果升级,先停止服务
if [[ "$is_upgrade" == true ]]; then
stop_services
fi
# 创建版本目录
if [[ -d "$version_dir" ]]; then
log_info "版本目录已存在,备份后更新"
rm -rf "$version_dir"
fi
# 创建新的版本目录
mkdir -p "$version_dir"
# 移动解压的文件到版本目录
log_info "移动文件到版本目录: $TEMP_DIR/* -> $version_dir/"
# 检查源目录是否有内容
if [[ ! "$(ls -A "$TEMP_DIR" 2>/dev/null)" ]]; then
log_error "临时目录为空,无法移动文件"
exit 1
fi
# 检查目标目录是否存在
if [[ ! -d "$version_dir" ]]; then
log_error "目标版本目录不存在: $version_dir"
exit 1
fi
# 执行文件移动
if mv "$TEMP_DIR"/* "$version_dir" 2>/dev/null; then
log_success "文件移动到版本目录完成"
else
log_error "移动文件到版本目录失败"
log_error "源目录内容:"
ls -la "$TEMP_DIR" || true
log_error "目标目录状态:"
ls -la "$version_dir" || true
log_error "权限检查:"
ls -ld "$TEMP_DIR" "$version_dir" || true
exit 1
fi
# 执行安装脚本
log_info "执行安装脚本..."
cd "$version_dir"
if [[ -f "install.sh" ]]; then
chmod +x install.sh
# 传递版本目录作为安装目录给安装脚本
if ./install.sh "$version_dir"; then
log_success "安装脚本执行完成"
else
log_error "安装脚本执行失败"
# 如果是升级失败,尝试回滚
if [[ "$is_upgrade" == true ]]; then
log_warning "升级失败,尝试回滚到之前版本..."
local latest_backup=$(ls -1t "$BACKUPS_DIR" 2>/dev/null | head -n 1)
if [[ -n "$latest_backup" ]]; then
rollback_to_backup "$latest_backup"
return 1
fi
fi
exit 1
fi
else
log_error "未找到安装脚本 install.sh"
exit 1
fi
# 更新软链接指向新版本
log_info "更新当前版本链接..."
if ln -sfn "$version_dir" "$CURRENT_LINK"; then
log_success "版本链接更新完成: $CURRENT_LINK -> $version_dir"
else
log_error "版本链接更新失败"
exit 1
fi
# 更新LATEST_VERSION文件
update_latest_version_file "$ARGUS_VERSION"
# 启动服务
start_services
log_success "Argus Metric v$ARGUS_VERSION 安装完成!"
# 显示安装信息
echo
log_info "安装信息:"
log_info " 版本: $ARGUS_VERSION"
log_info " 安装目录: $INSTALL_DIR"
log_info " 版本目录: $version_dir"
log_info " 当前链接: $CURRENT_LINK"
if [[ "$is_upgrade" == true ]]; then
log_info " 升级类型: 版本升级"
else
log_info " 安装类型: 全新安装"
fi
}
# 卸载
uninstall_argus_metric() {
log_info "开始卸载 Argus Metric..."
log_info "安装目录: $INSTALL_DIR"
# 检查是否已安装
if ! check_installed; then
log_info "未检测到已安装的 Argus Metric"
return 0
fi
local current_version=$(get_current_version)
log_info "检测到当前版本: v$current_version"
# 停止服务
stop_services
# 执行卸载脚本
log_info "执行卸载脚本..."
if [[ -f "$CURRENT_LINK/uninstall.sh" ]]; then
cd "$CURRENT_LINK"
chmod +x uninstall.sh
# 自动确认卸载(因为用户已经明确使用了 --uninstall 参数)
log_info "自动确认卸载操作..."
echo "y" | ./uninstall.sh
local uninstall_exit_code=$?
if [[ $uninstall_exit_code -eq 0 ]]; then
log_success "卸载脚本执行完成"
else
log_error "卸载脚本执行失败 (退出码: $uninstall_exit_code)"
exit 1
fi
else
log_warning "未找到卸载脚本,执行基本清理"
fi
# 清理安装目录
log_info "清理安装目录..."
if [[ -d "$INSTALL_DIR" ]]; then
# 询问是否完全删除安装目录
log_warning "这将删除整个安装目录: $INSTALL_DIR"
log_warning "包括所有版本、备份和配置文件"
# 在自动化环境中,直接删除
if rm -rf "$INSTALL_DIR"; then
log_success "安装目录已完全清理: $INSTALL_DIR"
else
log_error "清理安装目录失败"
exit 1
fi
else
log_info "安装目录不存在,无需清理"
fi
log_success "Argus Metric 卸载完成!"
}
# 显示状态
show_status() {
echo "=========================================="
echo " Argus Metric 安装状态"
echo "=========================================="
echo
if check_installed; then
local current_version=$(get_current_version)
log_info "当前版本: $current_version"
log_info "安装目录: $INSTALL_DIR"
log_info "当前链接: $CURRENT_LINK"
log_info "版本目录: $VERSIONS_DIR/$current_version"
log_info "版本文件: $LATEST_VERSION_FILE"
# 显示LATEST_VERSION文件内容
if [[ -f "$LATEST_VERSION_FILE" ]]; then
local file_version=$(cat "$LATEST_VERSION_FILE" 2>/dev/null | tr -d '[:space:]')
log_info "版本文件内容: $file_version"
fi
echo
log_info "目录结构:"
if [[ -d "$INSTALL_DIR" ]]; then
tree -L 2 "$INSTALL_DIR" 2>/dev/null || ls -la "$INSTALL_DIR"
fi
echo
log_info "可用版本:"
if [[ -d "$VERSIONS_DIR" ]]; then
ls -1 "$VERSIONS_DIR" 2>/dev/null | sed 's/^/ - /'
else
echo " 无"
fi
echo
log_info "备份版本:"
if [[ -d "$BACKUPS_DIR" ]] && [[ $(ls -1 "$BACKUPS_DIR" 2>/dev/null | wc -l) -gt 0 ]]; then
ls -1t "$BACKUPS_DIR" 2>/dev/null | sed 's/^/ - /'
else
echo " 无"
fi
else
log_warning "Argus Metric 未安装"
log_info "安装目录: $INSTALL_DIR"
fi
}
# 列出备份
list_backups() {
echo "=========================================="
echo " Argus Metric 备份列表"
echo "=========================================="
echo
if [[ -d "$BACKUPS_DIR" ]] && [[ $(ls -1 "$BACKUPS_DIR" 2>/dev/null | wc -l) -gt 0 ]]; then
log_info "可用备份版本:"
ls -1t "$BACKUPS_DIR" 2>/dev/null | while read backup; do
local backup_time=$(stat -c %y "$BACKUPS_DIR/$backup" 2>/dev/null | cut -d' ' -f1-2)
echo " - $backup (创建时间: $backup_time)"
done
else
log_warning "没有可用的备份版本"
fi
}
# 回滚功能
rollback_version() {
log_info "开始回滚操作..."
if ! check_installed; then
log_error "没有检测到已安装的版本,无法回滚"
exit 1
fi
# 获取最新的备份
local latest_backup=$(ls -1t "$BACKUPS_DIR" 2>/dev/null | head -n 1)
if [[ -z "$latest_backup" ]]; then
log_error "没有找到可用的备份版本"
exit 1
fi
log_info "将回滚到备份版本: $latest_backup"
if rollback_to_backup "$latest_backup"; then
log_success "回滚完成!"
# 显示当前状态
echo
show_status
else
log_error "回滚失败"
exit 1
fi
}
# 主函数
main() {
echo "=========================================="
echo " Argus Metric 在线安装脚本 v1.0"
echo "=========================================="
echo
# 对于状态和备份列表操作不需要FTP参数和root权限
if [[ "$ACTION" == "status" || "$ACTION" == "backup-list" ]]; then
if [[ "$ACTION" == "status" ]]; then
show_status
elif [[ "$ACTION" == "backup-list" ]]; then
list_backups
fi
return 0
fi
check_root
# 更新目录配置变量在设置INSTALL_DIR后
VERSIONS_DIR="$INSTALL_DIR/versions"
BACKUPS_DIR="$INSTALL_DIR/backups"
CURRENT_LINK="$INSTALL_DIR/current"
LATEST_VERSION_FILE="$INSTALL_DIR/LATEST_VERSION"
# 对于回滚操作不需要FTP参数
if [[ "$ACTION" == "rollback" ]]; then
rollback_version
return 0
fi
check_ftp_params
check_system
if [[ "$ACTION" == "uninstall" ]]; then
uninstall_argus_metric
else
install_argus_metric
fi
echo
log_info "操作完成!"
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,274 @@
#!/bin/bash
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 配置变量
INSTALL_DIR="/opt/aiops"
TEMP_DIR="/tmp/aiops-uninstall-$$"
VERSION_FILE="version.json"
# 检查是否为 root 用户
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本需要 root 权限运行"
log_info "请使用: sudo $0"
exit 1
fi
}
# 查找版本文件
find_version_file() {
log_info "查找版本信息文件..."
# 在当前目录查找
if [[ -f "$VERSION_FILE" ]]; then
VERSION_FILE_PATH="$VERSION_FILE"
log_success "找到版本文件: $VERSION_FILE"
return 0
fi
# 在 artifact 目录查找
for version_dir in artifact/*/; do
if [[ -f "${version_dir}${VERSION_FILE}" ]]; then
VERSION_FILE_PATH="${version_dir}${VERSION_FILE}"
log_success "找到版本文件: $VERSION_FILE_PATH"
return 0
fi
done
log_error "未找到版本信息文件 $VERSION_FILE"
log_info "请确保在正确的目录下运行此脚本"
exit 1
}
# 解析版本信息
parse_version_info() {
log_info "解析版本信息..."
if [[ ! -f "$VERSION_FILE_PATH" ]]; then
log_error "版本文件不存在: $VERSION_FILE_PATH"
exit 1
fi
# 使用 jq 解析 JSON如果可用
if command -v jq &> /dev/null; then
VERSION=$(jq -r '.version' "$VERSION_FILE_PATH")
BUILD_TIME=$(jq -r '.build_time' "$VERSION_FILE_PATH")
# 解析 install_order现在包含完整的文件名
if jq -e '.install_order' "$VERSION_FILE_PATH" > /dev/null 2>&1; then
jq -r '.install_order[]' "$VERSION_FILE_PATH" > "$TEMP_DIR/install_order.txt"
else
log_error "version.json 中缺少 install_order 字段"
exit 1
fi
else
log_warning "jq 未安装,使用简单的 JSON 解析"
VERSION=$(grep '"version"' "$VERSION_FILE_PATH" | sed 's/.*"version": *"\([^"]*\)".*/\1/')
BUILD_TIME=$(grep '"build_time"' "$VERSION_FILE_PATH" | sed 's/.*"build_time": *"\([^"]*\)".*/\1/')
# 解析 install_order
grep -A 100 '"install_order"' "$VERSION_FILE_PATH" | grep -E '^\s*"[^"]+"' | while read line; do
component=$(echo "$line" | sed 's/.*"\([^"]*\)".*/\1/')
echo "$component" >> "$TEMP_DIR/install_order.txt"
done
fi
log_success "版本信息解析完成"
log_info " 版本: $VERSION"
log_info " 构建时间: $BUILD_TIME"
}
# 创建临时目录
create_temp_dirs() {
log_info "创建临时目录..."
mkdir -p "$TEMP_DIR"
log_success "临时目录创建完成: $TEMP_DIR"
}
# 卸载组件
uninstall_components() {
log_info "开始卸载组件..."
artifact_dir=$(dirname "$VERSION_FILE_PATH")
uninstall_count=0
total_count=0
if [[ -f "$TEMP_DIR/install_order.txt" ]]; then
total_count=$(wc -l < "$TEMP_DIR/install_order.txt")
fi
if [[ -f "$TEMP_DIR/install_order.txt" ]]; then
while IFS= read -r filename; do
uninstall_count=$((uninstall_count + 1))
# 从文件名中提取组件名(去掉时间戳后缀)
component=$(echo "$filename" | sed 's/-[0-9]\{8\}-[0-9]\{6\}\.tar\.gz$//')
log_info "[$uninstall_count/$total_count] 卸载 $component..."
# 直接使用完整的文件名
tar_file="$artifact_dir/$filename"
if [[ ! -f "$tar_file" ]]; then
log_error "找不到组件文件: $filename"
exit 1
fi
# 解压到临时目录
component_temp_dir="$TEMP_DIR/$component"
mkdir -p "$component_temp_dir"
if tar -xzf "$tar_file" -C "$component_temp_dir"; then
log_success " $component 解压完成"
else
log_error " $component 解压失败"
exit 1
fi
# 查找解压后的目录
extracted_dir=""
for dir in "$component_temp_dir"/*; do
if [[ -d "$dir" ]]; then
extracted_dir="$dir"
break
fi
done
if [[ -z "$extracted_dir" ]]; then
log_error " $component 解压后未找到目录"
exit 1
fi
# 执行卸载脚本
if [[ -f "$extracted_dir/uninstall.sh" ]]; then
log_info " 执行 $component 卸载脚本..."
# 所有组件都只需要一个确认
if (cd "$extracted_dir" && echo "y" | ./uninstall.sh); then
log_success " $component 卸载完成"
else
log_error " $component 卸载失败"
exit 1
fi
else
log_warning " $component 缺少 uninstall.sh 文件,跳过卸载"
fi
# 清理临时文件
rm -rf "$component_temp_dir"
done < "$TEMP_DIR/install_order.txt"
fi
log_success "所有组件卸载完成"
}
# 清理全局文件
cleanup_global_files() {
log_info "清理全局文件..."
# 清理安装目录
if [[ -d "$INSTALL_DIR" ]]; then
rm -rf "$INSTALL_DIR"
log_success "安装目录已清理: $INSTALL_DIR"
else
log_info "安装目录不存在: $INSTALL_DIR"
fi
# 清理可能的全局配置文件
local global_configs=(
"/etc/aiops"
"/var/log/aiops"
)
for config in "${global_configs[@]}"; do
if [[ -d "$config" ]]; then
rm -rf "$config"
log_success "全局配置已清理: $config"
fi
done
}
# 显示卸载信息
show_uninstall_info() {
log_success "AIOps All-in-One 卸载完成!"
echo
echo "卸载信息:"
echo " 版本: $VERSION"
echo " 构建时间: $BUILD_TIME"
echo
echo "清理内容:"
echo " - 二进制文件"
echo " - 配置文件"
echo " - 数据目录"
echo " - 进程和服务"
echo " - 全局安装目录"
echo
echo "注意:"
echo " - 系统依赖包可能仍然存在"
echo " - 如需完全清理,请手动检查并删除相关文件"
echo
}
# 清理函数
cleanup() {
if [[ -d "$TEMP_DIR" ]]; then
rm -rf "$TEMP_DIR"
fi
}
# 设置清理陷阱
trap cleanup EXIT
# 主函数
main() {
echo "=========================================="
echo " AIOps All-in-One 卸载脚本"
echo "=========================================="
echo
check_root
find_version_file
create_temp_dirs
parse_version_info
log_warning "此操作将完全卸载 AIOps All-in-One"
read -p "确认继续?(y/N): " confirm
if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
log_info "取消卸载操作"
exit 0
fi
uninstall_components
cleanup_global_files
show_uninstall_info
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,350 @@
#!/bin/bash
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 显示帮助信息
show_help() {
echo "AIOps 版本管理工具"
echo
echo "用法: $0 <command> [options]"
echo
echo "命令:"
echo " bump <type> - 升级版本号 (major|minor|patch)"
echo " set <version> - 设置指定版本号"
echo " show - 显示当前版本信息"
echo " list - 列出所有版本"
echo " clean - 清理旧版本"
echo " validate - 验证版本配置"
echo
echo "示例:"
echo " $0 bump minor # 升级次版本号 1.0.0 -> 1.1.0"
echo " $0 set 2.0.0 # 设置版本为 2.0.0"
echo " $0 show # 显示当前版本"
echo " $0 list # 列出所有版本"
}
# 获取当前版本
get_current_version() {
if [[ -f "VERSION" ]]; then
cat VERSION
else
echo "0.0.0"
fi
}
# 设置版本号
set_version() {
local new_version="$1"
# 验证版本号格式
if [[ ! "$new_version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
log_error "无效的版本号格式: $new_version"
log_info "版本号格式应为: major.minor.patch (如: 1.2.3)"
exit 1
fi
echo "$new_version" > VERSION
log_success "版本号已设置为: $new_version"
}
# 升级版本号
bump_version() {
local bump_type="$1"
local current_version=$(get_current_version)
# 解析当前版本号
IFS='.' read -r major minor patch <<< "$current_version"
case "$bump_type" in
"major")
major=$((major + 1))
minor=0
patch=0
;;
"minor")
minor=$((minor + 1))
patch=0
;;
"patch")
patch=$((patch + 1))
;;
*)
log_error "无效的升级类型: $bump_type"
log_info "支持的类型: major, minor, patch"
exit 1
;;
esac
local new_version="$major.$minor.$patch"
set_version "$new_version"
log_success "版本号已从 $current_version 升级到 $new_version"
}
# 显示当前版本信息
show_version() {
local current_version=$(get_current_version)
log_info "当前版本: $current_version"
if [[ -f "checklist" ]]; then
echo
echo "组件清单:"
while IFS= read -r line; do
[[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
read -r component version dep order <<< "$line"
if [[ -n "$component" && -n "$version" ]]; then
echo " - $component v$version"
fi
done < checklist
fi
# 检查是否有对应的 artifact
local artifact_dir="artifact/$current_version"
if [[ -d "$artifact_dir" ]]; then
echo
echo "已构建的组件:"
for file in "$artifact_dir"/*.tar.gz; do
if [[ -f "$file" ]]; then
local filename=$(basename "$file")
local size=$(du -h "$file" | cut -f1)
echo " - $filename ($size)"
fi
done
if [[ -f "$artifact_dir/version.json" ]]; then
echo
echo "版本信息文件: $artifact_dir/version.json"
fi
else
echo
log_warning "未找到对应的构建目录: $artifact_dir"
log_info "运行 ./package.sh 进行构建"
fi
}
# 列出所有版本
list_versions() {
log_info "所有版本列表:"
echo
if [[ ! -d "artifact" ]]; then
log_warning "artifact 目录不存在"
return
fi
for version_dir in artifact/*/; do
if [[ -d "$version_dir" ]]; then
local version=$(basename "$version_dir")
local current_version=$(get_current_version)
if [[ "$version" == "$current_version" ]]; then
echo " * $version (当前版本)"
else
echo " $version"
fi
# 显示该版本的组件
local component_count=0
for file in "$version_dir"/*.tar.gz; do
if [[ -f "$file" ]]; then
component_count=$((component_count + 1))
fi
done
if [[ $component_count -gt 0 ]]; then
echo " 包含 $component_count 个组件"
fi
fi
done
}
# 清理旧版本
clean_versions() {
local current_version=$(get_current_version)
local keep_versions=5 # 保留最近5个版本
log_info "清理旧版本 (保留最近 $keep_versions 个版本)..."
if [[ ! -d "artifact" ]]; then
log_warning "artifact 目录不存在"
return
fi
# 获取所有版本目录,按修改时间排序
local versions=()
while IFS= read -r -d '' version_dir; do
versions+=("$(basename "$version_dir")")
done < <(find artifact -maxdepth 1 -type d -name "[0-9]*" -print0 | sort -z)
local total_versions=${#versions[@]}
local versions_to_remove=$((total_versions - keep_versions))
if [[ $versions_to_remove -le 0 ]]; then
log_info "无需清理,当前只有 $total_versions 个版本"
return
fi
log_info "将删除 $versions_to_remove 个旧版本..."
for ((i=0; i<versions_to_remove; i++)); do
local version="${versions[i]}"
if [[ "$version" != "$current_version" ]]; then
log_info "删除版本: $version"
rm -rf "artifact/$version"
fi
done
log_success "旧版本清理完成"
}
# 验证版本配置
validate_version() {
log_info "验证版本配置..."
local errors=0
# 检查 VERSION 文件
if [[ ! -f "VERSION" ]]; then
log_error "VERSION 文件不存在"
errors=$((errors + 1))
else
local version=$(get_current_version)
if [[ ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
log_error "VERSION 文件格式无效: $version"
errors=$((errors + 1))
else
log_success "VERSION 文件格式正确: $version"
fi
fi
# 检查 checklist 文件
if [[ ! -f "checklist" ]]; then
log_error "checklist 文件不存在"
errors=$((errors + 1))
else
local component_count=0
while IFS= read -r line; do
[[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
read -r component version dep order <<< "$line"
if [[ -n "$component" && -n "$version" ]]; then
component_count=$((component_count + 1))
# 检查组件目录是否存在
if [[ ! -d "components/$component" ]]; then
log_error "组件目录不存在: components/$component"
errors=$((errors + 1))
fi
fi
done < checklist
if [[ $component_count -gt 0 ]]; then
log_success "checklist 包含 $component_count 个组件"
else
log_error "checklist 中没有有效组件"
errors=$((errors + 1))
fi
fi
# 检查 package.sh 文件
if [[ ! -f "package.sh" ]]; then
log_error "package.sh 文件不存在"
errors=$((errors + 1))
else
if [[ -x "package.sh" ]]; then
log_success "package.sh 可执行"
else
log_warning "package.sh 不可执行,请运行: chmod +x package.sh"
fi
fi
# 检查 install.sh 文件
if [[ ! -f "install.sh" ]]; then
log_error "install.sh 文件不存在"
errors=$((errors + 1))
else
if [[ -x "install.sh" ]]; then
log_success "install.sh 可执行"
else
log_warning "install.sh 不可执行,请运行: chmod +x install.sh"
fi
fi
if [[ $errors -eq 0 ]]; then
log_success "版本配置验证通过"
else
log_error "发现 $errors 个配置问题"
exit 1
fi
}
# 主函数
main() {
case "${1:-}" in
"bump")
if [[ -z "${2:-}" ]]; then
log_error "请指定升级类型: major, minor, patch"
exit 1
fi
bump_version "$2"
;;
"set")
if [[ -z "${2:-}" ]]; then
log_error "请指定版本号"
exit 1
fi
set_version "$2"
;;
"show")
show_version
;;
"list")
list_versions
;;
"clean")
clean_versions
;;
"validate")
validate_version
;;
"help"|"-h"|"--help")
show_help
;;
"")
show_help
;;
*)
log_error "未知命令: $1"
echo
show_help
exit 1
;;
esac
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,55 @@
#!/bin/bash
# Node Exporter 健康检查脚本
# 输出 JSON 格式结果
set -e
# 检查 Node Exporter 健康状态
check_health() {
local url="http://localhost:9100"
local metrics_url="$url/metrics"
local name="node-exporter"
local status="unhealth"
local reason=""
# 检查 curl 是否可用
if ! command -v curl &> /dev/null; then
reason="curl 命令不可用,无法进行健康检查"
echo "{\"name\": \"$name\", \"status\": \"$status\", \"reason\": \"$reason\"}"
exit 1
fi
# 测试根路径连接
local http_code=$(curl -s -o /dev/null -w "%{http_code}" "$url" 2>/dev/null || echo "000")
if [[ "$http_code" == "200" ]]; then
# 测试 metrics 端点
local metrics_code=$(curl -s -o /dev/null -w "%{http_code}" "$metrics_url" 2>/dev/null || echo "000")
if [[ "$metrics_code" == "200" ]]; then
status="health"
reason="success"
echo "{\"name\": \"$name\", \"status\": \"$status\", \"reason\": \"$reason\"}"
exit 0
else
reason="Metrics 端点异常 (HTTP $metrics_code)"
echo "{\"name\": \"$name\", \"status\": \"$status\", \"reason\": \"$reason\"}"
exit 1
fi
else
reason="HTTP 服务异常 (HTTP $http_code),请检查 Node Exporter 是否正在运行在端口 9100"
echo "{\"name\": \"$name\", \"status\": \"$status\", \"reason\": \"$reason\"}"
exit 1
fi
}
# 主函数
main() {
check_health
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,297 @@
#!/bin/bash
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 显示帮助信息
show_help() {
echo "Node Exporter 安装脚本"
echo
echo "用法: $0 [选项]"
echo
echo "选项:"
echo " --help 显示此帮助信息"
echo
echo "示例:"
echo " $0 # 安装 Node Exporter"
echo
}
# 解析命令行参数
for arg in "$@"; do
case $arg in
--help|-h)
show_help
exit 0
;;
*)
log_error "未知参数: $arg"
show_help
exit 1
;;
esac
done
# 检查是否为 root 用户
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本需要 root 权限运行"
log_info "请使用: sudo $0"
exit 1
fi
}
# 检查系统要求
check_system() {
log_info "检查系统要求..."
# 检查操作系统
if [[ ! -f /etc/os-release ]]; then
log_error "无法检测操作系统版本"
exit 1
fi
source /etc/os-release
log_info "检测到操作系统: $NAME $VERSION"
# 检查是否为 Linux 系统
if [[ "$ID" != "ubuntu" && "$ID" != "debian" && "$ID" != "centos" && "$ID" != "rhel" && "$ID" != "fedora" ]]; then
log_warning "此脚本主要针对常见 Linux 发行版,其他系统可能需要调整"
fi
# 检查系统架构
local arch=$(uname -m)
log_info "系统架构: $arch"
if [[ "$arch" != "x86_64" && "$arch" != "amd64" ]]; then
log_warning "当前架构为 $archnode_exporter 主要支持 x86_64/amd64"
fi
}
# 停止可能运行的服务
stop_existing_service() {
log_info "检查并停止可能运行的服务..."
local pid_file="/var/run/node-exporter.pid"
# 检查并停止通过 PID 文件管理的服务
if [[ -f "$pid_file" ]]; then
local pid=$(cat "$pid_file")
if kill -0 "$pid" 2>/dev/null; then
log_info "发现正在运行的 Node Exporter 服务 (PID: $pid),正在停止..."
kill "$pid"
sleep 2
if kill -0 "$pid" 2>/dev/null; then
log_warning "进程未响应,强制终止..."
kill -9 "$pid" 2>/dev/null || true
fi
rm -f "$pid_file"
log_success "服务已停止"
else
log_warning "发现过期的 PID 文件,正在清理..."
rm -f "$pid_file"
fi
fi
# 查找并停止所有 node_exporter 和 node-exporter 进程
local pids=$(pgrep -f "node_exporter\|node-exporter" 2>/dev/null || true)
if [[ -n "$pids" ]]; then
log_info "发现 node_exporter 或 node-exporter 进程,正在停止..."
for pid in $pids; do
log_info "停止进程 PID: $pid"
kill "$pid" 2>/dev/null || true
done
sleep 2
# 检查是否还有进程在运行,如果有则强制终止
local remaining_pids=$(pgrep -f "node_exporter\|node-exporter" 2>/dev/null || true)
if [[ -n "$remaining_pids" ]]; then
log_warning "进程未响应,强制终止..."
for pid in $remaining_pids; do
log_info "强制终止进程 PID: $pid"
kill -9 "$pid" 2>/dev/null || true
done
sleep 1
fi
# 最终检查
if pgrep -f "node_exporter\|node-exporter" > /dev/null; then
log_error "无法停止所有 node_exporter 进程"
else
log_success "所有 node_exporter 进程已停止"
fi
fi
}
# 安装 Node Exporter 二进制文件
install_node_exporter() {
log_info "安装 Node Exporter..."
local binary_file="bin/node_exporter"
local install_dir="/usr/local/bin"
if [[ ! -f "$binary_file" ]]; then
log_error "找不到 Node Exporter 二进制文件: $binary_file"
exit 1
fi
# 停止可能运行的服务
stop_existing_service
# 复制二进制文件并重命名为统一格式
cp "$binary_file" "$install_dir/node-exporter"
chmod +x "$install_dir/node-exporter"
log_success "Node Exporter 二进制文件安装完成"
}
# 创建用户和组
create_user() {
log_info "创建 node_exporter 用户..."
# 检查用户是否已存在
if id "node_exporter" &>/dev/null; then
log_info "用户 node_exporter 已存在"
else
useradd --no-create-home --shell /bin/false node_exporter
log_success "用户 node_exporter 创建完成"
fi
}
# 安装配置文件
install_config() {
log_info "安装配置文件..."
local config_dir="/etc/node_exporter"
# 创建配置目录
mkdir -p "$config_dir"
# 创建文本文件收集器目录
mkdir -p "/var/lib/node_exporter/textfile_collector"
chown node_exporter:node_exporter "/var/lib/node_exporter/textfile_collector"
}
# 启动 Node Exporter 服务
start_node_exporter() {
log_info "启动 Node Exporter 服务..."
local binary_path="/usr/local/bin/node-exporter"
local log_file="/var/log/node-exporter.log"
local pid_file="/var/run/node-exporter.pid"
# 检查服务是否已经在运行
if [[ -f "$pid_file" ]]; then
local pid=$(cat "$pid_file")
if kill -0 "$pid" 2>/dev/null; then
log_info "Node Exporter 服务已在运行 (PID: $pid)"
return 0
else
log_warning "发现过期的 PID 文件,正在清理..."
rm -f "$pid_file"
fi
fi
# 检查端口是否被占用
if netstat -tuln 2>/dev/null | grep -q ":9100 "; then
log_warning "端口 9100 已被占用,请检查是否有其他服务在运行"
return 1
fi
# 启动服务
log_info "正在启动 Node Exporter..."
nohup "$binary_path" --web.listen-address=:9100 > "$log_file" 2>&1 &
local pid=$!
# 保存 PID
echo "$pid" > "$pid_file"
# 等待服务启动
sleep 2
# 检查服务是否成功启动
if kill -0 "$pid" 2>/dev/null; then
log_success "Node Exporter 服务启动成功 (PID: $pid)"
log_info "日志文件: $log_file"
log_info "PID 文件: $pid_file"
else
log_error "Node Exporter 服务启动失败"
rm -f "$pid_file"
return 1
fi
}
# 显示安装信息
show_install_info() {
log_success "Node Exporter 安装完成!"
echo
echo "安装信息:"
echo " 二进制文件: /usr/local/bin/node-exporter"
echo " 运行用户: node_exporter"
echo " 配置目录: /etc/node_exporter/"
echo " 默认端口: 9100"
echo
echo "使用方法:"
echo " 手动启动: /usr/local/bin/node-exporter --web.listen-address=:9100"
echo " 后台启动: nohup /usr/local/bin/node-exporter --web.listen-address=:9100 &"
echo
echo "测试连接:"
echo " curl http://localhost:9100/metrics"
echo " curl http://localhost:9100"
echo
echo "Prometheus 配置示例:"
echo " - job_name: 'node_exporter'"
echo " static_configs:"
echo " - targets: ['localhost:9100']"
echo
}
# 主函数
main() {
echo "=========================================="
echo " Node Exporter 安装脚本 v1.0"
echo "=========================================="
echo
check_root
check_system
log_info "开始安装 Node Exporter..."
install_node_exporter
create_user
install_config
start_node_exporter
show_install_info
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

View File

@ -0,0 +1,87 @@
#!/bin/bash
set -e
# 颜色定义
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
# 获取当前目录
CURRENT_DIR=$(pwd)
PACKAGE_NAME="node-exporter-installer-$(date +%Y%m%d-%H%M%S)"
PACKAGE_FILE="${PACKAGE_NAME}.tar.gz"
log_info "开始打包 Node Exporter 安装包..."
# 检查必要文件
log_info "检查必要文件..."
required_files=(
"install.sh"
"uninstall.sh"
"bin/node_exporter"
"check_health.sh"
)
missing_files=()
for file in "${required_files[@]}"; do
if [[ ! -f "$file" ]]; then
missing_files+=("$file")
fi
done
if [[ ${#missing_files[@]} -gt 0 ]]; then
echo "缺少以下文件:"
for file in "${missing_files[@]}"; do
echo " - $file"
done
exit 1
fi
log_success "所有必要文件检查完成"
# 创建临时目录
TEMP_DIR=$(mktemp -d)
log_info "创建临时目录: $TEMP_DIR"
# 复制文件到临时目录
cp -r . "$TEMP_DIR/$PACKAGE_NAME"
# 进入临时目录
cd "$TEMP_DIR"
# 创建压缩包
log_info "创建压缩包: $PACKAGE_FILE"
tar -czf "$PACKAGE_FILE" "$PACKAGE_NAME"
# 移动压缩包到原目录
mv "$PACKAGE_FILE" "$CURRENT_DIR/"
# 清理临时目录
rm -rf "$TEMP_DIR"
# 返回原目录
cd "$CURRENT_DIR"
# 显示结果
log_success "打包完成!"
echo
echo "安装包文件: $PACKAGE_FILE"
echo "文件大小: $(du -h "$PACKAGE_FILE" | cut -f1)"
echo
echo "使用方法:"
echo "1. 将 $PACKAGE_FILE 传输到目标服务器"
echo "2. 解压: tar -xzf $PACKAGE_FILE"
echo "3. 进入目录: cd $PACKAGE_NAME"
echo "4. 运行安装: sudo ./install.sh"
echo
echo "注意: 请确保所有必要文件都存在"

View File

@ -0,0 +1,239 @@
#!/bin/bash
# Node Exporter 卸载脚本
# 版本: 1.0
# 作者: AIOps Team
# 日期: $(date +%Y-%m-%d)
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 检查是否为 root 用户
check_root() {
if [[ $EUID -ne 0 ]]; then
log_error "此脚本需要 root 权限运行"
log_info "请使用: sudo $0"
exit 1
fi
}
# 停止运行中的进程
stop_processes() {
log_info "停止 Node Exporter 进程..."
local pid_file="/var/run/node-exporter.pid"
local stopped=false
# 首先尝试通过 PID 文件停止服务
if [[ -f "$pid_file" ]]; then
local pid=$(cat "$pid_file")
if kill -0 "$pid" 2>/dev/null; then
log_info "通过 PID 文件停止服务 (PID: $pid)..."
kill "$pid"
sleep 3
# 检查进程是否已停止
if kill -0 "$pid" 2>/dev/null; then
log_warning "进程未响应,强制终止..."
kill -9 "$pid" 2>/dev/null || true
fi
log_success "Node Exporter 进程已停止"
stopped=true
else
log_warning "PID 文件存在但进程已不存在,清理 PID 文件"
rm -f "$pid_file"
fi
fi
# 查找并杀死所有 node_exporter 和 node-exporter 进程
local pids=$(pgrep -f "node_exporter\|node-exporter" 2>/dev/null || true)
if [[ -n "$pids" ]]; then
log_info "发现 node_exporter 或 node-exporter 进程,正在停止..."
for pid in $pids; do
log_info "停止进程 PID: $pid"
kill "$pid" 2>/dev/null || true
done
sleep 2
# 检查是否还有进程在运行,如果有则强制终止
local remaining_pids=$(pgrep -f "node_exporter\|node-exporter" 2>/dev/null || true)
if [[ -n "$remaining_pids" ]]; then
log_warning "进程未响应,强制终止..."
for pid in $remaining_pids; do
log_info "强制终止进程 PID: $pid"
kill -9 "$pid" 2>/dev/null || true
done
sleep 1
fi
# 最终检查
if pgrep -f "node_exporter\|node-exporter" > /dev/null; then
log_error "无法停止所有 node_exporter 进程"
else
log_success "所有 Node Exporter 进程已停止"
stopped=true
fi
else
log_info "Node Exporter 进程未运行"
fi
# 清理 PID 文件
rm -f "$pid_file"
if [[ "$stopped" == "false" ]]; then
log_warning "未发现需要停止的 Node Exporter 进程"
fi
}
# 删除二进制文件
remove_binary() {
log_info "删除 Node Exporter 二进制文件..."
local binary_files=(
"/usr/local/bin/node-exporter"
"/usr/local/bin/node_exporter"
)
local deleted=false
for binary_file in "${binary_files[@]}"; do
if [[ -f "$binary_file" ]]; then
rm -f "$binary_file"
log_success "二进制文件已删除: $binary_file"
deleted=true
fi
done
if [[ "$deleted" == "false" ]]; then
log_info "二进制文件不存在"
fi
}
# 删除配置文件
remove_config() {
log_info "删除配置文件..."
local config_dir="/etc/node_exporter"
if [[ -d "$config_dir" ]]; then
rm -rf "$config_dir"
log_success "配置目录已删除"
else
log_info "配置目录不存在"
fi
}
# 删除数据目录
remove_data_dir() {
log_info "删除数据目录..."
local data_dir="/var/lib/node_exporter"
if [[ -d "$data_dir" ]]; then
rm -rf "$data_dir"
log_success "数据目录已删除"
else
log_info "数据目录不存在"
fi
}
# 检查用户状态(可选)
check_user_status() {
log_info "检查 node_exporter 用户状态..."
if id "node_exporter" &>/dev/null; then
log_info "检测到 node_exporter 用户存在"
log_warning "node_exporter 是系统用户,可能被其他服务使用"
log_info "为了系统稳定性,将保留 node_exporter 用户"
log_info "如需手动删除,请运行: sudo userdel node_exporter"
else
log_info "node_exporter 用户不存在"
fi
}
# 清理日志文件
cleanup_logs() {
log_info "清理日志文件..."
# 清理 journal 日志
journalctl --vacuum-time=1s --quiet || true
# 删除安装脚本创建的日志文件
rm -f /var/log/node-exporter.log
log_success "日志文件已清理"
}
# 显示卸载信息
show_uninstall_info() {
log_success "Node Exporter 卸载完成!"
echo
echo "已删除的内容:"
echo " - 二进制文件: /usr/local/bin/node-exporter"
echo " - 配置目录: /etc/node_exporter"
echo " - 数据目录: /var/lib/node_exporter"
echo " - 相关日志文件"
echo
echo "注意:"
echo " - node_exporter 用户已保留(系统用户,可能被其他服务使用)"
echo " - 如需完全清理,请手动检查并删除相关文件"
echo
}
# 主函数
main() {
echo "=========================================="
echo " Node Exporter 卸载脚本 v1.0"
echo "=========================================="
echo
check_root
log_warning "此操作将完全卸载 Node Exporter"
read -p "确认继续?(y/N): " confirm
if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
log_info "取消卸载操作"
exit 0
fi
log_info "开始卸载 Node Exporter..."
stop_processes
remove_binary
remove_config
remove_data_dir
cleanup_logs
# 检查用户状态
check_user_status
show_uninstall_info
}
# 脚本入口
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi

Binary file not shown.

View File

@ -0,0 +1,111 @@
# vsftpd 配置
配置 vsftpd FTP 服务器。
# 安装deps下 vsftpd 的离线安装包
sudo dpkg -i vsftpd_3.0.5-0ubuntu1.1_amd64.deb
# 有依赖问题,修复依赖
sudo apt-get install -f
## 启动服务
sudo service vsftpd start
# 重启服务
sudo service vsftpd restart
# 查看状态
sudo service vsftpd status
## 备份配置文件
先备份默认配置,出问题能恢复:
```bash
sudo cp /etc/vsftpd.conf /etc/vsftpd.conf.bak
```
## 修改配置文件
编辑配置:
```bash
sudo vim /etc/vsftpd.conf
```
### 基本配置参数
```bash
# 允许本地用户登录
local_enable=YES
# 允许写操作(上传/删除/修改)
write_enable=YES
# 限制用户在自己目录中,不能访问整个系统
chroot_local_user=YES
# 防止 chroot 错误(重要!)
allow_writeable_chroot=YES
# 被动模式配置
pasv_enable=YES
pasv_min_port=30000
pasv_max_port=31000
```
## 创建 FTP 目录和用户
### 创建共享目录
```bash
sudo mkdir -p /srv/ftp/share
sudo chmod 755 /srv/ftp/share
```
### 创建专用用户
```bash
sudo adduser ftpuser
# 修改用户主目录
sudo usermod -d /srv/ftp/share ftpuser
```
## 重启服务
```bash
sudo service vsftpd restart
```
## 防火墙配置
### 开放基本端口
```bash
sudo ufw allow 21/tcp
```
### 开放被动模式端口
```bash
sudo ufw allow 30000:31000/tcp
```
## 测试连接
```bash
# 本地测试
ftp localhost
# 远程测试
ftp 你的服务器IP
```
用户名ftpuser
密码:设置的密码

View File

@ -0,0 +1,49 @@
#!/bin/bash
# vsftpd 离线安装脚本
# 使用方法:./vsftpd-offline-install.sh
set -e
echo "开始 vsftpd 离线安装..."
# 检查是否为 root 用户
if [ "$EUID" -ne 0 ]; then
echo "请使用 root 权限运行此脚本"
exit 1
fi
# 定义离线包目录
OFFLINE_DIR="./vsftpd-offline"
DEB_DIR="$OFFLINE_DIR/debs"
# 检查离线包是否存在
if [ ! -d "$OFFLINE_DIR" ]; then
echo "错误:找不到离线包目录 $OFFLINE_DIR"
echo "请先准备离线包,方法:"
echo "1. 在有网络的机器上运行:"
echo " mkdir -p $DEB_DIR"
echo " cd $DEB_DIR"
echo " apt download vsftpd"
echo " apt download \$(apt-cache depends vsftpd | grep Depends | cut -d: -f2 | tr -d ' ')"
echo "2. 将整个 $OFFLINE_DIR 目录拷贝到目标机器"
exit 1
fi
# 安装 deb 包
echo "安装 vsftpd 及依赖包..."
cd "$DEB_DIR"
dpkg -i *.deb || apt-get install -f -y
# 检查安装状态
if systemctl is-active --quiet vsftpd; then
echo "vsftpd 安装成功并已启动"
else
echo "启动 vsftpd 服务..."
systemctl start vsftpd
systemctl enable vsftpd
fi
echo "vsftpd 离线安装完成!"
echo "配置文件位置: /etc/vsftpd.conf"
echo "服务状态: $(systemctl is-active vsftpd)"

View File

@ -0,0 +1,15 @@
global:
scrape_interval: 15s
scrape_configs:
- job_name: "node"
file_sd_configs:
- files:
- "targets/node_exporter.json"
refresh_interval: 30s
- job_name: "dcgm"
file_sd_configs:
- files:
- "targets/dcgm_exporter.json"
refresh_interval: 30s

View File

@ -0,0 +1,9 @@
[
{
"targets": ["localhost:9400"],
"labels": {
"job": "dcgm",
"instance": "dcgm-exporter"
}
}
]

View File

@ -0,0 +1,9 @@
[
{
"targets": ["localhost:9100", "192.168.16.116:9100"],
"labels": {
"job": "node",
"instance": "node-exporter"
}
}
]