feat: 运维标杆化打磨 P0/P1/P2 —— 审计日志、真实指标、备份恢复、菜单收敛
审计发现 5 处硬伤（/metrics 空壳、零备份、prod 双副本数据分裂、零审计、资源偏紧），
本轮全部落地。
=== P0-1 真实 /metrics（原来是空壳）===
原实现只返回一行注释 `# LokiStack Metrics`，注释却写着"可被 Prometheus 抓取"，
平台挂了/DB 写不进去/告警引擎卡死都只能靠用户反馈。
现接入 prometheus/client_golang，四层指标：
HTTP : lokistack_http_requests_total / _duration_seconds / _in_flight_requests
存储 : lokistack_db_size_bytes / _db_save_duration_seconds / _db_save_total / _db_records
业务 : lokistack_deployments{status,mode} / lokistack_collectors{status,type,run_mode}
后台任务: lokistack_alert_evaluations_total / _duration_seconds / lokistack_loki_queries_total
+ go_* / process_*（GoCollector、ProcessCollector）
关键点：path 标签用 c.FullPath() 路由模板，不用原始 URL —— 否则 117 个 Deployment
会把 Prometheus 基数炸掉。指标定义下沉 pkg/metrics 叶子包，避开
services ↔ repository 循环依赖。
=== P0-2 备份与恢复（原来 0 处代码）===
平台全部状态在 /app/data/opsxloki.json（51KB）+ kubeconfigs/ + known_hosts/，
DB 丢了 = 失去"这些资源是谁建的"的映射，从此无法管理/卸载/升级在跑的 Loki。
CLI : lokistack backup --output <path> / restore <pkg> / self-check / version
API : GET /system/backup（下载）/ POST /system/restore（校验暂存）/
POST /system/restore/apply（确认应用）/ GET /system/backups
K8s : kubernetes/pdb-backup.yaml —— 每日 03:30 CronJob，保留最近 7 份
安全设计：
- manifest.json 记录 ENCRYPTION_KEY 的 sha256 前 16 位**指纹**，用于恢复时
校验"这把钥匙能不能解开这份备份"，不泄露密钥本身
- 恢复分两步（校验暂存 → 确认应用），应用前自动把当前 DB 备份为
opsxloki.json.before-restore.<时间戳>
- 包内不含明文密钥（kubeconfig 本就是加密态）
=== P0-3 prod compose 双副本 → 单副本 ===
lokistack-1 / lokistack-2 各挂独立数据卷 + nginx 轮询 = 数据分裂：
页面刷新两次可能看到不同结果，写操作只落一个副本。不是高可用。
已改单实例（nginx 仅做反代），文件顶部与 nginx.conf 都写明原因。
=== P0-4 操作审计日志（借鉴 /usr/local/src/aiops 的字段口径）===
aiops 是每个 controller 各写 recordXxxAudit()；本平台有 60+ 写接口，
逐个埋点必然漏，漏掉的那个恰好最危险（删集群、改存储凭证）。
改为 **gin 中间件统一记录** + handler 通过 SetAudit 补充业务语义：
models/audit.go : 字段对齐 aiops，另加 Method/Path/Before/After
services/audit.go : 写入 + 90 天/2 万条自动裁剪 + 脱敏 + diff 生成
middleware/audit.go : 自动识别 module/action/resource，跳过只读接口
controllers/audit.go: 列表/详情/统计（仅 admin）
敏感字段（password/secretKey/privateKey/token）写入前统一替换为 ***。
=== P1 稳定性 ===
- 平台资源 1C/1Gi → 4C/4Gi 限（500m/512Mi 请求）：JSON DB 全量读写 +
每分钟告警评估 + 批量发布并发，1Gi 会 OOM
- terminationGracePeriodSeconds: 30 —— 收到 SIGTERM 要等 DB 完整落盘，
否则 kubelet SIGKILL 会把 JSON 写一半（全库丢失）
- liveness timeoutSeconds 10s（默认 1s 写盘时会被误杀）
- PDB minAvailable: 0 —— 让 kubectl drain 正确等待重建，不卡维护
- DB schemaVersion + migrateSchema() 版本递进迁移（原先加字段全靠零值兜底）
- scripts/release.sh —— 不可变 tag <版本>-<日期>-<commit> + IfNotPresent，
根治 latest 并发构建互相覆盖导致的静默回滚（本项目已实际踩过）
- PVC 保持 30Gi（按长期增长预留，云盘单价低，不做在线扩容）
=== P2 易用性 ===
- 一键自检 GET /system/self-check + 仪表盘自检卡：真实探活 Loki /ready、
集群凭据解密、磁盘空间、主机状态、近 24h 失败操作
- 审计日志页 /audit：统计卡 + 用户名/模块/结果筛选 + 变更前后 diff 弹窗
- 菜单收敛 13 → 7（页内 tab 切换，URL 全部不变）：
资源接入 = 集群 + 主机 + 存储
日志服务 = Loki 实例 + 采集器
日志 = 查询 + 分析
系统管理 = 用户 + 审计 + 设置
新增 GroupTabs 组件 + meta.group/groupKey，侧栏按分组去重并正确高亮
测试：go vet 通过、go test 全绿、tsc 通过
This commit is contained in:
opsx committed
1 parent
f6af12a731
commit
b49677f6a6
37 files changed
+2983
-147
No files matched your search
@@ -12,6 +12,7 @@ import (
|
||||
"time"
|
||||
|
||||
"lokistack/models"
|
||||
"lokistack/pkg/metrics"
|
||||
"lokistack/repository"
|
||||
)
|
||||
|
||||
@@ -27,7 +28,19 @@ func StartAlertEngine() {
|
||||
alertTicker = time.NewTicker(alertCheckInterval)
|
||||
go func() {
|
||||
for range alertTicker.C {
|
||||
RunAlertCheck(context.Background())
|
||||
start := time.Now()
|
||||
// 告警引擎是后台 goroutine：卡死或 panic 时页面完全看不出来，
|
||||
// 只能靠这两个指标发现（配合 Grafana 告警）
|
||||
ok := true
|
||||
func() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
ok = false
|
||||
}
|
||||
}()
|
||||
RunAlertCheck(context.Background())
|
||||
}()
|
||||
metrics.ObserveAlertEvaluation(time.Since(start).Seconds(), ok)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
@@ -0,0 +1,309 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"lokistack/models"
|
||||
"lokistack/repository"
|
||||
)
|
||||
|
||||
const (
|
||||
// maxAuditLogs 审计日志条数上限。JSON DB 是全量读进内存、全量写盘，
|
||||
// 不设上限的话审计表会把内存和落盘时间一起拖垮。
|
||||
maxAuditLogs = 20000
|
||||
// auditRetention 审计日志保留天数（合规常见要求 90 天）
|
||||
auditRetention = 90 * 24 * time.Hour
|
||||
)
|
||||
|
||||
// RecordAudit 写入一条审计日志。
|
||||
//
|
||||
// 并发安全：直接拿 db 锁追加，与其它业务写入同一把锁，避免 RequestSave 时丢更新。
|
||||
// 裁剪：超过条数上限或保留期时从最早开始删。
|
||||
func RecordAudit(entry models.AuditLog) {
|
||||
db := repository.GetDB()
|
||||
if db == nil {
|
||||
return
|
||||
}
|
||||
db.Lock()
|
||||
defer db.Unlock()
|
||||
|
||||
if entry.CreatedAt.IsZero() {
|
||||
entry.CreatedAt = time.Now()
|
||||
}
|
||||
// 单字段长度保护：UA/Detail 可能来自客户端，不能无限制落盘
|
||||
entry.UserAgent = truncateRunes(entry.UserAgent, 200)
|
||||
entry.Detail = truncateRunes(entry.Detail, 500)
|
||||
entry.Before = truncateRunes(entry.Before, 1000)
|
||||
entry.After = truncateRunes(entry.After, 1000)
|
||||
entry.Error = truncateRunes(entry.Error, 500)
|
||||
entry.ResourceID = truncateRunes(entry.ResourceID, 128)
|
||||
|
||||
nextID := uint(1)
|
||||
for _, a := range db.AuditLogs {
|
||||
if a.ID >= nextID {
|
||||
nextID = a.ID + 1
|
||||
}
|
||||
}
|
||||
entry.ID = nextID
|
||||
db.AuditLogs = append(db.AuditLogs, entry)
|
||||
|
||||
pruneAuditLocked(db)
|
||||
db.RequestSave()
|
||||
}
|
||||
|
||||
// pruneAuditLocked 裁剪审计日志（调用方必须已持锁）。
|
||||
// 从头部（最早）开始丢，直到满足条数与保留期两条约束。
|
||||
func pruneAuditLocked(db *repository.JsonDB) {
|
||||
logs := db.AuditLogs
|
||||
cut := 0
|
||||
deadline := time.Now().Add(-auditRetention)
|
||||
|
||||
// 1) 先按保留期裁
|
||||
for cut < len(logs) && logs[cut].CreatedAt.Before(deadline) {
|
||||
cut++
|
||||
}
|
||||
// 2) 再按条数上限裁（保留最新的 maxAuditLogs 条）
|
||||
if remain := len(logs) - cut; remain > maxAuditLogs {
|
||||
cut += remain - maxAuditLogs
|
||||
}
|
||||
if cut > 0 {
|
||||
db.AuditLogs = append([]models.AuditLog{}, logs[cut:]...)
|
||||
}
|
||||
}
|
||||
|
||||
// ListAuditLogs 分页查询审计日志（按时间倒序）。
|
||||
func ListAuditLogs(q models.AuditQuery) ([]models.AuditLog, int64) {
|
||||
db := repository.GetDB()
|
||||
if db == nil {
|
||||
return nil, 0
|
||||
}
|
||||
db.RLock()
|
||||
all := db.AuditLogs
|
||||
db.RUnlock()
|
||||
|
||||
matched := make([]models.AuditLog, 0, len(all))
|
||||
for _, a := range all {
|
||||
if q.Username != "" && !strings.Contains(strings.ToLower(a.Username), strings.ToLower(q.Username)) {
|
||||
continue
|
||||
}
|
||||
if q.Module != "" && a.Module != q.Module {
|
||||
continue
|
||||
}
|
||||
if q.Action != "" && a.Action != q.Action {
|
||||
continue
|
||||
}
|
||||
if q.ResourceID != "" && !strings.Contains(a.ResourceID, q.ResourceID) {
|
||||
continue
|
||||
}
|
||||
switch q.Status {
|
||||
case 1:
|
||||
if a.Status < 200 || a.Status >= 300 {
|
||||
continue
|
||||
}
|
||||
case 2:
|
||||
if a.Status < 400 {
|
||||
continue
|
||||
}
|
||||
}
|
||||
if q.StartTime != nil && a.CreatedAt.Before(*q.StartTime) {
|
||||
continue
|
||||
}
|
||||
if q.EndTime != nil && a.CreatedAt.After(*q.EndTime) {
|
||||
continue
|
||||
}
|
||||
matched = append(matched, a)
|
||||
}
|
||||
|
||||
// 时间倒序
|
||||
sort.Slice(matched, func(i, j int) bool { return matched[i].CreatedAt.After(matched[j].CreatedAt) })
|
||||
|
||||
total := int64(len(matched))
|
||||
if q.PageSize <= 0 {
|
||||
q.PageSize = 20
|
||||
}
|
||||
if q.Page <= 0 {
|
||||
q.Page = 1
|
||||
}
|
||||
start := (q.Page - 1) * q.PageSize
|
||||
if start >= len(matched) {
|
||||
return []models.AuditLog{}, total
|
||||
}
|
||||
end := start + q.PageSize
|
||||
if end > len(matched) {
|
||||
end = len(matched)
|
||||
}
|
||||
return matched[start:end], total
|
||||
}
|
||||
|
||||
// GetAuditLog 取单条（详情弹窗用）。
|
||||
func GetAuditLog(id uint) (*models.AuditLog, error) {
|
||||
db := repository.GetDB()
|
||||
if db == nil {
|
||||
return nil, fmt.Errorf("数据库未初始化")
|
||||
}
|
||||
db.RLock()
|
||||
defer db.RUnlock()
|
||||
for i := range db.AuditLogs {
|
||||
if db.AuditLogs[i].ID == id {
|
||||
entry := db.AuditLogs[i]
|
||||
return &entry, nil
|
||||
}
|
||||
}
|
||||
return nil, fmt.Errorf("审计记录不存在")
|
||||
}
|
||||
|
||||
// AuditStatistics 统计卡片数据。
|
||||
func AuditStatistics() models.AuditStats {
|
||||
db := repository.GetDB()
|
||||
stats := models.AuditStats{}
|
||||
if db == nil {
|
||||
return stats
|
||||
}
|
||||
db.RLock()
|
||||
logs := db.AuditLogs
|
||||
db.RUnlock()
|
||||
|
||||
now := time.Now()
|
||||
todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
|
||||
weekStart := todayStart.AddDate(0, 0, -6)
|
||||
|
||||
moduleCount := map[string]int64{}
|
||||
userCount := map[string]int64{}
|
||||
for _, a := range logs {
|
||||
stats.TotalCount++
|
||||
if a.CreatedAt.After(todayStart) {
|
||||
stats.TodayCount++
|
||||
}
|
||||
if a.CreatedAt.After(weekStart) {
|
||||
stats.WeekCount++
|
||||
}
|
||||
if a.Status >= 400 {
|
||||
stats.FailCount++
|
||||
}
|
||||
moduleCount[a.Module]++
|
||||
if a.Username != "" {
|
||||
userCount[a.Username]++
|
||||
}
|
||||
}
|
||||
stats.TopModules = topN(moduleCount, 5)
|
||||
stats.TopUsers = topN(userCount, 5)
|
||||
return stats
|
||||
}
|
||||
|
||||
func topN(m map[string]int64, n int) []models.AuditCount {
|
||||
out := make([]models.AuditCount, 0, len(m))
|
||||
for k, v := range m {
|
||||
out = append(out, models.AuditCount{Name: k, Count: v})
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool {
|
||||
if out[i].Count == out[j].Count {
|
||||
return out[i].Name < out[j].Name
|
||||
}
|
||||
return out[i].Count > out[j].Count
|
||||
})
|
||||
if len(out) > n {
|
||||
out = out[:n]
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// ───────────────────────── 脱敏 / 摘要 ─────────────────────────
|
||||
|
||||
// auditSensitiveKeys 这些字段一律不进审计（只留「已修改」的痕迹）。
|
||||
var auditSensitiveKeys = map[string]bool{
|
||||
"password": true, "oldpassword": true, "newpassword": true,
|
||||
"secretkey": true, "accesskey": true, "secretaccesskey": true,
|
||||
"privatekey": true, "token": true, "accesstoken": true, "refreshtoken": true,
|
||||
"encryptionkey": true, "jwtsecret": true,
|
||||
}
|
||||
|
||||
// MaskAuditPayload 把请求体里的敏感值替换成 ***，返回脱敏后的 JSON 字符串。
|
||||
// 解析失败时返回 "<非 JSON 请求体>"，避免把表单里的密码原样落盘。
|
||||
func MaskAuditPayload(body []byte, maxLen int) string {
|
||||
if len(body) == 0 {
|
||||
return ""
|
||||
}
|
||||
var v interface{}
|
||||
if err := json.Unmarshal(body, &v); err != nil {
|
||||
return "<非 JSON 请求体，已省略>"
|
||||
}
|
||||
masked := maskValue(v)
|
||||
out, err := json.Marshal(masked)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return truncateRunes(string(out), maxLen)
|
||||
}
|
||||
|
||||
func maskValue(v interface{}) interface{} {
|
||||
switch t := v.(type) {
|
||||
case map[string]interface{}:
|
||||
out := make(map[string]interface{}, len(t))
|
||||
for k, val := range t {
|
||||
if auditSensitiveKeys[strings.ToLower(k)] {
|
||||
if s, ok := val.(string); ok && s == "" {
|
||||
out[k] = ""
|
||||
} else {
|
||||
out[k] = "***"
|
||||
}
|
||||
continue
|
||||
}
|
||||
out[k] = maskValue(val)
|
||||
}
|
||||
return out
|
||||
case []interface{}:
|
||||
out := make([]interface{}, len(t))
|
||||
for i, val := range t {
|
||||
out[i] = maskValue(val)
|
||||
}
|
||||
return out
|
||||
default:
|
||||
return v
|
||||
}
|
||||
}
|
||||
|
||||
// AuditDiff 生成「变更前后」摘要，只保留真正变化的字段。
|
||||
// prev/next 传脱敏后的 JSON 字符串；解析失败时返回空（不硬编码原文）。
|
||||
func AuditDiff(prev, next string) (string, string) {
|
||||
var a, b map[string]interface{}
|
||||
if prev == "" || next == "" || json.Unmarshal([]byte(prev), &a) != nil || json.Unmarshal([]byte(next), &b) != nil {
|
||||
return "", ""
|
||||
}
|
||||
before := map[string]interface{}{}
|
||||
after := map[string]interface{}{}
|
||||
for k, nv := range b {
|
||||
ov, existed := a[k]
|
||||
if !existed || fmt.Sprint(ov) != fmt.Sprint(nv) {
|
||||
if existed {
|
||||
before[k] = ov
|
||||
}
|
||||
after[k] = nv
|
||||
}
|
||||
}
|
||||
for k, ov := range a {
|
||||
if _, ok := b[k]; !ok {
|
||||
before[k] = ov
|
||||
}
|
||||
}
|
||||
if len(after) == 0 && len(before) == 0 {
|
||||
return "", ""
|
||||
}
|
||||
bs, _ := json.Marshal(before)
|
||||
as, _ := json.Marshal(after)
|
||||
return truncateRunes(string(bs), 1000), truncateRunes(string(as), 1000)
|
||||
}
|
||||
|
||||
func truncateRunes(s string, n int) string {
|
||||
if n <= 0 {
|
||||
return s
|
||||
}
|
||||
r := []rune(s)
|
||||
if len(r) <= n {
|
||||
return s
|
||||
}
|
||||
return string(r[:n]) + "…"
|
||||
}
|
||||
@@ -0,0 +1,337 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"archive/tar"
|
||||
"compress/gzip"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"lokistack/repository"
|
||||
)
|
||||
|
||||
// 备份/恢复设计要点
|
||||
//
|
||||
// 为什么必须有：平台的全部状态（部署/采集/存储/集群/主机/策略/告警/用户/审计）
|
||||
// 都在这一个 JSON 文件里；kubeconfig 虽然加密存在 DB 内，但解密依赖
|
||||
// ENCRYPTION_KEY（K8s Secret）。DB 丢了 = 平台失去"这些资源是谁建的"的映射，
|
||||
// 从此无法管理/卸载/升级正在跑的 Loki 与采集器。
|
||||
//
|
||||
// 安全取舍：
|
||||
// - 备份包内含加密后的 kubeconfig 与 known_hosts，**不含明文密钥**
|
||||
// - manifest 里只记录 ENCRYPTION_KEY 的指纹（sha256 前 16 位），
|
||||
// 用于恢复时校验"这把钥匙能不能解开这份备份"，不泄露密钥本身
|
||||
// - 恢复分两步（校验暂存 → 手动应用），避免一个误点就覆盖线上 DB
|
||||
|
||||
// BackupManifest 备份包元信息（放在包内 manifest.json）
|
||||
type BackupManifest struct {
|
||||
Version string `json:"version"`
|
||||
CreatedAt time.Time `json:"createdAt"`
|
||||
DBBytes int64 `json:"dbBytes"`
|
||||
DBSHA256 string `json:"dbSha256"`
|
||||
KeyFP string `json:"encryptionKeyFingerprint"`
|
||||
RecordCount int `json:"recordCount"`
|
||||
Note string `json:"note"`
|
||||
}
|
||||
|
||||
// backupExclude 备份时跳过的文件/目录（临时文件、lost+found、正在写的 restore 暂存）
|
||||
var backupExclude = map[string]bool{
|
||||
"lost+found": true, ".restore-pending": true, "backups": true,
|
||||
}
|
||||
|
||||
// CreateBackup 把 /app/data 打包成 tar.gz 写入 w。
|
||||
func CreateBackup(w io.Writer) (*BackupManifest, error) {
|
||||
dataDir := dataDirPath()
|
||||
dbPath := databasePath()
|
||||
|
||||
dbInfo, err := os.Stat(dbPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("读取数据库失败: %w", err)
|
||||
}
|
||||
dbBytes, err := os.ReadFile(dbPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("读取数据库失败: %w", err)
|
||||
}
|
||||
sum := sha256.Sum256(dbBytes)
|
||||
|
||||
db := repository.GetDB()
|
||||
recordCount := 0
|
||||
if db != nil {
|
||||
db.RLock()
|
||||
recordCount = len(db.Users) + len(db.Clusters) + len(db.Hosts) + len(db.Storages) +
|
||||
len(db.Deployments) + len(db.Collectors) + len(db.LogSources) +
|
||||
len(db.AlertRules) + len(db.NotifyChannels) + len(db.LogPolicyGroups) + len(db.AuditLogs)
|
||||
db.RUnlock()
|
||||
}
|
||||
|
||||
manifest := &BackupManifest{
|
||||
Version: "2.0.0",
|
||||
CreatedAt: time.Now(),
|
||||
DBBytes: dbInfo.Size(),
|
||||
DBSHA256: hex.EncodeToString(sum[:]),
|
||||
KeyFP: encryptionKeyFingerprint(),
|
||||
RecordCount: recordCount,
|
||||
Note: "包内 kubeconfig 为加密态；恢复必须使用同一把 ENCRYPTION_KEY，否则 kubeconfig 无法解密",
|
||||
}
|
||||
|
||||
gz := gzip.NewWriter(w)
|
||||
defer gz.Close()
|
||||
tw := tar.NewWriter(gz)
|
||||
defer tw.Close()
|
||||
|
||||
// 1) manifest
|
||||
mBytes, _ := json.MarshalIndent(manifest, "", " ")
|
||||
if err := writeTarFile(tw, "manifest.json", mBytes, 0o600); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// 2) data 目录下所有文件（DB + kubeconfigs/ + known_hosts/）
|
||||
err = filepath.Walk(dataDir, func(path string, info os.FileInfo, err error) error {
|
||||
if err != nil {
|
||||
return nil // 单个文件读不到不阻断整包
|
||||
}
|
||||
if path == dataDir {
|
||||
return nil
|
||||
}
|
||||
rel, err := filepath.Rel(dataDir, path)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
top := strings.SplitN(rel, string(os.PathSeparator), 2)[0]
|
||||
if backupExclude[top] {
|
||||
if info.IsDir() {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if info.IsDir() {
|
||||
return nil
|
||||
}
|
||||
// 跳过正在写的临时文件
|
||||
if strings.HasPrefix(filepath.Base(path), ".lokistack-") && strings.HasSuffix(path, ".tmp") {
|
||||
return nil
|
||||
}
|
||||
f, err := os.Open(path)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
defer f.Close()
|
||||
hdr := &tar.Header{
|
||||
Name: filepath.ToSlash(filepath.Join("data", rel)),
|
||||
Mode: int64(info.Mode().Perm()),
|
||||
Size: info.Size(),
|
||||
ModTime: info.ModTime(),
|
||||
}
|
||||
if err := tw.WriteHeader(hdr); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = io.Copy(tw, f)
|
||||
return err
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return manifest, nil
|
||||
}
|
||||
|
||||
func writeTarFile(tw *tar.Writer, name string, data []byte, mode int64) error {
|
||||
hdr := &tar.Header{Name: name, Mode: mode, Size: int64(len(data)), ModTime: time.Now()}
|
||||
if err := tw.WriteHeader(hdr); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := tw.Write(data)
|
||||
return err
|
||||
}
|
||||
|
||||
// RestoreResult 校验结果
|
||||
type RestoreResult struct {
|
||||
Manifest *BackupManifest `json:"manifest"`
|
||||
KeyMatches bool `json:"keyMatches"`
|
||||
RowsInBackup int `json:"rowsInBackup"`
|
||||
CurrentRows int `json:"currentRows"`
|
||||
StagedPath string `json:"stagedPath,omitempty"`
|
||||
Warning string `json:"warning,omitempty"`
|
||||
}
|
||||
|
||||
// ValidateAndStageBackup 校验备份包并暂存到 <dataDir>/.restore-pending/。
|
||||
//
|
||||
// 不在这一步直接覆盖线上 DB：恢复是不可逆操作，必须让人再确认一次
|
||||
// （页面上的「应用恢复」或 run.sh restore）。
|
||||
func ValidateAndStageBackup(r io.Reader) (*RestoreResult, error) {
|
||||
gr, err := gzip.NewReader(r)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("不是合法的 gzip 文件: %w", err)
|
||||
}
|
||||
defer gr.Close()
|
||||
tr := tar.NewReader(gr)
|
||||
|
||||
var (
|
||||
manifest *BackupManifest
|
||||
dbBytes []byte
|
||||
)
|
||||
for {
|
||||
hdr, err := tr.Next()
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("解包失败: %w", err)
|
||||
}
|
||||
switch {
|
||||
case hdr.Name == "manifest.json":
|
||||
b, _ := io.ReadAll(io.LimitReader(tr, 1<<20))
|
||||
var m BackupManifest
|
||||
if err := json.Unmarshal(b, &m); err == nil {
|
||||
manifest = &m
|
||||
}
|
||||
case hdr.Name == "data/opsxloki.json":
|
||||
dbBytes, _ = io.ReadAll(io.LimitReader(tr, 64<<20))
|
||||
}
|
||||
}
|
||||
if manifest == nil {
|
||||
return nil, fmt.Errorf("备份包缺少 manifest.json，不是本平台导出的备份")
|
||||
}
|
||||
if len(dbBytes) == 0 {
|
||||
return nil, fmt.Errorf("备份包内没有 data/opsxloki.json")
|
||||
}
|
||||
|
||||
// 校验 DB 完整性：必须是合法 JSON 且能解析出预期集合
|
||||
var probe map[string]json.RawMessage
|
||||
if err := json.Unmarshal(dbBytes, &probe); err != nil {
|
||||
return nil, fmt.Errorf("备份内的数据库不是合法 JSON: %w", err)
|
||||
}
|
||||
for _, required := range []string{"users", "deployments", "collectors"} {
|
||||
if _, ok := probe[required]; !ok {
|
||||
return nil, fmt.Errorf("备份内数据库缺少集合 %q，可能不是 LokiStack 的备份", required)
|
||||
}
|
||||
}
|
||||
|
||||
// 哈希校验（防止传输损坏）
|
||||
sum := sha256.Sum256(dbBytes)
|
||||
if manifest.DBSHA256 != "" && hex.EncodeToString(sum[:]) != manifest.DBSHA256 {
|
||||
return nil, fmt.Errorf("备份内数据库校验失败（sha256 不匹配），文件可能已损坏")
|
||||
}
|
||||
|
||||
stagedDir := filepath.Join(dataDirPath(), ".restore-pending")
|
||||
if err := os.MkdirAll(stagedDir, 0o700); err != nil {
|
||||
return nil, fmt.Errorf("创建暂存目录失败: %w", err)
|
||||
}
|
||||
stagedPath := filepath.Join(stagedDir, "opsxloki.json")
|
||||
if err := os.WriteFile(stagedPath, dbBytes, 0o600); err != nil {
|
||||
return nil, fmt.Errorf("写入暂存文件失败: %w", err)
|
||||
}
|
||||
|
||||
currentRows := 0
|
||||
if db := repository.GetDB(); db != nil {
|
||||
db.RLock()
|
||||
currentRows = len(db.Deployments) + len(db.Collectors) + len(db.Clusters) + len(db.Hosts)
|
||||
db.RUnlock()
|
||||
}
|
||||
|
||||
res := &RestoreResult{
|
||||
Manifest: manifest,
|
||||
KeyMatches: manifest.KeyFP == "" || manifest.KeyFP == encryptionKeyFingerprint(),
|
||||
RowsInBackup: manifest.RecordCount,
|
||||
CurrentRows: currentRows,
|
||||
StagedPath: stagedPath,
|
||||
}
|
||||
if !res.KeyMatches {
|
||||
res.Warning = "备份的 ENCRYPTION_KEY 指纹与当前平台不一致：恢复后 kubeconfig / 存储凭证将无法解密，" +
|
||||
"需要用备份时的那把 ENCRYPTION_KEY 覆盖 lokistack-secrets 中的值后再启动"
|
||||
}
|
||||
return res, nil
|
||||
}
|
||||
|
||||
// encryptionKeyFingerprint 返回当前 ENCRYPTION_KEY 的指纹（sha256 前 16 位），不泄露密钥。
|
||||
func encryptionKeyFingerprint() string {
|
||||
key := os.Getenv("ENCRYPTION_KEY")
|
||||
if key == "" {
|
||||
// 兼容从文件读取的部署方式
|
||||
if p := os.Getenv("ENCRYPTION_KEY_FILE"); p != "" {
|
||||
if b, err := os.ReadFile(p); err == nil {
|
||||
key = strings.TrimSpace(string(b))
|
||||
}
|
||||
}
|
||||
}
|
||||
if key == "" {
|
||||
return ""
|
||||
}
|
||||
sum := sha256.Sum256([]byte(key))
|
||||
return hex.EncodeToString(sum[:])[:16]
|
||||
}
|
||||
|
||||
// ApplyStagedBackup 把暂存文件应用为正式 DB（调用方负责重启进程）。
|
||||
func ApplyStagedBackup() (string, error) {
|
||||
staged := filepath.Join(dataDirPath(), ".restore-pending", "opsxloki.json")
|
||||
b, err := os.ReadFile(staged)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("没有待应用的恢复文件: %w", err)
|
||||
}
|
||||
var probe map[string]json.RawMessage
|
||||
if err := json.Unmarshal(b, &probe); err != nil {
|
||||
return "", fmt.Errorf("暂存文件已损坏: %w", err)
|
||||
}
|
||||
|
||||
dbPath := databasePath()
|
||||
// 先把当前 DB 备份一份，恢复错了还能退回去
|
||||
if cur, err := os.ReadFile(dbPath); err == nil {
|
||||
rollback := dbPath + ".before-restore." + time.Now().Format("20060102-150405")
|
||||
_ = os.WriteFile(rollback, cur, 0o600)
|
||||
}
|
||||
tmp := dbPath + ".restoring"
|
||||
if err := os.WriteFile(tmp, b, 0o600); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := os.Rename(tmp, dbPath); err != nil {
|
||||
return "", err
|
||||
}
|
||||
_ = os.Remove(staged)
|
||||
return dbPath, nil
|
||||
}
|
||||
|
||||
// ListBackups 列出 dataDir/backups 下已有的备份文件（run.sh backup 产出）。
|
||||
func ListBackups() []map[string]interface{} {
|
||||
dir := filepath.Join(dataDirPath(), "backups")
|
||||
entries, err := os.ReadDir(dir)
|
||||
if err != nil {
|
||||
return []map[string]interface{}{}
|
||||
}
|
||||
type item struct {
|
||||
name string
|
||||
size int64
|
||||
mod time.Time
|
||||
}
|
||||
var items []item
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || !strings.HasSuffix(e.Name(), ".tar.gz") {
|
||||
continue
|
||||
}
|
||||
info, err := e.Info()
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
items = append(items, item{e.Name(), info.Size(), info.ModTime()})
|
||||
}
|
||||
sort.Slice(items, func(i, j int) bool { return items[i].mod.After(items[j].mod) })
|
||||
out := make([]map[string]interface{}, 0, len(items))
|
||||
for _, it := range items {
|
||||
out = append(out, map[string]interface{}{
|
||||
"name": it.name, "sizeBytes": it.size, "createdAt": it.mod,
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func dataDirPath() string {
|
||||
if p := os.Getenv("DATA_DIR"); p != "" {
|
||||
return p
|
||||
}
|
||||
return "/app/data"
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"lokistack/pkg/metrics"
|
||||
"lokistack/repository"
|
||||
)
|
||||
|
||||
// InitMetrics 注册指标并启动业务/存储指标的周期刷新。
|
||||
//
|
||||
// HTTP 层与 DB 落盘由 middleware / repository 直接埋点；
|
||||
// 这里只负责需要"扫 DB 算出来"的指标（记录数、部署/采集器状态分布、DB 大小）。
|
||||
func InitMetrics(version string) {
|
||||
metrics.Register(version)
|
||||
|
||||
go func() {
|
||||
ticker := time.NewTicker(30 * time.Second)
|
||||
defer ticker.Stop()
|
||||
refreshGauges()
|
||||
for range ticker.C {
|
||||
refreshGauges()
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// refreshGauges 刷新需要遍历 DB 才能得出的指标。
|
||||
func refreshGauges() {
|
||||
db := repository.GetDB()
|
||||
if db == nil {
|
||||
return
|
||||
}
|
||||
|
||||
if path := databasePath(); path != "" {
|
||||
if fi, err := os.Stat(path); err == nil {
|
||||
metrics.DBSizeBytes.Set(float64(fi.Size()))
|
||||
}
|
||||
}
|
||||
|
||||
db.RLock()
|
||||
users := len(db.Users)
|
||||
clusters := len(db.Clusters)
|
||||
hosts := len(db.Hosts)
|
||||
storages := len(db.Storages)
|
||||
deployList := db.Deployments
|
||||
collectorList := db.Collectors
|
||||
alertRules := len(db.AlertRules)
|
||||
auditCount := len(db.AuditLogs)
|
||||
db.RUnlock()
|
||||
|
||||
metrics.DBRecordsTotal.WithLabelValues("users").Set(float64(users))
|
||||
metrics.DBRecordsTotal.WithLabelValues("clusters").Set(float64(clusters))
|
||||
metrics.DBRecordsTotal.WithLabelValues("hosts").Set(float64(hosts))
|
||||
metrics.DBRecordsTotal.WithLabelValues("storages").Set(float64(storages))
|
||||
metrics.DBRecordsTotal.WithLabelValues("deployments").Set(float64(len(deployList)))
|
||||
metrics.DBRecordsTotal.WithLabelValues("collectors").Set(float64(len(collectorList)))
|
||||
metrics.DBRecordsTotal.WithLabelValues("alertRules").Set(float64(alertRules))
|
||||
metrics.DBRecordsTotal.WithLabelValues("auditLogs").Set(float64(auditCount))
|
||||
|
||||
// 状态分布：先 Reset 再重算，避免已删除对象留下僵尸时间序列
|
||||
metrics.DeploymentsTotal.Reset()
|
||||
for _, d := range deployList {
|
||||
status := d.Status
|
||||
if status == "" {
|
||||
status = "unknown"
|
||||
}
|
||||
mode := d.Mode
|
||||
if mode == "" {
|
||||
mode = "unknown"
|
||||
}
|
||||
metrics.DeploymentsTotal.WithLabelValues(status, mode).Inc()
|
||||
}
|
||||
|
||||
metrics.CollectorsTotal.Reset()
|
||||
for _, c := range collectorList {
|
||||
status := c.Status
|
||||
if status == "" {
|
||||
status = "unknown"
|
||||
}
|
||||
runMode := c.RunMode
|
||||
if runMode == "" {
|
||||
runMode = "unknown"
|
||||
}
|
||||
metrics.CollectorsTotal.WithLabelValues(status, c.Type, runMode).Inc()
|
||||
}
|
||||
}
|
||||
|
||||
func databasePath() string {
|
||||
if p := os.Getenv("DATABASE_PATH"); p != "" {
|
||||
return p
|
||||
}
|
||||
if p := os.Getenv("DATA_DIR"); p != "" {
|
||||
return p + "/opsxloki.json"
|
||||
}
|
||||
return "/app/data/opsxloki.json"
|
||||
}
|
||||
@@ -0,0 +1,233 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"lokistack/models"
|
||||
"lokistack/repository"
|
||||
)
|
||||
|
||||
// CheckItem 单条自检结果
|
||||
type CheckItem struct {
|
||||
// Name 检查项名称（中文可读）
|
||||
Name string `json:"name"`
|
||||
// Status ok / warn / error
|
||||
Status string `json:"status"`
|
||||
// Message 一句话结论
|
||||
Message string `json:"message,omitempty"`
|
||||
// Detail 补充信息（数量、路径、错误原文）
|
||||
Detail string `json:"detail,omitempty"`
|
||||
}
|
||||
|
||||
// SelfCheckResult 一键诊断结果
|
||||
type SelfCheckResult struct {
|
||||
CheckedAt time.Time `json:"checkedAt"`
|
||||
// Overall ok / warn / error —— 前端据此显示整体颜色
|
||||
Overall string `json:"overall"`
|
||||
Items []CheckItem `json:"items"`
|
||||
}
|
||||
|
||||
// SelfCheck 平台自检：把「能不能用」的判断集中到一处。
|
||||
//
|
||||
// 设计目标：新人接手或故障时，先看这一个接口，不必在 5 个页面之间来回跳。
|
||||
// 所有检查都必须有超时保护，不能让诊断本身把平台拖慢。
|
||||
func SelfCheck() SelfCheckResult {
|
||||
res := SelfCheckResult{CheckedAt: time.Now(), Overall: "ok"}
|
||||
add := func(item CheckItem) {
|
||||
res.Items = append(res.Items, item)
|
||||
if item.Status == "error" {
|
||||
res.Overall = "error"
|
||||
} else if item.Status == "warn" && res.Overall == "ok" {
|
||||
res.Overall = "warn"
|
||||
}
|
||||
}
|
||||
|
||||
db := repository.GetDB()
|
||||
|
||||
// 1) 数据库
|
||||
if db == nil {
|
||||
add(CheckItem{Name: "数据库", Status: "error", Message: "未初始化"})
|
||||
} else {
|
||||
dbPath := databasePath()
|
||||
fi, err := os.Stat(dbPath)
|
||||
if err != nil {
|
||||
add(CheckItem{Name: "数据库", Status: "error", Message: "数据文件读不到", Detail: err.Error()})
|
||||
} else {
|
||||
db.RLock()
|
||||
counts := fmt.Sprintf("集群 %d / 主机 %d / 存储 %d / 部署 %d / 采集器 %d / 审计 %d",
|
||||
len(db.Clusters), len(db.Hosts), len(db.Storages), len(db.Deployments), len(db.Collectors), len(db.AuditLogs))
|
||||
db.RUnlock()
|
||||
status := "ok"
|
||||
if fi.Size() > 16<<20 {
|
||||
status = "warn"
|
||||
}
|
||||
add(CheckItem{Name: "数据库", Status: status,
|
||||
Message: fmt.Sprintf("%.1f KB", float64(fi.Size())/1024), Detail: counts})
|
||||
}
|
||||
}
|
||||
|
||||
// 2) 加密密钥（丢了所有 kubeconfig/凭证都解不开）
|
||||
if fp := encryptionKeyFingerprint(); fp == "" {
|
||||
add(CheckItem{Name: "加密密钥", Status: "error",
|
||||
Message: "ENCRYPTION_KEY 未配置",
|
||||
Detail: "kubeconfig 与存储凭证依赖它解密；请确认 lokistack-secrets 中的 ENCRYPTION_KEY 已注入"})
|
||||
} else {
|
||||
add(CheckItem{Name: "加密密钥", Status: "ok", Message: "已配置", Detail: "指纹 " + fp})
|
||||
}
|
||||
|
||||
// 3) 数据目录可用空间
|
||||
if free, total, err := diskUsage(dataDirPath()); err == nil && total > 0 {
|
||||
pct := float64(free) / float64(total) * 100
|
||||
status, msg := "ok", fmt.Sprintf("剩余 %.1f GB（%.0f%%）", float64(free)/(1<<30), pct)
|
||||
if pct < 10 {
|
||||
status = "error"
|
||||
} else if pct < 20 {
|
||||
status = "warn"
|
||||
}
|
||||
add(CheckItem{Name: "数据盘", Status: status, Message: msg})
|
||||
}
|
||||
|
||||
if db != nil {
|
||||
db.RLock()
|
||||
clusterList := db.Clusters
|
||||
hostList := db.Hosts
|
||||
deployList := db.Deployments
|
||||
collectorList := db.Collectors
|
||||
auditList := db.AuditLogs
|
||||
db.RUnlock()
|
||||
|
||||
// 4) 集群接入（kubeconfig 能否解密）
|
||||
if len(clusterList) == 0 {
|
||||
add(CheckItem{Name: "K8s 集群", Status: "warn", Message: "尚未添加集群"})
|
||||
} else {
|
||||
bad := 0
|
||||
for i := range clusterList {
|
||||
if _, err := resolveKubeconfig(&clusterList[i]); err != nil {
|
||||
bad++
|
||||
}
|
||||
}
|
||||
if bad > 0 {
|
||||
add(CheckItem{Name: "K8s 集群", Status: "error",
|
||||
Message: fmt.Sprintf("%d/%d 个集群的 kubeconfig 无法解密", bad, len(clusterList)),
|
||||
Detail: "多半是 ENCRYPTION_KEY 与写入时不一致"})
|
||||
} else {
|
||||
add(CheckItem{Name: "K8s 集群", Status: "ok", Message: fmt.Sprintf("%d 个，kubeconfig 均可解密", len(clusterList))})
|
||||
}
|
||||
}
|
||||
|
||||
// 5) 主机可达性（用最近一次验证结果，不在这里做 SSH 连接，避免诊断变慢）
|
||||
if len(hostList) > 0 {
|
||||
errCount := 0
|
||||
for _, h := range hostList {
|
||||
if h.Status == "error" {
|
||||
errCount++
|
||||
}
|
||||
}
|
||||
if errCount > 0 {
|
||||
add(CheckItem{Name: "主机", Status: "warn",
|
||||
Message: fmt.Sprintf("%d/%d 台连接异常", errCount, len(hostList)),
|
||||
Detail: "到「主机管理」点「测试连接」查看具体原因"})
|
||||
} else {
|
||||
add(CheckItem{Name: "主机", Status: "ok", Message: fmt.Sprintf("%d 台均正常", len(hostList))})
|
||||
}
|
||||
}
|
||||
|
||||
// 6) Loki 部署实例（真实探活 /ready）
|
||||
if len(deployList) == 0 {
|
||||
add(CheckItem{Name: "Loki 实例", Status: "warn", Message: "尚未部署 Loki"})
|
||||
} else {
|
||||
var names []string
|
||||
bad := 0
|
||||
for _, d := range deployList {
|
||||
status, err := probeDeploymentReady(&d)
|
||||
if err != nil || !status {
|
||||
bad++
|
||||
names = append(names, d.Name)
|
||||
}
|
||||
}
|
||||
if bad > 0 {
|
||||
add(CheckItem{Name: "Loki 实例", Status: "error",
|
||||
Message: fmt.Sprintf("%d/%d 个实例未就绪", bad, len(deployList)),
|
||||
Detail: strings.Join(names, ", ")})
|
||||
} else {
|
||||
add(CheckItem{Name: "Loki 实例", Status: "ok", Message: fmt.Sprintf("%d 个全部 ready", len(deployList))})
|
||||
}
|
||||
}
|
||||
|
||||
// 7) 采集器
|
||||
if len(collectorList) > 0 {
|
||||
errCount, okCount := 0, 0
|
||||
for _, c := range collectorList {
|
||||
switch c.Status {
|
||||
case "active", "running":
|
||||
okCount++
|
||||
case "error":
|
||||
errCount++
|
||||
}
|
||||
}
|
||||
if errCount > 0 {
|
||||
add(CheckItem{Name: "采集器", Status: "error",
|
||||
Message: fmt.Sprintf("%d 个异常", errCount),
|
||||
Detail: fmt.Sprintf("正常 %d 个；到「采集器」页看具体报错", okCount)})
|
||||
} else {
|
||||
add(CheckItem{Name: "采集器", Status: "ok", Message: fmt.Sprintf("%d 个正常", okCount)})
|
||||
}
|
||||
}
|
||||
|
||||
// 8) 近期失败操作（审计）
|
||||
recentFail := 0
|
||||
cutoff := time.Now().Add(-24 * time.Hour)
|
||||
for _, a := range auditList {
|
||||
if a.CreatedAt.After(cutoff) && a.Status >= 400 {
|
||||
recentFail++
|
||||
}
|
||||
}
|
||||
if recentFail > 0 {
|
||||
add(CheckItem{Name: "近 24h 失败操作", Status: "warn",
|
||||
Message: fmt.Sprintf("%d 次", recentFail), Detail: "到「审计日志」筛选失败查看详情"})
|
||||
} else {
|
||||
add(CheckItem{Name: "近 24h 失败操作", Status: "ok", Message: "无"})
|
||||
}
|
||||
}
|
||||
|
||||
return res
|
||||
}
|
||||
|
||||
// probeDeploymentReady 探测某个 Loki 部署实例是否 /ready。
|
||||
//
|
||||
// 不用 DeploymentReady()：那个函数按"部署名 == 数据源名"匹配，
|
||||
// 而生成的 K8s 资源名固定是 loki，两者对不上会永远返回未就绪（已知问题）。
|
||||
// 这里直接按部署记录里的 endpoint 探活，并对主机模式修正监听地址：
|
||||
// 主机 Docker 部署存的是 0.0.0.0:3100，从平台 Pod 侧要用主机真实 IP。
|
||||
func probeDeploymentReady(d *models.LokiDeployment) (bool, error) {
|
||||
url := strings.TrimSuffix(strings.TrimSpace(d.Endpoint), "/")
|
||||
if url == "" {
|
||||
return false, fmt.Errorf("部署未记录访问地址")
|
||||
}
|
||||
if strings.Contains(url, "0.0.0.0") && d.Host != nil && d.Host.HostIP != "" {
|
||||
url = strings.Replace(url, "0.0.0.0", d.Host.HostIP, 1)
|
||||
}
|
||||
client := &http.Client{Timeout: 3 * time.Second}
|
||||
resp, err := client.Get(url + "/ready")
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
buf := make([]byte, 128)
|
||||
n, _ := resp.Body.Read(buf)
|
||||
return resp.StatusCode == 200 && strings.Contains(strings.ToLower(string(buf[:n])), "ready"), nil
|
||||
}
|
||||
|
||||
// diskUsage 返回剩余与总空间（字节）
|
||||
func diskUsage(path string) (free, total uint64, err error) {
|
||||
var st syscall.Statfs_t
|
||||
if err := syscall.Statfs(path, &st); err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
return st.Bavail * uint64(st.Bsize), st.Blocks * uint64(st.Bsize), nil
|
||||
}
|
||||
Reference in new issue
Block a user