南宫乘风

统一日志格式规范与 Filebeat+Logstash 实践落地

Wed, 16 Jul 2025 18:16:11 +0000

背景

在多部门、多技术栈并存的企业环境中，日志收集与分析是保障系统稳定运行的核心能力之一。然而，不同开发团队采用各异的日志打印方式，导致日志数据结构混乱，严重影响后续的收集、存储、检索与告警效率。

比如我们大部门就有多套日志格式，不同小部门有不同的格式，导致我们运维任务和成本大幅度增加。 典型问题场景包括：

开发团队A使用Log4j，格式为[%d] %p %c - %m%n 团队B采用Logback，格式为%date %level [%thread] %logger - %msg%n 微服务C输出JSON格式日志但缺少统一字段规范

本文将介绍我们如何建立统一的日志格式规范，并基于 Filebeat + Logstash 实现多环境（宿主机/Kubernetes）下的高效日志采集、解析与存储。

为什么要统一日志格式？

遇到的问题：

各部门日志格式五花八门，结构不一
多行异常堆栈无法完整还原，频繁切段
traceId/请求上下文缺失，无法链路追踪
结构化字段难以提取，告警系统误报频繁

统一格式的好处：

日志标准化后，便于多系统集中分析
traceId 实现服务链路跟踪（可接入 Skywalking/Jaeger）
多行异常可合并为单条日志事件
方便在 Elasticsearch 中建立字段索引，用于筛选、聚合与报警

日志格式统一规范

在设计日志标准时，我们遵循以下关键原则：

机器可读性：便于采集工具自动解析人类可读性：保留足够上下文，便于工程师直接阅读完整性与高效性的平衡：包含必要字段但不过度冗余可扩展性：支持未来增加新字段而不破坏兼容性行业兼容性：符合主流日志框架的最佳实践

经过多轮评审，最终确定的标准日志格式为：

`1`	`%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%X{traceId:-null}] [%thread] [%logger{36}] [%L] - %msg%n%wEx`

样例日志：

2025-04-09 13:36:39.947 [INFO ] [null] [main] [o.s.c.s.PostProcessorRegistrationDelegate$BeanPostProcessorChecker] [327] - Bean 'org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration' of type [org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration$$EnhancerBySpringCGLIB$$d712abb8] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)

Grok语法

`1`	`%{TIMESTAMP_ISO8601:date} \[\s{0,2}(?<loglevel>[^\]]+)\] \[\s{0,2}(?<traceId>[^\]]+)\] \[(?<thread>[^\]]+)\] \[(?<logger>[^\]]+)\] \[(?<codeline>\d+)\] - %{GREEDYDATA:msg}`

这个标准格式包含七大关键要素：

时间戳：精确到毫秒的ISO8601格式，确保跨时区协调日志级别：统一5字符宽度对齐（ERROR/WARN/INFO/DEBUG）追踪标识：分布式系统必备的traceId，缺省为null 线程信息：帮助理解异步处理流程类名：缩写为36字符保持简洁行号：精准定位日志产生位置消息体：包含可选的异常堆栈信息

字段占位符	对应字段	说明	必要性	示例
%d{yyyy-MM-dd HH:mm:ss.SSS}	时间戳	精确到毫秒的ISO8601格式	必要	2023-08-15 14:30:45.123
%-5level	日志级别	右对齐，5字符宽度	必要	INFO / ERROR
%X{traceId:-null}	请求链路ID	分布式追踪标识	重要	3f5e8a2b1c9d4f7e
%thread	线程名	执行线程标识	必要	http-nio-8080-exec-1
%logger{36}	类名	截断到36字符的类全名	必要	com.fjf.service.PaymentService
%L	代码行号	日志调用处的行号	可选	42
%msg	日志内容	实际日志信息	核心	“用户支付成功，金额:100.00”
%wEx	异常堆栈	附带异常时的堆栈信息	条件	java.lang.NullPointerException…

多语言实现示例

Java (Log4j2)：

`1`	`<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] [%X{traceId:-null}] [%thread] [%-36.36logger{36}] [%.-1L] - %msg%n%wEx"/>`

Python：

1
2

import logging
FORMAT = '%(asctime)s [%(levelname)-5s] [%(traceId)s] [%(threadName)s] [%(name)-36s] [%(lineno)d] - %(message)s'

日志采集方案设计

混合环境下的采集策略 面对物理机与Kubernetes并存的混合环境，我们设计了分层采集方案：

宿主机 Filebeat 配置

# filebeat.inputs配置
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /app/logs/app/hx-app.log
    - /app/logs/app/hx-consume.log
    - /fjf_work/logs/fujfu_member/fujfu_member_admin.log
  # 多行日志处理关键配置
  multiline.pattern: ^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}[.,:]0{0,1}\d{3}
  multiline.negate: true
  multiline.match: after
  # 元数据字段
  fields:
    logtype: "hx"

fields_under_root: true
fields:
  ip: 192.18.199.160

output.logstash:
  hosts: ["logstash.server.fjf:5044"]

技术关键点：

multiline.pattern使用正则严格匹配标准格式的时间戳开头
negate: true + match: after确保堆栈信息被正确关联到主日志行
通过fields添加主机IP等元信息，便于后续定位问题来源

Kubernetes Pod 内部 Filebeat ConfigMap

filebeat-configmap.yaml 可以注册到configmap中

filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /app/logs/app/*.log
  multiline.pattern: ^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}[.,:]0{0,1}\d{3}
  multiline.negate: true
  multiline.match: after
  fields:
    logtype: ${LOGTYPE:app}

fields_under_root: true
fields:
  ip: ${POD_IP}  # 自动注入Pod IP

output.logstash:
  hosts: ["logstash-server.default.svc.cloudcs.fjf:5044"]

✅ 说明：多行合并通过正则识别日志起始行（时间戳），其余行自动归入上一条日志。

K8s特定优化：

使用环境变量动态注入POD_IP和LOGTYPE
通配符路径匹配适配不同应用的日志文件
通过DaemonSet确保每个节点都有采集器

Logstash 解析规则设计

在 Logstash 中通过 filter 插件完成日志结构化处理，区分标准格式、PowerJob 特例与 JSON 格式：

filter {
  # JSON日志特殊处理
  if [fields][json] == "true" {
    json {
      source => "message"
      remove_field => ["message","agent","tags","ecs"]
    }
  }
  # 标准格式解析
  else {
    grok {
      match => { "message" => [
        "%{TIMESTAMP_ISO8601:date} \[\s{0,2}(?<loglevel>[^\]]+)\] \[\s{0,2}(?<traceId>[^\]]+)\] \[(?<thread>[^\]]+)\] \[(?<logger>[^\]]+)\] \[(?<codeline>\d+)\] - %{GREEDYDATA:msg}",
        # 备用模式匹配历史格式
      ]}
    }
  }
  
  # 添加业务标记
  ruby {
    code => 'event.set("projectname", event.get("host")["name"].split(".")[0])'
  }
  
  # 时间处理
  date {
    match => ["date","ISO8601","yyyy-MM-dd HH:mm:ss.SSS"]
    target => "@timestamp"
    timezone => "Asia/Shanghai"
  }
}

生产案例：

# ===========================
# 1. 输入配置（Beats 输入）
# ===========================
input {
  beats {
    port => 5044                      # 接收来自 Filebeat 的数据
    ssl => false                      # 未启用 SSL（可以视需求启用）
    client_inactivity_timeout => 36000 # 客户端连接空闲超时（秒）
  }
}
# ===========================
# 2. 过滤器（filter）
# ===========================
filter {

  # 如果是 JSON 格式日志（如前端或Node服务打印的 JSON 日志）
  if [fields][json] == "true" {
    json {
      source => "message"             # 指定从 message 字段中解析 JSON
      remove_field => ["message", "agent", "tags", "ecs"] # 清理多余字段
      add_field => {
        "loglevel" => "%{[severity]}" # 从 JSON 中提取 severity 字段作为 loglevel
      }
    }

  # 如果是 PowerJob 的日志格式（特殊格式日志单独处理）
  } else if [fields][logtype] == "powerjob" {
    grok {
      match => {
        "message" => "%{TIMESTAMP_ISO8601:date} \s{0,1}(?<severity>.*?) (?<pid>.*?) --- \[(?<thread>.*?)\] (?<class>.*?) \s*: (?<rest>.*+?)"
      }
      remove_field => ["message", "agent", "tags"]
      add_field => {
        "loglevel" => "%{[severity]}"
      }
    }
    mutate {
      update => {
        "[fields][logtype]" => "logstash" # 为统一索引，将 logtype 设置为 logstash
      }
    }

  # 默认解析逻辑：标准日志格式（适配多种格式）
  } else {
    grok {
      match => { 
        "message" => [
          # 标准推荐格式日志
          "%{TIMESTAMP_ISO8601:date} \[\s{0,2}(?<loglevel>[^\]]+)\] \[\s{0,2}(?<traceId>[^\]]+)\] \[(?<thread>[^\]]+)\] \[(?<logger>[^\]]+)\] \[(?<codeline>\d+)\] - %{GREEDYDATA:msg}",
          
          # 其他兼容格式 （防止有漏网之鱼，加的格式，注意格式越多，处理也耗费CPU）
          "%{TIMESTAMP_ISO8601:date} (?<loglevel>.*?)\s{1,2}\| \[(?<threadname>.*?)\] (?<classname>.*?) \[(?<codeline>.*?)\] \| \[(?<traceid>.*?)\] \| (?<msg>.*+?)",
          "%{TIMESTAMP_ISO8601:date} (?<loglevel>.*?)\s{1,2}\| \[(?<threadname>.*?)\] (?<classname>.*?) \[(?<codeline>.*?)\] \| (?<msg>.*+?)",
          "\[%{TIMESTAMP_ISO8601:date}\] \[(?<loglevel>.*?)\s{0,2}\] \[(?<threadname>.*?)\] (?<classname>.*?) (?<codeline>.*?) - (?<msg>.*+?)",
          "%{TIMESTAMP_ISO8601:date} \[(?<threadname>.*?)\] (?<loglevel>.*?)\s{0,2} (?<classname>.*?) (?<codeline>.*?) - (?<msg>.*+?)"
        ]
      }
      remove_field => ["message", "agent", "tags"] # 删除原始 message 字段等无用字段
    }
  }

  # Ruby 脚本：提取主机名的前缀作为项目名
  ruby {
    code =>'
      arr = event.get("host")["name"].split(".")[0]
      event.set("projectname", arr)
    '
  }

  # 时间字段统一转换为 @timestamp，便于时序检索
  date {
    match => ["date", "ISO8601", "yyyy-MM-dd HH:mm:ss.SSS"]
    target => "@timestamp"
    timezone => "Asia/Shanghai"   # 设置中国时区，避免时间错乱
  }

}

# ===========================
# 3. 输出到 Elasticsearch
# ===========================
output {
  elasticsearch {
    hosts => ["elasticsearch-log.prod.server.fjf:9200"]  # ES 地址
    user => "elastic"
    password => "xxxxxxxxxxxx"
    manage_template => false     # 不自动覆盖 ES 模板（防止冲突）
    index => "%{[fields][logtype]}-prod-%{+YYYY.MM.dd}"  # 动态索引名（按日志类型和日期）
  }
}

关键处理阶段：

格式识别路由：区分JSON和文本日志
多模式Grok解析：主模式匹配标准格式，备用模式兼容历史格式
元数据丰富：从主机名提取项目标识
时间标准化：统一转化为ES兼容的时间戳

实践效果

引入统一日志系统后取得的可测量改进：

故障定位时间：从平均2.5小时缩短至30分钟
日志存储量：通过合理字段设计减少25%存储需求
日志利用率：结构化日志使90%的日志可被监控系统利用
异常检测：基于标准字段建立的规则发现率提升40%

利用 Nginx 实现灰度环境的 H5 应用发布策略

Wed, 18 Jun 2025 18:15:08 +0000

背景介绍

在现代互联网应用开发中，灰度发布（又称金丝雀发布）是一种非常重要的部署策略。它允许我们将新版本服务逐步推送给部分用户，而不是一次性全量发布，从而降低风险并快速获得用户反馈。本文将分享一个实际的灰度环境部署案例，涉及两个服务（fbdm和grayfbdm）共享同一数据库但运行不同代码的场景。 **目前场景：**用于线上功能和需求验证，防止全量上线验证出问题，减少回滚的概率。

某业务系统中存在两个核心后端服务：

fbdm：正式服务，面向所有用户；
grayfbdm：灰度服务，仅对测试或特定用户开放。

两者数据库一致，配置相同，仅代码版本不同。灰度发布前必须先完成数据库字段变更，以保证向前兼容。

前端页面通过不同的访问地址与 Header 标签来区分灰度与正式流量。

访问角色	访问域名	Header 特征	Nginx 路由目标
测试用户	`gray.example.com`	`appenv=gray`	grayfbdm
正式用户	`prod.example.com`	无灰度标签	fbdm

灰度环境请求需满足下列任一条件，即可命中 grayfbdm：

请求 Header 包含 appenv=gray；
URL 参数中包含 appEnv=gray 或灰度域名作为 returnUrl；
Origin 为灰度域名。

系统架构概述

基本系统包含以下关键组件：

两个后端服务：
- fbdm：生产环境服务
- grayfbdm：灰度环境服务
共享数据库：两个服务使用相同的数据库实例
前端H5应用：能够通过header标识请求来源
Nginx反向代理：负责根据规则将请求路由到不同的后端服务

核心设计原理

1. 数据库共享策略

由于两个服务使用相同的数据库，在灰度发布过程中需要特别注意：

数据库变更先行：任何涉及数据库结构的变更必须先于服务部署执行
代码兼容性：新版本代码必须能够兼容旧版本的数据结构
数据一致性：确保灰度环境和生产环境不会因为数据操作相互干扰

2. 流量分流机制

Nginx作为流量入口，根据多种条件将请求路由到不同的后端：

# 上游服务定义 
upstream fbdm {
    server 10.0.0.1:8081 fail_timeout=5 max_fails=2;
    server 10.0.0.2:8081 fail_timeout=5 max_fails=2;
    keepalive 2000;
}
 
upstream grayfbdm {
    server 10.0.1.1:8081 fail_timeout=5 max_fails=2;
    keepalive 2000;
}

3. 路由判断条件

Nginx通过以下条件判断是否将请求路由到灰度环境：

HTTP Header：检查appenv=gray
URL参数：检查returnUrl或appEnv参数
Origin Header：检查请求来源是否为灰度域名

set $target http://fbdm;
if ($http_appEnv = "gray" ) {
    set $target http://grayfbdm;
}
if ($arg_returnUrl ~* "^https?%3A%2F%2Fmfbdgray\.xxxxx\.com" ) {
    set $target http://grayfbdm;
}
if ($arg_appEnv ~* "^gray" ) {
    set $target http://grayfbdm;
}
if ($http_origin ~* "https?://mfbdgray\.xxxxx\.com" ) {
    set $target http://grayfbdm;
}

4.完整Nginx配置

# 定义 upstream（正式服务 & 灰度服务）
upstream fbdm {
	server 10.0.0.1:8081 fail_timeout=5 max_fails=2;
	server 10.0.0.2:8081 fail_timeout=5 max_fails=2;
	keepalive 2000;
}
upstream grayfbdm {
	server 10.0.1.1:8081 fail_timeout=5 max_fails=2;
	keepalive 2000;
}

# 80 端口跳转到 HTTPS
server {
	listen 80;
	server_name prod.example.com;
	location / {
		rewrite ^/(.*)$ https://$host/$1 permanent;
	}
}

# 443 HTTPS 端口配置（灰度智能路由）
server {
	listen 443 ssl;
	server_name prod.example.com;
	ssl_certificate /path/to/cert.pem;
	ssl_certificate_key /path/to/key.pem;
	include ssl.conf;

	location / {
		set $target http://fbdm;

		# 灰度判断逻辑
		if ($http_appEnv = "gray") {
			set $target http://grayfbdm;
		}
		if ($arg_returnUrl ~* "^https?%3A%2F%2Fgray\.example\.com") {
			set $target http://grayfbdm;
		}
		if ($arg_appEnv ~* "^gray") {
			set $target http://grayfbdm;
		}
		if ($http_origin ~* "https?://gray\.example\.com") {
			set $target http://grayfbdm;
		}

		proxy_pass $target;
		include https_proxy.conf;
		proxy_next_upstream error timeout invalid_header http_403 http_404 http_500 http_502 http_503 http_504;

		# 黑名单控制（引用外部白名单/黑名单配置）
		include /opt/nginx/conf/whitelist/login.conf;
	}

	# 登录、发送验证码等接口灰度策略保持一致
	location ~* ^(/api/auth/sendCode|/api/user/login|/api/user/checkMobile)$ {
		set $target http://fbdm;

		if ($http_appEnv = "gray") {
			set $target http://grayfbdm;
		}
		if ($arg_returnUrl ~* "^https?%3A%2F%2Fgray\.example\.com") {
			set $target http://grayfbdm;
		}
		if ($arg_appEnv ~* "^gray") {
			set $target http://grayfbdm;
		}
		if ($http_origin ~* "https?://gray\.example\.com") {
			set $target http://grayfbdm;
		}

		proxy_pass $target;
		include https_proxy.conf;
		proxy_next_upstream error timeout invalid_header http_403 http_404 http_500 http_502 http_503 http_504;

		# 黑名单控制
		include /opt/nginx/conf/whitelist/mesg.conf;
		include /opt/nginx/conf/whitelist/login.conf;
		allow all;
	}
}

灵活灰度判断：通过 Header、Query 参数与 Origin 三层判断方式，确保请求正确识别；
接口隔离保护：关键接口如登录与验证码单独配置，防止因路由失误导致异常；
白名单机制：通过 include 引用外部配置，统一黑白名单管理；
自动 HTTPS 跳转：防止未加密请求造成信息泄露。

成功案例

在一次重大架构升级中，灰度发布机制帮助我们：

提前发现代码的bug，测试人员多轮验证，未影响正常用户
可以任何时间段发版，让测试人员测试，提升工作效率和速度

后续实践

版本兼容性：确保灰度版本代码能够回滚，避免因数据库变更导致生产环境不可用
监控与日志：为灰度环境设置独立的监控和日志收集，便于问题排查
流量比例控制：可以通过Nginx配置实现按比例的灰度发布
自动化测试：灰度环境应配备完整的自动化测试套件
用户标识策略：除了测试人员，可以考虑基于用户ID、设备ID等进行灰度分流

基于Nginx的微信支付回调跨网络环境解决方案

Fri, 13 Jun 2025 12:14:58 +0000

背景

在企业项目开发与测试过程中，我们经常会遇到微信支付这类必须公网可访问的第三方服务需要回调我们的应用接口的问题。但许多项目部署在内网环境，公网服务无法直接访问，尤其在多套餐测试环境中，这个限制尤为突出。

在现代分布式系统架构中，支付回调处理是一个关键但充满挑战的环节。以我们金融科技平台为例，我们遇到了以下典型问题：

混合网络环境：开发测试环境位于线下内网，而微信支付回调必须通过公网访问
多租户隔离：每个开发人员需要独立的回调地址进行联调测试
网络穿透需求：需要安全地将公网请求透传到内网特定开发环境
动态路由：根据URL路径参数动态路由到不同后端服务

传统解决方案如端口映射或直接暴露内网服务都存在安全风险和管理复杂度问题。为此，我们设计了一套基于Nginx的智能路由方案。

实现目标

使微信支付回调接口可通过公网地址访问。

微信服务器回调请求穿透公网到内网服务。

支持多个上下游项目通过统一的公网域名接收回调请求。

动态提取账号ID，转发请求到不同子系统。

技术架构设计

公网接入层Nginx
- 提供统一的公网接入域名 paycallback.example.com
- 基础安全防护（IP白名单等）
- 请求透传到线下环境网关
内网路由层Nginx
- 动态路径解析与路由
- 租户隔离与请求转发
- 本地静态资源服务

公网环境
[微信支付] → [公网Nginx (代理服务端)]
                  │
                  ▼
[代理隧道]
                  │
                  ▼
线下环境
[内网Nginx (代理客户端)] → [开发者A服务]
                      → [开发者B服务]

核心实现

公网Nginx配置（代理服务端）

公网服务部署在支持代理的云服务器上，配置一个统一的公网入口，如：

`1`	`http://paycallback.example.com/`

微信支付配置示例：

{
  "payNotifyUrl": "http://paycallback.example.com/wechatPayNotify/{developerId}" 
  // 示例：http://paycallback.example.com/wechatPayNotify/johndoe  
}

公网Nginx配置

server {
    listen       80;
    server_name  paycallback.example.com; 
    
    # IP白名单保护 
    include /etc/nginx/conf.d/whitelist/paycallback.conf; 
    
    location / {
        # 通过隧道转发到内网
        proxy_pass  http://10.0.0.10:80; # 指向内网VPN网关 
        include proxy_params.conf; 
    }
}

网Nginx配置（代理客户端）

部署在测试环境，连接公网VPN，负责路由转发请求到具体的子系统。以 /wechatCallback/{accountId} 路由为例：

server {
    listen       80;
    server_name  paycallback.example.com; 
    
    # 内网DNS解析 
    resolver 10.0.0.53 valid=30s;
    
    location ^~ /wechatPayNotify/ {
        # 提取开发者ID 
        set $developer_id $uri;
        if ($uri ~* "^/wechatPayNotify/([^/]+)$") {
            set $developer_id $1;
        }
        
        # 构造动态上游地址 
        set $upstream_host "dev-$developer_id.internal.example.com"; 
        
        # 请求转发配置 
        proxy_pass http://$upstream_host/api/payment/notify;
        proxy_set_header Host $upstream_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # 优化代理性能 
        proxy_http_version 1.1;
        proxy_request_buffering off;
        proxy_buffering off;
        
        # 日志记录 
        access_log /var/log/nginx/payment_notify.log  main;
    }
    
    # 静态资源服务 
    location / {
        try_files $uri /index.html; 
    }
}

业务接入流程

以项目 foo-app 为例：

统一配置微信支付回调地址为： http://paycallback.example.com/wechatCallback/foo
内网Nginx根据路径动态提取 foo 为账号ID，拼接成： http://subsys-foo.internal/api/pay/wechat/notify
内网应用接收到微信服务器回调的数据，进行正常处理。

测试方案

使用 curl 模拟微信回调请求：

1
2
3

curl -X POST http://paycallback.example.com/wechatCallback/foo \
     -H "Content-Type: application/json" \
     -d '{"order_id": "123456", "status": "PAID"}'

查看内网子系统日志是否正常接收到回调。

关键优势

动态路由机制 URL路径参数自动映射到对应开发者环境： devstream.example.com/wechatPayCallback/alice → dev-alice.internal.example.com
安全隔离
- 加密隧道保障传输安全
- 公网Nginx IP白名单控制访问源
- 内网环境完全隔离于公网
高效开发
- 支持多开发者并行测试
- 无需重复配置公网暴露点
- 回调请求实时到达内网环境
弹性扩展
- 新增开发者只需配置内网服务
- 无需修改公网Nginx配置
- 自动DNS解析支持服务发现

实施效果

微信支付回调延迟从分钟级降至200ms内
开发测试效率提升300%，支持10+开发者并行工作
完全消除公网暴露内网端口的风险
配置变更减少90%，新成员接入时间从2小时降至5分钟

为MySQL社区版实现审计功能：从插件配置到日志监控全解析

Tue, 10 Jun 2025 11:12:48 +0000

背景

公司要把重要的数据库的操作记录留存，方便查询操作可视化和告警监控等待。更能和其余相同的数据库保持一致。

本文将详细介绍如何通过MariaDB的server_audit插件为MySQL社区版实现完整的审计功能，包括版本兼容性处理、插件配置、日志解析和存储方案。

为什么MySQL社区版需要审计功能？

在公司数据库管理中，审计日志是安全合规和故障排查的重要工具。然而，许多使用MySQL社区版的企业面临一个尴尬的现实：原生的审计功能仅在企业版中提供。根据MySQL官方文档，社区版从5.7.34版本后不再支持第三方审计插件，这给需要合规审计的企业带来了挑战。

技术选型与版本兼容性分析

方案	优点	缺点	适用场景
MySQL企业版审计插件	官方支持，功能完善	需要付费许可	预算充足的企业
MariaDB server_audit插件	免费开源，功能完整	版本兼容性复杂	MySQL 5.7.34及以下版本
Percona审计插件	完全兼容MySQL	需要迁移到Percona Server	新建项目或可迁移环境
触发器+通用日志	无需额外组件	性能影响大，信息不完整	简单审计需求

在企业数据管理中，数据库操作审计是安全合规的核心需求。但MySQL社区版存在明显短板：

缺乏原生审计功能（仅企业版支持audit_log插件）
版本兼容陷阱
- MySQL 5.7.34：最后一个可原生使用MariaDB插件的版本
- MySQL ≥5.7.34 无法使用MariaDB的server_audit.so插件
- MySQL 8.0 完全移除插件兼容性
替代方案选择
- 方案1：MySQL 5.7低版本 + MariaDB插件（需版本匹配）
- 方案2：迁移至Percona Server（免费开源，兼容MySQL 5.6/5.7/8.0且支持审计）
- 方案3：全面迁移到MariaDB

实践建议：在测试环境中验证插件兼容性，生产环境部署前进行完整的回归测试。

环境

环境如下：

MySQL

1
2

[root@test_db01 ~]# mysql -V
mysql  Ver 14.14 Distrib 5.7.27, for Linux (x86_64) using  EditLine wrapper

Cnetos7

[root@test_db01 ~]# cat /etc/redhat-release 
CentOS Linux release 7.3.1611 (Core)

Linux test_db01 3.10.0-514.el7.x86_64 #1 SMP Tue Nov 22 16:42:41 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux

安装插件

查看插件安装目录


mysql>  show global variables like 'plugin_dir';
+---------------+--------------------------+
| Variable_name | Value                    |
+---------------+--------------------------+
| plugin_dir    | /usr/lib64/mysql/plugin/ |
+---------------+--------------------------+
1 row in set (0.00 sec)

提取mariadb审计插件并放置插件目录

此处需要注意版本，直接适配核对测试

wget  https://downloads.mariadb.com/MariaDB/mariadb-10.5.16/bintar-linux-x86_64/mariadb-10.5.16-linux-x86_64.tar.gz
tar -zxvf   mariadb-10.5.3-linux-x86_64.tar.gz
cp ./mariadb-10.5.3-linux-x86_64/lib/plugin/server_audit.so /usr/lib64/mysql/plugin/
chmod +x /usr/lib64/mysql/plugin/

mysql安装server_audit.so插件

mysql>  install plugin server_audit soname 'server_audit.so';
Query OK, 0 rows affected (0.02 sec)           
##也可以在my.cnf 加载插件方式安装
在my.cnf 设置 plugin_load = server_audit=server_audit.so

查看当前MySQL插件情况

1
2

mysql>  show plugins;
| SERVER_AUDIT                             | ACTIVE   | AUDIT              | server_audit.so       | GPL     |

增加审计目录授权

1
2

mkdir /opt/mysqldata/auditlogs
chown -R mysql:mysql /opt/mysqldata/auditlogs

开启审计，写入配置文件

#防止server_audit 插件被卸载 进行配置文件配置
server_audit=FORCE_PLUS_PERMANENT
#指定哪些操作被记录到日志文件中
server_audit_events='CONNECT,QUERY,TABLE,QUERY_DDL'
#开启审计功能
server_audit_logging=on
#默认存放路径，可以不写，默认到data文件下
server_audit_file_path=/opt/mysqldata/auditlogs
#设置文件大小 默认1000000，1073741824=1GB
server_audit_file_rotate_size=1073741824
#指定日志文件的数量，如果为0日志将从不轮转
server_audit_file_rotations=0

下面是我的配置文件
版本太低，不支持JSON，高版本支持JSON格式，方便Python处理，后续只能re来处理
```bash
#######server audit#####
server_audit_logging=ON
server_audit_file_path=/www/server/data/server_audit.log
server_audit=FORCE_PLUS_PERMANENT
server_audit_file_rotate_size=500M
server_audit_file_rotations=15
max_allowed_packet=32M
#audit_log_format=JSON
#audit_log_file=server_audit.json
#server_audit_logging=ON
#server_audit_file_path=/data/mysql/server_audit.json
#server_audit=FORCE_PLUS_PERMANENT
#server_audit_file_rotate_size=1G
#server_audit_file_rotations=10
#max_allowed_packet=32M

FORCE_PLUS_PERMANENT：防止插件被意外卸载
日志轮转设置：避免日志文件无限增长
max_allowed_packet：确保大SQL语句能被完整记录

重启mysql生效！

1
2
3

/etc/init.d/mysql restart
Shutting down MySQL............... SUCCESS! 
Starting MySQL.. SUCCESS!

检查日志状态

-- 检查插件状态 
SHOW PLUGINS WHERE NAME = 'server_audit';
 
-- 查看审计设置 
SHOW GLOBAL VARIABLES LIKE 'server_audit%';

日志格式

20250610 10:42:49,test_db01,root,192.168.102.207,7972452,438352983,QUERY,xxxx,'SELECT  id,ext_id,ext_table_name,target_type,value1,value2,spread_config  FROM t_target \n \n WHERE (ext_id = \'12606411819336451111124\' AND ext_table_name = \'t_discount_coupon\')',0
20250610 10:42:50,test_db01,root,192.168.83.18,7972073,438352984,QUERY,gazelle_model_assemble,'SELECT  id,code,name,handler,status,retry_times,create_time,update_time  FROM batch      WHERE  (status = \'running\')',0
20250610 10:42:50,test_db01,root,192.168.102.207,7969972,438352986,QUERY,xxxx,'select * from t_event_send where sent = 0 order by created_time asc',0
20250610 10:42:50,test_db01,root,192.168.83.36,7853786,438352985,QUERY,hxxxdb,'SELECT\n            MAX(IF(status = 1, create_time, null)) nearBankTime\n        FROM user_bank_cards\n        WHERE create_time >= NOW() - INTERVAL 12 HOUR',0
20250610 10:42:50,test_db01,root,192.168.83.27,7971636,438352987,QUERY,hixxxx_core,'SELECT id, user_id, trade_no, out_trade_no, order_sn, lease_id, period_no, amount, trade_status, alipay_close_status, trade_type, remark, trade_way, business_type, entry_param, coupon_id, coupon_amount, deleted, gmt_create, gmt_modified FROM hire_trade_flows WHERE deleted = 0 AND (trade_status = 3 AND trade_type = 1 AND trade_way IN (1, 3, 4) AND business_type IN (3, 5, 2, 1, 14, 4, 6, 10, 13))',0
20250610 10:42:50,test_db01,root,192.168.83.25,7972144,438352988,QUERY,historical_customer_data,'SELECT 1',0
20250610 10:42:50,test_db01,root,192.168.83.25,7972144,438352989,QUERY,historical_customer_data,'SELECT 1',0

解释这条日志格式

20250610 10:42:50,test_db01,root,192.168.83.36,7853786,438352985,QUERY,hxxxdb,'SELECT\n            MAX(IF(status = 1, create_time, null)) nearBankTime\n        FROM user_bank_cards\n        WHERE create_time >= NOW() - INTERVAL 12 HOUR',0

字段编号	字段值	含义
1	`20250610 10:42:50`	时间戳，表示审计事件发生的时间
2	`test_db01`	服务器主机名（或 MariaDB 实例名称）
3	`root`	数据库用户名，执行该语句的用户
4	`192.168.83.36`	客户端 IP 地址
5	`7853786`	线程 ID（MariaDB 内部线程号）
6	`438352985`	查询 ID，用于区分不同的 SQL 查询
7	`QUERY`	事件类型（`QUERY` 表示 SQL 查询）
8	`hxxxdb`	当前数据库名（`USE` 的数据库）
9	`'SELECT\n MAX(IF(...`	SQL 语句内容，使用单引号包裹，`\n` 为换行符
10	`0`	返回值 / 错误码，`0` 表示成功（无错误）

审计日志处理系统实现

系统架构设计

[MySQL Server] 
    ↓ (生成审计日志)
[server_audit.log]  
    ↓ (Python监控进程)
[日志解析模块] → [MySQL审计数据库]

Python处理程序核心逻辑

20250610 10:42:50,test_db01,root,192.168.83.36,7853786,438352985,QUERY,hxxxdb,'SELECT\n            MAX(IF(status = 1, create_time, null)) nearBankTime\n        FROM user_bank_cards\n        WHERE create_time >= NOW() - INTERVAL 12 HOUR',0

我们有上面的日志格式，可以进行如下操作处理

日志监控关键特性：

断点续传：通过state文件记录读取位置
文件轮转检测：通过inode和dev识别日志切换
异常处理：完善的错误捕获和日志记录

def process_log_entry(new_content):
    """处理单个审计日志条目"""
    # 定义正则表达式模式，用于解析审计日志格式
    # 模式匹配字段：时间，数据库名(1)，用户名，源IP，连接ID，查询ID，事件类型，数据库名(2)，SQL语句，执行结果
    pattern = r"^(\d{8} \d{2}:\d{2}:\d{2}),([\w]+),([\w]+),(\d+\.\d+\.\d+\.\d+),(\d+),(\d+),([\w]+),([\w]+),'(.*)',(\d+)"
    
    # 尝试匹配日志行
    match = re.match(pattern, new_content)
    if match:
        # 提取匹配的各个字段
        sql_time = match.group(1)        # 时间 (格式: 年月日 时分秒)
        database_name = match.group(8)   # 数据库名称 (从第8组获取)
        sql_content = match.group(9)      # SQL语句内容 (包含原始转义字符)
        s_sql_content = match.group(9)    # 保留原始SQL语句用于日志记录
        sql_result = match.group(10)      # SQL执行结果 (0表示成功)
        
        # 清洗SQL语句内容：
        # 1. 去除SQL注释（--、#和/* */类型的注释）
        COMMENT_PATTERN = re.compile(r"(--.*?\\r\\n|#.*?\\r\\n|/\*.*?\*/)", re.DOTALL | re.MULTILINE)
        sql_content = COMMENT_PATTERN.sub("", sql_content)
        
        # 2. 替换特殊转义字符
        #    - 将\n换行符替换为空格
        #    - 将\'转义单引号替换为普通单引号
        #    - 将\t制表符替换为空格
        #    - 将\r回车符替换为空格
        sql_content = sql_content.replace('\\n', ' ').replace('\\\'', '\'').replace('\\t', ' ').replace('\\r', ' ')
        
        # 3. 去除SQL语句前后的多余空格
        sql_content = sql_content.strip()
        
        # 检查是否为需要记录的DDL语句：
        # 1. SQL执行成功 (sql_result == "0")
        # 2. 是DDL操作 (CREATE/ALTER/DROP/RENAME开头)
        DDL_PATTERN = re.compile(r"^(CREATE|ALTER|DROP|RENAME)", re.IGNORECASE)
        if sql_result == "0" and DDL_PATTERN.match(sql_content):
            # 记录处理日志
            logging.info("-" * 50)
            logging.info(f"原始SQL内容: {s_sql_content}")
            logging.info(f"执行时间: {sql_time}")
            logging.info(f"数据库名称: {database_name}")
            logging.info(f"清洗后SQL: {sql_content}")
            logging.info("-" * 50)
            
            # 将审计记录保存到MySQL数据库
            save_to_mysql(sql_time, database_name, sql_content)

1
2

原始: 'SELECT\n            MAX(...) nearBankTime\n        FROM ...'
清洗后: 'SELECT MAX(...) nearBankTime FROM ...'

完整代码

# -*- coding: utf-8 -*-
import os, sys
import re
import time
import json, logging
from datetime import datetime
import pymysql

# 日志配置
logging.basicConfig(
    filename='mysql_monitor.log',
    level=logging.INFO,
    format='[%(asctime)s] %(levelname)s: %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

# 读取缓存文件，定位日志读取位置
def load_state(state_file):
    """Load saved state."""
    try:
        with open(state_file, 'r', encoding='utf-8') as f:
            state = json.load(f)
            return state.get('position', 0), state.get('inode', None), state.get('dev', None)
    except (IOError, ValueError):
        return 0, None, None
    except Exception as e:
        logging.error(f"Failed to load state: {str(e)}")
        return 0, None, None

# 保存位置数据到文件中
def save_state(state_file, position, inode, dev):
    """Save current state."""
    try:
        with open(state_file, 'w', encoding='utf-8') as f:
            json.dump({
                'position': position,
                'inode': inode,
                'dev': dev
            }, f)
    except Exception as e:
        logging.error(f"Failed to save state: {str(e)}")

# 保存sql数据到数据中，方便可视化 或者  告警
def save_to_mysql(sql_time, database_name, sql_content):
    """将日志信息写入到 MySQL 数据库的 audit_log 表中"""
    connection = pymysql.connect(
        host='192.168.102.201',
        user='root',
        password='xxxx.88',
        database='audit_db',
        charset='utf8mb4'
    )
    try:
        with connection.cursor() as cursor:
            sql = """
                  INSERT INTO audit_log (sql_time, database_name, sql_content)
                  VALUES (%s, %s, %s)
                  """
            sql_time = datetime.strptime(sql_time, "%Y%m%d %H:%M:%S").strftime("%Y-%m-%d %H:%M:%S")
            cursor.execute(sql, (sql_time, database_name, sql_content))
        connection.commit()
    except Exception as e:
        logging.error(f"Failed to insert data into MySQL: {str(e)}")
    finally:
        connection.close()

# 读取文件 ，数据 匹配 和 清洗
def process_log_entry(new_content):
    """Process a single log entry."""
    pattern = r"^(\d{8} \d{2}:\d{2}:\d{2}),([\w]+),([\w]+),(\d+\.\d+\.\d+\.\d+),(\d+),(\d+),([\w]+),([\w]+),'(.*)',(\d+)"
    match = re.match(pattern, new_content)
    if match:
        sql_time = match.group(1)
        database_name = match.group(8)
        sql_content = match.group(9)
        s_sql_content = match.group(9)
        sql_result = match.group(10)
        # 先匹配存在DDL语句的sql内容
        # 去除-- /* # 等注释符
        #logging.info(f"1 {sql_content}")
        COMMENT_PATTERN = re.compile(r"(--.*?\\r\\n|#.*?\\r\\n|/\*.*?\*/)", re.DOTALL | re.MULTILINE)
        sql_content = COMMENT_PATTERN.sub("", sql_content)
        # 去除多余的换行符/'等
        #logging.info(f"2 {sql_content}")
        sql_content = sql_content.replace('\\n', ' ').replace('\\\'', '\'').replace('\\t', ' ').replace('\\r', ' ')
        #logging.info(f"3 {sql_content}")
        # 去除前后多余的空格
        sql_content = sql_content.strip()
        #logging.info(f"4 {sql_content}")
        # 检查是否为 DDL 语句
        DDL_PATTERN = re.compile(r"^(CREATE|ALTER|DROP|RENAME)", re.IGNORECASE)
        if sql_result == "0" and DDL_PATTERN.match(sql_content):
            logging.info("-" * 50)
            logging.info(f"SQL Content: {s_sql_content}")
            logging.info(f"Time: {sql_time}")
            logging.info(f"Database Name: {database_name}")
            logging.info(f"SQL Content: {sql_content}")
            logging.info("-" * 50)
            save_to_mysql(sql_time, database_name, sql_content)

# 启动程序，传入 缓存 文件  和 审计日志记录 文件 位置
def monitor_log(state_file, log_file):
    """Monitor MySQL audit logs."""
    last_position, last_inode, last_dev = load_state(state_file)
    while True:
        try:
            current_st = os.stat(log_file)
        except OSError:
            logging.warning("Log file not found, retrying...")
            time.sleep(1)
            continue
        if (current_st.st_ino != last_inode) or (current_st.st_dev != last_dev):
            logging.info("New log file detected")
            last_position = 0
            last_inode = current_st.st_ino
            last_dev = current_st.st_dev
            save_state(state_file, last_position, last_inode, last_dev)
        if current_st.st_size < last_position:
            logging.info("File truncated")
            last_position = 0
            save_state(state_file, last_position, last_inode, last_dev)
        if current_st.st_size > last_position:
            try:
                with open(log_file, 'r', encoding='utf-8', errors='replace') as f:
                    f.seek(last_position)
                    for line in f:
                        process_log_entry(line.strip())
                    last_position = f.tell()
                    save_state(state_file, last_position, last_inode, last_dev)
            except Exception as e:
                logging.error(f"Error reading log file: {str(e)}")
        time.sleep(0.5)


if __name__ == "__main__":
    log_file = '/data/mysql/server_audit.log'
    state_file = "/opt/mysql_audit_monitor/mysqlMonitor.state"
    logging.info(f"Starting MySQL audit log monitoring: {log_file}")
    try:
        monitor_log(state_file, log_file)
    except KeyboardInterrupt:
        logging.info("Monitoring stopped")
        sys.exit(0)

后记

生产环境建议

场景	推荐方案
MySQL 5.7.34以下版本	MariaDB插件方案
MySQL 8.0+	Percona Server或迁移至MariaDB
审计日志存储	独立MySQL实例，与业务库物理隔离
高频操作环境	写入Elasticsearch替代MySQL

通过server_audit插件+Python监控的组合，可在MySQL社区版低成本实现企业级审计需求。但需注意：

📌 版本兼容性是成功前提，MySQL 8.0用户务必选择Percona/MariaDB 📌 日志清洗环节直接影响分析准确性（如转义符处理） 📌 审计日志存储分离是安全最佳实践

最终效果：

所有数据库操作可视化展示
实时捕获高危DDL语句
满足等保2.0/ISO 27001审计要求

基于阿里云DashScope API构建智能对话指南

Thu, 22 May 2025 18:40:54 +0000

背景

公司想对接AI智能体，用于客服系统，经过调研和实施，觉得DashScope 符合需求。阿里云推出的DashScope灵积模型服务为开发者提供了便捷高效的大模型接入方案。本文将详细介绍如何基于DashScope API构建一个功能完善的智能对话系统，包含流式对话、工具调用等高级特性。

项目背景与技术选型

我们的项目目标是构建一个企业级智能客服系统，需要满足以下核心需求：

支持多轮自然语言对话
实现低延迟的流式响应
可扩展的工具调用能力
稳定的生产环境部署

经过技术评估，我们选择了阿里云DashScope服务，主要基于以下优势：

模型多样性：提供QWEN系列等多种大语言模型
API兼容性：兼容OpenAI API格式，降低迁移成本
性能保障：阿里云基础设施确保服务稳定性
成本效益：相比自建模型集群更具性价比

模型地址：https://help.aliyun.com/zh/model-studio/videos/yi-large-quick-start

核心代码实现与优化

基础对话功能实现

我们首先实现了基础的对话功能模块，这是整个系统的核心：


import json
from typing import List, Dict, Optional
import requests
from pydantic import BaseModel
from utils.LogHandler import log


# 配置管理使用Pydantic模型，便于验证和文档化
class DashScopeConfig(BaseModel):
    base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1"
    api_key: str
    default_model: str = "qwen-plus"
    timeout: int = 30
    max_retries: int = 3


class GPTChatResponse(BaseModel):
    content: str
    tool_calls: Optional[List[Dict]] = None


def gpt_chat(
        messages: List[Dict[str, str]],
        config: DashScopeConfig,
        model: Optional[str] = None,
        temperature: Optional[float] = None,
        max_tokens: Optional[int] = 512
) -> str:
    """
    标准对话API实现
    :param messages: 对话消息列表
    :param config: 服务配置
    :param model: 指定模型，默认使用配置中的default_model
    :param temperature: 生成多样性控制
    :param max_tokens: 最大输出token数
    :return: 模型生成的文本内容
    """
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {config.api_key}'
    }

    payload = {
        'model': model or config.default_model,
        'messages': messages,
        'max_tokens': max_tokens,
    }

    if temperature is not None:
        payload['temperature'] = temperature

    for attempt in range(config.max_retries):
        try:
            resp = requests.post(
                f"{config.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=config.timeout
            )
            resp.raise_for_status()
            json_data = resp.json()

            if choices := json_data.get('choices'):
                if len(choices) > 0:
                    return choices[0]['message']['content']

            raise ValueError("No valid response from model")

        except requests.exceptions.RequestException as e:
            log.error(f"Attempt  {attempt + 1} failed: {str(e)}")
            if attempt == config.max_retries - 1:
                raise


if  __name__ == "__main__":
    config = DashScopeConfig(api_key="sk-xxxxxx")
    messages = [
        {"role": "system", "content": "你是一名专业客服人员"},
        {"role": "user", "content": "怎么处理客户争吵问题"}
    ]
    response = gpt_chat(messages, config)
    print(response)

流式对话高级实现

为提升用户体验，我们实现了流式对话功能，并进行了多项优化：


import json
from typing import List, Dict, Optional
import requests
from pydantic import BaseModel
from utils.LogHandler import log


# 配置管理使用Pydantic模型，便于验证和文档化
class DashScopeConfig(BaseModel):
    base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1"
    api_key: str
    default_model: str = "qwen-plus"
    timeout: int = 30
    max_retries: int = 3


class GPTChatResponse(BaseModel):
    content: str
    tool_calls: Optional[List[Dict]] = None


def gpt_stream_chat(
        messages: List[Dict[str, str]],
        config: DashScopeConfig,
        model: Optional[str] = None,
        tools: Optional[List[Dict]] = None,
        on_content: Optional[callable] = None
) -> GPTChatResponse:
    """
    流式对话实现，支持实时内容处理和工具调用
    :param messages: 对话消息列表
    :param config: 服务配置
    :param model: 指定模型
    :param tools: 可用工具列表
    :param on_content: 内容回调函数
    :return: GPTChatResponse对象
    """
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {config.api_key}'
    }

    payload = {
        'model': model or config.default_model,
        'messages': messages,
        'stream': True
    }

    if tools:
        payload['tools'] = tools

    content_list = []
    tool_calls = None

    try:
        resp = requests.post(
            f"{config.base_url}/chat/completions",
            headers=headers,
            json=payload,
            stream=True,
            timeout=config.timeout
        )
        resp.raise_for_status()

        for line in resp.iter_lines():
            if not line or line == b'data: [DONE]':
                continue

            try:
                chunk = json.loads(line.decode('utf-8')[6:])
                delta = chunk['choices'][0]['delta']

                # 处理推理过程内容
                if content := delta.get('reasoning_content'):
                    if on_content:
                        on_content(content, 'reasoning')
                    content_list.append(content)

                    # 处理最终回复内容
                if content := delta.get('content'):
                    if on_content:
                        on_content(content, 'content')
                    content_list.append(content)

                    # 处理工具调用
                if 'tool_calls' in delta:
                    tool_calls = delta['tool_calls']
                    if tool_calls and 'name' in str(tool_calls):
                        break

            except json.JSONDecodeError:
                log.warning(f"Failed  to decode chunk: {line}")
                continue

    except requests.exceptions.RequestException as e:
        log.error(f"Stream  request failed: {str(e)}")
        raise

    return GPTChatResponse(content=''.join(content_list), tool_calls=tool_calls)


def handle_stream_content(content: str, content_type: str):
    print(content, end='', flush=True)  # 实时输出，不换行


if __name__ == "__main__":
    config = DashScopeConfig(api_key="sk-xxxxxxxxxxxxxxxxxxxxxx")
    messages = [
        {"role": "system", "content": "你是一名专业客服人员"},
        {"role": "user", "content": "你好？"}
    ]
    response = gpt_stream_chat(messages, config, on_content=handle_stream_content)
    # print(response.content)

结束

我们成功构建了基于阿里云DashScope的高效智能对话系统。这套方案不仅适用于客服场景，也可扩展应用于智能助手、内容生成等多种AI应用场景。DashScope服务的稳定性和易用性为中小企业快速部署AI能力提供了可靠选择。

Chroma向量检索实战：打造智能客服的“最强大脑”

Tue, 29 Apr 2025 09:01:10 +0000

什么是向量库？

向量库（Vector Database）是一种专门设计用来存储和检索向量数据的数据库系统。在这个文件中使用的ChromaDB就是一种向量数据库。

向量库的核心概念：

向量嵌入（Embeddings）：将文本、图像等非结构化数据转换为高维数字向量
相似性搜索：基于向量间的距离（如余弦相似度）快速查找相似内容
高效索引：使用特殊的索引结构（如HNSW）加速相似性搜索

向量库的用途

在这个项目中，向量库主要用于客服问答系统：

知识库管理：存储问题和答案对，并将问题转换为向量形式存储
语义搜索：当用户提问时，将问题转换为向量，在向量库中查找最相似的已存问题
智能匹配：根据语义相似度而非简单的关键词匹配，找到最相关的答案

Chroma 向量库实战

Chroma 是一个用于构建带有嵌入向量（vector embedding）的 AI 应用程序的向量数据库。它们可以表示文本、图像，很快还可以表示音频和视频。它内置了您开始使用所需的一切，并在您的计算机上运行。他是开源免费，可以本地部署，支持python和js。这是他的优点。pinecone则是付费，而且需要存储数据到pinecone服务器上面，这点对于数据比较重要的企业尤其不好，Chroma则是存储在自己的服务器

ChromaDB 是一个开源的向量数据库，专门用于存储和检索向量数据。它特别适合构建语义搜索、问答系统等 AI 应用。本文将介绍如何使用 ChromaDB 实现基本的向量数据库操作，包括数据的增删改查。

环境准备

本示例使用了以下主要依赖：

chromadb：向量数据库
dashscope：文本向量化服务

1
2

pip install chromadb
pip install dashscope


import chromadb
# chroma_client = chromadb.Client() #内存模式
# 数据保存在磁盘
client = chromadb.PersistentClient(path="E:\\Code\\Python\\weather\\chromadbTest")
collection = client.get_collection(name="fruit_collection")
# 插入数据
collection.add(
    documents=["This is a document about apples", "This is a document about oranges"],
    metadatas=[{"source": "web"}, {"source": "book"}],
    ids=["id1", "id2"]
)

客服向量库实战

EmbeddingClient

EmbeddingClient 类负责将文本转换为向量表示。它使用单例模式确保全局只有一个实例，并通过 dashscope 服务进行文本向量化。

class EmbeddingClient:
    def get_embedding(self, text: Union[str, List[str]]) -> List[float]:
        """获取文本的向量表示"""
        # 通过 dashscope 服务将文本转换为向量
        resp = dashscope.TextEmbedding.call(
            model=self.model,
            input=text
        )
        return resp.output['embeddings'][0]['embedding']

完整代码： DashScope是阿里云的一款模型服务产品，简化了AI模型的应用与部署。已开通服务并获得API-KEY：开通DashScope并创建API-KEY。

from http import HTTPStatus
import dashscope
from typing import List, Union
from utils.LogHandler import log

# from conf.config import dashscope_api_key

dashscope_api_key = "sk-xxxxxxxxxxx"


class EmbeddingClient:
    _instance = None  # 用于保存单例对象

    def __new__(cls):
        """
        确保 `EmbeddingClient` 类只有一个实例（单例模式）
        """
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialize()
        return cls._instance

    def _initialize(self):
        """
        初始化客户端连接
        """
        dashscope.api_key = dashscope_api_key
        self.model = dashscope.TextEmbedding.Models.text_embedding_v3

    def get_embedding(self, text: Union[str, List[str]]) -> List[float]:
        """
        获取文本的向量表示
        :param text: 输入文本，可以是字符串或字符串列表
        :return: 向量列表
        """
        try:
            resp = dashscope.TextEmbedding.call(
                model=self.model,
                input=text
            )
            if resp.status_code == HTTPStatus.OK:
                embedding = resp.output['embeddings'][0]['embedding']
                return embedding
            else:
                log.error(f"Embedding生成失败: status_code={resp.status_code}")
                raise Exception(f"Embedding生成失败: {resp.status_code}")
        except Exception as e:
            log.error(f"Embedding异常: {str(e)}")
            raise


# 获取 embedding_client 的方法
def get_embedding_client() -> EmbeddingClient:
    """
    获取EmbeddingClient实例
    :return: EmbeddingClient的单例对象
    """
    return EmbeddingClient()

ChromaClient

ChromaClient 类封装了与 ChromaDB 的交互操作，提供了以下主要功能：

向量数据的插入和更新
相似向量查询
向量数据删除
集合统计信息查询

import hashlib
import os
from datetime import datetime
from pathlib import Path
from typing import Optional, Tuple

import chromadb
from chromadb.config import Settings

from embedding_client import get_embedding_client
from utils.LogHandler import log


class ChromaClient:
    def __init__(self, persist_directory: str = None):
        """
        初始化Chroma客户端
        :param persist_directory: 持久化存储路径，默认为项目根目录下的chroma_db
        """
        if persist_directory is None:
            # 获取项目根目录
            root_dir = Path(__file__).parent.parent
            persist_directory = os.path.join(root_dir, "chroma_db")

        # 确保目录存在
        os.makedirs(persist_directory, exist_ok=True)
        # 修改初始化设置
        self.client = chromadb.PersistentClient(
            path=persist_directory,
            settings=Settings(
                anonymized_telemetry=False,
                is_persistent=True  # 显式指定持久化
            )
        )
        # 创建或获取集合
        self.collection = self.client.get_or_create_collection(
            name="kefu_qa",
            metadata={"hnsw:space": "cosine", "description": "客服问答向量库"}
        )
        self.embedding_client = get_embedding_client()
        from utils.LogHandler import log
        log.info(f"ChromaDB initialized at: {persist_directory}")

    def upsert_vectors(self, question: str, answer: str) -> str:
        """
        插入或更新向量
        :param question: 问题文本
        :param answer: 答案文本
        :return: 操作结果信息
        """
        qhash = hashlib.md5(question.encode('utf-8')).hexdigest()
        try:
            embedding = self.embedding_client.get_embedding(question)

            metadata = {
                "answer": answer,
                "timestamp": datetime.now().isoformat()
            }

            self.collection.upsert(
                ids=[qhash],
                embeddings=[embedding],
                documents=[question],
                metadatas=[metadata]
            )
            log.info(f"Successfully upserted vector for question: {question}")
            return "插入更新成功"
        except Exception as e:
            log.error(f"向量更新失败: {str(e)}", exc_info=True)
            return f"向量更新失败: {str(e)}"

    def query_similar(self, query_text: str, top_k: int = 1) -> Tuple[str, Optional[str], Optional[str]]:
        """
        查询相似向量
        :param query_text: 查询文本
        :param top_k: 返回结果数量
        :return: (查询文本, 匹配问题, 匹配答案)
        """
        try:
            query_embedding = self.embedding_client.get_embedding(query_text)
            results = self.collection.query(
                query_embeddings=[query_embedding],
                n_results=top_k,
                include=["documents", "metadatas", "distances"],
                where=None,  # 可选的过滤条件
                where_document=None  # 可选的文档过滤条件
            )

            # 检查结果是否为空
            if not results['ids'] or not results['ids'][0]:
                log.info(f"未找到匹配问题：{query_text}")
                return query_text, None, None

            # 获取相似度分数
            distance = results['distances'][0][0]
            if distance > 0.4:  # 相似度阈值，可根据需要调整
                log.info(f"找到的匹配相似度过低：{distance}")
                return query_text, None, None

            question = results['documents'][0][0]
            answer = results['metadatas'][0][0]['answer']

            log.info(
                f"查询成功: question={query_text},link_query_text={question}, answer={answer}, distance={distance}")
            return query_text, question, answer

        except Exception as e:
            log.error(f"查询失败: {str(e)}", exc_info=True)
            return query_text, None, None

    def delete_vectors(self, qhash: str) -> str:
        """
        根据问题删除向量
        :param qhash:
        :return: 删除结果信息
        """
        try:
            # 先检查集合中的数据
            log.info(f"当前集合状态: {self.get_collection_stats()}")
            # 尝试获取要删除的记录
            existing = self.collection.get(
                ids=[qhash]
            )
            log.info(f"要删除的记录: {existing}")
            self.collection.delete(
                ids=[qhash]
            )
            log.info(f"已执行删除: {qhash}")
            log.info(f"当前集合状态: {self.get_collection_stats()}")
            return "问题记录已删除"
        except Exception as e:
            log.error(f"删除失败: {str(e)}", exc_info=True)
            return f"删除失败: {str(e)}"

    def get_collection_stats(self) -> dict:
        """
        获取集合统计信息
        """
        return {
            "total_count": self.collection.count(),
            "name": self.collection.name,
            "metadata": self.collection.metadata
        }


_chroma_client = None


def get_chroma_client():
    global _chroma_client
    try:
        # 如果是第一次创建，或者需要重新检查状态
        if _chroma_client is None:
            _chroma_client = ChromaClient()

        # 获取集合统计信息进行更详细的状态检查
        log.info(f'chroma_client_status={_chroma_client.get_collection_stats()}')

        return _chroma_client

    except Exception as e:
        # 如果出现任何异常，记录日志并重新创建
        log.error(f"获取ChromaClient失败，重新创建对象: {e}")
        _chroma_client = ChromaClient()
        return _chroma_client


if __name__ == "__main__":
    chroma_client = get_chroma_client()
    stats = chroma_client.get_collection_stats()
    print(f"删除前的集合统计: {stats}")

日志记录器

import os
import logging
from logging.handlers import TimedRotatingFileHandler

# 确定日志存储路径，确保路径存在
CURRENT_PATH = os.path.dirname(os.path.abspath(__file__))
ROOT_PATH = os.path.abspath(os.path.join(CURRENT_PATH, "..", "..", ".."))
# LOG_PATH = "/app/logs/app/"
LOG_PATH = os.path.join(ROOT_PATH, 'logs')
if not os.path.exists(LOG_PATH):
    os.makedirs(LOG_PATH)


# 自定义 Filter，用于确保日志 record 中包含 traceId 属性，不存在时设为默认 "null"
class TraceIdFilter(logging.Filter):
    def filter(self, record):
        if not hasattr(record, "traceId"):
            record.traceId = "null"
        return True


# 自定义 Formatter，用于将异常信息中的换行符替换为分隔符，使异常信息显示为单行
class SingleLineExceptionFormatter(logging.Formatter):
    def formatException(self, exc_info):
        result = super().formatException(exc_info)
        # 将换行符替换为空格或其他分隔符，例如 " | "
        return result.replace('\n', ' | ')


# 定义日志格式与时间格式（模仿 Java 输出格式）
LOG_FORMAT = '%(asctime)s.%(msecs)03d [%(levelname)s] [%(traceId)s] [%(threadName)s] [%(name).36s] [%(lineno)d] [ %(filename)s] [%(funcName)s] - %(message)s'
DATE_FORMAT = '%Y-%m-%d %H:%M:%S'


class LogHandler(logging.Logger):
    def __init__(self, name, level=logging.INFO, use_stream=True, use_file=True):
        super().__init__(name, level)
        self.name = name
        self.level = level

        # 添加 filter，确保 traceId 不为空
        self.addFilter(TraceIdFilter())

        if use_stream:
            self.__setStreamHandler__()
        if use_file:
            self.__setFileHandler__()

    def __setFileHandler__(self, level=None):
        # 日志文件名：LOG_PATH 下，名称为 {logger_name}.log
        file_name = os.path.join(LOG_PATH, f'{self.name}.log')
        # 使用按天滚动（每日一个文件），保留7天的日志
        file_handler = TimedRotatingFileHandler(filename=file_name, when='D', interval=1, backupCount=7,
                                                encoding="utf-8")
        file_handler.suffix = '%Y%m%d.log'
        file_handler.setLevel(level if level is not None else self.level)
        formatter = SingleLineExceptionFormatter(LOG_FORMAT, datefmt=DATE_FORMAT)
        file_handler.setFormatter(formatter)
        self.file_handler = file_handler
        self.addHandler(file_handler)

    def __setStreamHandler__(self, level=None):
        stream_handler = logging.StreamHandler()
        stream_handler.setLevel(level if level is not None else self.level)
        formatter = SingleLineExceptionFormatter(LOG_FORMAT, datefmt=DATE_FORMAT)
        stream_handler.setFormatter(formatter)
        self.addHandler(stream_handler)

    def resetName(self, name):
        self.name = name
        self.removeHandler(self.file_handler)
        self.__setFileHandler__()


project_name = 'app'
# 初始化 logger，级别设置为 DEBUG
log = LogHandler(project_name, level=logging.DEBUG)

# 使用示例：设置项目名称为 "app" 并初始化日志实例
if __name__ == '__main__':

    # 测试日志输出
    log.info('This is a test message')

    # 模拟异常情况，测试异常打印为单行
    try:
        1 / 0
    except Exception as e:
        # 这里使用 extra 参数传入 traceId，如果不传则默认显示 "null"
        log.exception("An error occurred", extra={"traceId": "trace-123"})

完整示例

chroma_demo.py

提供了一个完整的示例脚本 chroma_demo.py，展示了向量数据库的基本操作：

添加示例问答对数据
进行相似问题查询
删除指定的问答对
查看集合统计信息

import os
from chroma_client import get_chroma_client


def demo_chroma_operations():
    # 获取ChromaDB客户端实例
    chroma_client = get_chroma_client()

    # 1. 添加示例数据
    print("\n1. 添加示例数据")
    qa_pairs = [
        ("如何查询订单物流？",
         "登录账号后进入『我的订单』，点击对应订单的『物流详情』即可查看实时快递信息，若未更新可联系承运商查询。"),
        ("今日有什么限时优惠？", "今天是2025年4月28日，周一会员日可享全场9折，部分商品参与『五一提前购』活动，满300减50。"),
        ("商品签收后发现有破损怎么办？",
         "请于签收后48小时内拍照留存证据，通过订单页面提交『售后申请』，我们将优先处理您的补偿或换货需求。"),
        ("如何修改绑定的手机号？", "在账户设置的『安全中心』中验证原手机号后，可直接输入新手机号并接收验证码完成更换。"),
        ("积分会过期吗？", "积分有效期为1年，每年12月31日清零未使用的积分，当前账户积分可在『会员中心』查看到期时间。"),
        ("五一假期期间发货吗？", "2025年五一假期为5月1日至5日，期间仓库暂停发货，4月30日18:00前的订单将尽量节前发出。"),
        ("如何开具电子发票？", "下单时勾选『需要发票』并填写抬头信息，电子发票将在订单完成后72小时内发送至您的邮箱。"),
        ("新用户有哪些福利？", "首次注册可领取100元优惠券包（含3张券），首单满199元还可额外获得双倍积分。"),
        ("忘记密码如何重置？", "在登录页点击『忘记密码』，通过绑定的手机号或邮箱接收验证码，按指引设置新密码即可。"),
        ("今日下单何时能到货？",
         "当前时间为17:27，今日内下单且选择快递配送，同城预计4月30日前送达，异地需3-5个工作日（五一假期可能延迟）。")
    ]

    for question, answer in qa_pairs:
        result = chroma_client.upsert_vectors(question, answer)
        print(f"问题：{question}\n回答：{answer}\n结果：{result}\n")

    # # 2. 查询相似问题
    print("\n2. 查询相似问题示例")
    test_queries = [
        "我要退款怎么操作",
        # "订单地址写错了怎么改",
        # "几点发货"
    ]
    #
    for query in test_queries:
        query_text, matched_question, matched_answer = chroma_client.query_similar(query)
        print(f"\n用户问题：{query_text}")
        if matched_question and matched_answer:
            print(f"匹配问题：{matched_question}")
            print(f"匹配答案：{matched_answer}")
        else:
            print("未找到匹配的问答对")
    #
    # 3. 删除示例
    print("\n3. 删除示例")
    # 获取第一个问题的hash值
    import hashlib
    question_to_delete = qa_pairs[0][0]
    qhash = hashlib.md5(question_to_delete.encode('utf-8')).hexdigest()

    # 删除前查看统计信息
    print("删除前统计：", chroma_client.get_collection_stats())

    # 执行删除
    result = chroma_client.delete_vectors(qhash)
    print(f"删除问题：{question_to_delete}")
    print(f"删除结果：{result}")

    # 删除后查看统计信息
    print("删除后统计：", chroma_client.get_collection_stats())


if __name__ == "__main__":
    demo_chroma_operations()

基本操作示例

1. 插入/更新向量数据

# 插入问答对
question = "如何申请退款？"
answer = "您可以在订单详情页面点击'申请退款'按钮，填写退款原因后提交申请。"
result = chroma_client.upsert_vectors(question, answer)

2. 查询相似问题

# 查询相似问题
query_text = "我要退款怎么操作"
query_text, matched_question, matched_answer = chroma_client.query_similar(query_text)

if matched_question and matched_answer:
    print(f"匹配问题：{matched_question}")
    print(f"匹配答案：{matched_answer}")

3. 删除向量数据

# 删除指定问题的向量数据
    chroma_client = get_chroma_client()
    status = chroma_client.get_collection_stats()
    log.info(f"删除前ChromaDB状态: {status}")
    question = "如何申请退款？"
    qhash = hashlib.md5(question.encode('utf-8')).hexdigest()
    result = chroma_client.delete_vectors(qhash)
    log.info(f"删除问题：{question},结果：{result}")
    status = chroma_client.get_collection_stats()
    log.info(f"删除后ChromaDB状态: {status}")

实际应用场景

在客服系统中，这个向量库的应用流程大致为：

管理员预先录入常见问题和标准答案
系统将问题转换为向量并存储在ChromaDB中
用户提问时，系统将问题转换为向量
使用 query_similar 方法在向量库中查找语义最相似的问题
如果找到相似度足够高的匹配（距离小于0.4），返回对应的标准答案
在把答案通过约束的Prompt 给ChatGPT 回答
ChatGPT返回更完整的答案，发送给用户这种基于向量的匹配方式比传统的关键词匹配更智能，能够理解问题的语义而非仅仅是字面表达，大大提高了自动问答系统的准确性和用户体验。

注意事项

向量相似度阈值设置：
- 当前示例中相似度阈值设置为 0.4，可以根据实际需求调整
- 阈值越小，匹配要求越严格
持久化存储：
- ChromaDB 默认将数据存储在项目根目录的 chroma_db 文件夹中
- 可以通过 persist_directory 参数自定义存储路径
错误处理：
- 示例代码中包含了基本的错误处理机制
- 建议在生产环境中添加更完善的错误处理和重试机制

参考文档： https://zhuanlan.zhihu.com/p/658217843 https://www.cnblogs.com/rude3knife/p/chroma_tutorial.html

Harbor2.0仓库镜像清理策略

Sun, 27 Apr 2025 22:48:25 +0000

背景

在持续集成和持续部署的流程中，频繁的构建和部署会生成大量的镜像版本。这些历史镜像如果不及时清理，会占用大量的存储空间，导致 Harbor 仓库膨胀，影响系统性能。目前公司的Harbor存储已经占用1T，好多的repo的镜像tag达到上百多，没有清理十分占用空间。目前研究了下，可采取两种方案进行清理。（各自有各的优势） 1、采用Harbor自带的清理策略 2、写脚本，可以自定义控制清理，比较方便。

目的

释放存储空间：清理不再使用的镜像，释放被占用的磁盘空间。
提高系统性能：减少无用数据，提高 Harbor 的响应速度和稳定性。
简化管理：通过自动化策略，减少手动清理的工作量，提高管理效率。

方案一 Harbor 镜像自动清理策略

Harbor 提供了基于项目的镜像保留策略（Retention Policy），允许用户根据特定的规则自动保留或删除镜像。该策略支持以下配置：（需要每个仓库分别配置）

匹配规则：通过通配符匹配特定的仓库或镜像。
保留策略：设置保留最近推送或拉取的镜像数量或时间范围。
标签过滤：根据镜像的标签（Tag）进行筛选，如保留特定前缀的标签。
删除未打标签的镜像：选择是否删除未打标签的镜像（Untagged Artifacts）。

1、使用管理员账号登录 Harbor 的 Web 控制台。 2、在左侧导航栏选择“项目”，点击需要配置清理策略的项目名称。 3、配置保留策略

在项目页面，选择“策略”选项卡，点击“添加规则”按钮，进行以下配置：

规则名称：为策略命名，便于识别。
匹配仓库：使用通配符（如 **）匹配需要应用策略的仓库。
保留策略：选择保留最近推送或拉取的镜像数量或时间范围。
标签过滤：设置标签匹配规则，如保留以 release- 开头的标签。
删除未打标签的镜像：根据需要选择是否删除未打标签的镜像。

4、设置定时任务在策略页面，点击“编辑”按钮，配置策略的执行时间。Harbor 使用 UTC 时间，需注意与本地时间的差异。例如，设置每周六凌晨 0 点执行：

`1`	`0 0 0 ? * SAT`

这表示每周六 UTC 时间 0 点执行，若在中国时区，实际执行时间为周六上午 8 点。 5、手动执行策略（可选）在策略页面，点击“立即执行”按钮，可以手动触发策略，立即清理符合条件的镜像。

方案二使用Shell脚本处理

harbor_clean.sh

#!/bin/bash
#/**********************************************************
# * Author        : 南宫乘风
# * Email         : 1794748404@qq.com
# * Last modified : 2024-01-17 10:00
# * Filename      : harbor_clean.sh
# * Description   : 清理指定Harbor项目的镜像，只保留最近5次
# * *******************************************************/

set -e

# 日志文件配置
LOG_FILE="./harbor_clean.log"
user=$(whoami)

# Harbor配置(请配置账号和密码)
HARBOR_URL="bdata-hub.xxxxx.cn"
HARBOR_USERNAME="admin"
HARBOR_PASSWORD="xxxxxxxxx"
KEEP_NUM=15 # 保留最近的5个镜像

# 指定要清理的项目列表
PROJECTS=("service"  "pre")

# 创建临时目录
TMP_DIR="$PWD/harbor_clean_tmp"

# 日志函数
function log_info() {
    content="[INFO] $(date '+%Y-%m-%d %H:%M:%S') $0 $user msg : $@"
    echo $content >>$LOG_FILE
    echo -e "\033[32m${content}\033[0m"
}

function log_warn() {
    content="[WARN] $(date '+%Y-%m-%d %H:%M:%S') $0 $user msg : $@"
    echo $content >>$LOG_FILE
    echo -e "\033[33m${content}\033[0m"
}

function log_err() {
    content="[ERROR] $(date '+%Y-%m-%d %H:%M:%S') $0 $user msg : $@"
    echo $content >>$LOG_FILE
    echo -e "\033[31m${content}\033[0m"
}

# 获取指定项目的仓库列表
function get_repos_list() {
    local project=$1
    log_info "获取项目 ${project} 的仓库列表"
    mkdir -p "$TMP_DIR/repos"

    local repos_list=$(curl -s -k -u "${HARBOR_USERNAME}:${HARBOR_PASSWORD}" \
        "https://${HARBOR_URL}/api/v2.0/projects/${project}/repositories?page=1&page_size=100")

    if [ $? -ne 0 ]; then
        log_err "获取项目 ${project} 的仓库列表失败"
        return 1
    fi

    echo "${repos_list}" | jq '.[]' | jq -r '.name' | awk -F "/" '{print $2}' >"$TMP_DIR/repos/${project}.txt"
    log_info "成功获取项目 ${project} 的仓库列表"
}

# 获取镜像标签列表
function get_tag_list() {
    local project=$1
    local repo=$2
    log_info "获取仓库 ${project}/${repo} 的标签列表"
    mkdir -p "$TMP_DIR/tags/$project/$repo"

    local artifacts=$(curl -s -k -u "${HARBOR_USERNAME}:${HARBOR_PASSWORD}" \
        "https://${HARBOR_URL}/api/v2.0/projects/${project}/repositories/${repo}/artifacts?page=1&page_size=100&with_tag=true&with_label=false&with_scan_overview=false&with_signature=false&with_immutable_status=false")

    if [ $? -ne 0 ]; then
        log_err "获取仓库 ${project}/${repo} 的标签列表失败"
        return 1
    fi

    echo "${artifacts}" | jq '.[]' | jq -r '.digest' >"$TMP_DIR/tags/$project/$repo/digests.txt"
    log_info "成功获取仓库 ${project}/${repo} 的标签列表"
}

# 删除旧镜像
function delete_images() {
    local project=$1
    local repo=$2
    local digest_file="$TMP_DIR/tags/$project/$repo/digests.txt"

    if [ ! -f "$digest_file" ]; then
        log_warn "仓库 ${project}/${repo} 的标签文件不存在，跳过"
        return
    fi

    local total_num=$(wc -l <"$digest_file")
    if [ $total_num -gt $KEEP_NUM ]; then
        local delete_num=$((total_num - KEEP_NUM))
        log_info "仓库 ${project}/${repo} 有 ${delete_num} 个镜像需要删除"

        tail -n $delete_num "$digest_file" | while read digest; do
            log_info "准备删除镜像: ${project}/${repo}@${digest}"

            curl -X DELETE -s -k -u "${HARBOR_USERNAME}:${HARBOR_PASSWORD}" \
                "https://${HARBOR_URL}/api/v2.0/projects/${project}/repositories/${repo}/artifacts/${digest}"

            if [ $? -eq 0 ]; then
                log_info "成功删除镜像: ${project}/${repo}@${digest}"
            else
                log_err "删除镜像失败: ${project}/${repo}@${digest}"
            fi
        done

        log_info "仓库 ${project}/${repo} 的镜像清理完成"
    else
        log_info "仓库 ${project}/${repo} 的镜像数量未超过保留限制，跳过清理"
    fi
}

# 清理临时文件
function cleanup() {
    log_info "清理临时文件"
    rm -rf "$TMP_DIR"
}

# 主函数
function main() {
    log_info "开始执行Harbor镜像清理脚本"
    mkdir -p "$TMP_DIR"
    trap cleanup EXIT

    # 遍历指定的项目列表
    for project in "${PROJECTS[@]}"; do
        log_info "开始处理项目: ${project}"
        get_repos_list "$project"

        if [ -f "$TMP_DIR/repos/${project}.txt" ]; then
            while read repo; do
                get_tag_list "$project" "$repo"
                delete_images "$project" "$repo"
            done <"$TMP_DIR/repos/${project}.txt"
        else
            log_warn "项目 ${project} 的仓库列表文件不存在"
        fi
    done

    log_info "Harbor镜像清理脚本执行完成"
}

# 执行主函数
main

1
2
3

#定时任务
crontab -e
/bin/bash /root/shell/harbor_clean.sh

运行日志：

垃圾回收（Garbage Collection）

-配置并执行镜像清理策略后，镜像的元数据会被删除，但实际的存储空间不会立即释放。为彻底释放空间，需要执行垃圾回收操作。

执行步骤

在左侧导航栏选择“系统管理” > “垃圾清理”。
点击“立即清理”按钮，执行垃圾回收操作。
在“历史记录”中查看垃圾回收的执行情况和释放的空间大小。

垃圾回收操作可以配置为定时执行，确保系统定期释放无用的存储空间。

注意事项

策略优先级：多个策略可能存在冲突，Harbor 按照策略的创建顺序依次执行，建议合理规划策略的优先级。

标签管理：合理使用标签（Tag）命名规范，有助于策略的精确匹配和管理。

测试策略：在生产环境应用策略前，建议在测试环境验证策略的效果，避免误删重要镜像。

备份数据：执行清理操作前，建议备份重要数据，以防止数据丢失。

Python使用FastMCP开发MCP服务端

Thu, 17 Apr 2025 09:16:33 +0000

MCP简介

Model Context Protocol (MCP) 是一个专门为 LLM（大语言模型）应用设计的协议，它允许你构建服务器以安全、标准化的方式向 LLM 应用程序公开数据和功能。FastMCP 作为 Python 生态中的一款轻量级框架，利用装饰器来简化路由与工具函数的开发，帮助开发者快速构建面向工具的服务端应用。

MCP Server 提供了 3 种核心原语，每种原语都有其特定的用途和特点：

1. Tool（工具）：

Tool 允许服务器公开可执行的函数，这些函数可由客户端调用并由 LLM 使用来执行操作。Tool 不仅人让 LLM 能从外部获取信息，还能执行写入或操作，为 LLM 提供真正的行动力。
模型控制：Tool 直接暴露给 LLM 可执行函数，让模型可以主动调用。

2. Resource（资源）：

Resource 表示服务器希望提供给客户端的任何类型的只读数据。这可能包括：文件内容、数据库记录、图片、日志等等。
应用控制：Resource 由客户端或应用管理，用于为 LLM 提供上下文内容。

3. Prompt（提示模板） ：

Prompt 是由服务器定义的可重用的模板，用户可以选择这些模板来引导或标准化与 LLM 的交互过程。例如，Git MCP Server 可以提供一个“生成提交信息”的提示模板，用户可以用它来创建标准化的提交消息。
用户控制：Prompt 通常由用户自行选择。

MCP概述

MCP服务端当前支持两种与客户端的数据通信方式：标准输入输出(stdio) 和基于Http的服务器推送事件(http sse)

标准输入输出(stdio)

原理： 标准输入输出是一种用于本地通信的传输方式。在这种模式下，MCP 客户端会将服务器程序作为子进程启动，双方通过约定的标准输入和标准输出（可能是通过共享文件等方法）进行数据交换。具体而言，客户端通过标准输入发送请求，服务器通过标准输出返回响应。 适用场景： 标准输入输出方式适用于客户端和服务器在同一台机器上运行的场景（本地自行编写服务端或将别人编写的服务端代码pull到本地执行），确保了高效、低延迟的通信。这种直接的数据传输方式减少了网络延迟和传输开销，适合需要快速响应的本地应用。

基于Http的服务器推送事件(http sse)

原理: 客户端和服务端通过 HTTP 协议进行通信，利用 SSE 实现服务端向客户端的实时数据推送，服务端定义了/see与/messages接口用于推送与接收数据。这里要注意SSE协议和WebSocket协议的区别，SSE协议是单向的，客户端和服务端建立连接后，只能由服务端向客户端进行消息推送。而WebSocket协议客户端和服务端建立连接后，客户端可以通过send向服务端发送数据，并通过onmessage事件接收服务端传过来的数据。

适用场景： 适用于客户端和服务端位于不同物理位置的场景，尤其是对于分布式或远程部署的场景，基于 HTTP 和 SSE 的传输方式更合适。如：Prometheus，MySQL，MongoDB 数据库等等

环境介绍

uv快速构建Python环境

Win打开 powershell 进行安装参考文档：https://docs.astral.sh/uv/getting-started/installation/#standalone-installer

# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh

# On Windows.
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# With pip.
pip install uv

安装之后，可以通过uv help命令检查是否安装成功：

卸载

`1`	`powershell -c "irm https://astral.sh/uv/install.ps1 \| more"`

基本使用方法

# 创建项目文件夹、同时初始化并指定python版本
uv init py-app -p 3.11.9
# 创建并激活虚拟环境
uv venv
source .venv/bin/activate

# 退出虚拟环境
deactivate
uv venv --seed  # 强制安装基础包（如pip, setuptools, wheel）

# 同步依赖
uv sync
# 安装 requirements.txt
uv pip install -r requirements.txt

# 安装包（使用清华源）
cd py-app
uv add pandas pillow --default-index "https://pypi.tuna.tsinghua.edu.cn/simple"

# 安装CUDA版的torch（使用南京大学源）
uv pip install torch torchvision torchaudio --index-url https://mirror.nju.edu.cn/pytorch/whl/cu126

# 执行python
uv run app.py

Python版本的安装和管理

# 显示当前已经安装的和可供安装的Python版本
uv python list

# 安装指定的Python版本（注意：安装的Python并非全局可用，在命令行工具中输入Python无反映）
uv python install 3.10 3.11 3.12

# 卸载指定的版本
uv python uninstall 3.10

https://www.cnblogs.com/wang_yb/p/18635441

https://zhuanlan.zhihu.com/p/1888904532131575259

版本推荐

Python 版本： 推荐使用 Python 3.10 及以上版本，以便更好地支持异步函数（async/await）我的版本：Python 3.14

FastMCP 库： 该库需要通过 pip 或其他方式安装。安装指令如下：

`1`	`pip install fastmcp`

运行方式： 本示例采用标准输入/输出（stdio）作为传输层，可根据实际需求选择其他传输方式，如网络通信等。

实现步骤

下面按照步骤解析如何构建一个简单但功能完备的 MCP 服务端：

stdio

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo 🚀")


@mcp.tool()
def add(a: int, b: int) -> int:
    """两个数字相加"""
    return a + b


@mcp.tool()
async def calculate(expression: str) -> str:
    """
    计算一个简单的数学表达式。
    Args:
        expression: 要计算的数学表达式（如"1 + 2"）
    Returns:
        str: 计算结果
    """
    try:
        result = eval(expression)
        return f"计算结果: {result}"
    except Exception as e:
        return f"计算错误: {str(e)}"


@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """获取个性化问候语"""
    return f"Hello, {name}!"


if __name__ == "__main__":
    mcp.run(transport='stdio')

启动调试：

`1`	`mcp dev main.py`

错误报错：

Created web app transport
Created web app transport
Set up MCP proxy
file:///C:/Users/admin/AppData/Local/npm-cache/_npx/5a9d879542beca3a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js:103
            throw new Error("Not connected");
                  ^

Error: Not connected
    at SSEServerTransport.send (file:///C:/Users/admin/AppData/Local/npm-cache/_npx/5a9d879542beca3a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js:103:19)
    at Socket.<anonymous> (file:///C:/Users/admin/AppData/Local/npm-cache/_npx/5a9d879542beca3a/node_modules/@modelcontextprotocol/inspector/server/build/index.js:101:33)
    at Socket.emit (node:events:517:28)
    at addChunk (node:internal/streams/readable:368:12)
    at readableAddChunk (node:internal/streams/readable:341:9)
    at Readable.push (node:internal/streams/readable:278:10)
    at Pipe.onStreamRead (node:internal/stream_base_commons:190:23)

解决方案：

1
2
3

npm install -g @modelcontextprotocol/server-filesystem
npm install -g @modelcontextprotocol/server-memory
npm install -g @modelcontextprotocol/server-brave-search

sse模式

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo 🚀")


@mcp.tool()
def add(a: int, b: int) -> int:
    """两个数字相加"""
    return a + b


@mcp.tool()
async def calculate(expression: str) -> str:
    """
    计算一个简单的数学表达式。
    Args:
        expression: 要计算的数学表达式（如"1 + 2"）
    Returns:
        str: 计算结果
    """
    try:
        result = eval(expression)
        return f"计算结果: {result}"
    except Exception as e:
        return f"计算错误: {str(e)}"


@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """获取个性化问候语"""
    return f"Hello, {name}!"


if __name__ == "__main__":
    mcp.run(transport='sse')

在 FastMCP 中，有几个可以设置 SSE 协议相关的参数：

host: 服务地址，默认为 0.0.0.0
port: 服务端口，默认为 8000。上述代码中，我设置为 9000
sse_path：sse 的路由，默认为 /sse

Vscode-Cline调用

安装Vscode和Cline

stdio模式调用

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "E:\\Code\\Python\\weather",
        "run",
        "main.py"
      ],
      "timeout": 30
    }
  }
}

sse模式

{
  "mcpServers": {
    "weather": {
      "url": "http://192.168.96.19:8000/sse"
    }
  }
}

参考文档： https://github.com/GobinFan/python-mcp-server-client?tab=readme-ov-file

https://www.cnblogs.com/xiao987334176/p/18821197

https://www.cnblogs.com/ryanzheng/p/18781666

https://www.cnblogs.com/xiao987334176/p/18822444

https://www.modb.pro/db/1878984329888542720

https://blog.moontak.com/id/522381/

https://github.com/liaokongVFX/MCP-Chinese-Getting-Started-Guide

https://zhuanlan.zhihu.com/p/28700850694

基于Go语言和Kubernetes的多集群管理平台开发实践

Wed, 26 Mar 2025 15:11:01 +0000

项目背景

在云原生时代，Kubernetes已成为容器编排的事实标准。但随着业务规模的扩大，企业往往需要管理多个Kubernetes集群。本文通过一个实际项目，详细介绍如何基于Go语言和Gin框架开发一个支持多集群管理的Kubernetes控制平台，实现Pod资源的全生命周期管理（增删改查、日志查看），并支持数据过滤、排序和分页功能。

Client-go 介绍

client-go是kubernetes官方提供的go语言的客户端库，go应用使用该库可以访问kubernetes的API Server，这样我们就能通过编程来对kubernetes资源进行增删改查操作；
除了提供丰富的API用于操作kubernetes资源，client-go还为controller和operator提供了重要支持client-go的informer机制可以将controller关注的资源变化及时带给此controller，使controller能够及时响应变化。
通过client-go提供的客户端对象与kubernetes的API Server进行交互，而client-go提供了以下四种客户端对象： RESTClient、ClientSet、DynamicClient、DiscoveryClient

代码示例

package main

import (
	"context"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"

	"k8s.io/client-go/tools/clientcmd"
)

func main() {

	// 定义kubeconfig文件路径
	kubeconfig := "config/k8s.yaml"
	// 从kubeconfig文件中构建配置
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
	if err != nil {
		// 如果构建配置失败，则抛出错误
		panic(err.Error())
	}
	// 使用配置创建kubernetes客户端
	client, err := kubernetes.NewForConfig(config)
	if err != nil {
		// 如果创建客户端失败，则抛出错误
		panic(err.Error())
	}
	// 使用客户端获取default命名空间下的所有Pod
	pods, err := client.CoreV1().Pods("default").List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		// 如果获取Pod失败，则抛出错误
		panic(err.Error())
	}
	// 遍历所有Pod，并打印Pod名称
	for _, pod := range pods.Items {
		println(pod.Name)
	}
}

打印结果

常用方法

	// 获取podList类型的pod列表
	podList, err := client.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{})
   // 获取pod的详情
	pod, err := client.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
	// 删除pod
	err := client.CoreV1().Pods(namespace).Delete(context.TODO(), podName, metav1.DeleteOptions{})
	// 更新pod
	_, err = client.CoreV1().Pods(namespace).Update(context.TODO(), pod, metav1.UpdateOptions{})
	// 获取deployment副本数
	scale, err := K8s.ClientSet.AppsV1().Deployments(namespace).GetScale(context.TODO(),deploymentName, metav1.GetOptions{})
	// 创建deployment
	deployment, err =K8s.ClientSet.AppsV1().Deployments(data.Namespace).Create(context.TODO(), deployment,metav1.CreateOptions{})
	// 更新deployment（部分yaml）
	deployment, err = K8s.ClientSet.AppsV1().Deployments(namespace).Patch(context.TODO(),deploymentName, "application/strategic-merge-patch+json", patchByte,metav1.PatchOptions{})

项目架构与核心模块

项目采用分层设计，核心模块包括：

路由层（Router）：基于Gin框架定义API端点。
控制层（Controller）：处理HTTP请求，参数校验，调用服务层逻辑。
服务层（Service）：封装业务逻辑，与Kubernetes API交互。
数据层（Kubernetes Client）：管理多集群连接，提供客户端实例。
工具模块：数据筛选、分页、日志处理等。

技术栈

Gin框架：高性能HTTP框架，用于路由和请求处理。
Kubernetes Client-go：官方Go语言客户端，操作Kubernetes资源。
多集群管理：通过动态加载Kubeconfig支持多集群。
数据分页与过滤：自定义排序、过滤和分页逻辑。

多集群管理实现

在k8s_client.go中，项目通过K8s结构体实现了多集群管理：

type k8s struct {
    ClientMap    map[string]*kubernetes.Clientset  // 多集群Client
    KubeConfMap  map[string]string                 // 多集群配置
}

初始化时，从配置文件读取多个集群的kubeconfig，并为每个集群创建独立的ClientSet：


// Init 初始化k8s client
func (k *k8s) Init() {
	// 创建一个空的map，用于存储Kubeconfigs
	mp := make(map[string]string, 0)
	// 创建一个空的map，用于存储Kubernetes的Clientset
	k.ClientMap = make(map[string]*kubernetes.Clientset, 0)
	// 反序列化
	if err := json.Unmarshal([]byte(config.Kubeconfigs), &mp); err != nil {
		// 如果反序列化失败，则抛出异常
		panic(fmt.Sprintf("反序列化Kubeconfigs失败,%v\n", err))
	}
	// 将反序列化后的结果存储到KubeConfMap中
	k.KubeConfMap = mp
	// 初始化集群Client
	for key, value := range mp {
		// 根据Kubeconfigs中的配置，初始化集群Client
		client, err := clientcmd.BuildConfigFromFlags("", value)
		if err != nil {
			// 如果初始化失败，则抛出异常
			panic(fmt.Sprintf("初始化集群%s失败,%v\n", key, err))
		}
		clientSet, err := kubernetes.NewForConfig(client)
		if err != nil {
			// 如果初始化失败，则抛出异常
			panic(fmt.Sprintf("初始化集群%s失败,%v\n", key, err))
		}
		// 将初始化后的Clientset存储到ClientMap中
		k.ClientMap[key] = clientSet
		// 打印初始化成功的日志
		logger.Info(fmt.Sprintf("初始化集群%s成功", key))
	}
}

这种设计使得在API调用时，只需指定集群名称即可操作对应的集群资源。


// GetClient 根据集群名称获取Client
// 根据集群名称获取kubernetes客户端
func (k *k8s) GetClient(clusterName string) (*kubernetes.Clientset, error) {
	// 从ClientMap中获取指定集群名称的客户端
	client, ok := k.ClientMap[clusterName]
	// 如果不存在，则返回错误
	if !ok {
		logger.Error(fmt.Sprintf("集群%s不存在,无法获取Client\n", clusterName))
		return nil, errors.New(fmt.Sprintf("集群%s不存在,无法获取Client\n", clusterName))
	}
	// 返回客户端
	return client, nil
}

核心功能实现

Pod列表查询

Pod列表查询功能实现了过滤、分页和排序等高级特性，代码位于pod.go和dataselect.go中。

数据结构定义

首先定义了通用的数据选择器结构：

// dataSelect 用于封装排序、过滤、分页的数据类型
type dataSelector struct {
	GenericDateSelect []DataCell       // 可排序的数据集合
	dataSelectQuery   *DataSelectQuery // 查询条件
}

// DataCell 用于各种资源list的类型转换，转换后可以使用dataSelector的自定义排序方法
type DataCell interface {
	GetCreation() time.Time
	GetName() string
}

// DataSelectQuery 定义过滤和分页的属性，过滤：Name， 分页：Limit和Page
// Limit是单页的数据条数
// Page是第几页
type DataSelectQuery struct {
	FilterQuery     *FilterQuery     // 过滤条件
	PaginationQuery *PaginationQuery // 分页条件
}

type FilterQuery struct {
	Name string
}

type PaginationQuery struct {
	Limit int
	Page  int
}

过滤实现

过滤功能通过字符串匹配实现：


// Filter 方法用于过滤元素，比较元素的Name属性，若包含，再返回
func (d *dataSelector) Filter() *dataSelector {
	//如Name的传参为空，则返回所有元素
	if d.dataSelectQuery.FilterQuery.Name == "" {
		return d
	}
	// 若Name的传参不为空，则返回元素中包含Name的元素
	var filteredList []DataCell
	for _, item := range d.GenericDateSelect {
		matched := true
		objName := item.GetName()
		if !strings.Contains(objName, d.dataSelectQuery.FilterQuery.Name) {
			matched = false
			continue
		}
		if matched {
			filteredList = append(filteredList, item)
		}
	}
	d.GenericDateSelect = filteredList // 返回过滤后的元素
	return d
}

分页实现分页逻辑处理了边界情况：

func (d *dataSelector) Paginate() *dataSelector {
    limit := d.dataSelectQuery.PaginationQuery.Limit
    page := d.dataSelectQuery.PaginationQuery.Page
    
    if limit < 1 || page < 1 {
        return d
    }
    
    startIndex := (page - 1) * limit
    endIndex := page * limit

    if len(d.GenericDateSelect) < endIndex {
        endIndex = len(d.GenericDateSelect)
    }
    d.GenericDateSelect = d.GenericDateSelect[startIndex:endIndex]
    return d
}

排序实现通过实现sort.Interface接口实现排序：

func (d *dataSelector) Len() int {
    return len(d.GenericDateSelect)
}

func (d *dataSelector) Swap(i, j int) {
    d.GenericDateSelect[i], d.GenericDateSelect[j] = d.GenericDateSelect[j], d.GenericDateSelect[i]
}

func (d *dataSelector) Less(i, j int) bool {
    a := d.GenericDateSelect[i].GetCreation()
    b := d.GenericDateSelect[j].GetCreation()
    return b.Before(a) // 降序排列
}

dataselect.go

package service

import (
	"sort"
	"strings"
	"time"

	corev1 "k8s.io/api/core/v1"
)

/**
 * @Author: 南宫乘风
 * @Description:定义数据结构
 * @File:  dataselect.go
 * @Email: 1794748404@qq.com
 * @Date: 2025-03-20 14:38
 */

// dataSelect 用于封装排序、过滤、分页的数据类型
type dataSelector struct {
	GenericDateSelect []DataCell       // 可排序的数据集合
	dataSelectQuery   *DataSelectQuery // 查询条件
}

// DataCell 用于各种资源list的类型转换，转换后可以使用dataSelector的自定义排序方法
type DataCell interface {
	GetCreation() time.Time
	GetName() string
}

// DataSelectQuery 定义过滤和分页的属性，过滤：Name， 分页：Limit和Page
// Limit是单页的数据条数
// Page是第几页
type DataSelectQuery struct {
	FilterQuery     *FilterQuery     // 过滤条件
	PaginationQuery *PaginationQuery // 分页条件
}

type FilterQuery struct {
	Name string
}

type PaginationQuery struct {
	Limit int
	Page  int
}

//实现自定义结构的排序，需要重写Len、Swap、Less方法

// Len 方法用于获取数据长度
func (d *dataSelector) Len() int {
	return len(d.GenericDateSelect)
}

// Swap 方法用于数组中的元素在比较大小后的位置交换，可定义升序或降序   i j 是切片的下标
func (d *dataSelector) Swap(i, j int) {
	// 交换GenericDateSelect数组中的第i个和第j个元素
	d.GenericDateSelect[i], d.GenericDateSelect[j] = d.GenericDateSelect[j], d.GenericDateSelect[i]
}

// Less 方法用于定义数组中元素排序的“大小”的比较方式
// Less 方法返回true表示第i个元素小于第j个元素，返回false表示第i个元素大于第j个元素
func (d *dataSelector) Less(i, j int) bool {
	a := d.GenericDateSelect[i].GetCreation()
	b := d.GenericDateSelect[j].GetCreation()
	return b.Before(a)
}

// Sort 重新以上3个方法，使用sort.Sort()方法进行排序
func (d *dataSelector) Sort() *dataSelector {
	// 使用sort.Sort()方法进行排序
	sort.Sort(d)
	return d
}

// 过滤

// Filter 方法用于过滤元素，比较元素的Name属性，若包含，再返回
func (d *dataSelector) Filter() *dataSelector {
	//如Name的传参为空，则返回所有元素
	if d.dataSelectQuery.FilterQuery.Name == "" {
		return d
	}
	// 若Name的传参不为空，则返回元素中包含Name的元素
	var filteredList []DataCell
	for _, item := range d.GenericDateSelect {
		matched := true
		objName := item.GetName()
		if !strings.Contains(objName, d.dataSelectQuery.FilterQuery.Name) {
			matched = false
			continue
		}
		if matched {
			filteredList = append(filteredList, item)
		}
	}
	d.GenericDateSelect = filteredList // 返回过滤后的元素
	return d
}

// 分页

// Paginate 方法用于数组分页，根据Limit和Page的传参，返回数据
func (d *dataSelector) Paginate() *dataSelector {
	limit := d.dataSelectQuery.PaginationQuery.Limit
	page := d.dataSelectQuery.PaginationQuery.Page
	// 验证参数合法，若不合法，则返回所有元素
	if limit < 1 || page < 1 {
		return d
	}
	// 举例：25个元素的数组，limit是10，page是3，startIndex是20，endIndex是30（实际上endIndex是25）、
	startIndex := (page - 1) * limit
	endIndex := page * limit

	// 处理最后一页，这时候就把endIndex由30改为25了
	if len(d.GenericDateSelect) < endIndex {
		endIndex = len(d.GenericDateSelect)
	}
	d.GenericDateSelect = d.GenericDateSelect[startIndex:endIndex]
	return d
}

// 定义podCell 类型，实现两个方法GetCreation和GetName，可进行类型转换
type podCell corev1.Pod

func (p podCell) GetCreation() time.Time {
	return p.CreationTimestamp.Time
}

func (p podCell) GetName() string {
	return p.Name
}

Pod详情查询

通过Kubernetes客户端直接获取Pod详情：

func (p *pod) GetPodDetail(client *kubernetes.Clientset, namespace, podName string) (*corev1.Pod, error) {
    pod, err := client.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
    if err != nil {
        logger.Error(errors.New("获取Pod详情失败, " + err.Error()))
        return nil, errors.New("获取Pod详情失败, " + err.Error())
    }
    return pod, nil
}

Pod日志查询

日志查询功能支持指定容器和返回行数限制：

func (p *pod) GetPodLog(client *kubernetes.Clientset, namespace, podName, containerName string) (log string, err error) {
    lineLimit := int64(config.PodLogTailLine)
    options := &corev1.PodLogOptions{
        Container: containerName,
        TailLines: &lineLimit,
    }
    
    req := client.CoreV1().Pods(namespace).GetLogs(podName, options)
    podLogs, err := req.Stream(context.TODO())
    if err != nil {
        logger.Error(errors.New("获取Pod日志失败, " + err.Error()))
        return "", errors.New("获取Pod日志失败, " + err.Error())
    }
    defer podLogs.Close()
    
    buf := new(bytes.Buffer)
    _, err = io.Copy(buf, podLogs)
    if err != nil {
        logger.Error(errors.New("复制PodLog失败, " + err.Error()))
        return "", errors.New("复制PodLog失败, " + err.Error())
    }
    return buf.String(), nil
}

pod.go

package service

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"io"
	"kubea-go/config"

	"github.com/aryming/logger"

	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
)

/**
 * @Author: 南宫乘风
 * @Description:
 * @File:  pod.go
 * @Email: 1794748404@qq.com
 * @Date: 2025-03-20 15:42
 */

var Pod pod

type pod struct {
}

// PodsResp 定义列表的返回内容，Items是pod元素列表，Total为pod元素数量
type PodsResp struct {
	Items []corev1.Pod `json:"items"`
	Total int          `json:"total"`
}

// GetPods 获取pod列表，支持过滤和分页,排序
func (p *pod) GetPods(client *kubernetes.Clientset, filterName, namespace string, limit, page int) (*PodsResp, error) {
	// 获取podList类型的pod列表
	podList, err := client.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		logger.Error(errors.New("获取Pod列表失败, " + err.Error()))
		return nil, errors.New("获取Pod列表失败, " + err.Error())
	}
	// 实例化dataSelector对象
	selectableData := &dataSelector{
		GenericDateSelect: p.toCells(podList.Items),
		dataSelectQuery: &DataSelectQuery{
			FilterQuery: &FilterQuery{Name: filterName},
			PaginationQuery: &PaginationQuery{
				Limit: limit,
				Page:  page,
			},
		},
	}
	//先过滤
	filtered := selectableData.Filter()
	total := len(filtered.GenericDateSelect)
	data := filtered.Sort().Paginate()
	//将[]DataCell类型的pod列表转为v1.pod列表
	pods := p.fromCells(data.GenericDateSelect)
	return &PodsResp{Items: pods, Total: total}, nil
}

// GetPodDetail 获取pod详情
func (p *pod) GetPodDetail(client *kubernetes.Clientset, namespace, podName string) (*corev1.Pod, error) {
	pod, err := client.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
	if err != nil {
		logger.Error(errors.New("获取Pod详情失败, " + err.Error()))
		return nil, errors.New("获取Pod详情失败, " + err.Error())
	}
	return pod, nil
}

// DeletePod 删除POD
func (p *pod) DeletePod(client *kubernetes.Clientset, namespace, podName string) error {
	// 删除pod
	err := client.CoreV1().Pods(namespace).Delete(context.TODO(), podName, metav1.DeleteOptions{})
	if err != nil {
		logger.Error(errors.New("删除Pod失败, " + err.Error()))
		return errors.New("删除Pod失败, " + err.Error())
	}
	return nil
}

// UpdatePod 更新POD   content参数是请求中传入的pod对象的json数据
func (p *pod) UpdatePod(client *kubernetes.Clientset, namespace, podName, content string) error {
	var pod = &corev1.Pod{}
	// 将content参数的json数据解析到pod对象中
	err := json.Unmarshal([]byte(content), pod)
	if err != nil {
		logger.Error(errors.New("反序列化失败, " + err.Error()))
		return errors.New("反序列化失败, " + err.Error())
	}
	// 更新pod
	_, err = client.CoreV1().Pods(namespace).Update(context.TODO(), pod, metav1.UpdateOptions{})
	if err != nil {
		logger.Error(errors.New("更新Pod失败, " + err.Error()))
		return errors.New("更新Pod失败, " + err.Error())
	}
	return nil
}

// GetPodContainer 获取pod容器
func (p *pod) GetPodContainer(client *kubernetes.Clientset, namespace, podName string) (containers []string, err error) {
	// 获取pod详情
	pod, err := p.GetPodDetail(client, namespace, podName)
	if err != nil {
		logger.Error(errors.New("获取Pod详情失败, " + err.Error()))
		return nil, errors.New("获取Pod详情失败, " + err.Error())
	}
	// 从pod详情中获取容器列表
	for _, container := range pod.Spec.Containers {
		containers = append(containers, container.Name)
	}
	return containers, nil
}

// GetPodLog 获取pod内容器日志
func (p *pod) GetPodLog(client *kubernetes.Clientset, namespace, podName, containerName string) (log string, err error) {
	//设置日志的配置，容器名、tail的行数
	lineLimit := int64(config.PodLogTailLine)
	options := &corev1.PodLogOptions{
		Container: containerName,
		TailLines: &lineLimit,
	}
	// 获取request实例
	req := client.CoreV1().Pods(namespace).GetLogs(podName, options)
	// 发起request请求，返回一个io.ReadCloser类型（等同于response.body）
	podLogs, err := req.Stream(context.TODO())
	if err != nil {
		logger.Error(errors.New("获取Pod日志失败, " + err.Error()))
		return "", errors.New("获取Pod日志失败, " + err.Error())
	}
	defer podLogs.Close()
	//将response body写入到缓冲区，目的是为了转成string返回
	buf := new(bytes.Buffer)
	_, err = io.Copy(buf, podLogs)
	if err != nil {
		logger.Error(errors.New("复制PodLog失败, " + err.Error()))
		return "", errors.New("复制PodLog失败, " + err.Error())
	}
	return buf.String(), nil
}

// toCells 方法用于将pod类型数组，转换成DataCell类型数组
func (p *pod) toCells(std []corev1.Pod) []DataCell {
	cells := make([]DataCell, len(std))
	for i := range std {
		cells[i] = podCell(std[i])
	}
	return cells
}

// fromCells 方法用于将DataCell类型数组，转换成pod类型数组
func (p *pod) fromCells(cells []DataCell) []corev1.Pod {
	pods := make([]corev1.Pod, len(cells))
	for i := range cells {
		//cells[i].(podCell)就使用到了断言,断言后转换成了podCell类型，然后又转换成了Pod类型
		pods[i] = corev1.Pod(cells[i].(podCell))
	}
	return pods
}

Controller层面

package controller

import (
	"kubea-go/service"
	"net/http"

	"github.com/aryming/logger"
	"github.com/gin-gonic/gin"
)

/**
 * @Author: 南宫乘风
 * @Description:
 * @File:  pod.go.go
 * @Email: 1794748404@qq.com
 * @Date: 2025-03-25 15:37
 */

var Pod pod

type pod struct{}

//Controller中的方法入参是gin.Context，用于从上下文中获取请求参数及定义响应内容
//流程：绑定参数",调用service代码",根据调用结果响应具体内容

// GetPods 获取pod列表，支持过滤、排序、分页
func (p *pod) GetPods(c *gin.Context) {
	//匿名结构体，用于声明入参，get请求为form格式，其他请求为json格式
	params := new(
		struct {
			FilterName string `form:"filter_name"`
			Namespace  string `form:"namespace"`
			Page       int    `form:"page"`
			Limit      int    `form:"limit"`
			Cluster    string `form:"cluster"`
		})
	//绑定参数，给匿名结构体中的属性赋值，值是入参
	//	form格式使用ctx.Bind方法，json格式使用ctx.ShouldBindJSON方法
	if err := c.ShouldBind(params); err != nil {
		logger.Error("Bind请求参数失败," + err.Error())
		// ctx.JSON方法用于返回响应内容，入参是状态码和响应内容，响应内容放入gin.H的map中
		c.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	// 获取k8s的连接方式
	client, err := service.K8s.GetClient(params.Cluster)
	if err != nil {
		logger.Error("获取k8s连接失败," + err.Error())
		c.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	//service中的的方法通过 包名.结构体变量名.方法名 使用，serivce.Pod.GetPods()
	pods, err := service.Pod.GetPods(client, params.FilterName, params.Namespace, params.Limit, params.Page)
	if err != nil {
		logger.Error("获取pod列表失败," + err.Error())
		c.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	c.JSON(http.StatusOK, gin.H{
		"msg":  "获取pod列表成功",
		"data": pods,
	})
}

// GetPodDetail 获取pod详情
func (p *pod) GetPodDetail(cxt *gin.Context) {
	params := new(struct {
		Namespace string `form:"namespace"`
		PodName   string `form:"pod_name"`
		Cluster   string `form:"cluster"`
	})
	if err := cxt.ShouldBind(params); err != nil {
		logger.Error("Bind请求参数失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	client, err := service.K8s.GetClient(params.Cluster)
	if err != nil {
		logger.Error("获取k8s连接失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	data, err := service.Pod.GetPodDetail(client, params.Namespace, params.PodName)
	if err != nil {
		logger.Error("获取pod详情失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	cxt.JSON(http.StatusOK, gin.H{
		"msg":  "获取pod详情成功",
		"data": data,
	})
}

// DeletePod 删除pod
func (p *pod) DeletePod(cxt *gin.Context) {
	params := new(struct {
		Namespace string `form:"namespace"`
		PodName   string `form:"pod_name"`
		Cluster   string `form:"cluster"`
	})
	if err := cxt.ShouldBind(params); err != nil {
		logger.Error("Bind请求参数失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	client, err := service.K8s.GetClient(params.Cluster)
	if err != nil {
		logger.Error("获取k8s连接失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	if err := service.Pod.DeletePod(client, params.Namespace, params.PodName); err != nil {
		logger.Error("删除pod失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	cxt.JSON(http.StatusOK, gin.H{
		"msg":  "删除pod成功",
		"data": nil,
	})
}

// UpdatePod 更新pod
func (p *pod) UpdatePod(cxt *gin.Context) {
	params := new(struct {
		Namespace string `form:"namespace"`
		PodName   string `form:"pod_name"`
		Content   string `form:"content"`
		Cluster   string `form:"cluster"`
	})
	//PUT请求，绑定参数方法改为ctx.ShouldBindJSON
	if err := cxt.ShouldBindJSON(params); err != nil {
		logger.Error("Bind请求参数失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	client, err := service.K8s.GetClient(params.Cluster)
	if err != nil {
		logger.Error("获取k8s连接失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	if err := service.Pod.UpdatePod(client, params.Namespace, params.PodName, params.Content); err != nil {
		logger.Error("更新pod失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	cxt.JSON(http.StatusOK, gin.H{
		"msg":  "更新pod成功",
		"data": nil,
	})
}

// GetPodContainer 获取pod容器
func (p *pod) GetPodContainer(cxt *gin.Context) {
	params := new(struct {
		Namespace string `form:"namespace"`
		PodName   string `form:"pod_name"`
		Cluster   string `form:"cluster"`
	})
	// GET请求，绑定参数方法改为ctx.Bind
	if err := cxt.Bind(params); err != nil {
		logger.Error("Bind请求参数失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	client, err := service.K8s.GetClient(params.Cluster)
	if err != nil {
		logger.Error("获取k8s连接失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	containers, err := service.Pod.GetPodContainer(client, params.Namespace, params.PodName)
	if err != nil {
		logger.Error("获取pod容器失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	cxt.JSON(http.StatusOK, gin.H{
		"msg":  "获取pod容器成功",
		"data": containers,
	})
}

// GetPodLog 获取pod中容器日志
func (p *pod) GetPodLog(cxt *gin.Context) {
	params := new(struct {
		Namespace     string `form:"namespace"`
		PodName       string `form:"pod_name"`
		ContainerName string `form:"container_name"`
		Cluster       string `form:"cluster"`
	})
	// GET请求，绑定参数方法改为ctx.Bind
	if err := cxt.Bind(params); err != nil {
		logger.Error("Bind请求参数失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	client, err := service.K8s.GetClient(params.Cluster)
	if err != nil {
		logger.Error("获取k8s连接失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	log, err := service.Pod.GetPodLog(client, params.Namespace, params.PodName, params.ContainerName)
	if err != nil {
		logger.Error("获取pod日志失败," + err.Error())
		cxt.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	cxt.JSON(http.StatusOK, gin.H{
		"msg":  "获取pod日志成功",
		"data": log,
	})
}

API设计与路由

在router.go中定义了清晰的API路由：

func (*router) InitApiRouter(r *gin.Engine) {
    r.GET("/api/ping", func(c *gin.Context) { c.JSON(200, gin.H{"message": "pong"}) })

    // Pod 路由服务
    podGroup := r.Group(apiBasePath)
    {
        podGroup.GET("/pod", Pod.GetPods)               // 获取Pod列表
        podGroup.GET("/pod/detail", Pod.GetPodDetail)   // 获取Pod详情
        podGroup.DELETE("/pod/del", Pod.DeletePod)     // 删除Pod
        podGroup.PUT("/pod/update", Pod.UpdatePod)      // 更新Pod
        podGroup.GET("/pod/container", Pod.GetPodContainer) // 获取容器列表
        podGroup.GET("/pod/log", Pod.GetPodLog)         // 获取容器日志
    }
}

API设计遵循RESTful规范，使用合适的HTTP方法(GET/POST/PUT/DELETE)对应不同的操作类型。

package controller

import "github.com/gin-gonic/gin"

/**
 * @Author: 南宫乘风
 * @Description:
 * @File:  router.go
 * @Email: 1794748404@qq.com
 * @Date: 2025-03-17 17:18
 */

// Router 实例化对象，可以在main.go中调用
var Router router

type router struct {
}

const apiBasePath = "/api/k8s"

// InitRouter 初始化路由

func (*router) InitApiRouter(r *gin.Engine) {
	r.GET("/api/ping", func(c *gin.Context) { c.JSON(200, gin.H{"message": "pong"}) })

	// Pod 路由服务
	podGroup := r.Group(apiBasePath)
	{
		podGroup.GET("/pod", Pod.GetPods)
		podGroup.GET("/pod/detail", Pod.GetPodDetail)
		podGroup.DELETE("/pod/del", Pod.DeletePod)
		podGroup.PUT("/pod/update", Pod.UpdatePod)
		podGroup.GET("/pod/container", Pod.GetPodContainer)
		podGroup.GET("/pod/log", Pod.GetPodLog)
	}

}

优雅关闭

在main.go中实现了服务的优雅关闭：

// 创建信号通道
quit := make(chan os.Signal)
signal.Notify(quit, os.Interrupt)
<-quit  // 阻塞等待中断信号

// 设置5秒超时关闭
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// 优雅关闭服务器
if err := srv.Shutdown(ctx); err != nil {
    logger.Error("Gin Server Shutdown:", err)
}
logger.Info("Gin Server exiting")

完整代码：

package main

import (
	"context"
	"kubea-go/config"
	"kubea-go/controller"
	"kubea-go/service"
	"net/http"
	"os"
	"os/signal"
	"time"

	"github.com/aryming/logger"

	"github.com/gin-gonic/gin"
)

/**
 * @Author: 南宫乘风
 * @Description:
 * @File:  main.go
 * @Email: 1794748404@qq.com
 * @Date: 2025-03-17 14:49
 */
func main() {
	logger.SetLogger("config/log.json")
	// 初始化路由
	r := gin.Default()
	// 初始化K8S客户端
	service.K8s.Init()
	controller.Router.InitApiRouter(r)
	// 启动服务
	srv := &http.Server{
		Addr:    config.ListenAddress,
		Handler: r,
	}
	go func() {
		// service connections
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			logger.Error("listen: %s\n", err)
		}
	}()
	//优雅关闭
	// 声明一个系统信号的channel，并监听系统信号，如果没有信号，就一直阻塞，如果有，就继续执行。当接收到中断信号时，执行cancel()
	// 创建一个用于接收OS信号的通道
	quit := make(chan os.Signal)
	// 配置信号通知，将OS中断信号通知到quit通道
	signal.Notify(quit, os.Interrupt)
	// 阻塞等待，直到从quit通道接收到信号
	<-quit

	// 设置上下文对象ctx，带有5秒的超时
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	// 当函数返回时，调用cancel以取消上下文并释放资源
	defer cancel()

	// 尝试优雅关闭GIN服务器
	if err := srv.Shutdown(ctx); err != nil {
		// 如果关闭失败，记录致命错误
		logger.Error("Gin Server Shutdown:", err)
	}
	// 记录服务器退出信息
	logger.Info("Gin Server exiting")
}

配置管理

配置信息集中在config.go中管理：

const (
    ListenAddress = "0.0.0.0:8081"  // 服务监听地址
    // 多集群kubeconfig配置
    Kubeconfigs    = `{"TST-1":"E:\\GitHUB_Code_Check\\VUE\\kubea-go\\config\\k8s.yaml","TST-2":"E:\\GitHUB_Code_Check\\VUE\\kubea-go\\config\\k8s.yaml"}`
    PodLogTailLine = 500  // 日志默认返回行数
)

使用Vue CLI从零搭建企业级项目实战（Vue3+全家桶）

Mon, 10 Mar 2025 15:37:46 +0000

一篇关于 Vue3 项目搭建的博客文章。下面的示例包含了以下内容：

使用 Vue CLI 创建项目
安装并使用 axios 进行 API 请求
配置 vue-router 实现路由跳转
全局引入 ant-design-vue 组件库

Vue Cli脚手架使用

Vue CLI 是一个基于 Vue.js 进行快速开发的完整系统

配置npm淘宝源（默认国外源，下载依赖较慢）

#设置淘宝源
npm config set registry https://registry.npm.taobao.org --global

#查看源
npm config get registry

命令安装:  npm install -g @vue/cli@4.5.12
检查版本:  vue -V
创建项目:  vue create <项目名称>
选择Vue3项目
运行项目:  npm run serve
访问

创建项目

首先使用 Vue CLI 创建项目（默认生成 Vue3 版本）：

`1`	`vue create vue-demo`

进入项目目录后，安装所需的依赖包：

`1`	`npm install axios vue-router ant-design-vue`

Axios 介绍使用

官方文档: http://www.axios-js.com/zh-cn/docs/ 在前端页面展示的数据大多数都是通过访问一个API获取的，做这件事的方法有好几种，例如 jquery ajax、vue-resource、axios，而vue-resource是vue插件，但3版本不再更新，目前官方推荐主流的axios，aixos是一个http请求库。

安装axios: npm install axios

在组件中导入并使用

import axios from 'axios'

GET请求

使用 axios.get发起GET请求。
使用 .then 获取响应数据。
使用catch 异常处理

<template>
  <div class="home">
    <img alt="Vue logo" src="../assets/logo.png"/>
    <button type="button" @click="getData()">获取后端数据</button>
    {{ data }}
    <p v-if="error" style="color: red;">连接服务器失败，请稍后再试！"</p>
  </div>
</template>

<script>
//  导入话实例化对象
// import axios from "axios"
import axios from "axios"
import {onMounted, ref} from "vue"

export default {
  setup() {
    const data = ref('')
    const error = ref(false)

    function getData() {
     axios.get('http://httpbin.org/get')
          .then(res => {
            data.value = res.data
            console.log(res)
          }).catch(res => {
        error.value = true
        console.log(res)
      })
    }

    // 生命周期钩子
    onMounted(() => {
      getData()
      console.log('挂载完成')
    })

    return {
      error,
      getData,
      data
    }
  }
}
</script>

POST提交

<template>
  <div class="home">
    <img alt="Vue logo" src="../assets/logo.png"/>
    <h1>欢迎访问管理后台</h1>
    <form action="#">
      用户名：<input type="text" v-model="form.username"/>
      密码：<input type="password" v-model="form.password"/>
      <button @click="loginBtn">登录</button>

    </form>
    <p style="color: red;" v-if="notice">用户名和密码不能为空"</p>
  </div>
</template>

<script>
import axios from "axios"
import {ref, reactive} from "vue";

export default {
  name: "Home",
  setup() {
    const form = reactive({
      username: '',
      password: ''
    })
    const notice = ref(false)

    function loginBtn() {
      if (form.username === '' || form.password === '') {
        notice.value = true

      } else {
        axios.post('http://httpbin.org/post', form).then(res => {
          console.log(res)
        })
      }
    }

    return {
      form,
      notice,
      loginBtn
    }
  }
}

</script>

自定义实例自定义实例默默认值认值

有时候服务端接口有多个地址，就会涉及请求的域名不同、配置不同等，这时自定义实例可以很好解决。

创建src/request/index.js文件，定义实例

import axios from "axios";

const instance = axios.create({
    baseURL: "https://httpbin.org",
    timeout: 1000,
    // headers: { 'X-Custom-Header': 'foobar' }
});

// 拦截器 ，请求拦截
instance.interceptors.request.use(
    config => {
        // 在发送请求之前做些什么
        config.headers['Test-Header'] = '123456'
        return config;
    },
    error => {
        // 对请求错误做些什么
        return Promise.reject(error);
    }
);

// 拦截器 ，响应拦截
instance.interceptors.response.use(
    response => {
        // 对响应数据做点什么

        return response;
    },
    error => {
        // 对响应错误做点什么
        return Promise.reject(error);
    }
);



export default instance;

拦截器可以拦截每一次请求和响应，然后进行相应的处理。
请求拦截应用场景：
发起请求前添加header
响应拦截应用场景：
统一处理API响应状态码200或非200的提示消息
统一处理catch异常提示信息

Vue路由路由：Vue Router

Vue Router使用

Vue Router 是 Vue.js (opens new window)官方的路由管理器。

安装

`1`	`npm install vue-router`

创建src/router/index.js文件及目录，之后前端的路由都将维护在此文件中

使用流程

开发页面（组件）定义路由，src/router/index.js

import { createRouter, createWebHistory } from "vue-router";

// 引入组件，一开是就会引入，即使不进入页面，也会加载组件
import Home from "@/views/Home.vue";

const routes = [
    {
        path: "/home",
        name: "Home",
        component: Home,
    },
    {
        path: "/about",
        name: "About",
        // 引入组件，懒加载，只有在打开页面的时候才会加载
        component: () => import("@/views/About.vue"),
    },
    {
        path: "/login",
        name: "Login",
        // 引入组件，懒加载，只有在打开页面的时候才会加载
        component: () => import("@/views/Login.vue"),
    },
];

// 创建一个路由实例
const router = createRouter({
    // 使用基于hash的路由历史模式
    history: createWebHistory(),
    // 定义路由配置数组
    routes: routes,
    // 配置路由模式
    mode: "history",
});

// 导出路由实例以便在其他模块中使用
export default router;

组件使用路由，src/App.vue

<template>
  <img alt="Vue logo" src="./assets/logo.png">
  <div>
  <!-- 使用router-link组件来导航 -->
  <!-- 通过传入 to 属性制定链接 -->
  <!-- router-link 默认会被渲染成一个a标签 -->
    <router-link to="/home">Home</router-link>
    <br>
    <router-link to="/about">About</router-link>
  </div>
	<!-- 路由占位符，路由匹配到的组件都会在这里展示 -->
  <router-view />
</template>

src/main.js种导入router

// {} 导入的是组件的方法
import { createApp } from 'vue'
// 导入组件的别名
import App from './App.vue'
// @ 表示 src 目录
import Test from '@/components/Test.vue'
const app = createApp(App)
// 注册全局组件
app.component('Test1', Test)

import router from './router'

app.use(router)

app.mount('#app')
// createApp(App).mount('#app')

路由传参 URL传参：一般用于页面跳转，将当前数据传递到新页面，例如详情页 params传参：

配置路由: {path: '/user/:id', component: about}
传递方式：<router-link :to="/user/6"></router-link>
传递后路径: /user/6
接受参数法：$route.params.id

query传参

配置路由: {path: '/user/', component: about}
传递方式：<router-link :to="{path: '/about',query:{id:6}}"></router-link>
传递后路径: /user?id=6
接受参数法：$route.query.id

路由守卫

正如其名，vue-router 提供的导航守卫主要用来通过跳转或取消的方式守卫导航。简单来说，就是在路由跳转时候的一些钩子，当从一个页面跳转到另一个页面时，可以在跳转前、中、后做一些事情。

每个收尾方法接收参数：

top：即将要进入的目标，是一个路由对象
from：当前导航正要离开的路由，也是一个路由对象
next：可选，是一个方法，直接进入下一个路由

你可以使用 router.beforeEach 注册一个全局前置守卫，当一个导航触发时，就会异步执行这个回调函数。

const router = createRouter ({ .....
// 添加全局前置路由守卫
router.befoEach((to,from) ") {
 // 这里执行具体操作
 console.log(to)
 console.log(from)
})

在网站开发中，使用导航守卫一个普遍需求：登录验证，，即在没有登录的情况下，访问任何页面都跳转到登录页面。

router.beforeEach((to, from, next) => {
    // 添加全局前置导航守卫
    // ...
    console.log(to);
    console.log(from);
    if (to.path === "/login") {
        return next();
    }
    const token = "" //模拟token，正常是从本地cookie或localstorage中获取
    if (token) {
        return next();  // 如果有token，则正常跳转访问
    } else {
        return next("/login"); // 如果没有token，跳转到登录页
    }
});

完整代码

import { createRouter, createWebHistory } from "vue-router";

// 引入组件，一开是就会引入，即使不进入页面，也会加载组件
import Home from "@/views/Home.vue";

const routes = [
    {
        path: "/home",
        name: "Home",
        component: Home,
    },
    {
        path: "/about",
        name: "About",
        // 引入组件，懒加载，只有在打开页面的时候才会加载
        component: () => import("@/views/About.vue"),
    },
    {
        path: "/login",
        name: "Login",
        // 引入组件，懒加载，只有在打开页面的时候才会加载
        component: () => import("@/views/Login.vue"),
    },
];

// 创建一个路由实例
const router = createRouter({
    // 使用基于hash的路由历史模式
    history: createWebHistory(),
    // 定义路由配置数组
    routes: routes,
    // 配置路由模式
    mode: "history",
});
router.beforeEach((to, from, next) => {
    // 添加全局前置导航守卫
    // ...
    console.log(to);
    console.log(from);
    if (to.path === "/login") {
        return next();
    }
    const token = ""
    if (token) {
        return next();
    } else {
        return next("/login");
    }
});
// 导出路由实例以便在其他模块中使用
export default router;

Ant Design 使用

Element UI 它是由饿了么前端团队推出的基于 Vue 封装的 UI 组件库，提供PC 端组件，简化了常用组件的封装，降低开发难度。
Ant Design 是一套企业级 UI 设计语言和 React 组件库，提供了一套非常完整的组件化设计规范与组件化编码规范，能大幅提高了部分产品的设计研发效率及质量。组件库文档：https://antdv.com/components/overview-cn

安装

`1`	`npm install ant-design-vue`

全局注册

import { createApp } from 'vue'
import App from './App.vue'
// 引入antd和主题样式
import 'ant-design-vue/dist/reset.css';
import Antd from 'ant-design-vue'
// 全局引入antd图标
import * as Icons from '@ant-design/icons-vue';

const app = createApp(App)
// 全局引入antd图标, i是组件名。Icons[i]是具体的组件
for (const i in Icons) {
  app.component(i, Icons[i])
}
import router from './router'

app.use(router)

// 全局引入antd
app.use(Antd)
app.mount('#app')
// createApp(App).mount('#app')

路由页面

import {createRouter,createWebHistory}   from "vue-router";

const routes = [
    {
        path:"/btn",
        component:( ) => import("@/view/test/btn.vue")
    }
]

const router = createRouter({
    history:createWebHistory(),
    routes
})

export default router;

使用< router-view /> ，定义路由占位


// src/App.vue
<template>
<!-- 路由占位符  -->
<template>
  <!--  路由占位符-->
  <router-view/>

</template>

<!--这里是全局的css效果-->
<style>
#app {
  /* 100%的窗口宽和高 */
  width: 100%;
  height: 100%;
}
</style>

使用一个antd的按钮组件

<script setup>

</script>

<template>
<div style="margin: 20px;text-align: center;">
  <a-space wrap>
    <a-button type="primary">Primary Button</a-button>
    <a-button>Default Button</a-button>
    <a-button type="dashed">Dashed Button</a-button>
    <a-button type="text">Text Button</a-button>
    <a-button type="link">Link Button</a-button>
  </a-space>
</div>


</template>

<style scoped>
  .ant-btn {
    margin-right: 8px;
    margin-bottom: 20px;
  }
</style>

浏览器打开localhost:8080/btn

开发与响应流程

实战复盘：如何用JProfiler在30分钟内解决内存泄漏？

Sun, 09 Mar 2025 10:34:57 +0000

问题

近日公司有服务内存泄露导致服务假死，导致服务不可用。第一时间查看异常日志，并未发现什么异常，但是进入pod发现生成java_pid1.hprof文件。平台的线上环境均配置了jvm参数，在发生OOM时会自动dump出堆转储文件，接下来就要从dump文件入手来定位问题了。

项目背景

在Java应用开发中，内存溢出（Out Of Memory, OOM）是开发者最常遇到的严重问题之一。OOM通常由以下原因引发：

内存分配不足：JVM堆内存设置过小，无法应对高并发或复杂业务场景。
代码漏洞：如内存泄漏（对象无法被GC回收）、大对象未释放、集合类滥用等。
系统突然的流量增大，原有的可用内存不足以支撑等。

当系统突发OOM时，若仅依赖日志定位问题，往往难以快速找到根源。此时，JProfiler作为一款强大的JVM性能分析工具，能够通过内存快照（Dump文件）精准定位问题代码，成为解决问题的关键。

环境

官方网址：https://www.ej-technologies.com/jprofiler/download92

JDK版本：Java 8+（推荐JDK 11及以上，支持更全面的诊断功能）。
JProfiler版本：12.0+（支持与IDEA插件集成）。
IDE：IntelliJ IDEA（集成JProfiler插件）。
服务器环境：Linux（需配置OOM自动生成Dump文件）。

实战步骤：从OOM到问题定位

配置JVM参数生成Dump文件

Dump文件是在OOM内存溢出的时候，自动Dump文件转存快照的，配置JVM参数 ,就能够在发生Out of Memory错误的时候，就是把当前堆栈信息转存为快照Dump文件

-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/dev/test_service_jvmDump.hprof

生产
     java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/home/app.hprof -jar app.jar

HeapDumpOnOutOfMemoryError：触发OOM时生成快照。
HeapDumpPath：指定快照文件存储路径（需确保目录可写）。

获取并解析Dump文件

当OOM发生时，服务器会生成.hprof文件，下载至本地。
使用JProfiler打开快照：
- 启动JProfiler，选择 Open Snapshots → Open a Single Snapshot。
- 加载.hprof文件后，JProfiler会自动解析堆内存结构。

导入成功后可以看到如下界面:

Jprofiler使用分析大对象来源

Jprofile 分析对象,有两个特别重要的信息即对象的引用信息

incoming references
- 入引用, 显示这个对象被谁引用，找问题出现的代码位置
outcoming references
- 出引用,显示这个对象引用的其他对象，找出他有什么，他为什么这么大内存，内存里面存储的是啥

下面我们先预估对象内存大小

按照Size排序，这个byte[]使用15350次，占用内存1272MB，看着很大 Incomming References 入引用,找引用当前对象的对象

Use select Objects 分析对象引用

首先选中对象，点击右键，Use select Objects 选择 incoming references 找到对象引用的地方逐个分析，点击show more

查看代码，分析问题

Jprofile 大对象寻找法

上面我们通过 incomming references ，找对了对象的引用，下面我们我们采用更为直接的方法

我们都知道内存过高, 无法回收,肯定是内存中堆积的东西多了, 那么我们看下有哪些大对象占用了内存,如何找到大对象?

Jprofile提供了Biggest Objects的查找方法

我们可以看到按钮 Biggets OBjects
直接点击按钮, JProfiler就会显示当前堆栈中有哪些大对象

在上面的基础上进行操作然后点开大对象进行分析, 同样的 Used Selected Objects 点击Incomming References 查找对象引用信息

![![在这里插入图片描述](../../image/af4eba6408a6405f86d7a60748234e10.png) 同样的结果, 可以定位到148行代码存在问题

用Graph 查找对象源

先查找 Incomming References 找到对象被谁引用找到想要追查的对象后，选择User Selected Objects 然后点击 Show In Graph 定位线程及Class信息

然后根据数据源Heap Walker 定位到问题的Class类信息及具体的行信息

Show Path To GC Root 找到创建该方法的位置

选择Use Selected Objects ，选择Imcoming References，然后点击 Show Path To GC Root

从创建该对象的方法开始检查，检查所有用到该对象的地方，直到找到泄漏位置

选择All root，展示所有的根节点链路信息定位问题，查阅代码

总结

通过JProfiler分析Dump文件，开发者可以快速定位内存泄漏或大对象问题。关键在于：

生成准确的快照：确保JVM参数配置正确。
掌握分析工具的核心功能：如引用链追踪、大对象筛选。
结合代码与业务场景：避免“治标不治本”的临时修复。

Gin框架从入门到实战：核心用法与最佳实践

Tue, 04 Mar 2025 11:07:28 +0000

为什么选择Gin框架？

Gin 是一个基于 Go 语言的高性能 Web 框架，具备以下优势：

轻量高效：底层依赖 net/http，性能接近原生。
简洁优雅：API 设计友好，支持路由分组、中间件链、参数绑定等特性。
生态丰富：内置 JSON 解析、日志记录、错误恢复等实用功能，社区插件生态完善。
无论是构建 RESTful API 还是全栈应用，Gin 都能显著提升开发效率。

安装

要安装Gin软件包，您需要安装Go并首先设置Go工作区。

首先需要安装Go（需要1.10+版本），然后可以使用下面的Go命令安装Gin。

`1`	`go get -u github.com/gin-gonic/gin`

将其导入您的代码中：

`1`	`import "github.com/gin-gonic/gin"`

基础示例

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    // 1.创建 (实例化gin.Engine结构体对象）
    r := gin.Default()
    // 2.绑定路由规则，执行的函数
    // gin.Context，封装了request和response
    r.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, Gin!")
    })
    // 3.监听端口，默认在8080
    //  Run("里面不指定端口号默认为8080")
    r.Run(":8080")
}

运行后访问 http://localhost:8080，即可看到返回的字符串。

Gin工工作作流流程

核心概念

Engine 容器对象，整个框架的基础
Engine.tree 负责存储路由和handle方法的映射，采用类似于字典树的结构
Engine.RouterGroup 其中handlers存储着所有中间件
Context 上下文对象，负责处理请求回应，其中handles的存储处理请求时中间件和处理方法的

请求处理流程

GIN启动流程

`1`	`Gin初始化----> Use 中间件 ----> 注册Routers路由 ----> RUN()启动`

Gin原原理解析

参考资料：http://v5blog.cn/pages/dd7d5a/

gin.Default()

Default()跟New()几乎一模一样, 就是调用了gin内置的Logger(), Recovery()中间件

// Default返回一个已经附加了Logger和Recovery中间件的Engine实例
func Default() *Engine {
	debugPrintWARNINGDefault()
	engine := New() "# 默认实例
	// 注册中间建，中间件的是一个函数，最终只要返回一个 type HandlerFunc func(*Context) 就可以
	engine.Use(Logger(), Recovery()) // 默认注册的两个中间件
	return engine
}

engine := New() 初初始化始化

通过调用 gin.New() 方法来实例化 Engine容器

engine.Use() 注注册册中间件中间件

路由与参数处理

无参路由

func HelloWorldhandler(ctx *gin.Context){
    ctx.JSON(200, gin.H{
        "message": "Hello World",
    })
}

func main() {
    // 创建一个默认的路由器
    router := gin.Default()
    // gin.Context是一个结构体，包含了请求和响应的细节， 封装request和response
    router.GET("/",HelloWorldhandler)
    // 路由重定向
    router.GET("/re", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "https://www.baidu.com")
    })
    // 启动服务器
    router.Run(":8081")
}

动态路由参数

通过 :param 捕获 URL 中的变量： (可以通过Context的Param方法来获取API参数)

r.GET("/book/:id", func(c *gin.Context) {
    bookID := c.Param("id")
    c.String(http.StatusOK, "书籍ID: %s", bookID)
})

查询参数

使用 Query 或 DefaultQuery 获取 URL 参数： http://127.0.0.1:8000/user?name=zhangsan

r.GET("/user", func(c *gin.Context) {
    name := c.Query("name")
    role := c.DefaultQuery("role", "guest")
    c.JSON(200, gin.H{"name": name, "role": role})
})

ShouldBind参数绑定

通过 ShouldBind 自动解析请求体（支持 JSON、Form 等）：

我们可以基于请求的 Content-Type 识别请求数据类型并利用反射机制自动提取请求中 QueryString 、 form表单、 JSON 、 XML 等参数到结构体中

type LoginForm struct {
    Username string `form:"username" binding:"required"`
    Password string `form:"password" binding:"required"`
}

r.POST("/login", func(c *gin.Context) {
    var form LoginForm
    if err := c.ShouldBind(&form); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    c.String(200, "登录成功: %s", form.Username)
})

完整代码案例

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

// HelloWorldhandler 无参数路由处理函数
func HelloWorldhandler(ctx *gin.Context){
    ctx.JSON(200, gin.H{
        "message": "Hello World",
    })
}

func GetBookDetailHandler(ctx *gin.Context )  {
    bookId := ctx.Param("id")

    ctx.String(http.StatusOK, fmt.Sprintf("成功获取书籍详情：%s", bookId))

}

func GetUserDetailHandlers(ctx *gin.Context)   {
    username := ctx.Query("username")
    ctx.String(http.StatusOK, fmt.Sprintf("成功获取用户详情：%s", username))
}

type Login struct {
    Username string `form:"username" json:"username" binding:"required"`
    Password string `form:"password" json:"password" binding:"required"`
}

func ResponseJsonHandler(c *gin.Context) {
    type Data struct {
        Msg string `json:"msg:"`
        Code int    `json:"code"`
    }
    d := Data{
        Msg: "success",
        Code: 200,
    }
    c.JSON(http.StatusOK, d)
}
func Loginhandler(c *gin.Context)  {
    var login Login
    if err := c.ShouldBind(&login); err == nil {
        c.JSON(http.StatusOK, gin.H{
            "username": login.Username,
            "password": login.Password,
        })
    } else {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    }
}

func ResponseStringHandle(c *gin.Context)  {
    c.String(http.StatusOK, "Hello World")
}

func main() {
    // 创建一个默认的路由器
    router := gin.Default()
    // gin.Context是一个结构体，包含了请求和响应的细节， 封装request和response
    // 无参数路由
    router.GET("/",HelloWorldhandler)
    // 返回字符串
    router.GET("/string", ResponseStringHandle)
    // 返回json
    router.GET("/json", ResponseJsonHandler)
    // 动态路由参数
    router.GET("/book/:id", GetBookDetailHandler)
    // 查询参数 Query 或 DefaultQuery
    router.GET("/user/", GetUserDetailHandlers)
    // 参数绑定
    router.POST("/login", Loginhandler)
    // 路由重定向
    router.GET("/re", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "https://www.baidu.com")
    })
    // 启动服务器
    router.Run(":8081")
}

路由分发

为什么需要路由分发？

我们一个项目有非常多的模块，如果全部写在一块导致代码结构混乱，不利于后续的扩展
按照大的模块，每个模块有自己独立的路由，主路由可以再main.go中进行注册

项目结构

├── go.mod
├── go.sum
├── main.go
└── routers
  ├── books.go
  └── users.go

main.go


import (
"days/routers"
"fmt"
"github.com/gin-gonic/gin"
)
func main() {
    router := gin.Default()
    // 全局中间件
    router.Use(MiddleWare())
    // 加载路由
    routers.LoadUsers(router)
    routers.LoadBooks(router)
    router.Run(":8081")
}

routers/users.go

package routers
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
    "time"
)

func LoadUsers(e *gin.Engine)  {
    e.GET("/user",MiddleWareOne(),UserHandler)
}

func UserHandler(c *gin.Context) {

    fmt.Println("我是用户路由")
    time.Sleep(time.Second * 5)
    c.JSON(http.StatusOK,gin.H{
        "message" : "weclome user",
    })
}

routers/books.go

package routers
import (
"net/http"
"github.com/gin-gonic/gin"
)
func LoadBooks(e *gin.Engine) {
    e.GET("/book", GetBookHandler)
}
func GetBookHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Book Router",
    })
}

中间件

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。
这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑
比如登录认证、权限校验、数据分页、记录日志、耗时统计等

全局中间件

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        latency := time.Since(start)
        fmt.Printf("请求耗时: %v\n", latency)
    }
}

func main() {
    r := gin.Default()
    r.Use(Logger()) // 全局生效
    r.GET("/", func(c *gin.Context) { /* ... */ })
}

局部中间件

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("token")
        if token != "SECRET_KEY" {
            c.AbortWithStatusJSON(401, gin.H{"error": "身份验证失败"})
        }
        c.Next()
    }
}

r.GET("/profile", AuthMiddleware(), func(c *gin.Context) {
    c.JSON(200, gin.H{"data": "用户信息"})
})

next()方法

在中间件中调用next()方法，会从next()方法调用的地方跳转到Handler函数
Handler函数执行完成，若中间件还有部分代码未执行（中间件中next()之后的代码），则执行该代码

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
    "time"
)

func main() {
    r := gin.Default()
    r.Use(Log(), RequestID())
    r.GET("/", func(c *gin.Context) {
        fmt.Println("app running  1")
        time.Sleep(time.Second * 5)
        c.String(http.StatusOK, "hello World!")
    })
    r.Run()
}
func Log() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("log start")
        c.Next()
        fmt.Println("log end")
    }
}
func RequestID() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("requestid start")
        c.Next()
        fmt.Println("requestid end")
    }
}

实现token认证

http://127.0.0.1:8080/index index首页无需token直接访问
http://127.0.0.1:8080/home home家目录需要对token进行验证，验证通过才可访问

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
)

func AuthMiddleWare() func(c *gin.Context)  {

    return func(c *gin.Context){
        // 客户端携带token 有三种方式 1.放在请求头 2.放在请求体 3.放在url
        // token 验证成功，返回 c.next()才会继续，否则 c.Abort()
        token := c.Request.Header.Get("token")
        fmt.Println("获取token:",token)
        if token == "" {
            c.JSON(200, gin.H{
                "code": 401,
                "msg": "身份验证不通过",
            })
            c.Abort()
        }
        if token != "123456" {
            c.JSON(200, gin.H{
                "code": 401,
                "msg": "token错误",
            })
            c.Abort()
        }

    }
}





func main()  {
    router := gin.Default()
    // 首页无需验证
    router.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "首页",
        })
    })
    // Home页面需要验证
    router.GET("/home", AuthMiddleWare(), func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Home页面",
        })
    })
    router.Run(":8081")
}

轻量级日志分析利器：Go实战

Mon, 17 Feb 2025 17:22:29 +0000

背景

从重复劳动到自动化提效 在日常开发运维工作中，日志分析是每个工程师都会遇到的"必修课"。当我们需要定位线上问题、分析访问趋势或验证测试结果时，往往需要面对以下痛点场景：

在GB级的日志文件中手动grep关键信息
重复编写awk/sed脚本统计访问量
每次分析日志都需要进行相似的筛选、统计操作，重复劳动让人疲惫不堪
人工分析难以快速提取出日志中的关键指标，例如 IP 访问量、错误状态码分布等。

为此，我基于Go语言开发了这款命令行日志分析工具，它具备以下核心价值：

极简部署（单文件二进制）
实时交互式分析
常用统计场景全覆盖
毫秒级响应速度
测试友好型输出

工具功能概览

这款日志分析工具 ( log-analyzer ) 基于 Go 语言开发，充分利用了 Go 语言在处理文本和并发方面的优势，旨在提供简洁、高效的日志分析能力。它主要具备以下核心功能：

Top N 统计分析: 快速统计日志中出现频率最高的 IP 地址、HTTP 状态码和请求路径，帮助你快速了解访问概况和潜在热点。
关键词过滤: 支持根据关键词快速筛选出包含特定信息的日志行，例如错误日志、特定用户的访问日志等，方便问题定位。
时间范围过滤: 允许用户指定时间范围，筛选出特定时间段内的日志，例如分析某个时间段内的异常请求或用户行为。

环境准备与技术选型

开发环境要求

Go 1.18+（支持泛型特性）
支持正则表达式的日志格式（如Nginx/Apache通用格式）
内存：100MB+（取决于日志规模）

关键技术栈

组件	用途	优势
bufio.Scanner	大文件流式读取	内存效率高，支持GB级文件处理
regexp	结构化日志解析	高性能正则匹配（RE2引擎）
sort.Slice	统计结果排序	灵活的自定义排序实现
time.Parse	多时区时间解析	精确处理全球分布式系统日志

选择Go语言的核心考量：

编译为单文件二进制，无依赖部署
原生并发模型适合日志处理场景
卓越的性能表现（相比Python/Node.js）
丰富的标准库覆盖常见需求

核心功能实现解析

Nginx日志格式

Nginx配置

    log_format  main    '$remote_addr $host $document_uri [$time_local]  '
			'"$remote_user" "$scheme" "$request" "$status" "$body_bytes_sent" '
			'"X-Forwarded-For: $proxy_add_x_forwarded_for" '
			'"Referer: $http_referer" "User_Agent: $http_user_agent" '
			'"upstream_addr:$upstream_addr" "upstream_cache_status:$upstream_cache_status" '
			'"upstream_status:$upstream_status" "upstream_response_time:$upstream_response_time"';
    access_log  logs/access.log  main;

日志格式

1
2

106.224.56.100 track-backend.xxx.com /trace [28/Jan/2025:23:57:01 +0800]  "-" "https" "POST /trace HTTP/1.1" "200" "50" "X-Forwarded-For: 106.224.56.100, 106.224.56.100" "Referer: -" "User_Agent: okhttp/4.2.2" "upstream_addr:172.18.199.211:80" "upstream_cache_status:-" "upstream_status:200" "upstream_response_time:0.008"
8.135.0.81 ykdgate.xxx.com /api/v1/contract/query/WLSK/21070321435307266422910/LOAN_CONTRACT [28/Jan/2025:23:57:01 +0800]  "-" "https" "GET /api/v1/contract/query/WLSK/21070321435307266422910/LOAN_CONTRACT HTTP/1.1" "200" "120" "X-Forwarded-For: 8.135.0.81, 8.135.0.81" "Referer: -" "User_Agent: Apache-HttpClient/4.5.2 (Java/1.8.0_402)" "upstream_addr:172.18.199.211:80" "upstream_cache_status:-" "upstream_status:200" "upstream_response_time:0.013"

正则表达 https://hiregex.com/

`1`	`(?P<ip>\S+) (?P<host>\S+) (?P<uri>\S+) \[(?P<time>.?)\] "(?P<user>.?)" "(?P<scheme>.*?)" "(?P<request>[^"]+)" "(?P<status>\d+)"`

日志解析引擎设计

1
2

var logPattern = regexp.MustCompile(
    `(?P<ip>\S+) (?P<host>\S+) (?P<uri>\S+) \[(?P<time>.*?)\] "(?P<user>.*?)" "(?P<scheme>.*?)" "(?P<request>[^"]+)" "(?P<status>\d+)"`)

这个正则表达式定义了日志行中各个字段的提取规则，例如 IP 地址、主机名、请求 URI、时间戳、用户、请求协议、请求内容和 HTTP 状态码等。 (?P...) 是 Go 语言正则表达式的命名捕获组，可以将匹配到的内容存储到指定名称的组中，方便后续代码引用。

统计数据结构

type LogStats struct {
    IPs     map[string]int  // IP访问计数器
    Status  map[string]int  // 状态码分布
    Paths   map[string]int  // URI访问排行
    Lines   []string        // 原始日志缓存
}

IPs、 Status 和 Paths 字段使用 map[string]int 存储统计数据，键为字符串类型的 IP 地址、状态码或路径，值为出现次数。 Lines 字段使用字符串切片 []string 存储原始日志行，用于后续的关键词和时间范围过滤。

ProcessLine 函数：日志行的“处理器”

ProcessLine 函数负责逐行处理日志文件，解析每行日志并提取关键信息，更新 LogStats 结构体中的统计数据：

// ProcessLine 处理日志行
func (ls *LogStats) ProcessLine(line string) {
    matches := logPattern.FindStringSubmatch(line)
    if matches == nil {
       return //  如果日志行不匹配正则，则忽略
    }

    fields := make(map[string]string)
    for i, name := range logPattern.SubexpNames() {
       if i != 0 && name != "" {
          fields[name] = matches[i] //  将正则匹配到的内容存储到 fields map 中
       }
    }

    ls.IPs[fields["ip"]]++      //  统计 IP 地址
    ls.Status[fields["status"]]++  //  统计 HTTP 状态码
    ls.Paths[fields["uri"]]++     //  统计请求路径
    ls.Lines = append(ls.Lines, line) //  存储原始日志行
}

该函数首先使用 logPattern.FindStringSubmatch(line) 尝试匹配日志行，如果匹配失败则直接返回。匹配成功后，将匹配到的内容存储到 fields map 中，并根据字段名更新 LogStats 结构体中的 IPs、 Status 和 Paths 统计数据，同时将原始日志行添加到 Lines 切片中

交互式设计

请选择您的操作(输入数字:
1. 输出 Top 10 IPs, Status Codes, and Paths
2. 根据 keyword 过滤日志行
3. 根据 时间 过滤日志行
4. 退出程序

通过简单的菜单驱动，将常用操作封装为原子功能，提升用户体验。

完整代码

package main

import (
	"bufio"
	"fmt"
	"os"
	"regexp"
	"sort"
	"strings"
	"time"
)

/**
 * @Author: 南宫乘风
 * @Description:
 * @File:  main.go
 * @Email: 1794748404@qq.com
 * @Date: 2025-02-17 14:15
 */

// 正则匹配格式
var logPattern = regexp.MustCompile(`(?P<ip>\S+) (?P<host>\S+) (?P<uri>\S+) \[(?P<time>.*?)\]  "(?P<user>.*?)" "(?P<scheme>.*?)" "(?P<request>[^"]+)" "(?P<status>\d+)"`)

// 时间格式
const timeLayout = "02/Jan/2006:15:04:05 -0700" // 加入时区解析

// LogStats 日志统计结构体
type LogStats struct {
	IPs    map[string]int
	Status map[string]int
	Paths  map[string]int
	Lines  []string
}

// ProcessLine 处理日志行
func (ls *LogStats) ProcessLine(line string) {
	matches := logPattern.FindStringSubmatch(line)
	if matches == nil {
		return
	}

	fields := make(map[string]string)
	for i, name := range logPattern.SubexpNames() {
		if i != 0 && name != "" {
			fields[name] = matches[i]
		}
	}

	ls.IPs[fields["ip"]]++
	ls.Status[fields["status"]]++
	ls.Paths[fields["uri"]]++
	ls.Lines = append(ls.Lines, line)
}

// printTopN 统计数据
func printTopN(data map[string]int, n int) {
	type kv struct {
		Key   string
		Value int
	}

	var sortedData []kv
	for k, v := range data {
		sortedData = append(sortedData, kv{k, v})
	}

	sort.Slice(sortedData, func(i, j int) bool {
		return sortedData[i].Value > sortedData[j].Value
	})

	for i, item := range sortedData {
		if i >= n {
			break
		}
		fmt.Printf("%s: %d\n", item.Key, item.Value)
	}
}

// PrintTopN 打印统计数据
func (ls *LogStats) PrintTopN(n int) {
	fmt.Println("Top IPs:")
	printTopN(ls.IPs, n)
	fmt.Println("\nTop Status Codes:")
	printTopN(ls.Status, n)
	fmt.Println("\nTop Paths:")
	printTopN(ls.Paths, n)
}

// FilterLines 根据关键字过滤日志
func (ls *LogStats) FilterLines(keyword string) {
	fmt.Println("Filtered Lines:")
	for _, line := range ls.Lines {
		if strings.Contains(line, keyword) {
			fmt.Println(line)
		}
	}
}

// FilterByTime 根据时间过滤日志
func (ls *LogStats) FilterByTime(start, end string) {
	fmt.Println("按时间筛选日志:")
	startTime, err1 := time.Parse(timeLayout, start)
	endTime, err2 := time.Parse(timeLayout, end)

	if err1 != nil || err2 != nil {
		fmt.Println("Invalid time format. Use: 02/Jan/2006:15:04:05 -0700")
		return
	}

	for _, line := range ls.Lines {
		matches := logPattern.FindStringSubmatch(line)
		if matches == nil {
			continue
		}

		logTime, err := time.Parse(timeLayout, matches[4]) // 直接解析日志中的完整时间戳
		if err != nil {
			continue
		}

		if (logTime.Equal(startTime) || logTime.After(startTime)) && logTime.Before(endTime) {
			fmt.Println(line)
		}
	}
}

// NewLogStats 创建新的 LogStats 实例
func NewLogStats() *LogStats {
	return &LogStats{
		IPs:    make(map[string]int),
		Status: make(map[string]int),
		Paths:  make(map[string]int),
		Lines:  []string{},
	}
}

// main 函数
func main() {
	// 检查参数
	if len(os.Args) < 2 {
		fmt.Println("Usage: log-analyzer <logfile>")
		os.Exit(1)
	}
	// 打开文件
	file, err := os.Open(os.Args[1])
	if err != nil {
		fmt.Println("Error opening file:", err)
		os.Exit(1)
	}
	defer file.Close()
	// 创建 LogStats 实例
	stats := NewLogStats()
	// 读取文件
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		stats.ProcessLine(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("Error reading file:", err)
	}
	// 主循环
	for {
		fmt.Println("\n请选择您的操作(输入数字:")
		fmt.Println("1. 输出 Top 10 IPs, Status Codes, and Paths")
		fmt.Println("2. 根据 keyword 过滤日志行")
		fmt.Println("3. 根据 时间 过滤日志行")
		fmt.Println("4. 退出程序")
		fmt.Print("请输入您的选择: ")
		// 读取用户输入
		var choice int
		fmt.Scanln(&choice)
		// 根据选择执行操作
		switch choice {
		case 1:
			stats.PrintTopN(10)
		case 2:
			fmt.Print("您输入的 keyword 是: ")
			var keyword string
			fmt.Scanln(&keyword)
			stats.FilterLines(keyword)
		case 3:
			reader := bufio.NewReader(os.Stdin)
			fmt.Print("Enter start time (format: 29/Jan/2025:12:58:00 +0800): ")
			startTime, _ := reader.ReadString('\n')
			startTime = strings.TrimSpace(startTime) // 去除换行符
			fmt.Print("Enter end time (format: 29/Jan/2025:12:59:00 +0800): ")
			var endTime string
			endTime, _ = reader.ReadString('\n')
			endTime = strings.TrimSpace(endTime) // 去除换行符
			stats.FilterByTime(startTime, endTime)
		case 4:
			fmt.Println("退出...")
			return
		default:
			fmt.Println("无效的选择, 请重新输入")
		}
	}
}

测试

1
2

使用方法
./二进制文件   日志文件

Top显示

关键字时间过滤

总结

log-analyzer 是一个轻量级、实用的日志分析工具，它以简洁的代码实现了核心的日志分析功能，能够有效提升开发者和测试人员的日常工作效率。后续根据公司需求添加更多的功能

Kubernetes Pod扩容预热陷阱：如何避免5xx错误和CPU飙升？

Sun, 16 Feb 2025 19:50:18 +0000

问题背景

在Kubernetes（k8s）中，Pod的自动扩容（Horizontal Pod Autoscaler, HPA）是一个常见的功能，用于根据负载动态调整Pod的数量。然而，当新Pod加入时，如果没有预热机制，流量会立即涌入新Pod，导致新Pod在启动初期无法处理大量请求，进而引发5xx错误、CPU飙升等问题。特别是在基于JVM的应用程序中，JVM需要一定的时间进行预热（如JIT编译、类加载等），才能达到最佳性能。

阿里云介绍：在未启用慢启动预热功能时，每当新目标Pod加入时，请求方都会向该Pod发送一定比例的流量，不支持新Pod的渐进式流量增加。这对于需要一些预热时间来提供全部负载的服务可能是不可取的，并且可能会导致请求超时、数据丢失和用户体验恶化。例如在基于JVM的Web应用程序中，这些应用程序使用水平Pod自动缩放。当服务刚启动时，它会被大量请求淹没，这会导致应用程序预热时持续超时。因此，每次扩展服务时，都会丢失数据或者会导致这部分请求的响应时间增加。预热的基本思想就是让刚启动的机器逐步接入流量。地址：https://help.aliyun.com/zh/asm/user-guide/use-the-warm-up-feature

问题分析

是什么：
- Pod扩容时的流量分配问题：当新Pod加入时，Kubernetes默认会将流量均匀分配到所有Pod（包括新Pod），导致新Pod在启动初期无法处理大量请求。
- 预热陷阱：新Pod在启动初期需要时间进行预热（如JVM的JIT编译、缓存预热等），如果此时涌入大量请求，会导致请求超时、5xx错误、CPU飙升等问题。
为什么：
- 流量分配机制：Kubernetes默认的流量分配机制是均匀分配，不支持渐进式流量增加。
- 预热需求：某些应用程序（如基于JVM的应用）在启动初期需要时间进行预热，才能达到最佳性能。
怎么做：
- 解决方案：通过引入预热机制，让新Pod在启动初期逐步接入流量，避免一次性涌入大量请求

解决方案

方案一：使用Istio的LoadBalancerSettings进行流量预热

慢启动模式又称渐进式流量增加，用户可以为服务配置一个时间段，每当一个服务实例启动时，请求方会向该实例发送一部分请求负载，并在配置的时间段内逐步增加请求量。当慢启动窗口持续时间到达，就会退出慢启动模式。

在慢启动模式下，添加新的目标服务Pod时，避免新增Pod被大量请求击垮，这些新目标服务可以根据指定的加速期在接受其均衡策略的请求之前进行预热。

慢启动对于依赖缓存并且需要预热期才能以最佳性能响应请求的应用程序非常有用。只需在服务对应的DestinationRule下的配置trafficPolicy/loadBalancer即可，需要注意的是：

loadBalancer：表示负载均衡器信息。类型限定于ROUND_ROBIN和LEAST_REQUEST负载均衡器。

warmupDurationSecs：表示Service的预热持续时间。如果设置，则新创建的服务端点在此窗口期间从其创建时间开始保持预热模式，并且Istio逐渐增加该端点的流量，而不是发送成比例的流量。

慢启动要求应用在当前可用区的副本数不为0。例如：

数据面集群只有一个可用区A，可用区A中当前有一个副本，启动第二个时，慢启动会生效。

数据面集群有两个可用区A、B，当前应用只有一个副本，且位于可用区A，如果启动的第二个副本位于可用区B（一些调度器会默认采用跨可用区分布的策略），则不会触发慢启动。此时，如果再启动第三个副本，慢启动会生效。

Istio 提供了LoadBalancerSettings配置，可以通过warmupDurationSecs参数实现流量预热。该参数允许新Pod在启动后的一段时间内逐步增加流量。地址：https://istio.io/latest/docs/reference/config/networking/destination-rule/#LoadBalancerSettings 步骤：

在Istio的DestinationRule中配置LoadBalancerSettings。
设置warmupDurationSecs参数，定义预热时间。

代码示例：

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: mocka
spec:
  host: mocka
  trafficPolicy:
    loadBalancer:
      simple: ROUND_ROBIN
      warmupDurationSecs: 300  # 预热时间为300秒（5分钟）

优点：

简单易用，直接通过Istio配置实现流量预热。
无需修改应用程序代码。

缺点：

需要部署Istio，增加了系统复杂性。

方案二：使用阿里云的JVM预热方案（jwarmup）

参考文档：https://baijiahao.baidu.com/s?id=1752631259548476891&wfr=spider&for=pc

阿里云提供了jwarmup工具，可以将JVM的JIT编译信息保存到文件中，下次发布时自动加载，从而加速JVM预热过程。

JwarmUp的基本原理：根据前一次程序运行的情况，记录热点代码以及类加载顺序等信息。在应用下一次启动的时候积极主动地对相关类进行加载，并积极编译相关代码，进而使得应用尽快使用上C2编译优化的指令。从而在流量进来之前，提前完成类的加载、初始化和方法编译, 跳过解释阶段, 直接执行编译好的native code, 避免一面解释执行一面后台编译带来的CPU与load飙高, rt超时等问题。

上方为JWarmup的流程图，它将应用程序的发布分成了两个阶段，分别是Recording和Replaying。在Recording阶段，JVM会接受线上的请求，同时记录JVM即时编译器它所编译方法的信息，并且将这些信息都输出到一个文件之中。等到第二次再去启动的时候，JVM就可以去读取刚刚所记录的这些方法编译的信息，同时会主动的触发即时编译器编译刚刚记录的热点方法，使得在用户请求到来之前，就把热点方法编译成为性能较高的Native Code，避免了在用户请求大量进入的时候做编译，这样就能够进一步提高应用程序的性能，节约CPU使用率。

步骤：

在应用程序中集成jwarmup工具。
在发布前运行jwarmup，生成JIT编译信息文件。
在下次发布时，自动加载JIT编译信息文件。

代码示例：

记录编译信息阶段

`1`	`-XX:+CompilationWarmUpRecording -XX:CompilationWarmUpLogfile=jwarmup.log -XX:CompilationWarmUpRecordTime=300`

记录模式、记录存储的jwarmup.log，在5分钟后生成profiling data

使用编译信息阶段

`1`	`-XX:+CompilationWarmUp -XX:CompilationWarmUpLogfile=jwarmup.log -XX:CompilationWarmUpDeoptTime=0`

JWarmUp会在指定时间退优化warmup编译的方法，设置CompilationWarmUpDeoptTime为0可以取消这个定时。

1、recording记录下来的日志，是怎么分发到其他线上机的？

答：在应用启动的脚本文件进行控制：

预热节点，会将记录下来的编译信息上传到远程服务器oss上，
发布节点，在启动时从远处机器主动pull下来预热节点上传的编译信息。

2、是怎么制定一台机器做recording的呢？是访问某个url还是判断beta机器？

答：是通过访问oss做了一个类似于“文件锁”的东西，先拿到锁的beta机器做为预热节点，其余机器为发布节点。想要达到预热的效果请确保：

发布的机器的参数中有 -XX:+CompilationWarmUp
每次beta发布后，记得检查下编译信息文件是否已经上传
beta发布的那台机器必须是有流量的，Recording时间不要太短，尽量多编译一些方法。

如果不保证上述两点的话，便无法完成预热发布，即没有充分利用beta的编译信息，仍然走正常发布的流程

方案三：手动预热接口

在Pod启动后，手动调用所有接口进行预热，然后再接入流量。

步骤：

在Pod启动后，编写脚本调用所有接口。
确保所有接口都被调用后，再接入流量。

代码示例：

# 预热脚本示例
curl http://my-service/api/endpoint1
curl http://my-service/api/endpoint2
curl http://my-service/api/endpoint3

优点：

简单直接，适用于所有类型的应用程序。
无需额外工具或配置。

缺点：

需要手动编写和维护预热脚本。
无法动态调整预热时间。

方案四：使用Kubernetes的Readiness Probe

通过配置Kubernetes的Readiness Probe，确保Pod在完全预热后再接入流量。

步骤：

在Pod的Readiness Probe中配置预热检查。
确保Pod在预热完成后再标记为Ready。

代码示例：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: my-image
    readinessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 60  # 延迟60秒开始检查
      periodSeconds: 10        # 每10秒检查一次

优点：

简单易用，直接通过Kubernetes配置实现。
无需修改应用程序代码。

缺点：

无法精确控制预热时间。
需要应用程序提供健康检查接口。

Zabbix监控山特UPS电源：实现高效监控与告警

Mon, 20 Jan 2025 16:28:12 +0000

背景

近期，随着机房迁移的进行，为了提升电力保障并确保设备的持续运行，我们在原有基础上新增了多台山特UPS电源作为备用电源。这些UPS电源的主要作用是在电力中断时为机房设备提供足够的电力支持，确保设备有充足的时间进行正常关机，避免由于突然断电带来的数据丢失或硬件损坏。然而，UPS电源本身并未进行有效的监控，这使得我们无法实时掌握UPS的工作状态、电池电量等关键信息，从而错失可能出现故障的早期预警。因此，为了提高机房电力管理的智能化水平，确保UPS电源的稳定性与可靠性，我们决定对这些UPS电源进行全面的监控。

目的

通过构建一个完整的UPS监控方案，不仅能及时发现UPS的故障或异常状态，还能够在电池电量不足等紧急情况下，提前做出预警，避免对机房设备造成不必要的影响。

监控目标

监控UPS状态：实时获取UPS的运行状态，如是否正常、是否有故障等。
监控UPS电池容量：确保电池容量健康，避免突然断电。
监控UPS输入电压：确保UPS接收到的电压符合标准。
提高运维效率：通过自动化监控，减少人工检查和干预。

操作步骤

1. 配置山特UPS客户端

为了使Zabbix能够监控山特UPS电源，我们需要从UPS系统中获取相关数据。假设山特UPS的IP为192.168.81.11，并且它支持通过HTTP接口输出状态数据（比如通过REST API获取JSON格式的数据）。接下来，我们将编写一个Shell脚本，通过调用UPS的API接口，提取数据并交给Zabbix监控。

关于监控软件的安装：

下载软件：https://www.santak.com.cn/page/santak-downloads.html 软件名：Winpower_setup_LinuxAMD64.tar.gz

连接COM线并转为USB插入到负责监控的服务器，当前启动监控软件的服务器为192.168.81.11 安装：

tar zxf Winpower_setup_LinuxAMD64.tar.gz
cd Winpower_setup_LinuxAMD64/LinuxAMD64/
./setup_console.bin # 一路回车即可
# 启动agent
cd /opt/MonitorSoftware/
./agent start

配置：

1
2

# 需要安装图形化界面
startx

1
2
3

# 启动管理软件
cd /opt/MonitorSoftware/
./monitor

配置USB接口：系统->成为系统管理员(默认没有密码，直接确认即可)->通讯口设定->输入/dev/ttyUSB1增加→输入/dev/ttyUSB2增加→确定

扫描设备：系统→自动搜索设备，完成后即可在页面显示对应的UPS状态信息配置https端口：远程监控->Web服务器控制->停止->远程监控->Web服务器控制→修改端口为10086->开始->确定

打开网页

2. 测试数据

访问

1
2

0 代表ups的位置，假如有三台，则是：0 1 2
地址：https://192.168.96.200:8888/0/json

{
"key": "COM3/C6K",
"version": "",
-"device": {
"key": "COM3/C6K",
"id": 0,
"protocol": 18,
"portIndex": 1,
"ip": null,
"status": "",
"upsIndex": 0,
"statusIcon": "online",
"hasWarn": false
},
"status": "正常",
"model": "C6K",
"loadPercentMax": 16,
"loadSegment2State": "",
"loadSegment1State": "",
"redundantNumber": "",
"inVolt": "231.6V",
"bypassFreq": "",
"workMode": 3,
"loadPercent": "16%",
"lsCounter": -1,
"extStatus": 0,
"oidType": 0,
"outFreq": "50.0Hz",
"warning": "",
"noModule": false,
"batCapacity": "100%",
"batTimeRemain": "",
"bypassVolt": "",
"inFreq": "50.0Hz",
"iStatus": 0,
"outVolt": "219.5V",
"abmState": "",
"emdAlarm1": "",
"cfgBatNumber": "",
"cfgKVA": "",
"emdAlarm2": "",
"batTemp": "",
"emdHumidity": "",
"emdTemp": "",
"lastEvent1": "",
"statusColor": 0,
"supportTest": true,
"upsTemp": "27.2C",
"lastEvent2": "2025/01/15 17:34:54 Agent启动",
"batV": "201.9V",
"outVA": "0.9KVA",
"ls1": -1,
"outW": "0.6KW",
"ls2": -1,
"outA": ""
}

3. 安装Zabbix Agent并配置

在监控服务器上，我们首先需要安装Zabbix Agent，Zabbix Agent是用来采集数据并将其传递给Zabbix Server的工具。假设监控服务器IP为192.168.82.12，我们将在此服务器上进行安装并配置Zabbix Agent。

安装Zabbix Agent

如果您使用的是基于Debian/Ubuntu的操作系统，可以使用以下命令来安装Zabbix Agent：

1
2

sudo apt update
sudo apt install zabbix-agent

对于RedHat/CentOS系统：

`1`	`sudo yum install zabbix-agent`

安装完成后，启动Zabbix Agent：

1
2

sudo systemctl start zabbix-agent
sudo systemctl enable zabbix-agent

编写UPS监控脚本

在Zabbix Agent所在的服务器上，创建一个新的监控脚本。我们将在/etc/zabbix/zabbix_agentd.d/script/ups-monitor/ups.sh路径下创建脚本：

#!/bin/bash

 
num=$2
if [ "$num" = "0" ];then
  data=$(curl --connect-timeout 3 -k -s https://192.168.81.11:10086/1/json -w "|%{http_code}")
elif [ "$num" = "1" ];then
  data=$(curl --connect-timeout 3 -k -s https://192.168.81.11:10086/0/json -w "|%{http_code}")
elif [ "$num" = "2" ];then
  data=$(curl --connect-timeout 3 -k -s https://192.168.81.10:10086/0/json -w "|%{http_code}")
fi
 
 
case $1 in
  status)
    echo "$data"|awk -F'|' '{print $1}'|jq '.["status"]'|sed 's/"//g'
    ;;
  batCapacity)
    echo "$data"|awk -F'|' '{print $1}'|jq '.["batCapacity"]'|sed 's/"//g;s/%//g'
    ;;
  inVolt)
    echo "$data"|awk -F'|' '{print $1}'|jq '.["inVolt"]'|sed 's/"//g;s/V//g'
    ;;
  apiStatus)
    echo "$data"|awk -F'|' '{print $2}'
    ;;
  *)
esac

此脚本根据不同的参数(status, batCapacity, inVolt)来获取UPS设备的不同数据项。它通过curl命令访问UPS的API接口，并使用jq解析JSON格式的数据。

配置Zabbix Agent

在Zabbix Agent的配置文件中（通常位于/etc/zabbix/zabbix_agentd.conf），我们需要添加自定义监控项，使Zabbix能够调用上面创建的脚本来获取UPS相关的数据。

在zabbix_agentd.conf文件中，添加以下行：

自定义监控项：192.168.82.12:/etc/zabbix/zabbix_agentd.d/userparameter_ups.conf

UserParameter=ups.status[*],/usr/bin/bash /etc/zabbix/zabbix_agentd.d/script/ups-monitor/ups.sh status $1
UserParameter=ups.batCapacity[*],/usr/bin/bash /etc/zabbix/zabbix_agentd.d/script/ups-monitor/ups.sh batCapacity $1
UserParameter=ups.inVolt[*],/usr/bin/bash /etc/zabbix/zabbix_agentd.d/script/ups-monitor/ups.sh inVolt $1
UserParameter=ups.apiStatus[*],/usr/bin/bash /etc/zabbix/zabbix_agentd.d/script/ups-monitor/ups.sh apiStatus $1

保存配置文件并重新启动Zabbix Agent：

`1`	`sudo systemctl restart zabbix-agent`

3. 配置Zabbix Server

接下来，我们需要在Zabbix Server中配置相应的监控项，以便能够收集和显示UPS的相关数据。

3.1 创建监控项

在Zabbix前端，进入“Configuration” -> “Hosts”，选择您的监控主机，然后点击“Items”选项卡，创建以下监控项：

监控UPS状态：类型选择“Zabbix agent (active)”，键值输入ups.status。
监控电池容量：类型选择“Zabbix agent (active)”，键值输入ups.batCapacity。
监控输入电压：类型选择“Zabbix agent (active)”，键值输入ups.inVolt。

设置合适的数据收集周期，并保存监控项。 模板文件 Template UPS.xml

<?xml version="1.0" encoding="UTF-8"?>
<zabbix_export>
    <version>4.0</version>
    <date>2022-03-31T10:04:22Z</date>
    <groups>
        <group>
            <name>FJF Dev VM UPS</name>
        </group>
    </groups>
    <templates>
        <template>
            <template>Template UPS</template>
            <name>Template UPS</name>
            <description/>
            <groups>
                <group>
                    <name>FJF Dev VM UPS</name>
                </group>
            </groups>
            <applications>
                <application>
                    <name>UPS</name>
                </application>
            </applications>
            <items>
                <item>
                    <name>UPS[0]接口状态</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.apiStatus[0]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>3</value_type>
                    <allowed_hosts/>
                    <units/>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[1]接口状态</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.apiStatus[1]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>3</value_type>
                    <allowed_hosts/>
                    <units/>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[2]接口状态</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.apiStatus[2]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>3</value_type>
                    <allowed_hosts/>
                    <units/>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[0]电池剩余电量</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.batCapacity[0]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>3</value_type>
                    <allowed_hosts/>
                    <units>%</units>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[1]电池剩余电量</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.batCapacity[1]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>3</value_type>
                    <allowed_hosts/>
                    <units>%</units>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[2]电池剩余电量</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.batCapacity[2]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>3</value_type>
                    <allowed_hosts/>
                    <units>%</units>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[0]电源输入电压</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.inVolt[0]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>0</value_type>
                    <allowed_hosts/>
                    <units>V</units>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[1]电源输入电压</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.inVolt[1]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>0</value_type>
                    <allowed_hosts/>
                    <units>V</units>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[2]电源输入电压</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.inVolt[2]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>365d</trends>
                    <status>0</status>
                    <value_type>0</value_type>
                    <allowed_hosts/>
                    <units>V</units>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[0]电源状态</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.status[0]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>0</trends>
                    <status>0</status>
                    <value_type>4</value_type>
                    <allowed_hosts/>
                    <units/>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[1]电源状态</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.status[1]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>0</trends>
                    <status>0</status>
                    <value_type>4</value_type>
                    <allowed_hosts/>
                    <units/>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
                <item>
                    <name>UPS[2]电源状态</name>
                    <type>0</type>
                    <snmp_community/>
                    <snmp_oid/>
                    <key>ups.status[2]</key>
                    <delay>30s</delay>
                    <history>90d</history>
                    <trends>0</trends>
                    <status>0</status>
                    <value_type>4</value_type>
                    <allowed_hosts/>
                    <units/>
                    <snmpv3_contextname/>
                    <snmpv3_securityname/>
                    <snmpv3_securitylevel>0</snmpv3_securitylevel>
                    <snmpv3_authprotocol>0</snmpv3_authprotocol>
                    <snmpv3_authpassphrase/>
                    <snmpv3_privprotocol>0</snmpv3_privprotocol>
                    <snmpv3_privpassphrase/>
                    <params/>
                    <ipmi_sensor/>
                    <authtype>0</authtype>
                    <username/>
                    <password/>
                    <publickey/>
                    <privatekey/>
                    <port/>
                    <description/>
                    <inventory_link>0</inventory_link>
                    <applications>
                        <application>
                            <name>UPS</name>
                        </application>
                    </applications>
                    <valuemap/>
                    <logtimefmt/>
                    <preprocessing/>
                    <jmx_endpoint/>
                    <timeout>3s</timeout>
                    <url/>
                    <query_fields/>
                    <posts/>
                    <status_codes>200</status_codes>
                    <follow_redirects>1</follow_redirects>
                    <post_type>0</post_type>
                    <http_proxy/>
                    <headers/>
                    <retrieve_mode>0</retrieve_mode>
                    <request_method>0</request_method>
                    <output_format>0</output_format>
                    <allow_traps>0</allow_traps>
                    <ssl_cert_file/>
                    <ssl_key_file/>
                    <ssl_key_password/>
                    <verify_peer>0</verify_peer>
                    <verify_host>0</verify_host>
                    <master_item/>
                </item>
            </items>
            <discovery_rules/>
            <httptests/>
            <macros/>
            <templates/>
            <screens/>
        </template>
    </templates>
    <triggers>
        <trigger>
            <expression>{Template UPS:ups.apiStatus[0].last()}&lt;&gt;200</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.apiStatus[0].last()}=200</recovery_expression>
            <name>UPS-API[0]接口异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.apiStatus[1].last()}&lt;&gt;200</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.apiStatus[1].last()}=200</recovery_expression>
            <name>UPS-API[1]接口异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.apiStatus[2].last()}&lt;&gt;200</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.apiStatus[2].last()}=200</recovery_expression>
            <name>UPS-API[2]接口异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.status[0].str(零火线接反)}=0 and {Template UPS:ups.status[0].str(正常)}=0</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.status[0].str(零火线接反)}=1 or {Template UPS:ups.status[0].str(正常)}=1</recovery_expression>
            <name>UPS[0]状态异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.batCapacity[0].last()}&lt;90</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.batCapacity[0].last()}&gt;90</recovery_expression>
            <name>UPS[0]电池剩余电量小于90%</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.inVolt[0].avg(#3)}&lt;200</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.inVolt[0].avg(#3)}&gt;200</recovery_expression>
            <name>UPS[0]输入电压异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.status[1].str(正常)}=0</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.status[1].str(正常)}=1</recovery_expression>
            <name>UPS[1]状态异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.batCapacity[1].last()}&lt;90</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.batCapacity[1].last()}&gt;90</recovery_expression>
            <name>UPS[1]电池剩余电量小于90%</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.inVolt[1].avg(#3)}&lt;200</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.inVolt[1].avg(#3)}&gt;200</recovery_expression>
            <name>UPS[1]输入电压异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.status[2].str(正常)}=0</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.status[2].str(正常)}=1</recovery_expression>
            <name>UPS[2]状态异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.batCapacity[2].last()}&lt;90</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.batCapacity[2].last()}&gt;90</recovery_expression>
            <name>UPS[2]电池剩余电量小于90%</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
        <trigger>
            <expression>{Template UPS:ups.inVolt[2].avg(#3)}&lt;200</expression>
            <recovery_mode>1</recovery_mode>
            <recovery_expression>{Template UPS:ups.inVolt[2].avg(#3)}&gt;200</recovery_expression>
            <name>UPS[2]输入电压异常</name>
            <correlation_mode>0</correlation_mode>
            <correlation_tag/>
            <url/>
            <status>0</status>
            <priority>4</priority>
            <description/>
            <type>0</type>
            <manual_close>0</manual_close>
            <dependencies/>
            <tags/>
        </trigger>
    </triggers>
</zabbix_export>

监控项：

3.2 配置触发器

为了及时发现UPS故障，您可以设置触发器。例如，如果UPS的状态变为“故障”或电池容量低于某个阈值时，触发告警。根据您的需求，可以设置以下触发器：

UPS状态故障触发器：当ups.status的值为“Fault”时，触发告警。
电池容量低触发器：当ups.batCapacity小于某个阈值（例如20%）时，触发告警。

触发器：

4. 验证与测试

完成上述配置后，Zabbix Server将开始定期从Zabbix Agent中获取UPS的状态数据。您可以通过Zabbix前端查看UPS的状态、剩余电池容量和输入电压等信息，并根据设置的触发器在出现异常时收到告警。

Flask 与 SocketIO 正确初始化及最佳实践调试

Mon, 30 Dec 2024 18:02:10 +0000

1、问题

我使用Flask和Flask-SocketIO 来做 Websocket 链接。前期正常使用，但是后期布置修改什么导致Websocket连接失败。排查需求，才发现初始化不正常导致。

SocketIO 和 Flask 应用的初始化顺序和引用循环的问题

2、环境

1
2
3

python-engineio==4.11.1
python-socketio==5.12.0
Flask-SocketIO==5.3.6

3、正常初始化【单文件】

from flask import Flask, render_template
from flask_socketio import SocketIO

app = Flask(__name__)
socketio = SocketIO(app)  # 初始化 SocketIO

# 默认路由，用于渲染 HTML 页面
@app.route('/')
def index():
    return render_template('index.html')

# 出现消息后,率先执行此处
@socketio.on("message", namespace="/ws")
def socket(message):
    print(f"接收到消息: {message}")
    for i in range(1, 10):
        socketio.sleep(1)
        print(f"发送消息: {i}")
        socketio.emit("response",           # 绑定通信
                      {"data": i},           # 返回socket数据
                      namespace="/ws")


# 当websocket连接成功时,自动触发connect默认方法
@socketio.on("connect", namespace="/ws")
def connect():
    print("链接建立成功..")


# 当websocket连接失败时,自动触发disconnect默认方法
@socketio.on("disconnect", namespace="/ws")
def disconnect():
    print("链接建立失败..")

if __name__ == '__main__':
    socketio.run(app, debug=True, host='0.0.0.0', port=5000,allow_unsafe_werkzeug=True)

4、多文件初始化【两个文件】

主要是 manage.py 和 init.py 两个文件。 app/init.py

from flask import Flask
from flask_socketio import SocketIO
from flasgger import Swagger
from flask_cors import CORS
from flask_migrate import Migrate
from app.config import config
from app.extension import db

# 创建一个全局的 socketio 对象，但不立即初始化
socketio = SocketIO()

# 其他 swagger 配置保持不变...

def create_app(DevelopmentConfig=None):
    if DevelopmentConfig is None:
        DevelopmentConfig = 'development'

    app = Flask(__name__)
    app.config['SECRET_KEY'] = '123456'
    
    # 加载配置项
    app.config.from_object(config.get(DevelopmentConfig))
    
    from app.api import config_blueprint
    # 注册蓝图
    config_blueprint(app)
    
    # 数据库配置初始化
    config_extensions(app)
    
    # 数据库迁移相关代码...
    from app.api.models.EsModels import sysEsLogs,sysCretitLogs
    from app.api.models.NetModels import sysNetLogs
    from app.api.models.UpsModels import sysUpsLogs
    migrate = Migrate(app, db)
    
    # Swagger初始化
    Swagger(app, config=swagger_config, template=swagger_template)
    
    # CORS配置
    CORS(app, resources={r'/*': {'origins': '*'}}, supports_credentials=True)
    
    # 初始化 SocketIO
    socketio.init_app(app, cors_allowed_origins="*")
    
    return app

socket_events.py

from app import socketio

# Socket.IO 事件处理
@socketio.on("message", namespace="/ws")
def socket(message):
    print(f"接收到消息: {message}")
    for i in range(1, 10):
        socketio.sleep(1)
        print(f"发送消息: {i}")
        socketio.emit("response",
                     {"data": i},
                     namespace="/ws")

@socketio.on("connect", namespace="/ws")
def connect():
    print("链接建立成功..")

@socketio.on("disconnect", namespace="/ws")
def disconnect():
    print("链接建立失败..")

manage.py

# -*- coding: utf-8 -*-
# @Time    : 2024/5/2 12:01
# @Author  : 南宫乘风
# @Email   : 1794748404@qq.com
# @File    : manage.py
# @Software: PyCharm
import atexit
import os
import sys

from apscheduler.schedulers.background import BackgroundScheduler

from app import create_app, socketio
from app.common.util.LogHandler import log
from app.crontab.NetCronTab import NetworkMonitor
from app.crontab.UpsCronTab import UPSMonitor
from app.socket_events import *
# 默认为开发环境，按需求修改 production  development
config_name = 'development'

app = create_app(config_name)
# 解决中文乱码
# app.json.ensure_ascii = False

# from skywalking import agent, config
# config.init(agent_collector_backend_services='192.168.82.105:11800', agent_name='python-flask@devTenant',agent_instance_name="python-flask")
# agent.start()

# 数据库迁移
def start_scheduler():
    # 创建一个后台调度器
    scheduler = BackgroundScheduler(timezone="Asia/Shanghai")
    from app.crontab.EsCronTab import EsIndexCron
    scheduler.add_job(func=EsIndexCron, trigger='interval', minutes=1)
    log.info("EsIndexCron 定时任务启动成功")


    # scheduler.add_job(func=send_alert, trigger="interval", seconds=20)
    # 启动调度器
    scheduler.start()
    atexit.register(lambda: scheduler.shutdown())


if __name__ == '__main__':
    # 获取当前文件的绝对路径
    current_file = os.path.abspath(__file__)
    base_dir = os.path.dirname(current_file)
    # 将项目目录添加到 sys.path
    if base_dir not in sys.path:
        sys.path.append(base_dir)
    if not app.debug or app.testing:
        start_scheduler()
        log.info("定时任务启动成功")
    socketio.run(app, debug=True, use_reloader=True, host='0.0.0.0', port=5001)
    # use_reloader=False, threaded=True,

在postman输入地址和监听事件

CSDN数据大屏可视化【开源】

Thu, 19 Dec 2024 21:38:38 +0000

项目简介

本次基于版本3 开源

版本3开源地址：https://github.com/nangongchengfeng/CsdnBlogBoard.git

版本1开源地址：https://github.com/nangongchengfeng/CSDash.git

这是一个基于 Python 的 CSDN 博客数据可视化看板项目，通过爬虫采集 CSDN 博客数据，并以现代化的可视化界面展示博主的各项数据指标。该项目采用前后端分离架构，集成了数据采集、数据存储、API 服务和数据可视化等多个功能模块。 版本一 版本二 版本三

技术栈

后端技术

Python Flask: 作为 Web 框架，提供 RESTful API 服务
SQLAlchemy: ORM 框架，用于数据库操作
BeautifulSoup4: 网页解析，用于爬虫数据提取
Requests: HTTP 请求库，用于数据爬取

前端技术

ECharts: 强大的数据可视化图表库
Axios: HTTP 客户端，用于前后端数据交互
现代 CSS: Flexbox 布局、CSS 变量、响应式设计

核心功能模块

1. 数据采集模块

数据采集模块通过spider.py实现，是项目的核心组件之一。该模块采用了多种技术和策略来确保数据采集的准确性、稳定性和实时性。

1.1 核心技术栈

Requests: 处理 HTTP 请求，支持自定义请求头和超时设置
BeautifulSoup4: 使用 lxml 解析器进行高效的 HTML 解析
正则表达式(re): 用于精确提取数字和特定格式的数据
SQLAlchemy: 实现数据持久化和 ORM 映射
随机延时策略: 使用 random.uniform() 避免频繁请求

1.2 数据采集功能

1.2.1 博主基础信息采集

采集内容：
- 用户名和头像
- 文章数量统计
- 粉丝数和访问量
- 点赞和评论数
- 等级和积分信息
- 博主排名数据

技术实现：

1
2
3

# 示例：用户信息提取
user_info = soup.find('div', class_='user-info d-flex flex-column profile-intro-name-box')
author_name = user_info.find('a').get_text(strip=True)

1.2.2 文章分类信息采集

采集内容：
- 专栏名称和链接
- 专栏文章数量
- 订阅人数统计
- 阅读量和收藏数
- 专栏唯一标识

技术实现：

# 示例：分类信息提取
spans = soup.find_all('a', attrs={'class': 'special-column-name'})
for span in spans:
    href = span.get('href')
    blog_column = span.text.strip()

1.3 错误处理机制

多级异常处理
- 请求异常捕获
- 数据解析异常处理
- 数据库操作异常处理

重试机制

max_retries = 3
retry_count = 0
while retry_count < max_retries:
    try:
        # 请求逻辑
    except Exception:
        retry_count += 1
        time.sleep(5)  # 失败后等待

1.4 数据更新策略

增量更新机制
- 检查数据是否存在
- 根据情况执行更新或插入
- 保持数据时效性

数据一致性保证

with app.app_context():
    existing_info = Info.query.filter_by(author_name=author_name).first()
    if existing_info:
        # 更新现有记录
    else:
        # 插入新记录

1.5 性能优化策略

请求优化
- 自定义请求头
- 连接超时设置
- 随机延时控制
解析优化
- 使用 lxml 解析器提升性能
- 精确的选择器定位
- 数据预处理和清洗
存储优化
- 批量数据处理
- 事务管理
- 会话复用

1.6 反爬虫策略应对

请求头模拟

headers = {
    'User-Agent': 'Mozilla/5.0 (MSIE 10.0; Windows NT 6.1; Trident/5.0)',
    'referer': 'https://passport.csdn.net/login'
}

访问频率控制
- 随机延时间隔
- 请求限速
- IP 代理支持（预留）

2. 数据存储模块

数据存储模块采用 SQLAlchemy ORM 框架进行数据建模，实现了高效的数据持久化和查询操作。该模块设计了三个核心数据模型，每个模型都针对特定的数据场景进行了优化。

2.1 数据模型设计

2.1.1 博主信息模型 (Info)

class Info(db.Model):
    __tablename__ = 'info'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    date = db.Column(db.Text)                # 数据更新时间
    head_img = db.Column(db.Text)           # 博主头像URL
    author_name = db.Column(db.Text)        # 博主用户名
    article_num = db.Column(db.Text)        # 文章总数
    fans_num = db.Column(db.Text)           # 粉丝数量
    like_num = db.Column(db.Text)           # 获赞数量
    comment_num = db.Column(db.Text)        # 评论数量
    level = db.Column(db.Text)              # 博主等级
    visit_num = db.Column(db.Text)          # 访问量
    score = db.Column(db.Text)              # 积分
    rank = db.Column(db.Text)               # 排名

特点说明：

使用自增主键确保记录唯一性
采用 Text 类型存储可变长度文本
包含完整的博主数据画像
支持时间序列分析（通过 date 字段）

2.1.2 文章分类模型 (Categorize)

class Categorize(db.Model):
    __tablename__ = 'categorize'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    href = db.Column(db.Text)               # 分类链接
    categorize = db.Column(db.Text)         # 分类名称
    categorize_id = db.Column(db.BigInteger) # 分类ID
    column_num = db.Column(db.BigInteger)    # 专栏数量
    num_span = db.Column(db.BigInteger)      # 订阅数量
    article_num = db.Column(db.BigInteger)   # 文章数量
    read_num = db.Column(db.BigInteger)      # 阅读量
    collect_num = db.Column(db.BigInteger)   # 收藏数

特点说明：

使用 BigInteger 类型存储大数值数据
支持分类数据的统计分析
包含完整的分类元数据
可追踪分类的受欢迎程度

2.1.3 文章详情模型 (Article)

class Article(db.Model):
    __tablename__ = 'article'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    url = db.Column(db.Text)                # 文章链接
    title = db.Column(db.Text)              # 文章标题
    date = db.Column(db.Text)               # 发布日期
    read_num = db.Column(db.BigInteger)     # 阅读数
    comment_num = db.Column(db.BigInteger)  # 评论数
    type = db.Column(db.Text)               # 文章类型

特点说明：

记录文章的基本信息和统计数据
支持文章时间序列分析
可追踪章的受欢迎程度
便于文章分类统计

2.2 数据库优化策略

字段类型优化
- 使用 BigInteger 存储大数值，避免数值溢出
- 采用 Text 类型存储变长文本，节省存储空间
- 主键使用自增 Integer，提高插入性能
查询性能优化
- 可以根据需要添加索引
- 支持复杂的聚合查询
- 优化的数据结构设计
数据一致性保证
- 主键约束确保记录唯一性
- 适当的字段类型确保数据完整性
- 支持事务操作

2.3 数据操作示例

数据插入

new_info = Info(
    author_name="博主名称",
    article_num="100",
    fans_num="1000"
)
db.session.add(new_info)
db.session.commit()

数据查询

# 获取博主信息
author_info = Info.query.filter_by(author_name="博主名称").first()

# 获取分类统计
categories = Categorize.query.order_by(Categorize.read_num.desc()).all()

# 获取热门文章
hot_articles = Article.query.order_by(Article.read_num.desc()).limit(10).all()

数据更新

1
2
3

info = Info.query.filter_by(author_name="博主名称").first()
info.fans_num = str(int(info.fans_num) + 1)
db.session.commit()

3. 可视化展示模块

前端采用现代化的可视化方案，基于 ECharts 实现了丰富的数据可视化功能，并通过 Axios 实现了与后端的数据交互。

3.1 技术架构

核心技术
- ECharts 5.5.1：数据可视化库
- Axios：HTTP 客户端
- CSS3：现代布局和动画
- Flexbox：响应式布局

设计规范

:root {
  --bg-primary: #f7f8fa;
  --bg-secondary: #ffffff;
  --text-primary: #333333;
  --text-secondary: #555555;
  --accent-color: #0066cc;
  --border-radius: 12px;
  --shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
}

3.2 图表组件实现

3.2.1 柱状图（季度数据分析）

数据流程

async function updateBarChart() {
  // 1. 获取数据
  const response = await axios.get("/api/quarter");

  // 2. 数据转换
  const dimensions = [
    ...Object.keys(chartData[0]).filter((key) => key !== "category"),
  ];
  const source = chartData.map((item) => ({
    product: item.category,
    ...item,
  }));

  // 3. 图表配置
  const option = {
    legend: {},
    tooltip: {},
    dataset: {
      dimensions: dimensions,
      source: source,
    },
    xAxis: { type: "category" },
    yAxis: {},
    series: dimensions.slice(1).map((dim) => ({
      type: "bar",
      name: dim,
    })),
  };
}

交互特性
- 动态数据加载
- 点击事件响应
- 自适应布局

3.2.2 饼图（分类占比分析）

实现细节

async function updatePieChart() {
  // 1. 数据获取
  const response = await axios.get("/api/categorize");

  // 2. 图表配置
  const option = {
    tooltip: {
      trigger: "item",
      formatter: "{a} <br/>{b}: {c} ({d}%)",
    },
    series: [
      {
        name: "分类统计",
        type: "pie",
        radius: ["30%", "70%"],
        data: chartData,
        label: {
          show: true,
          position: "outside",
          formatter: "{b}: {d}%",
        },
      },
    ],
  };
}

视觉优化
- 内外半径设计
- 标签自动布局
- 悬停动画效果

3.2.3 混合图表（阅读量分析）

async function updateMixChart() {
  const option = {
    color: ["#3E82F7", "#F86C6B"],
    tooltip: {
      trigger: "axis",
      axisPointer: {
        type: "shadow",
      },
    },
    legend: {
      data: ["文章数", "阅读量"],
    },
    grid: {
      top: "10%",
      bottom: "25%",
      right: "10%",
    },
  };
}

3.3 响应式布局实现

布局结构

<div class="dashboard-container">
  <div class="top-section">
    <div class="mac-header">...</div>
    <div class="stats-grid">...</div>
  </div>
  <!-- 图表容器 -->
</div>

样式优化

.dashboard-container {
  display: flex;
  flex-direction: column;
  height: 100vh;
  padding: 15px;
  gap: 15px;
}

3.4 数据更新机制

初始化流程

function initCharts() {
  updateBarChart();
  updatePieChart();
  updateMixChart();
  updateHeatmap();
  updateArticleList();
}

数据刷新策略
- 页面加载时初始化
- 用户交互触发更新
- 定时自动刷新

3.5 交互设计

图表联动
- 点击饼图更新文章列表
- 柱状图分类筛选
- 数据钻取功能

视觉反馈

.stat-card:hover,
.chart-card:hover {
  transform: translateY(-5px);
  box-shadow: 0 6px 12px rgba(0, 0, 0, 0.08);
}

3.6 性能优化

加载优化
- 异步数据加载
- 图表按需渲染
- 防抖和节流处理
渲染优化
- 合理的图表配置
- 数据预处理
- 动画性能调优

4. 后端实现逻辑流程

4.1 核心技术栈

Flask: Web 框架
Blueprint: 路由模块化
Cache: 文件系统缓存
SQLAlchemy: ORM 数据库操作
PyMySQL: MySQL 数据库驱动

4.2 系统架构

4.3 核心功能实现

4.3.1 应用初始化

app = Flask(__name__)
# 配置缓存
cache.init_app(app, config={
    'CACHE_TYPE': 'filesystem',
    'CACHE_DIR': 'cache-directory'
})
# 数据库配置
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://user:pass@host:port/db'
db.init_app(app)

4.3.2 路由注册机制

DEFAULT_BLUEPRINT = [
    (cs, '/'),  # CSDN API蓝图
]
url_path_prefix = "/api"

def config_blueprint(app):
    for blueprint, url_prefix in DEFAULT_BLUEPRINT:
        url_prefix = url_path_prefix + url_prefix
        app.register_blueprint(blueprint, url_prefix=url_prefix)

4.4 API 接口设计

4.4.1 数据统计接口

季度数据统计

@cs.route('/quarter')
@cache.cached(timeout=60)
def GetQuarter():
    """获取每年每季度博客数量"""
    year_quarter_count = defaultdict(lambda: defaultdict(int))
    data = GetArticle()
    for article in data:
        year = article["year"]
        quarter = article["quarter"]
        year_quarter_count[year][quarter] += 1
    return Result.success(result)

分类数据统计

@cs.route('/categorize')
@cache.cached(timeout=60)
def Pie():
    """获取文章分类统计"""
    categorize_data = Categorize.query.all()
    pie_data = [
        {"value": item.article_num, "name": item.categorize}
        for item in categorize_data
    ]
    return Result.success(pie_data)

4.4.2 数据处理流程

4.5 性能优化策略

缓存优化
- 使用文件系统缓存
- 60 秒缓存过期时间
- 针对高频访问接口启用缓存
数据处理优化
- 使用 defaultdict 优化数据聚合
- 批量数据查询
- 查询据预处理和转换
查询优化
- ORM 延迟加载
- 查询结果缓存
- 合理的数据索引

4.6 数据流转流程

4.7 错误处理机制

全局异常处理

try:
    # 业务逻辑
except Exception as e:
    print(f"Error: {str(e)}")
    return Result.error(str(e))

数据验证

1
2

if not data or not data.labels:
    return Result.error("Invalid data format")

结果封装

class Result:
    @staticmethod
    def success(data):
        return jsonify({"code": 200, "data": data})

    @staticmethod
    def error(msg):
        return jsonify({"code": 500, "msg": msg})

技术总结

1. 技术栈全景图

集中管理与实时审计：构建Linux集群（1300台服务器）日志平台的最佳实践

Thu, 19 Dec 2024 15:27:19 +0000

简介

随着企业IT基础设施的不断扩大，Linux服务器的数量也日益增多，传统的单机日志管理方式已无法满足对日志数据集中管理、审计和分析的需求。尤其是在大型集群环境中，如何高效地收集、存储和分析日志成为了一项重要的技术挑战。

背景

在实现对大型Linux集群的日志集中管理与审计，特别是针对rsyslog日志的收集、操作命令日志以及登录日志的审计。通过部署集中的rsyslog服务端，能够统一收集1300多台Linux服务器的系统日志，确保日志数据的集中化管理。使用Filebeat作为日志收集工具，将日志数据推送至Logstash进行清洗和转换，最终存储到Elasticsearch中，并通过Kibana实现实时数据可视化展示。这种方式不仅简化了日志管理流程，还提高了系统的监控效率和安全性。

需求

统一管理 1300 台服务器的Linux系统日志，能够及时发现问题和告警。

解决方案

集中管理：通过统一的服务端收集所有Linux服务器的日志数据，减少单独配置每台服务器的工作量。
日志审计：对操作命令日志、登录日志等进行审计，确保系统行为的可追溯性。
数据清洗与分析：通过日志清洗与格式转换，确保日志数据的标准化，便于后续的分析和可视化展示。
实时展示：利用Kibana将清洗后的数据实时可视化，帮助运维人员快速发现潜在问题。

整体架构

为实现这些目标，我们设计了以下的系统架构：

rsyslog：作为日志收集的核心组件，它负责将来自Linux系统的各种日志（包括/var/log/messages等）统一推送到中心化的日志服务端。
Filebeat：作为轻量级的日志收集器，部署在各个Linux节点上，负责将日志文件传输到Logstash。
Logstash：对收集到的日志进行清洗、解析和转换，确保数据符合预定格式，便于存入Elasticsearch。
Elasticsearch：存储经过清洗和转换的日志数据，提供强大的全文搜索和数据查询功能。
Kibana：通过Kibana仪表盘实时展示存储在Elasticsearch中的日志数据，帮助运维人员进行数据分析和可视化展示。

rsyslog汇总

rsyslog服务端

首先配置rsyslog服务器，可以统一收集集群内部的日志。

# 加载本地系统日志模块（例如通过 logger 命令发送的日志）
$ModLoad imuxsock
# 加载内核日志模块（之前由 rklogd 处理）
$ModLoad imklog
# 加载 UDP 模块，支持通过 UDP 协议接收日志
$ModLoad imudp
# 配置 UDP 服务器在 514 端口接收日志
$UDPServerRun 514
# 加载 TCP 模块，支持通过 TCP 协议接收日志
$ModLoad imtcp
# 配置 TCP 服务器在 514 端口接收日志
$InputTCPServerRun 514
# 定义一个自定义的日志格式模板 'myFormat'
$template myFormat,"%timestamp:::date-rfc3339% %fromhost-ip% %HOSTNAME% [%programname%] %syslogseverity-text%:%msg%\n"
# 设置默认的文件格式为传统的 rsyslog 格式
$ActionFileDefaultTemplate RSYSLOG_TraditionalFileFormat
# 加载 /etc/rsyslog.d/ 目录下的所有配置文件
$IncludeConfig /etc/rsyslog.d/*.conf
# 配置收集 info 级别的日志，排除 mail、authpriv、cron 类别的日志，输出到 /var/log/messages 文件，并使用 myFormat 格式
*.info;mail.none;authpriv.none;cron.none /var/log/messages;myFormat
# 收集所有 authpriv 类别的日志（通常是认证相关的日志），输出到 /var/log/secure 文件，并使用 myFormat 格式
authpriv.* /var/log/secure;myFormat
# 收集所有 mail 类别的日志，输出到 /var/log/maillog 文件，使用异步写入（- 表示异步）
mail.* -/var/log/maillog
# 收集所有 cron 类别的日志（定时任务日志），输出到 /var/log/cron 文件
cron.* /var/log/cron
# 收集所有紧急级别（emerg）的日志，将其通过系统消息发送
*.emerg :omusrmsg:*
# 收集 uucp 和 news 类别的严重级别（crit）日志，输出到 /var/log/spooler 文件
uucp,news.crit /var/log/spooler
# 收集所有 local7 类别的日志，输出到 /var/log/boot.log 文件
local7.* /var/log/boot.log

重启服务端

`1`	`systemctl restart rsyslog`

修改前：

修改后：

rsyslog客户端

所有集群的客户端配置最后一行IP，就可以把数据汇总在一切

1
2
3

[root@zabbix ~]# cat /etc/rsyslog.conf  |tail -n 2
#authpriv.*      @10.10.10.17
*.* @@192.168.102.20   # rsyslog 服务端的IP

重启

`1`	`systemctl restart rsyslog.service`

日志已经打印到rsyslog 服务端的 /var/log/messages /var/log/secure 等文件

filebeaet收集

在rsyslog 服务端的安装filebeaet，并且使用如下配置启动

filebeat.config.modules:
  path: ${path.config}/modules.d/*.yml
  reload.enabled: false
filebeat.inputs:
- type: log
  enabled: true
  tail_files: true
  paths:
    - /var/log/messages
output.logstash:
  hosts: ["192.168.1.100:5514"]  
  # 把日志发送到logstatsh中

logstatsh配置

[root@game logstash]# cat config/rsyslog.conf
input {
   beats {
    port => 5514
    type => syslog
  }
}

filter {
    grok {
        match => { 
		"message" => "%{TIMESTAMP_ISO8601:time} %{IP:client_ip} %{HOSTNAME:host_name} \[%{DATA:type}\] %{GREEDYDATA:info}"
		}
		overwrite => ["message"]
		
    }
	mutate {  
	split => ["type",","]     
	}
	mutate{
                add_field =>   {
                 "types" => "%{[type][1]}"
} }
    mutate{remove_field => [ "tags","agent","host","log","ecs","type" ]}
	

	date {
        match => ["time", "yyyy-MM-dd HH:mm:ss,SSS", "UNIX"]
        target => "@timestamp"
        locale => "cn"
    }
}

output {
  stdout {
    codec=> rubydebug
  }
  elasticsearch {
    hosts => ["127.0.0.1:9200"]
    index => "message"
  }
}

数据格式

2024-12-03T18:35:30+08:00 192.168.102.30 master01 [kubelet] info: E1203 18:35:30.827608    1065 summary_sys_containers.go:83] "Failed to get system container stats" err="failed to get cgroup stats for \"/system.slice/docker.service\": failed to get container info for \"/system.slice/docker.service\": unknown container \"/system.slice/docker.service\"" containerName="/system.slice/docker.service"

GROK解析

`1`	`%{TIMESTAMP_ISO8601:time} %{IP:client_ip} %{HOSTNAME:host_name} \[%{DATA:type}\] %{GREEDYDATA:info}`

输出格式

{
  "client_ip": "192.168.102.30",
  "time": "2024-12-03T18:35:30+08:00",
  "type": "kubelet",
  "host_name": "master01",
  "info": "info: E1203 18:35:30.827608    1065 summary_sys_containers.go:83] \"Failed to get system container stats\" err=\"failed to get cgroup stats for \\\"/system.slice/docker.service\\\": failed to get container info for \\\"/system.slice/docker.service\\\": unknown container \\\"/system.slice/docker.service\\\"\" containerName=\"/system.slice/docker.service\"\r"
}

操作系统命令审计

Linux一般都是终端执行命令，我们可以让命令写到message日志上，在通过过滤，获取操作命令记录。

Linux终端配置

[root@zabbix ~]# cat /etc/profile | tail -n 2
unset MAILCHECK
export PROMPT_COMMAND='{ msg=$(history 1 | { read x y; echo $y; });logger -p local2.info "euid=$(whoami)" $(who am i) `pwd` "$msg"; }'


日志格式
Oct 11 17:32:41 zabbix root: euid=root root pts/0 2021-10-11 15:13 (10.10.10.3) /root cat /etc/profile
Oct 11 17:32:47 zabbix root: euid=root root pts/0 2021-10-11 15:13 (10.10.10.3) /root cat /etc/profile | tail -n 2

rsyslog服务端展示

filebeat配置

[root@logserver01 filebeat]# cat system_messages.yml 
#=========================== Filebeat inputs =============================
filebeat.inputs:
- type: log
  enabled: true
  tail_files: true
  paths:
    - /var/log/messages

logstatsh配置

[root@logserver01 config]# cat system_userlog_FromKafkaInES.conf
input{
    beats {
        host => '172.17.9.200'
        port => 5046
    }

#	kafka{
#		bootstrap_servers => ["172.17.8.232:6667"]
#		topics => ["sys_os_exe"]
#		codec => "json"
#		group_id => "ELK_SYSTEM_EXE_GROUP"
#		consumer_threads => 3
#		client_id => "logstash"
#		decorate_events => false
#		auto_offset_reset => "earliest"
#		request_timeout_ms => "300000"
#		session_timeout_ms => "20000"
#		max_poll_interval_ms => "600000"
#	}
}
filter{
	if ([message] =~ "euid"){
		grok{
			match => {"message" => '^(?<exetime>\d+-\d+-\d+)(?:[^\d]+)(?<hhmmss>\d+:\d+:\d+)(?:[^\d]+\d+:\d+)(?:\s)(?<deshost>[^ ]+)(?:\s)(?<name>[^ ]+)(?:\s\[)(?<loginuser>[^ |\]]*)(?:\]\s[^ ]+\seuid=)(?<exeuser>[^ ]+)(?:\s+)(?<userinfo>[^\(]+)(?:\s\()(?<srchost>[^\)]+)(?:\)\s)(?<exepath>[^ ]+)(\s+)(?<exeinfo>.*)'}
		}
		if "_grokparsefailure" in [tags] { drop { } }
		mutate{
			add_field => ["tmp_exeinfo","%{exeinfo}"]
		}
		mutate{
			split => ["exetime","-"]
			split => ["tmp_exeinfo"," "]
                }
		mutate{
			add_field => ["indextime","%{[exetime][0]}%{[exetime][1]}"]
			add_field => ["evtTime","%{[exetime][0]}-%{[exetime][1]}-%{[exetime][2]} %{hhmmss}"]
			add_field => ["cmd","%{[tmp_exeinfo][0]}"]

		}
		#Retention log insertion time to ES..............
		ruby { code => "event.set('inserttime', event.get('@timestamp').time.to_i)" }
		#replace InsertTime with evtTime "yyyy-MM-dd HH:mm:ss eg:2020-06-29 09:24:29"
		date{
                        match => ["evtTime","yyyy-MM-dd HH:mm:ss"]
              		#kibana use this time....................
			target => "@timestamp"
                }
		mutate{replace => ["evtTime","%{evtTime} +0800"]}
		date{
			match => ["evtTime","yyyy-MM-dd HH:mm:ss +0800"]
                       	timezone =>"UTC"
			#log event time timestamp................
                       	target => "logtimestamp"
                }
		#log event time long string......................
		ruby { code => "event.set('longtime', event.get('logtimestamp').time.to_i)" }

		mutate{remove_field => [ "tmp_exeinfo","evtTime","host","ecs","log","hhmmss","input","agent","exetime" ]}
	}
	else{
                drop{}
        }
}
output{
	stdout{codec => rubydebug}
	if [indextime] !~ "index"{
		elasticsearch{
			hosts => ["http://172.17.9.176:9200"]
			#hosts => "172.17.9.176"
			index => "sys_os_userlog_%{[indextime]}"
                        user => "*********"
                        password => "*********"
		}
	}
}

数据格式

`1`	`2024-12-03T18:39:05+08:00 192.168.102.30 master01 [root] info: euid=root root pts/0 2024-12-03 18:21 (192.168.96.19) /root [2024-12-03 18:39:05]ip a`

GROK解析

^(?<exetime>\d+-\d+-\d+)(?:[^\d]+)(?<hhmmss>\d+:\d+:\d+)(?:[^\d]+\d+:\d+)(?:\s)(?<deshost>[^ ]+)(?:\s)(?<name>[^ ]+)(?:\s\[)(?<loginuser>[^ |\]]*)(?:\]\s[^ ]+\seuid=)(?<exeuser>[^ ]+)(?:\s+)(?<userinfo>[^\(]+)(?:\s\()(?<srchost>[^\)]+)(?:\)\s)(?<exepath>[^ ]+)(\s+)(?<exeinfo>.*)

输出格式

{
  "loginuser": "root",
  "hhmmss": "18:39:05",
  "exepath": "/root",
  "deshost": "192.168.102.30",
  "srchost": "192.168.96.19",
  "name": "master01",
  "exeinfo": "[2024-12-03 18:39:05]ip a\r",
  "exeuser": "root",
  "userinfo": "root pts/0 2024-12-03 18:21",
  "exetime": "2024-12-03"
}

系统用户登录审计

filebeat配置

[root@logserver01 filebeat]# cat system_secure.yml
#=========================== Filebeat inputs =============================
filebeat.inputs:
- type: log
  enabled: true
  tail_files: true
  paths:
    - /var/log/secure
#=========================== Filebeat outppp_id: messuts =============================
output.logstash:
  hosts: ["172.17.9.200:5045"]

logstatsh配置

[root@logserver01 config]# cat system_login_FromKafkaInES.conf
input{
    beats {
        host => '172.17.9.200'
        port => 5045
    }

#
#	kafka{
#		bootstrap_servers => ["172.17.8.232:6667"]
#		topics => ["sys_os_login"]
#		codec => "json"
#		group_id => "ELK_SYSTEM_LOGIN_GROUP"
#		consumer_threads => 3
#		client_id => "logstash"
#		decorate_events => false
#		auto_offset_reset => "earliest"
#		request_timeout_ms => "300000"
#		session_timeout_ms => "20000"
#		max_poll_interval_ms => "600000"
#	}
}
filter{
	#login successed log
	if ([message] =~ "Accepted"){
		grok{
			match => {"message" => '^(?<atime>\d+-\d+-\d+)(?:[^\d]+)(?<hhmmss>\d+:\d+:\d+)(?:[^\d]+\d+:\d+)(?:\s+)(?<deshost>\d+\.\d+\.\d+\.\d+)(?:\s)(?<name>[^ ]+)(?:[\S\s]*Failed\spassword\sfor[\sinvalid\suser]*\s)(?<loginuser>[^ ]+)(?:\sfrom\s)(?<srchost>[\d.]+)(?:\s\w+\s\d+\s)(?<loginmode>\w*)'}
		}
		if "_grokparsefailure" in [tags] { drop { } }
		mutate{
			add_field => ["type","systemlogin"]
			split => ["atime","-"]
                }
		mutate{
			add_field => ["indextime","%{[atime][0]}%{[atime][1]}"]
			add_field => ["evtTime","%{[atime][0]}-%{[atime][1]}-%{[atime][2]} %{hhmmss}"]
		}
		#Retention log insertion time to ES..............
		ruby { code => "event.set('inserttime', event.get('@timestamp').time.to_i)" }

		#replace InsertTime with evtTime "yyyy-MM-dd HH:mm:ss eg:2020-06-29 09:24:29"
		date{
                        match => ["evtTime","yyyy-MM-dd HH:mm:ss"]
              		#kibana use this time....................
			target => "@timestamp"
                }
		mutate{replace => ["evtTime","%{evtTime} +0800"]}
		date{
			match => ["evtTime","yyyy-MM-dd HH:mm:ss +0800"]
                       	timezone =>"UTC"
			#log event time timestamp................
                       	target => "logtimestamp"
                }
		#log event time long string......................
		ruby { code => "event.set('longtime', event.get('logtimestamp').time.to_i)" }
		mutate{remove_field => [ "evtTime","host","ecs","log","hhmmss","input","agent","atime" ]}
	}
	#login failed log
	else if ([message] =~ "Failed password for"){
		grok{
			match => {"message" => '^(?<atime>\d+-\d+-\d+)(?:[^\d]+)(?<hhmmss>\d+:\d+:\d+)(?:[^\d]+\d+:\d+)(?:\s+)(?<deshost>\d+\.\d+\.\d+\.\d+)(?:[\S\s]*Failed\spassword\sfor[\sinvalid\suser]*\s)(?<loginuser>[^ ]+)(?:\sfrom\s)(?<srchost>[\d.]+)(?:\s\w+\s\d+\s)(?<loginmode>\w*)'}
		}
		if "_grokparsefailure" in [tags] { drop { } }
                mutate{
                        add_field => ["type","systemloginfailed"]
                        split => ["atime","-"]
                }
                mutate{
                        add_field => ["indextime","%{[atime][0]}%{[atime][1]}"]
                        add_field => ["evtTime","%{[atime][0]}-%{[atime][1]}-%{[atime][2]} %{hhmmss}"]
                }
                #Retention log insertion time to ES..............
                ruby { code => "event.set('inserttime', event.get('@timestamp').time.to_i)" }

                #replace InsertTime with evtTime "yyyy-MM-dd HH:mm:ss eg:2020-06-29 09:24:29"
                date{
                        match => ["evtTime","yyyy-MM-dd HH:mm:ss"]
                        #kibana use this time....................
                        target => "@timestamp"
                }
                mutate{replace => ["evtTime","%{evtTime} +0800"]}
                date{
                        match => ["evtTime","yyyy-MM-dd HH:mm:ss +0800"]
                        timezone =>"UTC"
                        #log event time timestamp................
                        target => "logtimestamp"
                }
                #log event time long string......................
                ruby { code => "event.set('longtime', event.get('logtimestamp').time.to_i)" }

                mutate{remove_field => [ "evtTime","host","ecs","log","hhmmss","input","agent","atime" ]}
	}
	#other log
	else{
		drop{}
	}
}
output{
	if [type] == "systemlogin"{
		if [indextime] !~ "index"{
			stdout{codec => rubydebug}
			elasticsearch{
				hosts => "172.17.9.176"
				index => "sys_os_systemlogin_%{[indextime]}"
				user => "elastic"
				password => "f5OPbv6sqfstmc+"
                	}
		}
		
	}
	else if [type] == "systemloginfailed"{
                if [indextime] !~ "index"{
                        stdout{codec => rubydebug}
                        elasticsearch{
                               hosts => "172.17.9.176"
                               index => "sys_os_systemloginfailed_%{[indextime]}"
                               user => "elastic"
                               password => "xxxxxxx+"
                        }
                }

        }
}

成功日志解析

日志格式

`1`	`2024-12-03T18:45:09+08:00 192.168.102.42 node03 [sshd] info: Accepted password for root from 192.168.96.19 port 14347 ssh2`

GROK语法

`1`	`%{TIMESTAMP_ISO8601:atime} %{IP:deshost} %{HOSTNAME:name} \[%{WORD:type}\] %{DATA:loglevel}: Accepted password for %{WORD:loginuser} from %{IP:srchost} port %{NUMBER:port} %{WORD:loginmode}`

日志格式

{
  "loginuser": "root",
  "atime": "2024-12-03T18:45:09+08:00",
  "type": "sshd",
  "deshost": "192.168.102.42",
  "srchost": "192.168.96.19",
  "port": "14347",
  "loglevel": "info",
  "name": "node03",
  "loginmode": "ssh2"
}

失败日志格式

日志格式

`1`	`2024-12-03T19:01:57+08:00 192.168.102.42 node03 [sshd] info: Failed password for invalid user 123 from 192.168.96.19 port 12103 ssh2`

GROK语法

^(?<atime>\d+-\d+-\d+)(?:[^\d]+)(?<hhmmss>\d+:\d+:\d+)(?:[^\d]+\d+:\d+)(?:\s+)(?<deshost>\d+\.\d+\.\d+\.\d+)(?:[\S\s]*Failed\spassword\sfor[\sinvalid\suser]*\s)(?<loginuser>[^ ]+)(?:\sfrom\s)(?<srchost>[\d.]+)(?:\s\w+\s\d+\s)(?<loginmode>\w*)

日志输出

{
  "loginuser": "123",
  "atime": "2024-12-03",
  "hhmmss": "19:01:57",
  "deshost": "192.168.102.42",
  "srchost": "192.168.96.19",
  "loginmode": "ssh2"
}

构建全面的生产监控体系：从基础设施到业务服务

Wed, 18 Dec 2024 22:18:28 +0000

在现代 IT 系统中，监控体系是确保高可用性、高性能和稳定性的核心工具。一个完善的监控体系能够及时发现系统问题、分析问题根源并快速采取应对措施，避免故障进一步扩散。本文将从基础设施层、中间件层、容器与编排层、应用与服务层逐步展开，全面介绍如何构建生产环境的监控体系。

1. 基础设施层监控

基础设施是支撑整个 IT 系统运行的根基，对其进行有效的监控，可以及时发现并解决问题，确保整个系统的稳定性和可靠性。

关键监控指标：

CPU：
- 监控 CPU 使用率，及时发现过高使用情况。
- 分析可能的原因，如无效循环、死锁等。
- 工具建议：使用 Prometheus + Node Exporter。
内存：
- 监控内存使用情况，避免内存泄露导致服务崩溃。
- 设置阈值告警，提前预警。
网络：
- 监控网络流量和连接状态，确保网络通畅。
- 及时发现并处理网络拥堵或攻击事件。
- 工具建议：使用 cAdvisor、Ntop。
硬盘：
- 监控硬盘使用率和 I/O 性能，避免磁盘空间不足或 I/O 瓶颈。
- 工具建议：Prometheus Disk Exporter。

2. 中间件层监控

中间件是应用与底层基础设施之间的桥梁，其性能直接影响上层应用的响应速度和稳定性。

常见中间件的监控策略：

Nginx：
- 监控请求处理时间、并发连接数、5xx 错误率等指标。
- 工具建议：Nginx 模块 + Prometheus。
MySQL：
- 监控数据库响应时间、查询效率、连接数。
- 设置慢查询日志分析性能瓶颈。
- 工具建议：Percona Monitoring Plugins 或 Prometheus MySQL Exporter。
RabbitMQ：
- 监控消息队列长度、处理速度、消费者状态。
- 工具建议：RabbitMQ 管理插件。
Consul：
- 监控服务发现与配置的健康状态。
- 工具建议：Consul 内置监控 API + Prometheus。
Kafka + Zookeeper：
- 监控 Kafka 消息流量、延迟和消费者组状态。
- 监控 Zookeeper 的节点状态。
- 工具建议：Kafka Exporter + Zookeeper Exporter。

3. 容器与编排层监控

容器化和自动化编排是现代云原生应用的标配，对其进行监控可以确保服务的灵活性和可扩展性。

容器与编排层监控的重点：

Kubernetes 集群：
- 监控集群的资源使用情况、节点健康状态和服务部署状态。
- 工具建议：kube-state-metrics + Prometheus。
Kubernetes 事件监控：
- 监控事件日志，及时响应 Pod 的异常状态和调度失败。
Docker 容器监控：
- 监控容器的运行状态、资源使用情况，确保容器的稳定运行。
- 工具建议：cAdvisor、Prometheus Docker Exporter。

4. 应用与服务层监控

应用与服务层是与用户直接交互的层面，其性能和稳定性直接影响用户体验。

监控关键点：

服务应用进程：
- 监控应用进程的健康状态，包括内存泄露、死锁等问题。
业务链路追踪：
- 使用分布式链路追踪工具（如 Pinpoint、SkyWalking 或阿里云 ARMS）追踪服务调用链路。
- 分析服务间调用的延迟，优化性能。
业务日志监控：
- 使用 Elasticsearch、Logstash 和 Kibana (ELK Stack) 分析业务日志。
- 在资源有限（如磁盘空间 200G）时，可结合阿里云 SLS。
业务接口响应时间监控：
- 监控接口的响应时间，确保快速响应用户请求。
- 工具建议：SkyWalking 或 Prometheus。
调用失败次数监控：
- 监控服务调用失败次数，分析失败原因并快速修复。

5. 告警平台建设

告警策略：

多渠道通知：
- 集成钉钉、邮件、电话、短信、微信等多种通知方式。
工具选择：
- 开源自建：Alertmanager、PrometheusAlert。
- 商业方案：阿里云告警平台。
关键配置：
- 定义告警规则（如 CPU 使用率超 90%、接口响应时间超过 1 秒）。
- 配置分级告警策略，根据问题严重性选择通知方式。

6. 监控可视化建设

可视化的重要性：

监控可视化是监控体系中的重要组成部分，它可以将复杂的数据以图形化的方式直观展示，帮助运维和开发人员快速理解系统状态。

工具选择：

Grafana：
- 支持多种数据源（如 Prometheus）。
- 提供丰富的图表类型（折线图、柱状图、饼图等）。
Nightingale：
- 汇总各个平台的监控数据，集中展示。

总结

一个完善的生产监控体系需要涵盖基础设施、中间件、容器与编排、应用与服务等多个层面，并辅以告警和可视化工具来提升监控效果。通过合理的监控部署和持续优化，能够显著提升系统的可靠性、性能和运维效率，最终为业务保驾护航。

基于 Flask 和 RabbitMQ 构建高效消息队列系统：从数据生成到消费

Wed, 27 Nov 2024 14:27:58 +0000

简介

在构建 Web 应用时，处理和传输大量数据是不可避免的。对于需要高效、可扩展的消息处理和异步任务执行的场景，使用 RabbitMQ（一种流行的消息队列中间件）与 Flask（一个轻量级的 Python Web 框架）结合，能够大大提升应用的性能和可靠性。本文将带你通过一个基于 Flask 和 RabbitMQ 的实际应用案例，深入了解如何构建一个高效的消息队列系统，完成从生成假数据到消费数据的全过程。

背景

我们要开发一个移动可视化平台监控系统，并且这些信息需要被实时分析或存储。面对这样的需求，直接将所有逻辑放在单个应用中可能会导致性能瓶颈。因此，我们考虑采用微服务架构，通过分离数据生成与处理逻辑来提高系统的可扩展性和响应速度。

环境介绍

为了实现这个项目，我们需要以下环境：

Python：一个强大的编程语言，适合快速开发。
Flask：一个轻量级的Web应用框架。
Pika：Python的RabbitMQ客户端库。
Faker：一个生成伪数据的Python库，用于生成测试数据
RabbitMQ：消息队列服务，用来存储生产者产生的数据

技术选型

Flask：轻量级Web框架，非常适合快速开发小型到中等规模的应用。
RabbitMQ：一个广泛使用的开源消息代理软件（也称为消息中间件），用于实现应用程序之间的通信。

系统架构概览

生产者：负责生成模拟用户数据并将其发送至RabbitMQ。
消费者：从RabbitMQ接收数据后执行特定任务，如数据分析或存储。
Flask应用：提供REST API接口给外部调用，同时启动消费者线程监听RabbitMQ中的消息。

搭建RabbitMQ服务

我们使用docker来搭建服务，如果win可以直接跑程序，相关流程请自行查询

临时使用（停止会自动删除服务）

`1`	`docker run -it --rm --name rabbitmq -p 5672:5672 -p 15672:15672 docker.cloudimages.asia/rabbitmq:4.0-management`

长久使用

`1`	`docker run -it -d --name rabbitmq -p 5672:5672 -p 15672:15672 docker.cloudimages.asia/rabbitmq:4.0-management`

1
2

[root@prometheus-server ~]# docker ps | grep 9b3a9355fa4a
9b3a9355fa4a   docker.cloudimages.asia/rabbitmq:4.0-management   "docker-entrypoint.s…"   21 seconds ago   Up 19 seconds             4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp           rabbitmq

访问页面地址：http://192.168.82.105:15672/ 使用 RabbitMQ 的管理界面。访问账号和密码： guest | guest

队列页面

生产者：将数据发送到 RabbitMQ 队列

生产者的任务是生成一些假数据，并将这些数据发送到 RabbitMQ 队列中。我们使用 Faker 库生成数据，并通过 RabbitMQ 的 basic_publish 方法发送消息。

确保你的环境中安装了Python。然后，使用pip安装Flask、Pika和Faker：

`1`	`pip install flask pika faker`

生产者代码

生产者部分主要负责生成随机数据并通过RabbitMQ发送出去。这里我们使用Faker库来生成看起来真实的数据。

# -*- coding: utf-8 -*-
# @Time    : 2024/11/24 10:20
# @Author  : 南宫乘风
# @Email   : 1794748404@qq.com
# @File    : test.py
# @Software: PyCharm
from faker import Faker
import pika
import json
import time

# 初始化 Faker 实例
fake = Faker()

# 配置 RabbitMQ 连接
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.82.105',heartbeat=60))
channel = connection.channel()

# 声明一个队列
queue_name = 'ownit_queue'
channel.queue_declare(queue=queue_name)

# 生成并发送假数据
def generate_fake_data():
    return {
        "name": fake.name(),
        "address": fake.address(),
        "email": fake.email(),
        "phone": fake.phone_number(),
        "company": fake.company(),
        "date": fake.date_this_year().isoformat(),
        "text": fake.text(max_nb_chars=200),
    }

try:
    for _ in range(10000):  # 生成 1000 条假数据
        fake_data = generate_fake_data()
        channel.basic_publish(
            exchange='',
            routing_key=queue_name,
            body=json.dumps(fake_data)  # 将数据序列化为 JSON 格式
        )
        # time.sleep(0.1)
        print(f"Sent: {fake_data}")
finally:
    connection.close()

执行插入10000条数据

数据持久化

重启docker 服务。让mq重启

`1`	`docker restart 9b3a9355fa4a`

因为重启，队列没有持久化，导致数据丢失

为了确保消息不会丢失，可以配置 RabbitMQ 的队列为持久化队列，即使 RabbitMQ 宕机或重启，队列中的消息也能被恢复。

channel.queue_declare(queue='ownit_queue', durable=True)



 properties=pika.BasicProperties(delivery_mode=2)

咦，还是没有数据？为什么？因为使用Dokcer启动没有持久数据，重启会丢失数据，就算我们mq做持久化也不起作用。

`1`	`docker stop 9b3a9355fa4a && docker rm 9b3a9355fa4a`

持久化命令

docker run -it -d \
  --name rabbitmq \
  -p 5672:5672 \
  -p 15672:15672 \
  -v rabbitmq_data:/var/lib/rabbitmq/mnesia \
  docker.cloudimages.asia/rabbitmq:4.0-management

解释：

-it -d：以交互模式启动并在后台运行容器。
--name rabbitmq：给容器指定一个名字 rabbitmq。
-p 5672:5672：映射 RabbitMQ 的默认 AMQP 协议端口（5672）到宿主机。
-p 15672:15672：映射 RabbitMQ 的管理界面端口（15672）到宿主机。
-v rabbitmq_data:/var/lib/rabbitmq/mnesia：将宿主机的 Docker 卷 rabbitmq_data 持久化到容器内的 /var/lib/rabbitmq/mnesia 目录，这是 RabbitMQ 默认存储队列和消息数据的地方。使用宿主机目录

docker run -it -d \
  --name rabbitmq \
  -p 5672:5672 \
  -p 15672:15672 \
  -v /root/rabbitmq:/var/lib/rabbitmq \
  docker.cloudimages.asia/rabbitmq:4.0-management

1
2

[root@prometheus-server ~]# docker restart 9e200cf168c3
9e200cf168c3

关键点解析

Faker 库：用于生成虚拟数据。每次调用 generate_fake_data 函数时都会生成不同的姓名、地址、邮箱等信息。
RabbitMQ 连接：我们使用 pika 库与 RabbitMQ 进行连接，并声明了一个队列 ownit_queue，用于存储消息。
数据发布：使用 channel.basic_publish() 方法将消息发布到指定的队列中，消息体使用 json.dumps() 序列化为 JSON 格式。

持久化完整代码

# -*- coding: utf-8 -*-
# @Time    : 2024/11/24 10:20
# @Author  : 南宫乘风
# @Email   : 1794748404@qq.com
# @File    : test.py
# @Software: PyCharm
from faker import Faker
import pika
import json
import time

# 初始化 Faker 实例
fake = Faker()

# 配置 RabbitMQ 连接
connection = pika.BlockingConnection(pika.ConnectionParameters(host='192.168.82.105',heartbeat=60))
channel = connection.channel()

# 声明一个队列
queue_name = 'ownit_queue'
channel.queue_declare(queue=queue_name, durable=True)

# 生成并发送假数据
def generate_fake_data():
    return {
        "name": fake.name(),
        "address": fake.address(),
        "email": fake.email(),
        "phone": fake.phone_number(),
        "company": fake.company(),
        "date": fake.date_this_year().isoformat(),
        "text": fake.text(max_nb_chars=200),
    }

try:
    for _ in range(1000):  # 生成 1000 条假数据
        fake_data = generate_fake_data()
        channel.basic_publish(
            exchange='',
            routing_key=queue_name,
            body=json.dumps(fake_data),  # 将数据序列化为 JSON 格式
            properties=pika.BasicProperties(delivery_mode=2)
        )
        # time.sleep(0.1)
        print(f"Sent: {fake_data}")
finally:
    connection.close()

消费者：从 RabbitMQ 中获取数据

消费者部分由Flask应用托管，它不仅提供了API接口，还启动了一个后台线程持续监听RabbitMQ上的消息。消费者的任务是从队列中读取消息，并进行处理。在这个例子中，我们将模拟一个简单的消息消费过程，打印接收到的数据。

import json
import threading
import time

import pika
from flask import Flask, request

app = Flask(__name__)


@app.route('/', methods=['GET'])
def send_order():
    return 'Hello, World! MQ'



# 消费者函数
def consume():
    # 创建与 RabbitMQ 服务器的连接
    connection = pika.BlockingConnection(pika.ConnectionParameters('192.168.82.105'))
    # 从连接中创建一个通道
    channel = connection.channel()

    # 声明一个名为 order_queue 的队列，如果队列不存在则创建它
    channel.queue_declare(queue='ownit_queue',durable=True)

    # 定义一个回调函数，用于处理接收到的消息
    def callback(ch, method, properties, body):
        # 打印接收到的消息体
        print(f"数据接受: {body}")
        time.sleep(1)

    # 配置通道以消费来自 order_queue 的消息，指定回调函数处理消息，并设置自动确认消息
    channel.basic_consume(queue='ownit_queue', on_message_callback=callback, auto_ack=True)
    # 打印消息表示程序正在等待接收消息，并提示用户按 CTRL+C 退出
    print('Waiting for messages. To exit press CTRL+C')
    # 开始一个循环以持续接收消息
    channel.start_consuming()


# 启动消费者线程
def run_consumer():
    thread = threading.Thread(target=consume, daemon=True)  # 设置守护线程
    thread.start()
    print("Consumer thread started.")


if __name__ == '__main__':
    run_consumer()
    app.run(debug=True)

关键点解析

consume() 函数：通过 pika 连接 RabbitMQ，声明 ownit_queue 队列，并通过回调函数 callback 处理接收到的消息。
线程化消费：为了使 Flask 应用能够正常处理 Web 请求，同时也能处理消息队列中的消息，我们将消息消费部分放在一个单独的线程中运行。
auto_ack=True：自动确认消息，表示一旦消费者接收到消息后会自动从队列中删除该消息。

持续发送数据

每秒接收1条数据没消费的数据一直在MQ中

总结

结合 Flask 和 RabbitMQ 构建一个高效的消息队列系统，从假数据的生成到数据的消费处理，整个过程都得到了详细展示。在实现过程中，我们主要涵盖了以下内容：

RabbitMQ 的安装与配置：了解了如何通过 RabbitMQ 管理消息队列，以及如何与 Python 进行交互。
生产者的实现：使用 Faker 库生成假数据，并将其发布到 RabbitMQ 队列中。通过 pika 库与 RabbitMQ 进行连接，确保数据能够被成功发送到队列中。
消费者的实现：通过 Flask 启动一个独立的消费者线程，从 RabbitMQ 队列中获取数据并进行处理。我们还讨论了如何在 Flask 应用中嵌入多线程操作，保证 Web 应用的响应性和消息处理的高效性。
消息确认和持久化：我们讨论了消息的持久化和确认机制，这对于生产环境中的高可用性和数据安全性至关重要。

深入浅出 WebSocket：构建实时数据大屏的高级实践

Mon, 25 Nov 2024 11:39:51 +0000

简介

请参考下方，学习入门操作

基于 Flask 和 Socket.IO 的 WebSocket 实时数据更新实现

在当今数字化时代，实时性是衡量互联网应用的重要指标之一。无论是股票交易、在线游戏，还是实时监控大屏，WebSocket 已成为实现高效、双向实时通信的最佳选择之一。本文将通过一个基于 WebSocket 实现的实时数据大屏案例，深入探讨 WebSocket 的高级用法和优化技巧。

WebSocket 的典型应用场景

实时数据监控：如运营监控大屏、设备状态监控等。
在线协作：如 Google Docs 的多人编辑。
实时聊天：如即时通讯工具。
实时通知：如电商的价格变动提醒。

场景分析：实时数据监控大屏

本案例的目标是实现一个实时数据监控大屏，通过 WebSocket 技术，将实时更新的数据动态展示在用户界面中。

需求分析

实现不同房间的数据订阅（如销售数据和访问数据）。
支持多客户端实时接收服务器推送的最新数据。
动态更新界面，提供流畅的用户体验。

技术选型

前端：HTML、CSS、JavaScript 使用 Socket.IO 客户端库。
后端：基于 Flask 和 Flask-SocketIO 实现 WebSocket 服务。
实时数据生成：使用 Python 的 random 模块模拟实时数据。

后端实现

from flask import Flask, render_template, request
from flask_socketio import SocketIO, emit, join_room, leave_room
import random
import time
from threading import Thread

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)

# 存储客户端订阅的房间信息
client_rooms = {}
# 存储数据生成器线程
data_threads = {}

def generate_sales_data(room):
    """生成销售相关数据"""
    while room in data_threads and data_threads[room]['active']:
        data = {
            'sales': random.randint(1000, 5000),
            'orders': random.randint(50, 200),
            'timestamp': time.strftime('%H:%M:%S')
        }
        socketio.emit('update_data', data, room=room)
        time.sleep(2)

def generate_visitor_data(room):
    """生成访问量相关数据"""
    while room in data_threads and data_threads[room]['active']:
        data = {
            'visitors': random.randint(100, 1000),
            'active_users': random.randint(50, 300),
            'timestamp': time.strftime('%H:%M:%S')
        }
        socketio.emit('update_data', data, room=room)
        time.sleep(3)

@app.route('/')
def index():
    return render_template('index.html')

@socketio.on('join')
def on_join(data):
    """处理客户端加入房间请求"""
    room = data.get('room')
    if not room:
        return
    
    # 获取客户端ID
    client_id = request.sid
    
    # 将客户端加入房间
    join_room(room)
    client_rooms[client_id] = room
    
    print(f'Client {client_id} joined room: {room}')
    
    # 如果房间没有数据生成器线程，创建一个
    if room not in data_threads:
        data_threads[room] = {
            'active': True,
            'thread': Thread(
                target=generate_sales_data if room == 'sales' else generate_visitor_data,
                args=(room,),
                daemon=True
            )
        }
        data_threads[room]['thread'].start()

@socketio.on('leave')
def on_leave(data):
    """处理客户端离开房间请求"""
    room = data.get('room')
    if not room:
        return
    
    client_id = request.sid
    leave_room(room)
    
    if client_id in client_rooms:
        del client_rooms[client_id]
    
    print(f'Client {client_id} left room: {room}')

@socketio.on('connect')
def handle_connect():
    print(f'Client connected: {request.sid}')

@socketio.on('disconnect')
def handle_disconnect():
    client_id = request.sid
    if client_id in client_rooms:
        room = client_rooms[client_id]
        leave_room(room)
        del client_rooms[client_id]
        
        # 检查房间是否还有其他客户端
        if not client_rooms.values().__contains__(room):
            # 如果没有，停止数据生成器
            if room in data_threads:
                data_threads[room]['active'] = False
                data_threads[room]['thread'].join(timeout=1)
                del data_threads[room]
    
    print(f'Client disconnected: {client_id}')

if __name__ == '__main__':
    socketio.run(app, debug=True, host='0.0.0.0', port=5000)

数据生成与推送

后端的核心逻辑是数据生成与推送：

数据生成：通过 generate_sales_data 和 generate_visitor_data 函数生成随机数据，并定时推送到客户端。
房间管理：通过 join_room 和 leave_room 方法管理客户端的房间订阅。
线程管理：使用线程来生成数据，并在客户端离开房间时停止线程。

HTML 结构

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>实时数据大屏</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
    <style>
        body {
            margin: 0;
            padding: 20px;
            background-color: #1a1a1a;
            color: #fff;
            font-family: Arial, sans-serif;
        }
        .controls {
            text-align: center;
            margin-bottom: 30px;
        }
        .btn {
            background-color: #4CAF50;
            border: none;
            color: white;
            padding: 10px 20px;
            margin: 0 10px;
            border-radius: 5px;
            cursor: pointer;
            transition: background-color 0.3s;
        }
        .btn:hover {
            background-color: #45a049;
        }
        .btn.active {
            background-color: #2E7D32;
        }
        .dashboard {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 20px;
            max-width: 1200px;
            margin: 0 auto;
        }
        .card {
            background-color: #2a2a2a;
            border-radius: 10px;
            padding: 20px;
            text-align: center;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .card h2 {
            margin: 0 0 10px 0;
            color: #4CAF50;
        }
        .value {
            font-size: 2.5em;
            font-weight: bold;
            margin: 10px 0;
        }
        .timestamp {
            text-align: right;
            color: #888;
            margin-top: 20px;
        }
        @keyframes pulse {
            0% { transform: scale(1); }
            50% { transform: scale(1.05); }
            100% { transform: scale(1); }
        }
        .update {
            animation: pulse 0.5s ease-in-out;
        }
    </style>
</head>
<body>
    <h1 style="text-align: center; margin-bottom: 40px;">实时数据监控</h1>
    
    <div class="controls">
        <button class="btn" onclick="toggleRoom('sales')" id="salesBtn">销售数据</button>
        <button class="btn" onclick="toggleRoom('visitors')" id="visitorsBtn">访问数据</button>
    </div>

    <div class="dashboard">
        <!-- 销售数据卡片 -->
        <div class="card" id="salesCard" style="display: none;">
            <h2>销售额</h2>
            <div id="sales" class="value">0</div>
            <div>实时销售金额 (元)</div>
        </div>
        <div class="card" id="ordersCard" style="display: none;">
            <h2>订单数</h2>
            <div id="orders" class="value">0</div>
            <div>实时订单统计</div>
        </div>

        <!-- 访问数据卡片 -->
        <div class="card" id="visitorsCard" style="display: none;">
            <h2>访问量</h2>
            <div id="visitors" class="value">0</div>
            <div>当前访问人数</div>
        </div>
        <div class="card" id="activeUsersCard" style="display: none;">
            <h2>活跃用户</h2>
            <div id="active_users" class="value">0</div>
            <div>实时活跃用户数</div>
        </div>
    </div>

    <div class="timestamp" id="timestamp">最后更新时间: --:--:--</div>

    <script>
        const socket = io();
        let currentRooms = new Set();
        
        // 更新数据的函数
        function updateValue(elementId, value) {
            const element = document.getElementById(elementId);
            if (element) {
                element.textContent = value;
                element.classList.remove('update');
                void element.offsetWidth; // 触发重绘
                element.classList.add('update');
            }
        }

        // 切换房间
        function toggleRoom(room) {
            const btn = document.getElementById(room + 'Btn');
            if (currentRooms.has(room)) {
                // 离开房间
                socket.emit('leave', { room: room });
                currentRooms.delete(room);
                btn.classList.remove('active');
                // 隐藏相关卡片
                if (room === 'sales') {
                    document.getElementById('salesCard').style.display = 'none';
                    document.getElementById('ordersCard').style.display = 'none';
                } else {
                    document.getElementById('visitorsCard').style.display = 'none';
                    document.getElementById('activeUsersCard').style.display = 'none';
                }
            } else {
                // 加入房间
                socket.emit('join', { room: room });
                currentRooms.add(room);
                btn.classList.add('active');
                // 显示相关卡片
                if (room === 'sales') {
                    document.getElementById('salesCard').style.display = 'block';
                    document.getElementById('ordersCard').style.display = 'block';
                } else {
                    document.getElementById('visitorsCard').style.display = 'block';
                    document.getElementById('activeUsersCard').style.display = 'block';
                }
            }
        }

        // 监听数据更新事件
        socket.on('update_data', function(data) {
            // 更新所有收到的数据
            Object.keys(data).forEach(key => {
                if (key !== 'timestamp') {
                    updateValue(key, data[key]);
                }
            });
            document.getElementById('timestamp').textContent = '最后更新时间: ' + data.timestamp;
        });

        // 连接时自动加入销售数据房间
        socket.on('connect', function() {
            toggleRoom('sales');
        });
    </script>
</body>
</html>

JavaScript 逻辑

在前端代码中，我们使用了 Socket.IO 客户端库来与服务器进行 WebSocket 通信。主要逻辑如下：

连接服务器：通过 io() 方法连接到服务器。
切换房间：用户点击按钮时，通过 toggleRoom 函数切换不同的数据房间。
更新数据：监听 update_data 事件，更新页面上的数据。

WebSocket 的高级实践与优化

在实际应用中，可能需要管理多个房间，每个房间对应不同的数据类型或用户组。通过 join_room 和 leave_room 方法，可以轻松实现多房间管理。

数据压缩与优化

对于大规模数据传输，可以考虑使用数据压缩技术来减少带宽占用。例如，使用 gzip 或 brotli 压缩数据包，或者在前端进行数据解压缩。

断线重连与心跳机制

WebSocket 连接可能会因为网络问题而断开。为了保证连接的稳定性，可以实现断线重连机制和心跳包检测。通过定时发送心跳包，可以及时检测连接状态，并在断线时自动重连。

安全性与权限控制

在生产环境中，安全性是一个不可忽视的问题。可以通过以下方式增强 WebSocket 连接的安全性：

使用 HTTPS：确保 WebSocket 连接通过加密的 HTTPS 协议进行。
身份验证：在连接建立时进行身份验证，确保只有授权用户才能访问数据。
权限控制：根据用户角色控制其访问的房间和数据类型。

扩展与定制

WebSocket 的应用场景非常广泛，可以根据具体需求进行扩展和定制。例如，结合 WebRTC 实现实时音视频通信，或者结合 WebGL 实现实时3D数据可视化。

基于 Flask 和 Socket.IO 的 WebSocket 实时数据更新实现

Mon, 25 Nov 2024 11:05:13 +0000

简介

随着现代化应用的快速发展，实时数据交互已经成为许多 Web 应用的核心需求，比如实时消息推送、数据监控大屏等。本文将基于一个完整的 WebSocket 实现示例，带你一步步理解如何使用 Flask 和 Socket.IO 构建实时数据更新的 Web 应用。将实现一个实时数据监控大屏，数据会通过后台自动生成，并以 WebSocket 的方式实时推送到前端页面进行展示

背景

为什么选择 WebSocket？ 传统的 HTTP 协议是无状态的，服务端和客户端之间的交互通常是基于请求-响应模式。如果需要实时更新数据，比如展示销售额、访问量等统计信息，那么通常需要客户端定时向服务端发起轮询请求。但这种方式有明显的缺点：

效率低下：轮询会消耗大量的资源，因为大多数情况下数据并未改变，但轮询仍然会占用带宽和计算资源。延迟较高：无法达到毫秒级的实时性，特别是在高频场景中，数据更新的延迟可能导致用户体验下降。相比之下，WebSocket 是一种持久化的双向通信协议，可以在客户端和服务端之间建立全双工连接，能够更高效地实现实时数据的双向传输。这使得 WebSocket 成为实时应用的首选技术。

项目实现的核心功能

服务端：

使用 Flask 框架和 Flask-SocketIO 实现 WebSocket 协议。
后台自动生成模拟数据（如销售额、访问量、订单数等）。
将生成的数据通过 WebSocket 实时推送到客户端。

客户端：

通过 Socket.IO 客户端接收服务端推送的数据。
动态更新页面内容并展示实时变化。
提供美观的前端界面，模拟数据监控大屏的效果。

环境准备

在开始之前，请确保你的开发环境中安装了以下工具：

Python 3.x
Flask
Flask-SocketIO

你可以通过以下命令安装相关依赖库：

`1`	`pip install flask flask-socketio`

服务端实现

from flask import Flask, render_template
from flask_socketio import SocketIO, emit
import random
import time
from threading import Thread

# 创建 Flask 应用
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)

# 模拟数据生成函数
def generate_random_data():
    """后台线程：生成模拟数据并推送到客户端"""
    while True:
        # 生成随机数据
        data = {
            'sales': random.randint(1000, 5000),  # 销售额
            'visitors': random.randint(100, 1000),  # 访问量
            'orders': random.randint(50, 200),  # 订单数
            'timestamp': time.strftime('%H:%M:%S')  # 当前时间
        }
        # 推送数据到客户端
        socketio.emit('update_data', data)
        time.sleep(2)  # 每 2 秒生成一次数据

# 首页路由
@app.route('/')
def index():
    return render_template('index.html')

# WebSocket 事件：客户端连接
@socketio.on('connect')
def handle_connect():
    print('Client connected')
    emit('server_response', {'data': 'Connected to server!'})

# WebSocket 事件：客户端断开连接
@socketio.on('disconnect')
def handle_disconnect():
    print('Client disconnected')

# WebSocket 事件：接收客户端消息
@socketio.on('client_message')
def handle_message(message):
    print('Received message:', message)
    # 将客户端消息广播给所有连接的客户端
    emit('server_response', {'data': message['data']}, broadcast=True)

# 主函数：启动应用
if __name__ == '__main__':
    # 启动后台线程
    Thread(target=generate_random_data, daemon=True).start()
    # 启动 Flask-SocketIO 服务
    socketio.run(app, debug=True, host='0.0.0.0', port=5000)

服务端代码解析

Flask-SocketIO 的使用： Flask-SocketIO 是基于 Flask 的扩展库，支持 WebSocket 协议，可以轻松实现实时通信。
1

socketio = SocketIO(app)
后台数据生成线程：使用 Python 的 Thread 模块在后台不断生成随机数据并通过 socketio.emit 方法推送到客户端。
1

Thread(target=generate_random_data, daemon=True).start()
WebSocket 事件监听：
- @socketio.on('connect')：当客户端连接时触发。
- @socketio.on('disconnect')：当客户端断开连接时触发。
- @socketio.on('client_message')：监听客户端发送的消息，并将其广播给所有连接的客户端。

前端实现

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>实时数据大屏</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
    <style>
        body {
            margin: 0;
            padding: 20px;
            background-color: #1a1a1a;
            color: #fff;
            font-family: Arial, sans-serif;
        }
        .dashboard {
            display: grid;
            grid-template-columns: repeat(3, 1fr);
            gap: 20px;
            max-width: 1200px;
            margin: 0 auto;
        }
        .card {
            background-color: #2a2a2a;
            border-radius: 10px;
            padding: 20px;
            text-align: center;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .card h2 {
            margin: 0 0 10px 0;
            color: #4CAF50;
        }
        .value {
            font-size: 2.5em;
            font-weight: bold;
            margin: 10px 0;
        }
        .timestamp {
            text-align: right;
            color: #888;
            margin-top: 20px;
        }
        @keyframes pulse {
            0% { transform: scale(1); }
            50% { transform: scale(1.05); }
            100% { transform: scale(1); }
        }
        .update {
            animation: pulse 0.5s ease-in-out;
        }
    </style>
</head>
<body>
    <h1 style="text-align: center; margin-bottom: 40px;">实时数据监控</h1>
    <div class="dashboard">
        <div class="card">
            <h2>销售额</h2>
            <div id="sales" class="value">0</div>
            <div>实时销售金额 (元)</div>
        </div>
        <div class="card">
            <h2>访问量</h2>
            <div id="visitors" class="value">0</div>
            <div>当前访问人数</div>
        </div>
        <div class="card">
            <h2>订单数</h2>
            <div id="orders" class="value">0</div>
            <div>实时订单统计</div>
        </div>
    </div>
    <div class="timestamp" id="timestamp">最后更新时间: --:--:--</div>

    <script>
        const socket = io();

        // 更新数据的函数
        function updateValue(elementId, value) {
            const element = document.getElementById(elementId);
            element.textContent = value;
            element.classList.remove('update');
            void element.offsetWidth; // 触发重绘
            element.classList.add('update');
        }

        // 监听数据更新事件
        socket.on('update_data', function(data) {
            updateValue('sales', data.sales);
            updateValue('visitors', data.visitors);
            updateValue('orders', data.orders);
            document.getElementById('timestamp').textContent = '最后更新时间: ' + data.timestamp;
        });
    </script>
</body>
</html>

前端代码解析

引入 Socket.IO 客户端库：引入 Socket.IO 客户端库，用于与服务端建立 WebSocket 连接。
1

<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>

动态更新数据的实现：前端 JavaScript 代码通过监听 update_data 事件来获取服务端推送的数据，然后更新对应的 HTML 元素内容，并通过 CSS 动画增加视觉效果。

socket.on('update_data', function(data) {
    updateValue('sales', data.sales);
    updateValue('visitors', data.visitors);
    updateValue('orders', data.orders);
    document.getElementById('timestamp').textContent = '最后更新时间: ' + data.timestamp;
});

样式和布局：使用 CSS Grid 布局创建整洁的数据卡片界面，每个卡片显示一种数据类型。卡片使用动画效果突出数据更新。

机房私有云OpenStack搭建详细步骤流程

Fri, 25 Oct 2024 16:28:51 +0000

OpenStack介绍

OpenStack是一个开源的云计算管理平台，旨在为公共及私有云的建设与管理提供软件。它由几个主要的组件组合起来完成一些具体的工作，包括计算、存储和网络资源的管理。OpenStack支持所有类型的云环境，可以简单地实施并大规模扩展，提供了一个丰富、标准化、统一的云计算管理平台。

在私有云的部署中，OpenStack提供了强大的灵活性和可扩展性，允许企业根据自己的需求来定制和优化云环境。例如，通过OpenStack，企业可以规划并管理大量虚拟机，提供所需的对象及块存储资源，并实现网络资源的高扩展和自动化管理

组件	说明
Nova	Compute HyperV管理(libvirt,qumu…)
Neutron	网络和地址管理(原名Quantum)
Swift	对象存储(Object)
Cinder	块存储管理(Cinder):主机指虚拟机的存储管理
Keystone	身份认证授权(Identity)
Glance	镜象管理(Image)，支持本地存储、NFS、Swift、sheepdog和Ceph
Horizon	UI界面 (Dashboard)
Ceilometer	监控计量(Metering)
Heat	软件部署(编配Orchestration)
Lbass	负载均衡，后端可以是各种商业和开源产品，如：F5、Nginx、Haproxy、LVS
oslo	把所有组件需要用的相同的东西集中起来
Moniker	DNS:每个虚拟机，都会自动有一个dns记录
marconi	消息队列扩展(Queue Service)
Trove	Database Service
Ironic	裸机部署(Bare Metal)
Savannah	Data Processing

公司需求

因为公司业务拓展，需要有相关的设备建设对应的环境，我们采购多台服务器，使用raid5在组成存储。在这基础上使用OpenStack搭建私有云，来运行相关的业务和虚拟机。

机房检测环境通常需要一个稳定、安全、可控制的私有云环境。在这样的环境中，OpenStack能够提供以下优势：

自主可控：企业可以根据自己的需求定制和优化云环境，不受外部云服务提供商的限制。
安全性：私有云部署在企业内部，可以提供更高的安全和隐私级别，确保敏感数据不被第三方访问。
灵活性：OpenStack的开源特性使得企业可以灵活地选择硬件和软件，以及如何部署和管理这些资源。
成本效益：虽然初期建设成本可能较高，但随着业务量的增加，私有云的平均运营成本可能会低于公有云。

准备

OS：Centos 7 1804 Minimal CPU：4c MEM：8G xvda：50G 系统盘 xvdb：100G 数据盘 Master IP：192.168.81.40

目标： 1.安装openstack Ocata 2.参考文档 https://docs.openstack.org/ocata/install-guide-rdo/

初始化

#初始化配置
1.配置静态IP
2.关闭 selinux
sed -i "s/SELINUX=.*/SELINUX=disabled/g" /etc/selinux/config
3.关闭 NetworkManger
systemctl stop NetworkManger
systemctl disable NetworkManager
4.关闭 firewalld
systemctl stop firewalld
systemctl disable firewalld
5.配置主机名
hostnamectl set-hostname controller.openstack.fjf
6.重启
reboot

网络时间协议（NTP）

1.编辑 /etc/chrony.conf
server ntp1.aliyun.com iburst
server ntp2.aliyun.com iburst
server ntp3.aliyun.com iburst
server 0.centos.pool.ntp.org iburst
server 1.centos.pool.ntp.org iburst
server 2.centos.pool.ntp.org iburst
server 3.centos.pool.ntp.org iburst
driftfile /var/lib/chrony/drift
makestep 1.0 3
rtcsync
allow 192.168.0.0/16
logdir /var/log/chrony
2.重启服务
systemctl restart chronyd

安装OpenStack软件包


1.准备密码
ADMIN_PASS=Pass@w0rd
CINDER_DBPASS=Pass@w0rd
CINDER_PASS=Pass@w0rd
DASH_DBPASS=Pass@w0rd
DEMO_PASS=Pass@w0rd
GLANCE_DBPASS=Pass@w0rd
GLANCE_PASS=Pass@w0rd
KEYSTONE_DBPASS=Pass@w0rd
METADATA_SECRET=Pass@w0rd
NEUTRON_DBPASS=Pass@w0rd
NEUTRON_PASS=Pass@w0rd
NOVA_DBPASS=Pass@w0rd
NOVA_PASS=Pass@w0rd
PLACEMENT_PASS=Pass@w0rd
RABBIT_PASS=Pass@w0rd
2.配置hosts
echo "192.168.81.40 controller.openstack.fjf" >> /etc/hosts
echo "192.168.81.40 controller" >> /etc/hosts
3.安装openstack yum 源，官方已经移除了ocata的yum源，所以用本地同步好的
mkdir /etc/yum.repos.d/bak
mv /etc/yum.repos.d/* /etc/yum.repos.d/bak/
for i in CentOS-Base.repo  CentOS-OpenStack-Ocata.repo epel.repo;do
  curl -s -o /etc/yum.repos.d/$i http://source.fjf.com/bdata/centos7/$i
done
4.重建yum缓存
yum clean all
yum makecache
5.升级软件
yum upgrade -y
6.内核可能会有更新，重启一次系统
reboot
7.安装openstack client
yum install python-openstackclient -y

`1`	`mkdir -p /var/lib/nova`

分区并格式化磁盘

[root@controller nova]# fdisk /dev/xvdb
Welcome to fdisk (util-linux 2.23.2).
 
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.
 
Device does not contain a recognized partition table
Building a new DOS disklabel with disk identifier 0x3974d932.
 
Command (m for help): n
Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-209715199, default 2048):
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-209715199, default 209715199):
Using default value 209715199
Partition 1 of type Linux and of size 100 GiB is set
 
Command (m for help): p
 
Disk /dev/xvdb: 107.4 GB, 107374182400 bytes, 209715200 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk label type: dos
Disk identifier: 0x3974d932
 
    Device Boot      Start         End      Blocks   Id  System
/dev/xvdb1            2048   209715199   104856576   83  Linux
 
Command (m for help): w
The partition table has been altered!
 
Calling ioctl() to re-read partition table.
Syncing disks.
[root@controller lib]# mkfs.xfs /dev/xvdb1

挂载至/var/lib/nova

1
2
3

mount /dev/xvdb1 /var/lib/nova
编辑/etc/fstab,添加一行
/dev/xvdb1 /var/lib/nova           xfs     defaults        0 0

部署基础组件

安装数据库

1.安装
yum install mariadb mariadb-server python2-PyMySQL -y
2.配置
cat > /etc/my.cnf.d/openstack.cnf <<EOF
[mysqld]
bind-address = 192.168.81.40
 
default-storage-engine = innodb
innodb_file_per_table = on
max_connections = 4096
collation-server = utf8_general_ci
character-set-server = utf8
EOF
3.优化参数
在文件 /usr/lib/systemd/system/mariadb.service 的[Service]字段添加下列参数，否则会造成虚拟机创建失败的情况
LimitNOFILE=10000
LimitNPROC=10000
4.启动
systemctl enable mariadb.service
systemctl start mariadb.service
5.设置密码
[root@master ~]# mysql_secure_installation
 
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!
 
In order to log into MariaDB to secure it, we'll need the current
password for the root user.  If you've just installed MariaDB, and
you haven't set the root password yet, the password will be blank,
so you should just press enter here.
 
Enter current password for root (enter for none): 默认没密码，直接回车
OK, successfully used password, moving on...
 
Setting the root password ensures that nobody can log into the MariaDB
root user without the proper authorisation.
 
Set root password? [Y/n] Y
New password: Pass@w0rd
Re-enter new password: Pass@w0rd
Password updated successfully!
Reloading privilege tables..
 ... Success!
 
 
By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.
 
Remove anonymous users? [Y/n] Y
 ... Success!
 
Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.
 
Disallow root login remotely? [Y/n] Y          #禁止root远程登陆，选择为Y之后只有master节点能使用root账号登陆。如果不想这样，按n
 ... Success!
 
By default, MariaDB comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.
 
Remove test database and access to it? [Y/n] Y
 - Dropping test database...
 ... Success!
 - Removing privileges on test database...
 ... Success!
 
Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.
 
Reload privilege tables now? [Y/n] Y
 ... Success!
 
Cleaning up...
 
All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.
 
Thanks for using MariaDB!
6.测试一下
[root@master ~]# mysql -uroot -pPass@w0rd
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 16
Server version: 10.3.20-MariaDB MariaDB Server
 
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
 
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
 
show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
+--------------------+
3 rows in set (0.001 sec)

安装消息队列服务

1.安装rabbitmq
yum install rabbitmq-server -y
2.启动
systemctl enable rabbitmq-server.service
systemctl start rabbitmq-server.service
3.设置密码
rabbitmqctl add_user openstack Pass@w0rd
4.授权
rabbitmqctl set_permissions openstack ".*" ".*" ".*"
5.开启rabbitmq management方便以后管理
rabbitmq-plugins enable rabbitmq_management
默认密码：guest/guest
后台：192.168.81.40:15672

安装缓存服务

1.安装memcached
yum install memcached python-memcached -y
2.修改配置文件
vim /etc/sysconfig/memcached
OPTIONS="-l 127.0.0.1,::1,controller.openstack.fjf"
3.启动
systemctl enable memcached.service
systemctl start memcached.service

安装键值存储服务

1.安装etcd
yum install etcd -y
2.配置
cat > /etc/etcd/etcd.conf <<EOF
#[Member]
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="http://192.168.81.40:2380"
ETCD_LISTEN_CLIENT_URLS="http://192.168.81.40:2379"
ETCD_NAME="controller.openstack.fjf"
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://192.168.81.40:2380"
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.81.40:2379"
ETCD_INITIAL_CLUSTER="controller.openstack.fjf=http://192.168.81.40:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster-01"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF
3.启动
systemctl enable etcd
systemctl start etcd

系统参数优化

1.修改/etc/security/limits.d/20-nproc.conf
*          soft    nproc     65535
root       soft    nproc     unlimited
2.修改
/etc/security/limits.conf
*     soft  nofile  655350
*     hard  nofile  655350
*     soft  nproc   655350
*     hard  nproc   655350

安装keystone

一. 安装keystone(身份认证服务)

建库，建用户

[root@controller ~]# mysql -uroot -pPass@w0rd  
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 11
Server version: 10.1.20-MariaDB MariaDB Server
 
Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.
 
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
 
MariaDB [(none)]> CREATE DATABASE keystone;
Query OK, 1 row affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'localhost' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON keystone.* TO 'keystone'@'%' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)

安装组件

`1`	`yum install openstack-keystone httpd mod_wsgi -y`

编辑/etc/keystone/keystone.conf文件并完成以下操作：


1.在该[database]部分中，配置数据库访问：
[database]
# ...
connection = mysql+pymysql://keystone:Pass@w0rd@controller.openstack.fjf/keystone
2.在该[token]部分中，配置Fernet令牌提供者
[token]
# ...
provider = fernet

填充身份服务数据库

`1`	`su -s /bin/sh -c "keystone-manage db_sync" keystone`

初始化Fernet密钥存储库

1
2

keystone-manage fernet_setup --keystone-user keystone --keystone-group keystone
keystone-manage credential_setup --keystone-user keystone --keystone-group keystone

引导身份服务

keystone-manage bootstrap --bootstrap-password Pass@w0rd \
  --bootstrap-admin-url http://controller.openstack.fjf:5000/v3/ \
  --bootstrap-internal-url http://controller.openstack.fjf:5000/v3/ \
  --bootstrap-public-url http://controller.openstack.fjf:5000/v3/ \
  --bootstrap-region-id RegionOne

配置HTTP接口

1
2

vim /etc/httpd/conf/httpd.conf
ServerName controller.openstack.fjf

创建链接

`1`	`ln -s /usr/share/keystone/wsgi-keystone.conf /etc/httpd/conf.d/`

启动

1
2

systemctl enable httpd.service
systemctl start httpd.service

创建admin-openrc

cat > /root/admin-openrc <<EOF
export OS_USERNAME=admin
export OS_PASSWORD=Pass@w0rd
export OS_PROJECT_NAME=admin
export OS_USER_DOMAIN_NAME=Default
export OS_PROJECT_DOMAIN_NAME=Default
export OS_AUTH_URL=http://controller.openstack.fjf:5000/v3
export OS_IDENTITY_API_VERSION=3
EOF

加载admin-openrc

1
2


. admin-openrc

创建service

openstack project create --domain default \
  --description "Service Project" service
+-------------+----------------------------------+
| Field       | Value                            |
+-------------+----------------------------------+
| description | Service Project                  |
| domain_id   | default                          |
| enabled     | True                             |
| id          | 2c7d5b03d68746229cb60b9ae382d0ae |
| is_domain   | False                            |
| name        | service                          |
| parent_id   | default                          |
| tags        | []                               |
+-------------+----------------------------------+

验证操作

openstack --os-auth-url http://controller.openstack.fjf:5000/v3 \
 --os-project-domain-name Default --os-user-domain-name Default \
 --os-project-name admin --os-username admin token issue
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Field      | Value                                                                                                                                                                                   |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| expires    | 2021-03-18T12:10:01+0000                                                                                                                                                                |
| id         | gAAAAABgUzUJjJTsx4Vz1OY_vBBN28FQC3hH-xpqhITyvjSdF4pOykX8tCd0WX59rChxhC7kWZkrhQygcLj9Ari3pmKcZ5u9Ae4RTYJh1NpF8418xbbZCeZgxbVb9SOUgqCe0ftFzbewGmEL-hxhOmr3rd3WO2HYG47H6CR9WmDzSWsIei2NpPw |
| project_id | 750d6512fc3043d1b1c6d832465cbf9f                                                                                                                                                        |
| user_id    | 99cb132981a74d339868e54a0a4deb3c                                                                                                                                                        |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

安装glance

二、安装glance(镜像服务)

建库，建用户

[root@controller ~]# mysql -uroot -pPass@w0rd 
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 3
Server version: 10.1.20-MariaDB MariaDB Server
 
Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.
 
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
 
MariaDB [(none)]> CREATE DATABASE glance;
Query OK, 1 row affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON glance.* TO 'glance'@'localhost' IDENTIFIED BY 'Passw0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON glance.* TO 'glance'@'%' IDENTIFIED BY 'Passw0rd';
Query OK, 0 rows affected (0.00 sec)

加载admin-openrc

`1`	`. admin-openrc`

创建用户


[root@controller ~]# openstack user create --domain default --password-prompt glance
User Password:Pass@w0rd
Repeat User Password:Pass@w0rd
+---------------------+----------------------------------+
| Field               | Value                            |
+---------------------+----------------------------------+
| domain_id           | default                          |
| enabled             | True                             |
| id                  | 06d7dd9775a3482886790405f3bfe298 |
| name                | glance                           |
| options             | {}                               |
| password_expires_at | None                             |
+---------------------+----------------------------------+

授权

`1`	`openstack role add --project service --user glance admin`

创建服务

[root@controller ~]# openstack service create --name glance   --description "OpenStack Image" image
+-------------+----------------------------------+
| Field       | Value                            |
+-------------+----------------------------------+
| description | OpenStack Image                  |
| enabled     | True                             |
| id          | 56c2b257f48d4d7aa4768a0f1f2367ca |
| name        | glance                           |
| type        | image                            |
+-------------+----------------------------------+

创建API接口

[root@controller ~]# openstack endpoint create --region RegionOne   image public http://controller.openstack.fjf:9292
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | 36c0f0dec23f435fb5e3bbd6ac0ce5ff     |
| interface    | public                               |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 56c2b257f48d4d7aa4768a0f1f2367ca     |
| service_name | glance                               |
| service_type | image                                |
| url          | http://controller.openstack.fjf:9292 |
+--------------+--------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne   image internal http://controller.openstack.fjf:9292
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | 236f70c24afb4049ac2660cbecd0b7a2     |
| interface    | internal                             |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 56c2b257f48d4d7aa4768a0f1f2367ca     |
| service_name | glance                               |
| service_type | image                                |
| url          | http://controller.openstack.fjf:9292 |
+--------------+--------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne   image admin http://controller.openstack.fjf:9292
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | 36f005f69dd74f52b3f5bf0cce3c46d7     |
| interface    | admin                                |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 56c2b257f48d4d7aa4768a0f1f2367ca     |
| service_name | glance                               |
| service_type | image                                |
| url          | http://controller.openstack.fjf:9292 |
+--------------+--------------------------------------+

安装和配置组件

1
2


yum install openstack-glance -y

编辑/etc/glance/glance-api.conf

[database]
# ...
# 注意此处的密码是Passw0rd而不是Pass@w0rd,改组件连接串中不支持'@'符号
connection = mysql+pymysql://glance:Passw0rd@controller.openstack.fjf/glance
 
[keystone_authtoken]
# ...
www_authenticate_uri  = http://controller.openstack.fjf:5000
auth_url = http://controller.openstack.fjf:5000
memcached_servers = controller.openstack.fjf:11211
auth_type = password
project_domain_name = Default
user_domain_name = Default
project_name = service
username = glance
password = Pass@w0rd
 
[paste_deploy]
# ...
flavor = keystone
 
[glance_store]
# ...
stores = file,http
default_store = file
filesystem_store_datadir = /var/lib/glance/images/

填充图像服务数据库

[root@controller ~]# su -s /bin/sh -c "glance-manage db_sync" glance
# 出现此警告可以忽略   
/usr/lib/python2.7/site-packages/oslo_db/sqlalchemy/enginefacade.py:1336: OsloDBDeprecationWarning: EngineFacade is deprecated; please use oslo_db.sqlalchemy.enginefacade
  expire_on_commit=expire_on_commit, _conf=conf)
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Running upgrade  -> liberty, liberty initial
INFO  [alembic.runtime.migration] Running upgrade liberty -> mitaka01, add index on created_at and updated_at columns of 'images' table
INFO  [alembic.runtime.migration] Running upgrade mitaka01 -> mitaka02, update metadef os_nova_server
INFO  [alembic.runtime.migration] Running upgrade mitaka02 -> ocata_expand01, add visibility to images
INFO  [alembic.runtime.migration] Running upgrade ocata_expand01 -> pike_expand01, empty expand for symmetry with pike_contract01
INFO  [alembic.runtime.migration] Running upgrade pike_expand01 -> queens_expand01
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
Upgraded database to: queens_expand01, current revision(s): queens_expand01
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
Database migration is up to date. No migration needed.
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Running upgrade mitaka02 -> ocata_contract01, remove is_public from images
INFO  [alembic.runtime.migration] Running upgrade ocata_contract01 -> pike_contract01, drop glare artifacts tables
INFO  [alembic.runtime.migration] Running upgrade pike_contract01 -> queens_contract01
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
Upgraded database to: queens_contract01, current revision(s): queens_contract01
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
Database is synced successfully.

启动

1
2

systemctl enable openstack-glance-api.service
systemctl start openstack-glance-api.service

安装Compute|控制节点

三、安装Compute(计算服务)&Placement(调度服务)

建库，建用户

[root@controller ~]# mysql -uroot -pPass@w0rd               
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 11
Server version: 10.1.20-MariaDB MariaDB Server
 
Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.
 
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
 
MariaDB [(none)]> CREATE DATABASE nova_api;
Query OK, 1 row affected (0.00 sec)
 
MariaDB [(none)]> CREATE DATABASE nova;
Query OK, 1 row affected (0.00 sec)
 
MariaDB [(none)]> CREATE DATABASE nova_cell0;
Query OK, 1 row affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nova_api.* TO 'nova'@'localhost' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nova_api.* TO 'nova'@'%' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nova.* TO 'nova'@'localhost' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nova.* TO 'nova'@'%' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nova_cell0.* TO 'nova'@'localhost' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON nova_cell0.* TO 'nova'@'%' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)

加载admin-openrc

`1`	`. admin-openrc`

创建Nova用户

[root@controller ~]# openstack user create --domain default --password-prompt nova
User Password:Pass@w0rd
Repeat User Password:Pass@w0rd
+---------------------+----------------------------------+
| Field               | Value                            |
+---------------------+----------------------------------+
| domain_id           | default                          |
| enabled             | True                             |
| id                  | fa90e0ee1be34a7c8d9d77bf2db3ca7e |
| name                | nova                             |
| options             | {}                               |
| password_expires_at | None                             |
+---------------------+----------------------------------+

授权Nova

`1`	`openstack role add --project service --user nova admin`

创建计算服务

[root@controller ~]# openstack service create --name nova --description "OpenStack Compute" compute
+-------------+----------------------------------+
| Field       | Value                            |
+-------------+----------------------------------+
| description | OpenStack Compute                |
| enabled     | True                             |
| id          | 0795642e98ce42c8bac111a21625976c |
| name        | nova                             |
| type        | compute                          |
+-------------+----------------------------------+

创建计算API接口

[root@controller ~]# openstack endpoint create --region RegionOne compute public http://controller.openstack.fjf:8774/v2.1
+--------------+-------------------------------------------+
| Field        | Value                                     |
+--------------+-------------------------------------------+
| enabled      | True                                      |
| id           | f1569159f0444831b29d4e0732aeca27          |
| interface    | public                                    |
| region       | RegionOne                                 |
| region_id    | RegionOne                                 |
| service_id   | 0795642e98ce42c8bac111a21625976c          |
| service_name | nova                                      |
| service_type | compute                                   |
| url          | http://controller.openstack.fjf:8774/v2.1 |
+--------------+-------------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne compute internal http://controller.openstack.fjf:8774/v2.1
+--------------+-------------------------------------------+
| Field        | Value                                     |
+--------------+-------------------------------------------+
| enabled      | True                                      |
| id           | 465c36ab7dcc4e849c835ae9ef174eba          |
| interface    | internal                                  |
| region       | RegionOne                                 |
| region_id    | RegionOne                                 |
| service_id   | 0795642e98ce42c8bac111a21625976c          |
| service_name | nova                                      |
| service_type | compute                                   |
| url          | http://controller.openstack.fjf:8774/v2.1 |
+--------------+-------------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne compute admin http://controller.openstack.fjf:8774/v2.1
+--------------+-------------------------------------------+
| Field        | Value                                     |
+--------------+-------------------------------------------+
| enabled      | True                                      |
| id           | 879816f84f6444b4a65bab6f8d620d08          |
| interface    | admin                                     |
| region       | RegionOne                                 |
| region_id    | RegionOne                                 |
| service_id   | 0795642e98ce42c8bac111a21625976c          |
| service_name | nova                                      |
| service_type | compute                                   |
| url          | http://controller.openstack.fjf:8774/v2.1 |
+--------------+-------------------------------------------+

创建placement用户

[root@controller ~]# openstack user create --domain default --password-prompt placement
User Password:Pass@w0rd
Repeat User Password:Pass@w0rd
+---------------------+----------------------------------+
| Field               | Value                            |
+---------------------+----------------------------------+
| domain_id           | default                          |
| enabled             | True                             |
| id                  | f0b41802435f4d3dad27c6711bb3de73 |
| name                | placement                        |
| options             | {}                               |
| password_expires_at | None                             |
+---------------------+----------------------------------+

授权placement

`1`	`openstack role add --project service --user placement admin`

创建调度器服务

[root@controller ~]# openstack service create --name placement --description "Placement API" placement
+-------------+----------------------------------+
| Field       | Value                            |
+-------------+----------------------------------+
| description | Placement API                    |
| enabled     | True                             |
| id          | 315aa5dae18c4c6bb2a6105f25a11c98 |
| name        | placement                        |
| type        | placement                        |
+-------------+----------------------------------+

创建调度器API接口

[root@controller ~]# openstack endpoint create --region RegionOne placement public http://controller.openstack.fjf:8778
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | bb6eeb117b2c421498bd5d74ab2304e0     |
| interface    | public                               |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 7b2281d9a2e1436e8d6b9721774deb01     |
| service_name | placement                            |
| service_type | placement                            |
| url          | http://controller.openstack.fjf:8778 |
+--------------+--------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne placement internal http://controller.openstack.fjf:8778
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | fed2080d301247e4b9cb9e2b2a4bde55     |
| interface    | internal                             |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 7b2281d9a2e1436e8d6b9721774deb01     |
| service_name | placement                            |
| service_type | placement                            |
| url          | http://controller.openstack.fjf:8778 |
+--------------+--------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne placement admin http://controller.openstack.fjf:8778
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | 3d255c3a2ebb4d249f063e1392767fd7     |
| interface    | admin                                |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 7b2281d9a2e1436e8d6b9721774deb01     |
| service_name | placement                            |
| service_type | placement                            |
| url          | http://controller.openstack.fjf:8778 |
+--------------+--------------------------------------+

安装和配置组件

`1`	`yum install openstack-nova-api openstack-nova-conductor openstack-nova-console openstack-nova-novncproxy openstack-nova-scheduler openstack-nova-placement-api -y`

编辑/etc/nova/nova.conf

[DEFAULT]
# ...
enabled_apis = osapi_compute,metadata
use_neutron = True
firewall_driver = nova.virt.firewall.NoopFirewallDriver
my_ip = 192.168.81.40
connection = mysql+pymysql://nova:Pass@w0rd@controller.openstack.fjf/nova_api
transport_url = rabbit://openstack:Pass@w0rd@controller.openstack.fjf
 
[api_database]
# ...
connection = mysql+pymysql://nova:Pass@w0rd@controller.openstack.fjf/nova_api
 
[database]
# ...
connection = mysql+pymysql://nova:Pass@w0rd@controller.openstack.fjf/nova
 
[api]
# ...
auth_strategy = keystone
 
[keystone_authtoken]
# ...
auth_uri = http://controller.openstack.fjf:5000
auth_url = http://controller.openstack.fjf:35357
memcached_servers = controller.openstack.fjf:11211
auth_type = password
project_domain_name = default
user_domain_name = default
project_name = service
username = nova
password = Pass@w0rd
 
[vnc]
enabled = true
# ...
vncserver_listen = $my_ip
vncserver_proxyclient_address = $my_ip
novncproxy_base_url = http://controller.openstack.fjf:6080/vnc_auto.html
 
[glance]
# ...
api_servers = http://controller.openstack.fjf:9292
[oslo_concurrency]
# ...
lock_path = /var/lib/nova/tmp
 
[placement]
# ...
os_region_name = RegionOne
project_domain_name = Default
project_name = service
auth_type = password
user_domain_name = Default
auth_url = http://controller.openstack.fjf:35357/v3
username = placement
password = Pass@w0rd

编辑/etc/httpd/conf.d/00-nova-placement-api.conf，尾部添加

<Directory /usr/bin>
   <IfVersion >= 2.4>
      Require all granted
   </IfVersion>
   <IfVersion < 2.4>
      Order allow,deny
      Allow from all
   </IfVersion>
</Directory>

重启httpd

`1`	`systemctl restart httpd`

初始化数据

[root@controller ~]# su -s /bin/sh -c "nova-manage api_db sync" nova
[root@controller ~]# su -s /bin/sh -c "nova-manage cell_v2 map_cell0" nova
[root@controller ~]# su -s /bin/sh -c "nova-manage cell_v2 create_cell --name=cell1 --verbose" nova
5d590937-4a0e-488e-9766-9db19d151a51
[root@controller ~]# su -s /bin/sh -c "nova-manage db sync" nova
# 警告信息可以忽略
/usr/lib/python2.7/site-packages/pymysql/cursors.py:170: Warning: (1831, u'Duplicate index `block_device_mapping_instance_uuid_virtual_name_device_name_idx`. This is deprecated and will be disallowed in a future release.')
  result = self._query(query)
/usr/lib/python2.7/site-packages/pymysql/cursors.py:170: Warning: (1831, u'Duplicate index `uniq_instances0uuid`. This is deprecated and will be disallowed in a future release.')
  result = self._query(query)
[root@controller ~]# nova-manage cell_v2 list_cells
# 验证数据
+-------+--------------------------------------+--------------------------------------------------+---------------------------------------------------------------+
|  Name |                 UUID                 |                  Transport URL                   |                      Database Connection                      |
+-------+--------------------------------------+--------------------------------------------------+---------------------------------------------------------------+
| cell0 | 00000000-0000-0000-0000-000000000000 |                      none:/                      | mysql+pymysql://nova:****@controller.openstack.fjf/nova_cell0 |
| cell1 | 5d590937-4a0e-488e-9766-9db19d151a51 | rabbit://openstack:****@controller.openstack.fjf |    mysql+pymysql://nova:****@controller.openstack.fjf/nova    |
+-------+--------------------------------------+--------------------------------------------------+---------------------------------------------------------------+

启动服务

1
2
3


systemctl enable openstack-nova-api.service   openstack-nova-consoleauth.service openstack-nova-scheduler.service   openstack-nova-conductor.service openstack-nova-novncproxy.service
systemctl start openstack-nova-api.service   openstack-nova-consoleauth.service openstack-nova-scheduler.service   openstack-nova-conductor.service openstack-nova-novncproxy.service

安装Compute|计算节点

四、安装Compute(计算服务)，为了节省资源可以将计算节点和控制节点安装在一起这样控制节点也可以运行虚拟机

安装组件

`1`	`yum install openstack-nova-compute`

编辑配置/etc/nova/nova.conf，如果是在控制节点上添加计算服务则不需要修改

[DEFAULT]
# ...
enabled_apis = osapi_compute,metadata
my_ip = 192.168.81.40
use_neutron = True
firewall_driver = nova.virt.firewall.NoopFirewallDriver
transport_url = rabbit://openstack:Pass@w0rd@controller.openstack.fjf
 
[api]
# ...
auth_strategy = keystone
 
[keystone_authtoken]
# ...
auth_uri = http://controller.openstack.fjf:5000
auth_url = http://controller.openstack.fjf:35357
memcached_servers = controller.openstack.fjf:11211
auth_type = password
project_domain_name = default
user_domain_name = default
project_name = service
username = nova
password = Pass@w0rd
 
[vnc]
# ...
enabled = True
vncserver_listen = 0.0.0.0
vncserver_proxyclient_address = $my_ip
novncproxy_base_url = http://controller.openstack.fjf:6080/vnc_auto.html
 
[glance]
# ...
api_servers = http://controller.openstack.fjf:9292
 
[oslo_concurrency]
# ...
lock_path = /var/lib/nova/tmp
 
[placement]
# ...
os_region_name = RegionOne
project_domain_name = Default
project_name = service
auth_type = password
user_domain_name = Default
auth_url = http://controller.openstack.fjf:35357/v3
username = placement
password = Pass@w0rd

检查是否支持硬件虚拟化

[root@controller ~]# egrep -c '(vmx|svm)' /proc/cpuinfo
8
# 如果结果为0，则需要添加以下配置
编辑 /etc/nova/nova.conf
[libvirt]
# ...
virt_type = qemu

启动服务

1
2

systemctl enable libvirtd.service openstack-nova-compute.service
systemctl start  libvirtd.service openstack-nova-compute.service

添加计算节点到元数据库


. admin-openrc
# 扫描计算主机
[root@controller ~]# su -s /bin/sh -c "nova-manage cell_v2 discover_hosts --verbose" nova
Found 2 cell mappings.
Skipping cell0 since it does not contain hosts.
Getting computes from cell 'cell1': 5d590937-4a0e-488e-9766-9db19d151a51
Checking host mapping for compute host 'controller.openstack.fjf': deb6c5fe-24a6-4b1e-af8f-fe448491a565
Creating host mapping for compute host 'controller.openstack.fjf': deb6c5fe-24a6-4b1e-af8f-fe448491a565
Found 1 unmapped computes in cell: 5d590937-4a0e-488e-9766-9db19d151a51
# 查看主机状态
[root@controller ~]# openstack hypervisor list                                          
+----+--------------------------+-----------------+---------------+-------+
| ID | Hypervisor Hostname      | Hypervisor Type | Host IP       | State |
+----+--------------------------+-----------------+---------------+-------+
|  1 | controller.openstack.fjf | QEMU            | 192.168.81.40 | up    |
+----+--------------------------+-----------------+---------------+-------+

注意：添加计算节点后必须在控制节点执行nova-manage cell_v2 discover_hosts才能发现新的计算节点，可以调整/etc/nova/nova.conf中的参数discover_hosts_in_cells_interval = 300，表示为300s自动扫描一次

安装neutron

五、安装neutron(网络服务)

建库，建用户


[root@controller ~]# mysql -uroot -pPass@w0rd              
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 3182
Server version: 10.1.20-MariaDB MariaDB Server
 
Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.
 
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
 
MariaDB [(none)]> CREATE DATABASE neutron;
Query OK, 1 row affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON neutron.* TO 'neutron'@'localhost' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)
 
MariaDB [(none)]> GRANT ALL PRIVILEGES ON neutron.* TO 'neutron'@'%' IDENTIFIED BY 'Pass@w0rd';
Query OK, 0 rows affected (0.00 sec)

加载admin-openrc

1
2


. admin-openrc

创建用户


[root@controller ~]# openstack user create --domain default --password-prompt neutron
User Password:
Repeat User Password:
+---------------------+----------------------------------+
| Field               | Value                            |
+---------------------+----------------------------------+
| domain_id           | default                          |
| enabled             | True                             |
| id                  | c6ea433a2f83472f8218b60dbdf1827a |
| name                | neutron                          |
| options             | {}                               |
| password_expires_at | None                             |
+---------------------+----------------------------------+

授权

1
2


openstack role add --project service --user neutron admin

创建服务

[root@controller ~]# openstack service create --name neutron --description "OpenStack Networking" network
+-------------+----------------------------------+
| Field       | Value                            |
+-------------+----------------------------------+
| description | OpenStack Networking             |
| enabled     | True                             |
| id          | 9b2865e3489c4da3b6c250abf2e73e80 |
| name        | neutron                          |
| type        | network                          |
+-------------+----------------------------------+

创建API接口

[root@controller ~]# openstack endpoint create --region RegionOne network public http://controller.openstack.fjf:9696
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | f3a7c91366d84b49aa84841585ee3d36     |
| interface    | public                               |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 9b2865e3489c4da3b6c250abf2e73e80     |
| service_name | neutron                              |
| service_type | network                              |
| url          | http://controller.openstack.fjf:9696 |
+--------------+--------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne network internal http://controller.openstack.fjf:9696
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | e5bac77508904343b93f12a19294a7dd     |
| interface    | internal                             |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 9b2865e3489c4da3b6c250abf2e73e80     |
| service_name | neutron                              |
| service_type | network                              |
| url          | http://controller.openstack.fjf:9696 |
+--------------+--------------------------------------+
[root@controller ~]# openstack endpoint create --region RegionOne network admin http://controller.openstack.fjf:9696
+--------------+--------------------------------------+
| Field        | Value                                |
+--------------+--------------------------------------+
| enabled      | True                                 |
| id           | 20e22cf74f9b4ac99ee20bc95cfd3433     |
| interface    | admin                                |
| region       | RegionOne                            |
| region_id    | RegionOne                            |
| service_id   | 9b2865e3489c4da3b6c250abf2e73e80     |
| service_name | neutron                              |
| service_type | network                              |
| url          | http://controller.openstack.fjf:9696 |
+--------------+--------------------------------------+

安装网络组件，有两种Provider networks和Self-service networks，Self-service networks提供L3（三层路由）的能力，因为网络组件部署后无法更改，所以使用Self-service networks，其可以涵盖更多的网络类型方便以后网络变化

`1`	`yum install openstack-neutron openstack-neutron-ml2 openstack-neutron-linuxbridge ebtables -y`

编辑配置文件

编辑/etc/neutron/neutron.conf

[database]
# ...
connection = mysql+pymysql://neutron:Pass@w0rd@controller.openstack.fjf/neutron
 
[DEFAULT]
# ...
core_plugin = ml2
service_plugins = router
allow_overlapping_ips = true
transport_url = rabbit://openstack:Pass@w0rd@controller.openstack.fjf
auth_strategy = keystone
notify_nova_on_port_status_changes = true
notify_nova_on_port_data_changes = true
 
[keystone_authtoken]
# ...
auth_uri = http://controller.openstack.fjf:5000
auth_url = http://controller.openstack.fjf:35357
memcached_servers = controller.openstack.fjf:11211
auth_type = password
project_domain_name = default
user_domain_name = default
project_name = service
username = neutron
password = Pass@w0rd
 
[nova]
# ...
auth_url = http://controller.openstack.fjf:35357
auth_type = password
project_domain_name = default
user_domain_name = default
region_name = RegionOne
project_name = service
username = nova
password = Pass@w0rd
 
[oslo_concurrency]
# ...
lock_path = /var/lib/neutron/tmp

编辑/etc/neutron/plugins/ml2/ml2_conf.ini

[ml2]
# ...
type_drivers = flat,vlan,vxlan
tenant_network_types = vxlan
mechanism_drivers = linuxbridge,l2population
extension_drivers = port_security
 
[ml2_type_flat]
# ...
flat_networks = provider
 
[ml2_type_vlan]
# ...
network_vlan_ranges = physvlan:1:1000
 
[ml2_type_vxlan]
# ...
vni_ranges = 1:1000
 
[securitygroup]
# ...
enable_ipset = true

编辑/etc/neutron/plugins/ml2/linuxbridge_agent.ini

[linux_bridge]
physical_interface_mappings = provider:eth0
 
[vxlan]
enable_vxlan = true
local_ip = 192.168.81.40
l2_population = true
 
[securitygroup]
# ...
enable_security_group = true
firewall_driver = neutron.agent.linux.iptables_firewall.IptablesFirewallDriver

编辑/etc/neutron/l3_agent.ini

1
2
3

[DEFAULT]
# ...
interface_driver = linuxbridge

编辑/etc/neutron/dhcp_agent.ini

[DEFAULT]
# ...
interface_driver = linuxbridge
dhcp_driver = neutron.agent.linux.dhcp.Dnsmasq
enable_isolated_metadata = true

编辑/etc/neutron/metadata_agent.ini

[DEFAULT]
# ...
nova_metadata_host = controller.openstack.fjf
# 共享密钥随机生成一个
metadata_proxy_shared_secret = RpP55i3dSRRoHq8x

编辑/etc/nova/nova.conf

[neutron]
# ...
url = http://controller.openstack.fjf:9696
auth_url = http://controller.openstack.fjf:35357
auth_type = password
project_domain_name = default
user_domain_name = default
region_name = RegionOne
project_name = service
username = neutron
password = Pass@w0rd
service_metadata_proxy = true
metadata_proxy_shared_secret = RpP55i3dSRRoHq8x

创建配置链接

`1`	`ln -s /etc/neutron/plugins/ml2/ml2_conf.ini /etc/neutron/plugin.ini`

初始化数据库

[root@controller ~]# su -s /bin/sh -c "neutron-db-manage --config-file /etc/neutron/neutron.conf --config-file /etc/neutron/plugins/ml2/ml2_conf.ini upgrade head" neutron
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
  Running upgrade for neutron ...
INFO  [alembic.runtime.migration] Context impl MySQLImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
INFO  [alembic.runtime.migration] Running upgrade  -> kilo, kilo_initial
INFO  [alembic.runtime.migration] Running upgrade kilo -> 354db87e3225, nsxv_vdr_metadata.py
INFO  [alembic.runtime.migration] Running upgrade 354db87e3225 -> 599c6a226151, neutrodb_ipam
INFO  [alembic.runtime.migration] Running upgrade 599c6a226151 -> 52c5312f6baf, Initial operations in support of address scopes
INFO  [alembic.runtime.migration] Running upgrade 52c5312f6baf -> 313373c0ffee, Flavor framework
INFO  [alembic.runtime.migration] Running upgrade 313373c0ffee -> 8675309a5c4f, network_rbac
INFO  [alembic.runtime.migration] Running upgrade 8675309a5c4f -> 45f955889773, quota_usage
INFO  [alembic.runtime.migration] Running upgrade 45f955889773 -> 26c371498592, subnetpool hash
INFO  [alembic.runtime.migration] Running upgrade 26c371498592 -> 1c844d1677f7, add order to dnsnameservers
INFO  [alembic.runtime.migration] Running upgrade 1c844d1677f7 -> 1b4c6e320f79, address scope support in subnetpool
INFO  [alembic.runtime.migration] Running upgrade 1b4c6e320f79 -> 48153cb5f051, qos db changes
INFO  [alembic.runtime.migration] Running upgrade 48153cb5f051 -> 9859ac9c136, quota_reservations
INFO  [alembic.runtime.migration] Running upgrade 9859ac9c136 -> 34af2b5c5a59, Add dns_name to Port
INFO  [alembic.runtime.migration] Running upgrade 34af2b5c5a59 -> 59cb5b6cf4d, Add availability zone
INFO  [alembic.runtime.migration] Running upgrade 59cb5b6cf4d -> 13cfb89f881a, add is_default to subnetpool
INFO  [alembic.runtime.migration] Running upgrade 13cfb89f881a -> 32e5974ada25, Add standard attribute table
INFO  [alembic.runtime.migration] Running upgrade 32e5974ada25 -> ec7fcfbf72ee, Add network availability zone
INFO  [alembic.runtime.migration] Running upgrade ec7fcfbf72ee -> dce3ec7a25c9, Add router availability zone
INFO  [alembic.runtime.migration] Running upgrade dce3ec7a25c9 -> c3a73f615e4, Add ip_version to AddressScope
INFO  [alembic.runtime.migration] Running upgrade c3a73f615e4 -> 659bf3d90664, Add tables and attributes to support external DNS integration
INFO  [alembic.runtime.migration] Running upgrade 659bf3d90664 -> 1df244e556f5, add_unique_ha_router_agent_port_bindings
INFO  [alembic.runtime.migration] Running upgrade 1df244e556f5 -> 19f26505c74f, Auto Allocated Topology - aka Get-Me-A-Network
INFO  [alembic.runtime.migration] Running upgrade 19f26505c74f -> 15be73214821, add dynamic routing model data
INFO  [alembic.runtime.migration] Running upgrade 15be73214821 -> b4caf27aae4, add_bgp_dragent_model_data
INFO  [alembic.runtime.migration] Running upgrade b4caf27aae4 -> 15e43b934f81, rbac_qos_policy
INFO  [alembic.runtime.migration] Running upgrade 15e43b934f81 -> 31ed664953e6, Add resource_versions row to agent table
INFO  [alembic.runtime.migration] Running upgrade 31ed664953e6 -> 2f9e956e7532, tag support
INFO  [alembic.runtime.migration] Running upgrade 2f9e956e7532 -> 3894bccad37f, add_timestamp_to_base_resources
INFO  [alembic.runtime.migration] Running upgrade 3894bccad37f -> 0e66c5227a8a, Add desc to standard attr table
INFO  [alembic.runtime.migration] Running upgrade 0e66c5227a8a -> 45f8dd33480b, qos dscp db addition
INFO  [alembic.runtime.migration] Running upgrade 45f8dd33480b -> 5abc0278ca73, Add support for VLAN trunking
INFO  [alembic.runtime.migration] Running upgrade 5abc0278ca73 -> d3435b514502, Add device_id index to Port
INFO  [alembic.runtime.migration] Running upgrade d3435b514502 -> 30107ab6a3ee, provisioning_blocks.py
INFO  [alembic.runtime.migration] Running upgrade 30107ab6a3ee -> c415aab1c048, add revisions table
INFO  [alembic.runtime.migration] Running upgrade c415aab1c048 -> a963b38d82f4, add dns name to portdnses
INFO  [alembic.runtime.migration] Running upgrade kilo -> 30018084ec99, Initial no-op Liberty contract rule.
INFO  [alembic.runtime.migration] Running upgrade 30018084ec99 -> 4ffceebfada, network_rbac
INFO  [alembic.runtime.migration] Running upgrade 4ffceebfada -> 5498d17be016, Drop legacy OVS and LB plugin tables
INFO  [alembic.runtime.migration] Running upgrade 5498d17be016 -> 2a16083502f3, Metaplugin removal
INFO  [alembic.runtime.migration] Running upgrade 2a16083502f3 -> 2e5352a0ad4d, Add missing foreign keys
INFO  [alembic.runtime.migration] Running upgrade 2e5352a0ad4d -> 11926bcfe72d, add geneve ml2 type driver
INFO  [alembic.runtime.migration] Running upgrade 11926bcfe72d -> 4af11ca47297, Drop cisco monolithic tables
INFO  [alembic.runtime.migration] Running upgrade 4af11ca47297 -> 1b294093239c, Drop embrane plugin table
INFO  [alembic.runtime.migration] Running upgrade 1b294093239c -> 8a6d8bdae39, standardattributes migration
INFO  [alembic.runtime.migration] Running upgrade 8a6d8bdae39 -> 2b4c2465d44b, DVR sheduling refactoring
INFO  [alembic.runtime.migration] Running upgrade 2b4c2465d44b -> e3278ee65050, Drop NEC plugin tables
INFO  [alembic.runtime.migration] Running upgrade e3278ee65050 -> c6c112992c9, rbac_qos_policy
INFO  [alembic.runtime.migration] Running upgrade c6c112992c9 -> 5ffceebfada, network_rbac_external
INFO  [alembic.runtime.migration] Running upgrade 5ffceebfada -> 4ffceebfcdc, standard_desc
INFO  [alembic.runtime.migration] Running upgrade 4ffceebfcdc -> 7bbb25278f53, device_owner_ha_replicate_int
INFO  [alembic.runtime.migration] Running upgrade 7bbb25278f53 -> 89ab9a816d70, Rename ml2_network_segments table
INFO  [alembic.runtime.migration] Running upgrade a963b38d82f4 -> 3d0e74aa7d37, Add flavor_id to Router
INFO  [alembic.runtime.migration] Running upgrade 3d0e74aa7d37 -> 030a959ceafa, uniq_routerports0port_id
INFO  [alembic.runtime.migration] Running upgrade 030a959ceafa -> a5648cfeeadf, Add support for Subnet Service Types
INFO  [alembic.runtime.migration] Running upgrade a5648cfeeadf -> 0f5bef0f87d4, add_qos_minimum_bandwidth_rules
INFO  [alembic.runtime.migration] Running upgrade 0f5bef0f87d4 -> 67daae611b6e, add standardattr to qos policies
INFO  [alembic.runtime.migration] Running upgrade 89ab9a816d70 -> c879c5e1ee90, Add segment_id to subnet
INFO  [alembic.runtime.migration] Running upgrade c879c5e1ee90 -> 8fd3918ef6f4, Add segment_host_mapping table.
INFO  [alembic.runtime.migration] Running upgrade 8fd3918ef6f4 -> 4bcd4df1f426, Rename ml2_dvr_port_bindings
INFO  [alembic.runtime.migration] Running upgrade 4bcd4df1f426 -> b67e765a3524, Remove mtu column from networks.
INFO  [alembic.runtime.migration] Running upgrade 67daae611b6e -> 6b461a21bcfc, uniq_floatingips0floating_network_id0fixed_port_id0fixed_ip_addr
INFO  [alembic.runtime.migration] Running upgrade 6b461a21bcfc -> 5cd92597d11d, Add ip_allocation to port
INFO  [alembic.runtime.migration] Running upgrade 5cd92597d11d -> 929c968efe70, add_pk_version_table
INFO  [alembic.runtime.migration] Running upgrade 929c968efe70 -> a9c43481023c, extend_pk_with_host_and_add_status_to_ml2_port_binding
INFO  [alembic.runtime.migration] Running upgrade a9c43481023c -> 804a3c76314c, Add data_plane_status to Port
INFO  [alembic.runtime.migration] Running upgrade 804a3c76314c -> 2b42d90729da, qos add direction to bw_limit_rule table
INFO  [alembic.runtime.migration] Running upgrade 2b42d90729da -> 62c781cb6192, add is default to qos policies
INFO  [alembic.runtime.migration] Running upgrade 62c781cb6192 -> c8c222d42aa9, logging api
INFO  [alembic.runtime.migration] Running upgrade c8c222d42aa9 -> 349b6fd605a6, Add dns_domain to portdnses
INFO  [alembic.runtime.migration] Running upgrade 349b6fd605a6 -> 7d32f979895f, add mtu for networks
INFO  [alembic.runtime.migration] Running upgrade 7d32f979895f -> 594422d373ee, fip qos
INFO  [alembic.runtime.migration] Running upgrade b67e765a3524 -> a84ccf28f06a, migrate dns name from port
INFO  [alembic.runtime.migration] Running upgrade a84ccf28f06a -> 7d9d8eeec6ad, rename tenant to project
INFO  [alembic.runtime.migration] Running upgrade 7d9d8eeec6ad -> a8b517cff8ab, Add routerport bindings for L3 HA
INFO  [alembic.runtime.migration] Running upgrade a8b517cff8ab -> 3b935b28e7a0, migrate to pluggable ipam
INFO  [alembic.runtime.migration] Running upgrade 3b935b28e7a0 -> b12a3ef66e62, add standardattr to qos policies
INFO  [alembic.runtime.migration] Running upgrade b12a3ef66e62 -> 97c25b0d2353, Add Name and Description to the networksegments table
INFO  [alembic.runtime.migration] Running upgrade 97c25b0d2353 -> 2e0d7a8a1586, Add binding index to RouterL3AgentBinding
INFO  [alembic.runtime.migration] Running upgrade 2e0d7a8a1586 -> 5c85685d616d, Remove availability ranges.

重启Nova服务

`1`	`systemctl restart openstack-nova-api.service`

启动网络服务

1
2

systemctl enable neutron-server.service neutron-linuxbridge-agent.service neutron-dhcp-agent.service neutron-metadata-agent.service neutron-l3-agent.service
systemctl start neutron-server.service neutron-linuxbridge-agent.service neutron-dhcp-agent.service neutron-metadata-agent.service neutron-l3-agent.service

安装dashboard

安装Dashboard(WEB管理控制台)

安装组件

`1`	`yum install openstack-dashboard -y`

编辑配置/etc/openstack-dashboard/local_settings，如果是在控制节点上添加计算服务则不需要修改

OPENSTACK_HOST = "controller.openstack.fjf"
ALLOWED_HOSTS = ['controller.openstack.fjf', '192.168.81.40','localhost']
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
CACHES = {
    'default': {
         'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
         'LOCATION': 'controller.openstack.fjf:11211',
    }
}
OPENSTACK_KEYSTONE_URL = "http://%s:5000/v3" % OPENSTACK_HOST
OPENSTACK_KEYSTONE_MULTIDOMAIN_SUPPORT = True
OPENSTACK_API_VERSIONS = {
    "identity": 3,
    "image": 2,
    "volume": 2,
}
OPENSTACK_KEYSTONE_DEFAULT_DOMAIN = "Default"
OPENSTACK_KEYSTONE_DEFAULT_ROLE = "admin"
OPENSTACK_NEUTRON_NETWORK = {
    ...
    'enable_router': False,
    'enable_quotas': False,
    'enable_distributed_router': False,
    'enable_ha_router': False,
    'enable_lb': False,
    'enable_firewall': False,
    'enable_vpn': False,
    'enable_fip_topology_check': False,
}
TIME_ZONE = "Asia/Shanghai"

重启服务

`1`	`systemctl restart httpd.service memcached.service`

访问控制台：http://192.168.81.40/dashboard 账号/密码

cat admin-openrc
# 这个账号密码就是用来登陆控制台的，如果要求输入域则参考OS_USER_DOMAIN_NAME
export OS_USERNAME=admin
export OS_PASSWORD=Pass@w0rd
export OS_USER_DOMAIN_NAME=Default

下载并导入镜像导入镜像

下载镜像

#测试镜像：cirros，最小的一种镜像，只有16M，方便测试
wget http://download.cirros-cloud.net/0.5.1/cirros-0.5.1-x86_64-disk.img
#Centos7镜像
http://cloud.centos.org/centos/7/images/
#其他类型镜像
https://docs.openstack.org/image-guide/obtain-images.html

加载admin-openrc

`1`	`. admin-openrc`

导入镜像

openstack image create "cirros" --file cirros-0.5.1-x86_64-disk.img --disk-format qcow2 --container-format bare --public
+------------------+------------------------------------------------------+
| Field            | Value                                                |
+------------------+------------------------------------------------------+
| checksum         | 1d3062cd89af34e419f7100277f38b2b                     |
| container_format | bare                                                 |
| created_at       | 2021-03-26T11:09:11Z                                 |
| disk_format      | qcow2                                                |
| file             | /v2/images/b3befb16-19c7-4775-ac0a-1961ff269461/file |
| id               | b3befb16-19c7-4775-ac0a-1961ff269461                 |
| min_disk         | 0                                                    |
| min_ram          | 0                                                    |
| name             | cirros                                               |
| owner            | 750d6512fc3043d1b1c6d832465cbf9f                     |
| protected        | False                                                |
| schema           | /v2/schemas/image                                    |
| size             | 16338944                                             |
| status           | active                                               |
| tags             |                                                      |
| updated_at       | 2021-03-26T11:09:11Z                                 |
| virtual_size     | None                                                 |
| visibility       | public                                               |
+------------------+------------------------------------------------------+

创建网络&虚拟机

创建一个桥接网络，Flat，管理员 -> 网络 -> 网络 -> 创建网络物理网络名称通过：cat /etc/neutron/plugins/ml2/ml2_conf.ini |grep flat_networks 获取配置网络信息创建实例类型，管理员 -> 计算 -> 实例类型 -> 创建实例类型创建密钥对，项目 -> 计算 -> 密钥对 -> 导入公钥，创建完会自动下载私钥，也可以导入已经存在的密钥对公钥

可以进入控制台通过SSH连接

OpenStack将运行的系统导出 QCOW2 镜像并导入阿里云

Wed, 23 Oct 2024 18:44:38 +0000

项目背景

OpenStack，作为一个开源的云计算平台，经常被用于构建私有云和公有云服务。然而，随着业务的发展和扩展，企业可能会面临将在OpenStack上运行的虚拟机迁移到其他云服务供应商的需求

需求

因为运营团队在本地机房有一台 OpenStack中的虚拟机业务，负责邮件发送，跑定时任务等等。但是由于机房迁移，会导致机房服务中断。但由于考虑业务继续跑，需要把这台机器迁移到阿里云的环境。但是由于依赖和环境众多，差异性太大，需要有个简便的方式完成迁移。

环境介绍

源环境：OpenStack 版本（适用于其他版本，但步骤可能略有不同）
目标环境：阿里云ECS
操作系统：以Centos7 为例（其他Linux发行版的操作可能类似）
必要工具：qemu-img（用于转换镜像格式）

准备工作

在开始之前，确保您有以下准备：

确认您有足够的权限来访问OpenStack环境和阿里云账户。
安装qemu-img工具，这通常可以在Linux发行版的官方仓库中找到。
确保有足够的本地存储空间来保存导出的QCOW2镜像文件。

导出OpenStack虚拟机镜像

首先排查这台机器虚拟机在那台OpenStack宿主机上，比如我这台OpenStack虚拟机在 compute4.openstack.fjf，虚拟机id：e7c5b097-e842-4db1-849b-fd4af3cb9380 进入工作目录 进入compute4.openstack.fjf 这台OpenStack 的node节点，在进入下方目录

1
2
3

cd /var/lib/nova/instaces/$your_instance_id$
这个是我的
 cd /var/lib/nova/instances/e7c5b097-e842-4db1-849b-fd4af3cb9380/

导出运行的镜像 使用qemu-img工具将OpenStack的QCOW2镜像转换为适合阿里云的格式：

如果保存，请关闭虚拟机在试试

[dev][root@compute4-192.168.81.14 e7c5b097-e842-4db1-849b-fd4af3cb9380]# qemu-img convert -c -O qcow2 disk test.qcow2
qemu-img: Could not open 'disk': Failed to get shared "write" lock
Is another process using the image [disk]?

#这个正常的
qemu-img convert -c -O qcow2 disk test.qcow2
#这个命令会创建一个新的压缩的QCOW2镜像文件

传镜像到阿里云OSS

在导入镜像到阿里云ECS之前，您需要先将镜像上传到阿里云的对象存储服务（OSS）。

登录到阿里云控制台。
创建一个OSS Bucket。
使用OSS的上传功能或者OSS提供的命令行工具ossutil上传您的QCOW2镜像文件。

导入镜像到阿里云ECS

一旦镜像上传到OSS，您可以通过阿里云ECS控制台导入镜像：

在ECS控制台中，找到“镜像和模板”部分。
选择“导入镜像”。
提供OSS中镜像的URL，以及其他必要的信息。
启动导入任务。阿里云会处理镜像的导入过程，这可能需要一些时间。

创建ECS实例

导入镜像完成后，您可以使用该镜像创建新的ECS实例：

在ECS控制台中，选择“实例”。
点击“创建实例”。
在创建向导中，选择您刚刚导入的镜像作为基础。
完成实例的配置，包括选择实例类型、配置网络和安全组等。
启动实例。

总结

将OpenStack环境中的虚拟机镜像成功迁移到阿里云ECS。这个过程不仅增强了云资源的可移植性，而且为企业提供了更多的灵活性和选择权。无论是为了成本优化、性能提升还是遵循合规性要求，这种迁移策略都是现代云基础设施管理不可或缺的一部分。

Kubernetes部署(haproxy+keepalived)高可用环境和办公网络打通

Mon, 09 Sep 2024 15:43:46 +0000

HAProxy + Keepalived 部署高可用性入口：
- 部署两台或多台节点运行 HAProxy 作为负载均衡器。
- 使用 Keepalived 实现 VIP（虚拟 IP），为 HAProxy 提供高可用性。Keepalived 会监控 HAProxy 的状态，如果主节点失效，VIP 会自动漂移到备用节点，确保高可用性。
HAProxy 配置：
- HAProxy 会作为 Kubernetes 的入口，转发流量到 Kubernetes 集群的 apiserver。
- 配置 HAProxy 负载均衡规则，分发流量到多个 Kubernetes master 节点的 API server。
Keepalived 配置：
- Keepalived 会监控 HAProxy 的状态，确保在节点失效时自动切换到备用服务器，保障服务连续性。
- 配置高优先级的主节点和低优先级的备份节点，当主节点不可用时，VIP 切换到备份节点。
办公网络打通：
- 办公网络通过 VPN 或路由器配置，将办公网络和 Kubernetes 集群的网络打通。
- 确保办公网络能够通过 VIP 访问 Kubernetes 集群服务，包括 API server 和集群内的其他服务。

环境准备

环境

系统版本：CentOS 7.5.1804 Kubernetes 版本：v1.23.1 Calico 版本：v3.8.0

机器

主机名	IP	角色	安装软件
k8s-test-lvs-1.fjf	192.168.83.15/vip 192.168.83.3	高可用&负载均衡 Master	keepalive、haproxy
k8s-test-lvs-2.fjf	192.168.83.26/vip 192.168.83.3	高可用&负载均衡 Slave	keepalive、haproxy
k8s-test-master-1.fjf	192.168.83.36	Kubernetes Master Node	kubernetes
k8s-test-master-2.fjf	192.168.83.54	Kubernetes Master Node	kubernetes
k8s-test-master-3.fjf	192.168.83.49	Kubernetes Master Node	kubernetes
k8s-test-node-1.fjf	192.168.83.52	Kubernetes Worker Node	kubernetes
k8s-test-node-2.fjf	192.168.83.22	Kubernetes Worker Node	kubernetes
k8s-test-node-3.fjf	192.168.83.37	Kubernetes Worker Node	kubernetes

网络规划

名称	网络	备注
节点网络	192.168.83.0/24	容器宿主机所用网络
Pod网络	172.15.0.0/16	容器网络
Svc 网络	172.16.0.0/16	服务网络

系统配置

# 所有节点关闭Selinux
sed -i "/SELINUX/ s/enforcing/disabled/g" /etc/selinux/config


# 所有节点关闭防火墙
systemctl disable firewalld


# 所有节点配置内核参数
cat > /etc/sysctl.conf <<EOF
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1

vm.swappiness = 0
net.ipv4.neigh.default.gc_stale_time=120

# see details in https://help.aliyun.com/knowledge_detail/39428.html
net.ipv4.conf.all.rp_filter=0
net.ipv4.conf.default.rp_filter=0
net.ipv4.conf.default.arp_announce = 2
net.ipv4.conf.lo.arp_announce=2
net.ipv4.conf.all.arp_announce=2

# see details in https://help.aliyun.com/knowledge_detail/41334.html
net.ipv4.tcp_max_tw_buckets = 5000
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 1024
net.ipv4.tcp_synack_retries = 2

net.ipv4.tcp_fin_timeout = 30

net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
EOF

如果是在OpenStack中部署，需要关闭所有主机的端口安全组，如果不关闭，pod网络和svc网络将无法正常通信在openstack控制节点执行

# 所有节点都需要操作，可以使用for循环批量操作，下面是单主机移除步骤


# 查看端口ID
neutron port-list| grep 192.168.83.15 
| ea065e6c-65d9-457b-a68e-282653c890e5 |      | 9f83fb35aed1422588096b578cc01341 | fa:16:3e:bd:41:81 | {"subnet_id": "710ffde5-d820-4a30-afe2-1dfd6f40e288", "ip_address": "192.168.83.15"} |


# 移除安全组
neutron port-update --no-security-groups ea065e6c-65d9-457b-a68e-282653c890e5
Updated port: ea065e6c-65d9-457b-a68e-282653c890e5


# 关闭端口安全组
neutron port-update ea065e6c-65d9-457b-a68e-282653c890e5 --port-security-enabled=False
Updated port: ea065e6c-65d9-457b-a68e-282653c890e5


# 查看状态
neutron port-show fcf46a43-5a72-4a28-8e57-1eb04ae24c42
+-----------------------+--------------------------------------------------------------------------------------+
| Field                 | Value                                                                                |
+-----------------------+--------------------------------------------------------------------------------------+
| admin_state_up        | True                                                                                 |
| allowed_address_pairs |                                                                                      |
| binding:host_id       | compute6.openstack.fjf                                                               |
| binding:profile       | {}                                                                                   |
| binding:vif_details   | {"port_filter": true}                                                                |
| binding:vif_type      | bridge                                                                               |
| binding:vnic_type     | normal                                                                               |
| created_at            | 2021-07-01T10:13:32Z                                                                 |
| description           |                                                                                      |
| device_id             | 0a10a372-95fa-4b95-a036-ee43675f1ff4                                                 |
| device_owner          | compute:nova                                                                         |
| extra_dhcp_opts       |                                                                                      |
| fixed_ips             | {"subnet_id": "710ffde5-d820-4a30-afe2-1dfd6f40e288", "ip_address": "192.168.83.22"} |
| id                    | fcf46a43-5a72-4a28-8e57-1eb04ae24c42                                                 |
| mac_address           | fa:16:3e:3f:1d:a8                                                                    |
| name                  |                                                                                      |
| network_id            | 02a8d505-af1e-4da5-af08-ed5ea7600293                                                 |
| port_security_enabled | False                                                                                | # 此项为False则代表端口安全组关闭
| project_id            | 9f83fb35aed1422588096b578cc01341                                                     |
| revision_number       | 10                                                                                   |
| security_groups       |                                                                                      | # 此项必须为空
| status                | ACTIVE                                                                               |
| tags                  |                                                                                      |
| tenant_id             | 9f83fb35aed1422588096b578cc01341                                                     |
| updated_at            | 2021-07-01T10:13:42Z                                                                 |
+-----------------------+--------------------------------------------------------------------------------------+

部署haproxy+keepalived

[192.168.83.15,192.168.83.26]安装haproxy+keepalived

`1`	`yum -y install haproxy keepalived`

[192.168.83.15,192.168.83.26]配置haproxy

cat > /etc/haproxy/haproxy.cfg <<EOF
global
    log         127.0.0.1 local2
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    maxconn     4000
    user        haproxy
    group       haproxy
    daemon
 
    stats socket /var/lib/haproxy/stats
 
defaults
    mode                    http
    log                     global
    option                  httplog
    option                  dontlognull
    option http-server-close
    option forwardfor       except 127.0.0.0/8
    option                  redispatch
    retries                 3
    timeout http-request    10s
    timeout queue           1m
    timeout connect         10s
    timeout client          1m
    timeout server          1m
    timeout http-keep-alive 10s
    timeout check           10s
    maxconn                 5000
 
defaults
    mode                    tcp
    option                  redispatch
    option                  abortonclose
    timeout connect         5000s
    timeout client          50000s
    timeout server          50000s
    log 127.0.0.1           local0
    balance                 roundrobin
    maxconn                 50000
 
listen  admin_stats 0.0.0.0:50101
        mode        http
        stats uri   /
        stats realm     Global\ statistics
        stats auth  haproxy:password
        stats hide-version
        stats admin if TRUE
 
listen KubeApi
    bind 0.0.0.0:6443
    mode tcp
    server KubeMaster1 192.168.83.36:6443 weight 1 check port 6443 inter 12000 rise 1 fall 3
    server KubeMaster2 192.168.83.54:6443 weight 1 check port 6443 inter 12000 rise 1 fall 3
    server KubeMaster3 192.168.83.49:6443 weight 1 check port 6443 inter 12000 rise 1 fall 3
EOF

[192.168.83.15]配置keepalived

cat > /etc/keepalived/keepalived.conf <<EOF
! Configuration File for keepalived
 
global_defs {
   router_id LVS_DEVEL
   vrrp_skip_check_adv_addr
   vrrp_strict
   vrrp_garp_interval 0
   vrrp_gna_interval 0
}
 
vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 52
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass test-pass
    }
    virtual_ipaddress {
        192.168.83.3
    }
}
EOF

[192.168.83.26]配置keepalived

cat > /etc/keepalived/keepalived.conf <<EOF
! Configuration File for keepalived
 
global_defs {
   router_id LVS_DEVEL
   vrrp_skip_check_adv_addr
   vrrp_strict
   vrrp_garp_interval 0
   vrrp_gna_interval 0
}
 
vrrp_instance VI_1 {
    state BACKUP # 与master值不同
    interface eth0
    virtual_router_id 52
    priority 99 # 与master值不同
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass test-pass
    }
    virtual_ipaddress {
        192.168.83.3
    }
}
EOF

[192.168.83.15,192.168.83.26]启动服务

systemctl start haproxy keepalived
systemctl enable haproxy keepalived     
Created symlink from /etc/systemd/system/multi-user.target.wants/haproxy.service to /usr/lib/systemd/system/haproxy.service.
Created symlink from /etc/systemd/system/multi-user.target.wants/keepalived.service to /usr/lib/systemd/system/keepalived.service.

查看管理后台，http://192.168.83.3:50101/，账号密码在haproxy配置文件中stats auth字段。此时所有后端处于Down的状态属于正常情况，因为kubernetes master节点还没有部署

部署kubernetes master

[192.168.83.36,192.168.83.54,192.168.83.49]添加Yum源

# 移除可能存在的组件
yum remove docker docker-common docker-selinux docker-engine
# 安装一些依赖
yum install -y yum-utils device-mapper-persistent-data lvm2
# 配置Docker CE 源
wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo
sudo sed -i 's+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo
 
 
# Kubernetes
cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
 
 
# 重建缓存
yum makecache fast

[192.168.83.36,192.168.83.54,192.168.83.49]安装

`1`	`yum -y install docker-ce kubelet-1.23.1 kubeadm-1.23.1 kubectl-1.23.1`

[192.168.83.36,192.168.83.54,192.168.83.49]添加docker配置

mkdir /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://xxxxxx.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
        "max-size": "100m",
        "max-file": "10"
  },
  "oom-score-adjust": -1000,
  "live-restore": true
}
EOF

[192.168.83.36,192.168.83.54,192.168.83.49]启动服务

systemctl start docker kubelet
systemctl enable docker kubelet
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.

[192.168.83.36]创建集群初始化配置文件

cat > /etc/kubernetes/kubeadm-config.yaml <<EOF
apiVersion: kubeadm.k8s.io/v1beta2
kind: ClusterConfiguration
kubernetesVersion: stable
controlPlaneEndpoint: "192.168.83.3:6443" #VIP，浮动IP，端口固定6443不要修改
kubernetesVersion: v1.15.0
networking:
  podSubnet: 172.15.0.0/16
  serviceSubnet: 172.16.0.0/16
  dnsDomain: k8s-test.fjf # 默认值：cluster.local,在使用svc网络是可以使用此后缀,需要dns指定到k8s内部dns才能完成解析
EOF

[192.168.83.36,192.168.83.54,192.168.83.49]手动下载镜像，加速集群初始化

KUBE_VERSION=v1.15.0
KUBE_PAUSE_VERSION=3.1
ETCD_VERSION=3.3.10
CORE_DNS_VERSION=1.3.1
 
GCR_URL=k8s.gcr.io
ALIYUN_URL=registry.cn-hangzhou.aliyuncs.com/google_containers
 
images=(kube-proxy:${KUBE_VERSION}
kube-scheduler:${KUBE_VERSION}
kube-controller-manager:${KUBE_VERSION}
kube-apiserver:${KUBE_VERSION}
pause:${KUBE_PAUSE_VERSION}
etcd:${ETCD_VERSION}
coredns:${CORE_DNS_VERSION})
 
 
for imageName in ${images[@]} ; do
  docker pull $ALIYUN_URL/$imageName
  docker tag  $ALIYUN_URL/$imageName $GCR_URL/$imageName
  docker rmi $ALIYUN_URL/$imageName
done

[192.168.83.36]初始化集群

# --upload-certs 用于上传证书到集群，其他节点就不需要手动复制证书了
# tee kubeadm-init.log 保存屏幕输出信息，后面节点加入需要此信息
kubeadm init --config=/etc/kubernetes/kubeadm-config.yaml  --upload-certs | tee kubeadm-init.log
# 以下，输出信息
W0705 18:04:22.814808   11579 strict.go:54] error unmarshaling configuration schema.GroupVersionKind{Group:"kubeadm.k8s.io", Version:"v1beta2", Kind:"ClusterConfiguration"}: error converting YAML to JSON: yaml: unmarshal errors:
  line 5: key "kubernetesVersion" already set in map
[init] Using Kubernetes version: v1.15.0
[preflight] Running pre-flight checks
        [WARNING SystemVerification]: this Docker version is not on the list of validated versions: 20.10.7. Latest validated version: 18.09
        [WARNING Hostname]: hostname "k8s-test-master-1.fjf" could not be reached
        [WARNING Hostname]: hostname "k8s-test-master-1.fjf": lookup k8s-test-master-1.fjf on 192.168.81.10:53: no such host
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Activating the kubelet service
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [k8s-test-master-1.fjf localhost] and IPs [192.168.83.36 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [k8s-test-master-1.fjf localhost] and IPs [192.168.83.36 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [k8s-test-master-1.fjf kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.k8s-test.fjf] and IPs [172.16.0.1 192.168.83.36 192.168.83.3]
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
[control-plane] Creating static Pod manifest for "kube-scheduler"
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
[apiclient] All control plane components are healthy after 18.005364 seconds
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.15" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Storing the certificates in Secret "kubeadm-certs" in the "kube-system" Namespace
[upload-certs] Using certificate key:
d3123a4998a8715f1c12830d7d54a63aa790fcf3da0cf4b5e7514cd7ffd6e200
[mark-control-plane] Marking the node k8s-test-master-1.fjf as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node k8s-test-master-1.fjf as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[bootstrap-token] Using token: mpzs9m.oec6ixeesemzbxle
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy
 
Your Kubernetes control-plane has initialized successfully!
 
To start using your cluster, you need to run the following as a regular user:
 
  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config
 
You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/
 
You can now join any number of the control-plane node running the following command on each as root:
# Master加入
  kubeadm join 192.168.83.3:6443 --token mpzs9m.oec6ixeesemzbxle \
    --discovery-token-ca-cert-hash sha256:7c05c8001693061902d6f20947fbc60c1b6a12e9ded449e6c59a71e6448fac5d \
    --experimental-control-plane --certificate-key d3123a4998a8715f1c12830d7d54a63aa790fcf3da0cf4b5e7514cd7ffd6e200
 
Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.
 
Then you can join any number of worker nodes by running the following on each as root:
# Worker节点接入
kubeadm join 192.168.83.3:6443 --token mpzs9m.oec6ixeesemzbxle \
    --discovery-token-ca-cert-hash sha256:7c05c8001693061902d6f20947fbc60c1b6a12e9ded449e6c59a71e6448fac5d

[192.168.83.54,192.168.83.49]其他master节点加入集群

# 此命令直接复制上一步输出的结果就可以了，注意区分master节点和worker节点的指令是不同的
kubeadm join 192.168.83.3:6443 --token mpzs9m.oec6ixeesemzbxle \
    --discovery-token-ca-cert-hash sha256:7c05c8001693061902d6f20947fbc60c1b6a12e9ded449e6c59a71e6448fac5d \
    --experimental-control-plane --certificate-key d3123a4998a8715f1c12830d7d54a63aa790fcf3da0cf4b5e7514cd7ffd6e200
# 以下，输出信息
Flag --experimental-control-plane has been deprecated, use --control-plane instead
[preflight] Running pre-flight checks
        [WARNING SystemVerification]: this Docker version is not on the list of validated versions: 20.10.7. Latest validated version: 18.09
        [WARNING Hostname]: hostname "k8s-test-master-2.fjf" could not be reached
        [WARNING Hostname]: hostname "k8s-test-master-2.fjf": lookup k8s-test-master-2.fjf on 192.168.81.10:53: no such host
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[preflight] Running pre-flight checks before initializing the new control plane instance
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'
[download-certs] Downloading the certificates in Secret "kubeadm-certs" in the "kube-system" Namespace
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [k8s-test-master-2.fjf localhost] and IPs [192.168.83.54 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [k8s-test-master-2.fjf localhost] and IPs [192.168.83.54 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [k8s-test-master-2.fjf kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.k8s-test.fjf] and IPs [172.16.0.1 192.168.83.54 192.168.83.3]
[certs] Generating "front-proxy-client" certificate and key
[certs] Valid certificates and keys now exist in "/etc/kubernetes/pki"
[certs] Using the existing "sa" key
[kubeconfig] Generating kubeconfig files
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
[control-plane] Creating static Pod manifest for "kube-scheduler"
[check-etcd] Checking that the etcd cluster is healthy
[kubelet-start] Downloading configuration for the kubelet from the "kubelet-config-1.15" ConfigMap in the kube-system namespace
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Activating the kubelet service
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...
[etcd] Announced new etcd member joining to the existing etcd cluster
[etcd] Wrote Static Pod manifest for a local etcd member to "/etc/kubernetes/manifests/etcd.yaml"
[etcd] Waiting for the new etcd member to join the cluster. This can take up to 40s
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[mark-control-plane] Marking the node k8s-test-master-2.fjf as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node k8s-test-master-2.fjf as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
 
This node has joined the cluster and a new control plane instance was created:
 
* Certificate signing request was sent to apiserver and approval was received.
* The Kubelet was informed of the new secure connection details.
* Control plane (master) label and taint were applied to the new node.
* The Kubernetes control plane instances scaled up.
* A new etcd member was added to the local/stacked etcd cluster.
 
To start administering your cluster from this node, you need to run the following as a regular user:
 
        mkdir -p $HOME/.kube
        sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
        sudo chown $(id -u):$(id -g) $HOME/.kube/config
 
Run 'kubectl get nodes' to see this node join the cluster.

[192.168.83.36,192.168.83.54,192.168.83.49]创建集群配置文件

1
2
3

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

检查集群状态

kubectl get node
NAME                    STATUS     ROLES    AGE     VERSION
k8s-test-master-1.fjf   NotReady   master   7m19s   v1.15.0
k8s-test-master-2.fjf   NotReady   master   112s    v1.15.0
k8s-test-master-3.fjf   NotReady   master   62s     v1.15.0
 
 
kubectl get pod -A
NAMESPACE     NAME                                            READY   STATUS    RESTARTS   AGE
kube-system   coredns-5c98db65d4-6kxg6                        0/1     Pending   0          7m30s  # Pending状态正常，在安装网络组件后即可恢复
kube-system   coredns-5c98db65d4-x6x4b                        0/1     Pending   0          7m30s  # Pending状态正常，在安装网络组件后即可恢复
kube-system   etcd-k8s-test-master-1.fjf                      1/1     Running   0          6m37s
kube-system   etcd-k8s-test-master-2.fjf                      1/1     Running   0          2m22s
kube-system   etcd-k8s-test-master-3.fjf                      1/1     Running   0          93s
kube-system   kube-apiserver-k8s-test-master-1.fjf            1/1     Running   0          6m31s
kube-system   kube-apiserver-k8s-test-master-2.fjf            1/1     Running   0          2m22s
kube-system   kube-apiserver-k8s-test-master-3.fjf            1/1     Running   1          91s
kube-system   kube-controller-manager-k8s-test-master-1.fjf   1/1     Running   1          6m47s
kube-system   kube-controller-manager-k8s-test-master-2.fjf   1/1     Running   0          2m22s
kube-system   kube-controller-manager-k8s-test-master-3.fjf   1/1     Running   0          22s
kube-system   kube-proxy-hrfgq                                1/1     Running   0          2m23s
kube-system   kube-proxy-nlm68                                1/1     Running   0          93s
kube-system   kube-proxy-tt8dg                                1/1     Running   0          7m30s
kube-system   kube-scheduler-k8s-test-master-1.fjf            1/1     Running   1          6m28s
kube-system   kube-scheduler-k8s-test-master-2.fjf            1/1     Running   0          2m22s
kube-system   kube-scheduler-k8s-test-master-3.fjf            1/1     Running   0          21s

查看管理后台，http://192.168.83.3:50101/，账号密码在haproxy配置文件中stats auth字段。所有Master节点状态为UP则为正常，如果不是，检查前面的步骤是否全部完成，并且输出内容一致

部署kubernetes 网络组件

目前主要支持的CNI组件 CNI插件：Flannel、Calico、Weave和Canal(技术上是多个插件的组合)

本次部署，使用Calico组件，可以使用改组件的BGP功能与内网打通Pod和SVC网络

在Kubernetes集群中部署Calico，在任一Master节点执行即可

# 下载calico部署文件
wget https://docs.projectcalico.org/v3.8/manifests/calico.yaml
# 修改CIDR
- name: CALICO_IPV4POOL_CIDR
  value: "172.15.0.0/16"  #修改为Pod的网络
# 部署calico
kubectl apply -f calico.yaml
# 以下为输出
configmap/calico-config created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
clusterrole.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrolebinding.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrole.rbac.authorization.k8s.io/calico-node created
clusterrolebinding.rbac.authorization.k8s.io/calico-node created
daemonset.apps/calico-node created
serviceaccount/calico-node created
deployment.apps/calico-kube-controllers created
serviceaccount/calico-kube-controllers created

等待CNI生效

watch kubectl get pods --all-namespaces
 
 
# 所有Pod状态为Running后即可退出
Every 2.0s: kubectl get pods --all-namespaces                                                                                                                        Mon Jul  5 18:49:49 2021
 
NAMESPACE     NAME                                            READY   STATUS    RESTARTS   AGE         
kube-system   calico-kube-controllers-7fc57b95d4-wsvpm        1/1     Running   0          85s
kube-system   calico-node-7f99k                               0/1     Running   0          85s
kube-system   calico-node-jssb6                               0/1     Running   0          85s
kube-system   calico-node-qgvp9                               1/1     Running   0          85s
kube-system   coredns-5c98db65d4-6kxg6                        1/1     Running   0          44m         
kube-system   coredns-5c98db65d4-x6x4b                        1/1     Running   0          44m         
kube-system   etcd-k8s-test-master-1.fjf                      1/1     Running   0          43m         
kube-system   etcd-k8s-test-master-2.fjf                      1/1     Running   0          39m         
kube-system   etcd-k8s-test-master-3.fjf                      1/1     Running   0          38m         
kube-system   kube-apiserver-k8s-test-master-1.fjf            1/1     Running   0          43m         
kube-system   kube-apiserver-k8s-test-master-2.fjf            1/1     Running   0          39m         
kube-system   kube-apiserver-k8s-test-master-3.fjf            1/1     Running   1          38m         
kube-system   kube-controller-manager-k8s-test-master-1.fjf   1/1     Running   1          44m         
kube-system   kube-controller-manager-k8s-test-master-2.fjf   1/1     Running   0          39m         
kube-system   kube-controller-manager-k8s-test-master-3.fjf   1/1     Running   0          37m         
kube-system   kube-proxy-hrfgq                                1/1     Running   0          39m         
kube-system   kube-proxy-nlm68                                1/1     Running   0          38m         
kube-system   kube-proxy-tt8dg                                1/1     Running   0          44m         
kube-system   kube-scheduler-k8s-test-master-1.fjf            1/1     Running   1          43m         
kube-system   kube-scheduler-k8s-test-master-2.fjf            1/1     Running   0          39m         
kube-system   kube-scheduler-k8s-test-master-3.fjf            1/1     Running   0          37m

查看CoreDNS状态是否恢复

kubectl get pod -A -owide
NAMESPACE     NAME                                            READY   STATUS    RESTARTS   AGE   IP               NODE                    NOMINATED NODE   READINESS GATES
kube-system   calico-kube-controllers-7fc57b95d4-zxc4d        1/1     Running   0          88s   172.15.139.1     k8s-test-master-1.fjf   <none>           <none>
kube-system   calico-node-24j88                               1/1     Running   0          89s   192.168.83.36    k8s-test-master-1.fjf   <none>           <none>
kube-system   calico-node-49vnk                               1/1     Running   0          89s   192.168.83.54    k8s-test-master-2.fjf   <none>           <none>
kube-system   calico-node-vzjk8                               1/1     Running   0          89s   192.168.83.49    k8s-test-master-3.fjf   <none>           <none>
kube-system   coredns-5c98db65d4-frfx7                        1/1     Running   0          16s   172.15.159.129   k8s-test-master-2.fjf   <none>           <none> # 状态已经为Running  
kube-system   coredns-5c98db65d4-tt9w5                        1/1     Running   0          27s   172.15.221.1     k8s-test-master-3.fjf   <none>           <none> # 状态已经为Running  
kube-system   etcd-k8s-test-master-1.fjf                      1/1     Running   0          48m   192.168.83.36    k8s-test-master-1.fjf   <none>           <none>
kube-system   etcd-k8s-test-master-2.fjf                      1/1     Running   0          44m   192.168.83.54    k8s-test-master-2.fjf   <none>           <none>
kube-system   etcd-k8s-test-master-3.fjf                      1/1     Running   0          43m   192.168.83.49    k8s-test-master-3.fjf   <none>           <none>
kube-system   kube-apiserver-k8s-test-master-1.fjf            1/1     Running   0          48m   192.168.83.36    k8s-test-master-1.fjf   <none>           <none>
kube-system   kube-apiserver-k8s-test-master-2.fjf            1/1     Running   0          44m   192.168.83.54    k8s-test-master-2.fjf   <none>           <none>
kube-system   kube-apiserver-k8s-test-master-3.fjf            1/1     Running   1          43m   192.168.83.49    k8s-test-master-3.fjf   <none>           <none>
kube-system   kube-controller-manager-k8s-test-master-1.fjf   1/1     Running   1          48m   192.168.83.36    k8s-test-master-1.fjf   <none>           <none>
kube-system   kube-controller-manager-k8s-test-master-2.fjf   1/1     Running   0          44m   192.168.83.54    k8s-test-master-2.fjf   <none>           <none>
kube-system   kube-controller-manager-k8s-test-master-3.fjf   1/1     Running   0          42m   192.168.83.49    k8s-test-master-3.fjf   <none>           <none>
kube-system   kube-proxy-hrfgq                                1/1     Running   0          44m   192.168.83.54    k8s-test-master-2.fjf   <none>           <none>
kube-system   kube-proxy-nlm68                                1/1     Running   0          43m   192.168.83.49    k8s-test-master-3.fjf   <none>           <none>
kube-system   kube-proxy-tt8dg                                1/1     Running   0          49m   192.168.83.36    k8s-test-master-1.fjf   <none>           <none>
kube-system   kube-scheduler-k8s-test-master-1.fjf            1/1     Running   1          48m   192.168.83.36    k8s-test-master-1.fjf   <none>           <none>
kube-system   kube-scheduler-k8s-test-master-2.fjf            1/1     Running   0          44m   192.168.83.54    k8s-test-master-2.fjf   <none>           <none>
kube-system   kube-scheduler-k8s-test-master-3.fjf            1/1     Running   0          42m   192.168.83.49    k8s-test-master-3.fjf   <none>           <none>

部署kuberntes node

[192.168.83.52,192.168.83.22,192.168.83.37]添加Yum源

# 移除可能存在的组件
yum remove docker docker-common docker-selinux docker-engine
# 安装一些依赖
yum install -y yum-utils device-mapper-persistent-data lvm2
# 配置Docker CE 源
wget -O /etc/yum.repos.d/docker-ce.repo https://download.docker.com/linux/centos/docker-ce.repo
sudo sed -i 's+download.docker.com+mirrors.tuna.tsinghua.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo
 
 
# Kubernetes
cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
 
 
# 重建缓存
yum makecache fast

[192.168.83.52,192.168.83.22,192.168.83.37]安装

1
2
3


yum -y install kubelet-1.23.1 kubeadm-1.23.1 kubectl-1.23.1
yum install -y docker-ce-18.09.9 docker-ce-cli-18.09.9 containerd.io

[192.168.83.52,192.168.83.22,192.168.83.37]添加docker配置

mkdir /etc/docker
cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors": ["https://h3klxkkx.mirror.aliyuncs.com"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
        "max-size": "100m",
        "max-file": "10"
  },
  "oom-score-adjust": -1000,
  "live-restore": true
}
EOF

[192.168.83.52,192.168.83.22,192.168.83.37]启动服务

systemctl start docker kubelet
systemctl enable docker kubelet
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.

[192.168.83.52,192.168.83.22,192.168.83.37]手动下载镜像，加速集群初始化

KUBE_VERSION=v1.15.0
KUBE_PAUSE_VERSION=3.1
  
GCR_URL=k8s.gcr.io
ALIYUN_URL=registry.cn-hangzhou.aliyuncs.com/google_containers
  
images=(kube-proxy:${KUBE_VERSION}
pause:${KUBE_PAUSE_VERSION})
  
  
for imageName in ${images[@]} ; do
  docker pull $ALIYUN_URL/$imageName
  docker tag  $ALIYUN_URL/$imageName $GCR_URL/$imageName
  docker rmi $ALIYUN_URL/$imageName
done

[192.168.83.52,192.168.83.22,192.168.83.37]加入集群

1
2

# 此命令在初始化Master集群时有记录，如果找不到了，可以参考 http://wiki.fjf.com/pages/viewpage.action?pageId=14682096
kubeadm join 192.168.83.2:6443 --token wiqtis.k4g3jm9z94qykiyl     --discovery-token-ca-cert-hash sha256:2771e3f29b2628edac9c5e1433dff5c3275ab870ad14ca7c9e6adaf1eed3179e

在Master节点查看node节点状态

kubectl get node         
NAME                    STATUS   ROLES    AGE   VERSION
k8s-test-master-1.fjf   Ready    master   73m   v1.15.0
k8s-test-master-2.fjf   Ready    master   68m   v1.15.0
k8s-test-master-3.fjf   Ready    master   67m   v1.15.0
k8s-test-node-1.fjf     Ready    <none>   75s   v1.15.0 #状态为Ready即为成功加入集群
k8s-test-node-2.fjf     Ready    <none>   63s   v1.15.0 #状态为Ready即为成功加入集群
k8s-test-node-3.fjf     Ready    <none>   59s   v1.15.0 #状态为Ready即为成功加入集群

使用Calico打通Pod网络

现状集群内pod&node可以通过pod ip直接进行访问，容器访问虚拟机没有问题，但是虚拟机不能访问容器，尤其是通过consul注册的服务，必须打通网络后才可以互相调用

目标打通pod和虚拟机的网络，使虚拟机可以访问pod ip 官方文档：https://docs.projectcalico.org/archive/v3.8/networking/bgp

[Kubernetes Master节点]安装calico控制命令calicoctl

1
2
3

curl -O -L  https://github.com/projectcalico/calicoctl/releases/download/v3.8.9/calicoctl
chmod +x calicoctl
mv calicoctl /usr/bin/calicoctl

[calicoctl安装节点]添加calico配置

mkdir /etc/calico
cat > /etc/calico/calicoctl.cfg <<EOF
apiVersion: projectcalico.org/v3
kind: CalicoAPIConfig
metadata:
spec:
  datastoreType: "kubernetes"
  kubeconfig: "/root/.kube/config"
EOF
 
 
# 测试
calicoctl version
Client Version:    v3.8.9
Git commit:        0991d2fb
Cluster Version:   v3.8.9        # 出现此行代表配置正确
Cluster Type:      k8s,bgp,kdd   # 出现此行代表配置正确

[calicoctl安装节点]配置集群路由反射器，node节点与master节点对等、master节点彼此对等

# 在本环境下将kubernetes master节点作为反射器使用
# 查看节点信息
kubectl get node
NAME                    STATUS   ROLES    AGE     VERSION
k8s-test-master-1.fjf   Ready    master   3d1h    v1.15.0
k8s-test-master-2.fjf   Ready    master   3d1h    v1.15.0
k8s-test-master-3.fjf   Ready    master   3d1h    v1.15.0
k8s-test-node-1.fjf     Ready    <none>   2d23h   v1.15.0
k8s-test-node-2.fjf     Ready    <none>   2d23h   v1.15.0
k8s-test-node-3.fjf     Ready    <none>   2d23h   v1.15.0
 
 
# 导出Master节点配置
calicoctl get node k8s-test-master-1.fjf --export -o yaml > k8s-test-master-1.yml
calicoctl get node k8s-test-master-2.fjf --export -o yaml > k8s-test-master-2.yml
calicoctl get node k8s-test-master-3.fjf --export -o yaml > k8s-test-master-3.yml
 
 
# 在3个Master节点配置中添加以下配置用于标识该节点为反射器
metadata:
  ......
  labels:
    ......
    i-am-a-route-reflector: true
  ......
spec:
  bgp:
    ......
    routeReflectorClusterID: 224.0.0.1
 
 
# 更新节点配置
calicoctl apply -f k8s-test-master-1.yml
calicoctl apply -f k8s-test-master-2.yml
calicoctl apply -f k8s-test-master-3.yml
 
 
# 其他节点与反射器对等
calicoctl apply -f - <<EOF
kind: BGPPeer
apiVersion: projectcalico.org/v3
metadata:
  name: peer-to-rrs
spec:
  nodeSelector: "!has(i-am-a-route-reflector)"
  peerSelector: has(i-am-a-route-reflector)
EOF
 
 
# 反射器彼此对等
calicoctl apply -f - <<EOF
kind: BGPPeer
apiVersion: projectcalico.org/v3
metadata:
  name: rr-mesh
spec:
  nodeSelector: has(i-am-a-route-reflector)
  peerSelector: has(i-am-a-route-reflector)
EOF

[calicoctl安装节点]配置Master节点与核心交换机对等

calicoctl apply -f - <<EOF
apiVersion: projectcalico.org/v3
kind: BGPPeer
metadata:
  name: rr-border
spec:
  nodeSelector: has(i-am-a-route-reflector)
  peerIP: 192.168.83.1
  asNumber: 64512
EOF
# peerIP: 核心交换机IP
# asNumber: 用于和核心交换机对等的ID

[192.168.83.1,设备型号：cisco 3650]配置核心交换与Master(反射器)节点对等，这一步需要在对端BGP设备上操作，这里是用核心交换机

router bgp 64512
bgp router-id 192.168.83.1
neighbor 192.168.83.36 remote-as 64512
neighbor 192.168.83.49 remote-as 64512
neighbor 192.168.83.54 remote-as 64512

查看BGP 对等状态

calicoctl node status
# INFO字段全部为Established 即为正常
Calico process is running.
 
IPv4 BGP status
+---------------+---------------+-------+----------+-------------+
| PEER ADDRESS  |   PEER TYPE   | STATE |  SINCE   |    INFO     |
+---------------+---------------+-------+----------+-------------+
| 192.168.83.1  | node specific | up    | 06:38:55 | Established |
| 192.168.83.54 | node specific | up    | 06:38:55 | Established |
| 192.168.83.22 | node specific | up    | 06:38:55 | Established |
| 192.168.83.37 | node specific | up    | 06:38:55 | Established |
| 192.168.83.49 | node specific | up    | 06:38:55 | Established |
| 192.168.83.52 | node specific | up    | 06:38:55 | Established |
+---------------+---------------+-------+----------+-------------+
 
IPv6 BGP status
No IPv6 peers found.

测试，使用其他网段，如192.168.82.0/24的虚拟机ping 某一个pod ip，能正常通信即代表成功

[dev][root@spring-boot-demo1-192.168.82.85 ~]# ping -c 3 172.15.190.2
PING 172.15.190.2 (172.15.190.2) 56(84) bytes of data.
64 bytes from 172.15.190.2: icmp_seq=1 ttl=62 time=0.677 ms
64 bytes from 172.15.190.2: icmp_seq=2 ttl=62 time=0.543 ms
64 bytes from 172.15.190.2: icmp_seq=3 ttl=62 time=0.549 ms
 
--- 172.15.190.2 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2000ms
rtt min/avg/max/mdev = 0.543/0.589/0.677/0.067 ms
[dev][root@spring-boot-demo1-192.168.82.85 ~]#

使用Calico打通Svc网络

现状一般情况下，Kuberntes集群暴露服务的方式有Ingress、NodePort、HostNetwork，这几种方式用在生产环境下是没有问题的，安全性和稳定性有保障。但是在内部开发环境下，使用起来就有诸多不便，开发希望可以直接访问自己的服务，但是Pod IP又是随机变化的，这个时候我们就可以使用SVC IP 或者SVC Name进行访问

目标打通SVC网络，使开发本地可以通过SVC IP 或 SVC Name访问集群服务官方文档：https://docs.projectcalico.org/archive/v3.8/networking/service-advertisement 注意：前提是已经用BGP打通了Pod网络或已经建立了BGP对等才可以继续进行

[Kubernetes Master]确定SVC网络信息

kubectl cluster-info dump|grep -i  "service-cluster-ip-range"
# 以下为输出
                            "--service-cluster-ip-range=172.16.0.0/16",
                            "--service-cluster-ip-range=172.16.0.0/16",
                            "--service-cluster-ip-range=172.16.0.0/16",

[Kubernetes Master]启用SVC网络广播

kubectl patch ds -n kube-system calico-node --patch \
    '{"spec": {"template": {"spec": {"containers": [{"name": "calico-node", "env": [{"name": "CALICO_ADVERTISE_CLUSTER_IPS", "value": "172.16.0.0/16"}]}]}}}}'
# 以下为输出
daemonset.extensions/calico-node patched

测试，正常情况下启用BGP广播后，3分钟内核心交换即可接收到路由信息

# 找到集群DNS服务进行测试
kubectl get svc kube-dns -n kube-system
NAME       TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)                  AGE
kube-dns   ClusterIP   172.16.0.10   <none>        53/UDP,53/TCP,9153/TCP   3d21h
 
 
# 找一个Pod IP在集群外进行解析测试，如果可以解析到结果说明SVC网络已经打通
[dev][root@spring-boot-demo1-192.168.82.85 ~]# dig -x 172.15.190.2 @172.16.0.10     
 
; <<>> DiG 9.9.4-RedHat-9.9.4-61.el7_5.1 <<>> -x 172.15.190.2 @172.16.0.10
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 23212
;; flags: qr aa rd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
;; WARNING: recursion requested but not available
 
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;2.190.15.172.in-addr.arpa.     IN      PTR
 
;; ANSWER SECTION:
2.190.15.172.in-addr.arpa. 30   IN      PTR     172-15-190-2.ingress-nginx.ingress-nginx.svc.k8s-test.fjf. # 可以正常解析到主机记录
 
;; Query time: 3 msec
;; SERVER: 172.16.0.10#53(172.16.0.10)
;; WHEN: Fri Jul 09 15:26:55 CST 2021
;; MSG SIZE  rcvd: 150

南宫乘风

统一日志格式规范与 Filebeat+Logstash 实践落地

背景

为什么要统一日志格式？

日志格式统一规范

多语言实现示例

日志采集方案设计

宿主机 Filebeat 配置

Kubernetes Pod 内部 Filebeat ConfigMap

Logstash 解析规则设计

实践效果

利用 Nginx 实现灰度环境的 H5 应用发布策略

背景介绍

系统架构概述

核心设计原理

1. 数据库共享策略

2. 流量分流机制

3. 路由判断条件

4.完整Nginx配置

成功案例

后续实践

基于Nginx的微信支付回调跨网络环境解决方案

背景

实现目标

技术架构设计

核心实现

公网Nginx配置（代理 服务端）

网Nginx配置（代理客户端）

业务接入流程

测试方案

关键优势

实施效果

为MySQL社区版实现审计功能：从插件配置到日志监控全解析

背景

为什么MySQL社区版需要审计功能？

技术选型与版本兼容性分析

环境

安装插件

查看插件安装目录

提取mariadb审计插件并放置插件目录

mysql安装server_audit.so插件

增加审计目录授权

开启审计，写入配置文件

检查日志状态

日志格式

审计日志处理系统实现

系统架构设计

Python处理程序核心逻辑

后记

生产环境建议

基于阿里云DashScope API构建智能对话指南

背景

项目背景与技术选型

核心代码实现与优化

基础对话功能实现

流式对话高级实现

结束

Chroma向量检索实战：打造智能客服的“最强大脑”

什么是向量库？

向量库的用途

Chroma 向量库实战

环境准备

客服向量库实战

EmbeddingClient

ChromaClient

日志记录器

完整示例

基本操作示例

1. 插入/更新向量数据

2. 查询相似问题

3. 删除向量数据

实际应用场景

注意事项

Harbor2.0仓库镜像清理策略

背景

目的

方案一 Harbor 镜像自动清理策略

方案二 使用Shell脚本处理

垃圾回收（Garbage Collection）

注意事项

公网Nginx配置（代理服务端）

方案二使用Shell脚本处理

自定义实例自定义实例默默认值认值

Jprofiler使用分析大对象来源

请求处理流程