gitea_admin/k3s
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

首次提交：初始化项目

Browse Source
This commit is contained in:
fei
2026-02-05 00:11:05 +08:00
commit 26eaf8110b
171 changed files with 17105 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
009-基础设施/007-keda/deploy.sh Normal file
View File

@@ -0,0 +1,40 @@
#!/bin/bash
# KEDA 部署脚本
echo "开始部署 KEDA..."
# 设置 KUBECONFIG
export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
# 添加 KEDA Helm 仓库
echo "添加 KEDA Helm 仓库..."
helm repo add kedacore https://kedacore.github.io/charts
helm repo update
# 创建命名空间
echo "创建 keda 命名空间..."
kubectl create namespace keda --dry-run=client -o yaml | kubectl apply -f -
# 安装 KEDA
echo "安装 KEDA..."
helm install keda kedacore/keda \
--namespace keda \
-f values.yaml
# 等待 KEDA 组件就绪
echo "等待 KEDA 组件启动..."
kubectl wait --for=condition=ready pod -l app.kubernetes.io/name=keda-operator -n keda --timeout=300s
# 显示状态
echo ""
echo "KEDA 部署完成！"
kubectl get pods -n keda
kubectl get svc -n keda
echo ""
echo "验证 KEDA CRD："
kubectl get crd | grep keda
echo ""
echo "KEDA 已成功部署到命名空间: keda"

16
009-基础设施/007-keda/http-scale-rule.yaml-这是gemini推荐的.md Normal file
View File

@@ -0,0 +1,16 @@
apiVersion: http.keda.sh/v1alpha1
kind: HTTPScaledObject
metadata:
name: my-web-app-scaler
spec:
host: my-app.example.com # 你的域名
targetPendingRequests: 100
scaleTargetRef:
name: your-deployment-name # 你想缩放到 0 的应用名
kind: Deployment
apiVersion: apps/v1
service: your-service-name
port: 80
replicas:
min: 0 # 核心：无人访问时缩放为 0
max: 10

22
009-基础设施/007-keda/install-http-addon.sh Normal file
View File

@@ -0,0 +1,22 @@
#!/bin/bash
# 安装 KEDA HTTP Add-on
echo "安装 KEDA HTTP Add-on..."
export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
# 安装 HTTP Add-on（使用默认配置）
helm install http-add-on kedacore/keda-add-ons-http \
--namespace keda
echo "等待 HTTP Add-on 组件启动..."
sleep 10
echo ""
echo "HTTP Add-on 部署完成！"
kubectl get pods -n keda | grep http
echo ""
echo "HTTP Add-on 服务："
kubectl get svc -n keda | grep http

458
009-基础设施/007-keda/readme.md Normal file
View File

@@ -0,0 +1,458 @@
# KEDA 自动扩缩容
## 功能说明
KEDA (Kubernetes Event Driven Autoscaling) 为 K3s 集群提供基于事件驱动的自动扩缩容能力。
### 核心功能
- **按需启动/停止服务**：空闲时自动缩容到 0，节省资源
- **基于指标自动扩缩容**：根据实际负载动态调整副本数
- **多种触发器支持**：CPU、内存、Prometheus 指标、数据库连接等
- **与 Prometheus 集成**：利用现有监控数据进行扩缩容决策
## 部署方式
```bash
cd /home/fei/k3s/009-基础设施/007-keda
bash deploy.sh
```
## 已配置的服务
### 1. Navigation 导航服务 ✅
- **最小副本数**: 0（空闲时完全停止）
- **最大副本数**: 10
- **触发条件**:
- HTTP 请求速率 > 10 req/min
- CPU 使用率 > 60%
- **冷却期**: 3 分钟
**配置文件**: `scalers/navigation-scaler.yaml`
### 2. Redis 缓存服务 ⏳
- **最小副本数**: 0（空闲时完全停止）
- **最大副本数**: 5
- **触发条件**:
- 有客户端连接
- CPU 使用率 > 70%
- **冷却期**: 5 分钟
**配置文件**: `scalers/redis-scaler.yaml`
**状态**: 待应用（需要先为 Redis 添加 Prometheus exporter）
### 3. PostgreSQL 数据库 ❌
**不推荐使用 KEDA 扩展 PostgreSQL！**
原因：
- PostgreSQL 是有状态服务，多个副本会导致存储冲突
- 需要配置主从复制才能安全扩展
- 建议使用 PostgreSQL Operator 或 PgBouncer + KEDA
详细说明：`scalers/postgresql-说明.md`
## 应用 ScaledObject
### 部署所有 Scaler
```bash
# 应用 Navigation Scaler
kubectl apply -f scalers/navigation-scaler.yaml
# 应用 Redis Scaler（需要先配置 Redis exporter）
kubectl apply -f scalers/redis-scaler.yaml
# ⚠️ PostgreSQL 不推荐使用 KEDA 扩展
# 详见: scalers/postgresql-说明.md
```
### 查看 ScaledObject 状态
```bash
# 查看所有 ScaledObject
kubectl get scaledobject -A
# 查看详细信息
kubectl describe scaledobject navigation-scaler -n navigation
kubectl describe scaledobject redis-scaler -n redis
kubectl describe scaledobject postgresql-scaler -n postgresql
```
### 查看自动创建的 HPA
```bash
# KEDA 会自动创建 HorizontalPodAutoscaler
kubectl get hpa -A
```
## 支持的触发器类型
### 1. Prometheus 指标
```yaml
triggers:
- type: prometheus
metadata:
serverAddress: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
metricName: custom_metric
query: sum(rate(http_requests_total[1m]))
threshold: "100"
```
### 2. CPU/内存使用率
```yaml
triggers:
- type: cpu
metadata:
type: Utilization
value: "70"
- type: memory
metadata:
type: Utilization
value: "80"
```
### 3. Redis 队列长度
```yaml
triggers:
- type: redis
metadata:
address: redis.redis.svc.cluster.local:6379
listName: mylist
listLength: "5"
```
### 4. PostgreSQL 查询
```yaml
triggers:
- type: postgresql
metadata:
connectionString: postgresql://user:pass@host:5432/db
query: "SELECT COUNT(*) FROM tasks WHERE status='pending'"
targetQueryValue: "10"
```
### 5. Cron 定时触发
```yaml
triggers:
- type: cron
metadata:
timezone: Asia/Shanghai
start: 0 8 * * * # 每天 8:00 扩容
end: 0 18 * * * # 每天 18:00 缩容
desiredReplicas: "3"
```
## 为新服务添加自动扩缩容
### 步骤 1: 确保服务配置正确
服务的 Deployment 必须配置 `resources.requests`：
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: myapp
spec:
# 不要设置 replicas，由 KEDA 管理
template:
spec:
containers:
- name: myapp
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 500m
memory: 512Mi
```
### 步骤 2: 创建 ScaledObject
```yaml
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: myapp-scaler
namespace: myapp
spec:
scaleTargetRef:
name: myapp
minReplicaCount: 0
maxReplicaCount: 10
pollingInterval: 30
cooldownPeriod: 300
triggers:
- type: prometheus
metadata:
serverAddress: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
metricName: myapp_requests
query: sum(rate(http_requests_total{app="myapp"}[1m]))
threshold: "50"
```
### 步骤 3: 应用配置
```bash
kubectl apply -f myapp-scaler.yaml
```
## 监控和调试
### 查看 KEDA 日志
```bash
# Operator 日志
kubectl logs -n keda -l app.kubernetes.io/name=keda-operator -f
# Metrics Server 日志
kubectl logs -n keda -l app.kubernetes.io/name=keda-metrics-apiserver -f
```
### 查看扩缩容事件
```bash
# 查看 HPA 事件
kubectl describe hpa -n <namespace>
# 查看 Pod 事件
kubectl get events -n <namespace> --sort-by='.lastTimestamp'
```
### 在 Prometheus 中查询 KEDA 指标
访问 https://prometheus.u6.net3w.com，查询：
```promql
# KEDA Scaler 活跃状态
keda_scaler_active
# KEDA Scaler 错误
keda_scaler_errors_total
# 当前指标值
keda_scaler_metrics_value
```
### 在 Grafana 中查看 KEDA 仪表板
1. 访问 https://grafana.u6.net3w.com
2. 导入 KEDA 官方仪表板 ID: **14691**
3. 查看实时扩缩容状态
## 测试自动扩缩容
### 测试 Navigation 服务
**测试缩容到 0：**
```bash
# 1. 停止访问导航页面，等待 3 分钟
sleep 180
# 2. 检查副本数
kubectl get deployment navigation -n navigation
# 预期输出：READY 0/0
```
**测试从 0 扩容：**
```bash
# 1. 访问导航页面
curl https://dh.u6.net3w.com
# 2. 监控副本数变化
kubectl get deployment navigation -n navigation -w
# 预期：副本数从 0 变为 1（约 10-30 秒）
```
### 测试 Redis 服务
**测试基于连接数扩容：**
```bash
# 1. 连接 Redis
kubectl run redis-client --rm -it --image=redis:7-alpine -- redis-cli -h redis.redis.svc.cluster.local
# 2. 在另一个终端监控
kubectl get deployment redis -n redis -w
# 预期：有连接时副本数从 0 变为 1
```
### 测试 PostgreSQL 服务
**测试基于连接数扩容：**
```bash
# 1. 创建多个数据库连接
for i in {1..15}; do
kubectl run pg-client-$i --image=postgres:16-alpine --restart=Never -- \
psql -h postgresql-service.postgresql.svc.cluster.local -U postgres -c "SELECT pg_sleep(60);" &
done
# 2. 监控副本数
kubectl get statefulset postgresql -n postgresql -w
# 预期：连接数超过 10 时，副本数从 1 增加到 2
```
## 故障排查
### ScaledObject 未生效
**检查 ScaledObject 状态：**
```bash
kubectl describe scaledobject <name> -n <namespace>
```
**常见问题：**
1. **Deployment 设置了固定 replicas**
- 解决：移除 Deployment 中的 `replicas` 字段
2. **缺少 resources.requests**
- 解决：为容器添加 `resources.requests` 配置
3. **Prometheus 查询错误**
- 解决：在 Prometheus UI 中测试查询语句
### 服务无法缩容到 0
**可能原因：**
1. **仍有活跃连接或请求**
- 检查：查看 Prometheus 指标值
2. **cooldownPeriod 未到**
- 检查：等待冷却期结束
3. **minReplicaCount 设置错误**
- 检查：确认 `minReplicaCount: 0`
### 扩容速度慢
**优化建议：**
1. **减少 pollingInterval**
```yaml
pollingInterval: 15 # 从 30 秒改为 15 秒
```
2. **降低 threshold**
```yaml
threshold: "5" # 降低触发阈值
```
3. **使用多个触发器**
```yaml
triggers:
- type: prometheus
# ...
- type: cpu
# ...
```
## 最佳实践
### 1. 合理设置副本数范围
- **无状态服务**：`minReplicaCount: 0`，节省资源
- **有状态服务**：`minReplicaCount: 1`，保证可用性
- **关键服务**：`minReplicaCount: 2`，保证高可用
### 2. 选择合适的冷却期
- **快速响应服务**：`cooldownPeriod: 60-180`（1-3 分钟）
- **一般服务**：`cooldownPeriod: 300`（5 分钟）
- **数据库服务**：`cooldownPeriod: 600-900`（10-15 分钟）
### 3. 监控扩缩容行为
- 定期查看 Grafana 仪表板
- 设置告警规则
- 分析扩缩容历史
### 4. 测试冷启动时间
- 测量从 0 扩容到可用的时间
- 优化镜像大小和启动脚本
- 考虑使用 `minReplicaCount: 1` 避免冷启动
## 配置参考
### ScaledObject 完整配置示例
```yaml
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: example-scaler
namespace: example
spec:
scaleTargetRef:
name: example-deployment
kind: Deployment # 可选：Deployment, StatefulSet
apiVersion: apps/v1 # 可选
minReplicaCount: 0 # 最小副本数
maxReplicaCount: 10 # 最大副本数
pollingInterval: 30 # 轮询间隔（秒）
cooldownPeriod: 300 # 缩容冷却期（秒）
idleReplicaCount: 0 # 空闲时的副本数
fallback: # 故障回退配置
failureThreshold: 3
replicas: 2
advanced: # 高级配置
restoreToOriginalReplicaCount: false
horizontalPodAutoscalerConfig:
behavior:
scaleDown:
stabilizationWindowSeconds: 300
policies:
- type: Percent
value: 50
periodSeconds: 60
triggers:
- type: prometheus
metadata:
serverAddress: http://prometheus:9090
metricName: custom_metric
query: sum(rate(metric[1m]))
threshold: "100"
```
## 卸载 KEDA
```bash
# 删除所有 ScaledObject
kubectl delete scaledobject --all -A
# 卸载 KEDA
helm uninstall keda -n keda
# 删除命名空间
kubectl delete namespace keda
```
## 参考资源
- KEDA 官方文档: https://keda.sh/docs/
- KEDA Scalers: https://keda.sh/docs/scalers/
- KEDA GitHub: https://github.com/kedacore/keda
- Grafana 仪表板: https://grafana.com/grafana/dashboards/14691
---
**KEDA 让您的 K3s 集群更智能、更高效！** 🚀

380
009-基础设施/007-keda/scalers/KEDA-自动缩容到0-配置指南.md Normal file
View File

@@ -0,0 +1,380 @@
# KEDA HTTP Add-on 自动缩容到 0 配置指南
本指南说明如何使用 KEDA HTTP Add-on 实现应用在无流量时自动缩容到 0，有访问时自动启动。
## 前提条件
1. K3s 集群已安装
2. KEDA 已安装
3. KEDA HTTP Add-on 已安装
4. Traefik 作为 Ingress Controller
### 检查 KEDA HTTP Add-on 是否已安装
```bash
kubectl get pods -n keda | grep http
```
应该看到类似输出：
```
keda-add-ons-http-controller-manager-xxx 1/1 Running
keda-add-ons-http-external-scaler-xxx 1/1 Running
keda-add-ons-http-interceptor-xxx 1/1 Running
```
### 如果未安装，执行以下命令安装
```bash
helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install http-add-on kedacore/keda-add-ons-http --namespace keda
```
## 配置步骤
### 1. 准备应用的基础资源
确保你的应用已经有以下资源：
- Deployment
- Service
- Namespace
示例：
```yaml
apiVersion: v1
kind: Namespace
metadata:
name: myapp
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: myapp
namespace: myapp
spec:
replicas: 1
selector:
matchLabels:
app: myapp
template:
metadata:
labels:
app: myapp
spec:
containers:
- name: myapp
image: your-image:tag
ports:
- containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: myapp
namespace: myapp
spec:
selector:
app: myapp
ports:
- port: 80
targetPort: 80
```
### 2. 创建 HTTPScaledObject
这是实现自动缩容到 0 的核心配置。
```yaml
apiVersion: http.keda.sh/v1alpha1
kind: HTTPScaledObject
metadata:
name: myapp-http-scaler
namespace: myapp # 必须与应用在同一个 namespace
spec:
hosts:
- myapp.example.com # 你的域名
pathPrefixes:
- / # 匹配的路径前缀
scaleTargetRef:
name: myapp # Deployment 名称
kind: Deployment
apiVersion: apps/v1
service: myapp # Service 名称
port: 80 # Service 端口
replicas:
min: 0 # 空闲时缩容到 0
max: 10 # 最多扩容到 10 个副本
scalingMetric:
requestRate:
granularity: 1s
targetValue: 100 # 每秒 100 个请求时扩容
window: 1m
scaledownPeriod: 300 # 5 分钟（300秒）无流量后缩容到 0
```
**重要参数说明：**
- `hosts`: 你的应用域名
- `scaleTargetRef.name`: 你的 Deployment 名称
- `scaleTargetRef.service`: 你的 Service 名称
- `scaleTargetRef.port`: 你的 Service 端口
- `replicas.min: 0`: 允许缩容到 0
- `scaledownPeriod`: 无流量后多久缩容（秒）
### 3. 创建 Traefik IngressRoute
**重要：IngressRoute 必须在 keda namespace 中创建**，因为它需要引用 keda namespace 的拦截器服务。
```yaml
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: myapp-ingress
namespace: keda # 注意：必须在 keda namespace
spec:
entryPoints:
- web # HTTP 入口
# - websecure # 如果需要 HTTPS，添加这个
routes:
- match: Host(`myapp.example.com`) # 你的域名
kind: Rule
services:
- name: keda-add-ons-http-interceptor-proxy
port: 8080
```
**如果需要 HTTPS，添加 TLS 配置：**
```yaml
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: myapp-ingress
namespace: keda
spec:
entryPoints:
- websecure
routes:
- match: Host(`myapp.example.com`)
kind: Rule
services:
- name: keda-add-ons-http-interceptor-proxy
port: 8080
tls:
certResolver: letsencrypt # 你的证书解析器
```
### 4. 完整配置文件模板
将以下内容保存为 `myapp-keda-scaler.yaml`，并根据你的应用修改相应的值：
```yaml
---
# HTTPScaledObject - 实现自动缩容到 0
apiVersion: http.keda.sh/v1alpha1
kind: HTTPScaledObject
metadata:
name: myapp-http-scaler
namespace: myapp # 改为你的 namespace
spec:
hosts:
- myapp.example.com # 改为你的域名
pathPrefixes:
- /
scaleTargetRef:
name: myapp # 改为你的 Deployment 名称
kind: Deployment
apiVersion: apps/v1
service: myapp # 改为你的 Service 名称
port: 80 # 改为你的 Service 端口
replicas:
min: 0
max: 10
scalingMetric:
requestRate:
granularity: 1s
targetValue: 100
window: 1m
scaledownPeriod: 300 # 5 分钟无流量后缩容
---
# Traefik IngressRoute - 路由流量到 KEDA 拦截器
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: myapp-ingress
namespace: keda # 必须在 keda namespace
spec:
entryPoints:
- web
routes:
- match: Host(`myapp.example.com`) # 改为你的域名
kind: Rule
services:
- name: keda-add-ons-http-interceptor-proxy
port: 8080
```
### 5. 应用配置
```bash
kubectl apply -f myapp-keda-scaler.yaml
```
### 6. 验证配置
```bash
# 查看 HTTPScaledObject 状态
kubectl get httpscaledobject -n myapp
# 应该看到 READY = True
# NAME TARGETWORKLOAD TARGETSERVICE MINREPLICAS MAXREPLICAS AGE READY
# myapp-http-scaler apps/v1/Deployment/myapp myapp:80 0 10 10s True
# 查看 IngressRoute
kubectl get ingressroute -n keda
# 查看当前 Pod 数量
kubectl get pods -n myapp
```
## 工作原理
1. **有流量时**：
- 用户访问 `myapp.example.com`
- Traefik 将流量路由到 KEDA HTTP 拦截器
- 拦截器检测到请求，通知 KEDA 启动 Pod
- Pod 启动后（5-10秒），拦截器将流量转发到应用
- 用户看到正常响应（首次访问可能有延迟）
2. **无流量时**：
- 5 分钟（scaledownPeriod）无请求后
- KEDA 自动将 Deployment 缩容到 0
- 不消耗任何计算资源
## 常见问题排查
### 1. 访问返回 404
**检查 IngressRoute 是否在 keda namespace：**
```bash
kubectl get ingressroute -n keda | grep myapp
```
如果不在，删除并重新创建：
```bash
kubectl delete ingressroute myapp-ingress -n myapp # 删除错误的
kubectl apply -f myapp-keda-scaler.yaml # 重新创建
```
### 2. HTTPScaledObject READY = False
**查看详细错误信息：**
```bash
kubectl describe httpscaledobject myapp-http-scaler -n myapp
```
**常见错误：**
- `workload already managed by ScaledObject`: 删除旧的 ScaledObject
```bash
kubectl delete scaledobject myapp-scaler -n myapp
```
### 3. Pod 没有自动缩容到 0
**检查是否有旧的 ScaledObject 阻止缩容：**
```bash
kubectl get scaledobject -n myapp
```
如果有，删除它：
```bash
kubectl delete scaledobject <name> -n myapp
```
### 4. 查看 KEDA 拦截器日志
```bash
kubectl logs -n keda -l app.kubernetes.io/name=keda-add-ons-http-interceptor --tail=50
```
### 5. 测试拦截器是否工作
```bash
# 获取拦截器服务 IP
kubectl get svc keda-add-ons-http-interceptor-proxy -n keda
# 直接测试拦截器
curl -H "Host: myapp.example.com" http://<CLUSTER-IP>:8080
```
## 调优建议
### 调整缩容时间
根据你的应用特点调整 `scaledownPeriod`：
- **频繁访问的应用**：设置较长时间（如 600 秒 = 10 分钟）
- **偶尔访问的应用**：设置较短时间（如 180 秒 = 3 分钟）
- **演示/测试环境**：可以设置很短（如 60 秒 = 1 分钟）
```yaml
scaledownPeriod: 600 # 10 分钟
```
### 调整扩容阈值
根据应用负载调整 `targetValue`：
```yaml
scalingMetric:
requestRate:
targetValue: 50 # 每秒 50 个请求时扩容（更敏感）
```
### 调整最大副本数
```yaml
replicas:
min: 0
max: 20 # 根据你的资源和需求调整
```
## 监控和观察
### 实时监控 Pod 变化
```bash
watch -n 2 'kubectl get pods -n myapp'
```
### 查看 HTTPScaledObject 事件
```bash
kubectl describe httpscaledobject myapp-http-scaler -n myapp
```
### 查看 Deployment 副本数变化
```bash
kubectl get deployment myapp -n myapp -w
```
## 完整示例：navigation 应用
参考 `navigation-complete.yaml` 文件，这是一个完整的工作示例。
## 注意事项
1. **首次访问延迟**：Pod 从 0 启动需要 5-10 秒，用户首次访问会有延迟
2. **数据库连接**：确保应用能够快速重新建立数据库连接
3. **会话状态**：不要在 Pod 中存储会话状态，使用 Redis 等外部存储
4. **健康检查**：配置合理的 readinessProbe，确保 Pod 就绪后才接收流量
5. **资源限制**：设置合理的 resources limits，避免启动过慢
## 参考资源
- KEDA 官方文档: https://keda.sh/
- KEDA HTTP Add-on: https://github.com/kedacore/http-add-on
- Traefik IngressRoute: https://doc.traefik.io/traefik/routing/providers/kubernetes-crd/

45
009-基础设施/007-keda/scalers/navigation-complete.yaml Normal file
View File

@@ -0,0 +1,45 @@
---
# HTTPScaledObject - 用于实现缩容到 0 的核心配置
apiVersion: http.keda.sh/v1alpha1
kind: HTTPScaledObject
metadata:
name: navigation-http-scaler
namespace: navigation
spec:
hosts:
- dh.u6.net3w.com
pathPrefixes:
- /
scaleTargetRef:
name: navigation
kind: Deployment
apiVersion: apps/v1
service: navigation
port: 80
replicas:
min: 0 # 空闲时缩容到 0
max: 10 # 最多 10 个副本
scalingMetric:
requestRate:
granularity: 1s
targetValue: 100 # 每秒 100 个请求时扩容
window: 1m
scaledownPeriod: 300 # 5 分钟无流量后缩容到 0
---
# Traefik IngressRoute - 将流量路由到 KEDA HTTP Add-on 的拦截器
# 注意：必须在 keda namespace 中才能引用该 namespace 的服务
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
name: navigation-ingress
namespace: keda
spec:
entryPoints:
- web
routes:
- match: Host(`dh.u6.net3w.com`)
kind: Rule
services:
- name: keda-add-ons-http-interceptor-proxy
port: 8080

24
009-基础设施/007-keda/scalers/navigation-http-scaler.yaml Normal file
View File

@@ -0,0 +1,24 @@
apiVersion: http.keda.sh/v1alpha1
kind: HTTPScaledObject
metadata:
name: navigation-http-scaler
namespace: navigation
spec:
hosts:
- dh.u6.net3w.com
pathPrefixes:
- /
scaleTargetRef:
name: navigation
kind: Deployment
apiVersion: apps/v1
service: navigation
port: 80
replicas:
min: 0 # 空闲时缩容到 0
max: 10 # 最多 10 个副本
scalingMetric:
requestRate:
granularity: 1s
targetValue: 100 # 每秒 100 个请求时扩容
window: 1m

19
009-基础设施/007-keda/scalers/navigation-ingress-http.yaml Normal file
View File

@@ -0,0 +1,19 @@
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: navigation-ingress
namespace: navigation
annotations:
traefik.ingress.kubernetes.io/router.entrypoints: web
spec:
rules:
- host: dh.u6.net3w.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: keda-add-ons-http-interceptor-proxy
port:
number: 8080

23
009-基础设施/007-keda/scalers/navigation-scaler.yaml Normal file
View File

@@ -0,0 +1,23 @@
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: navigation-scaler
namespace: navigation
spec:
scaleTargetRef:
name: navigation
minReplicaCount: 1 # 至少保持 1 个副本（HPA 限制）
maxReplicaCount: 10 # 最多 10 个副本
pollingInterval: 15 # 每 15 秒检查一次
cooldownPeriod: 180 # 缩容冷却期 3 分钟
triggers:
- type: prometheus
metadata:
serverAddress: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
metricName: nginx_http_requests_total
query: sum(rate(nginx_http_requests_total{namespace="navigation"}[1m]))
threshold: "10" # 每分钟超过 10 个请求时启动
- type: cpu
metricType: Utilization
metadata:
value: "60" # CPU 使用率超过 60% 时扩容

261
009-基础设施/007-keda/scalers/postgresql-说明.md Normal file
View File

@@ -0,0 +1,261 @@
# ⚠️ PostgreSQL 不适合使用 KEDA 自动扩缩容
## 问题说明
对于传统的 PostgreSQL 架构，直接通过 KEDA 增加副本数会导致：
### 1. 存储冲突
- 多个 Pod 尝试挂载同一个 PVC
- ReadWriteOnce 存储只能被一个 Pod 使用
- 会导致 Pod 启动失败
### 2. 数据损坏风险
- 如果使用 ReadWriteMany 存储，多个实例同时写入会导致数据损坏
- PostgreSQL 不支持多主写入
- 没有锁机制保护数据一致性
### 3. 缺少主从复制
- 需要配置 PostgreSQL 流复制（Streaming Replication）
- 需要配置主从切换机制
- 需要使用专门的 PostgreSQL Operator
## 正确的 PostgreSQL 扩展方案
### 方案 1: 使用 PostgreSQL Operator
推荐使用专业的 PostgreSQL Operator：
#### Zalando PostgreSQL Operator
```bash
# 添加 Helm 仓库
helm repo add postgres-operator-charts https://opensource.zalando.com/postgres-operator/charts/postgres-operator
# 安装 Operator
helm install postgres-operator postgres-operator-charts/postgres-operator
# 创建 PostgreSQL 集群
apiVersion: "acid.zalan.do/v1"
kind: postgresql
metadata:
name: acid-minimal-cluster
spec:
teamId: "acid"
volume:
size: 10Gi
storageClass: longhorn
numberOfInstances: 3 # 1 主 + 2 从
users:
zalando:
- superuser
- createdb
databases:
foo: zalando
postgresql:
version: "16"
```
#### CloudNativePG Operator
```bash
# 安装 CloudNativePG
kubectl apply -f https://raw.githubusercontent.com/cloudnative-pg/cloudnative-pg/release-1.22/releases/cnpg-1.22.0.yaml
# 创建集群
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
name: cluster-example
spec:
instances: 3
storage:
storageClass: longhorn
size: 10Gi
```
### 方案 2: 读写分离 + KEDA
如果需要使用 KEDA，正确的架构是：
```
┌─────────────────┐
│ 主库 (Master) │ ← 固定 1 个副本，处理写入
│ StatefulSet │
└─────────────────┘
│
│ 流复制
↓
┌─────────────────┐
│ 从库 (Replica) │ ← KEDA 管理，处理只读查询
│ Deployment │ 可以 0-N 个副本
└─────────────────┘
```
**配置示例：**
```yaml
# 主库 - 固定副本
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: postgresql-master
spec:
replicas: 1 # 固定 1 个
# ... 配置主库
---
# 从库 - KEDA 管理
apiVersion: apps/v1
kind: Deployment
metadata:
name: postgresql-replica
spec:
# replicas 由 KEDA 管理
# ... 配置从库（只读）
---
# KEDA ScaledObject - 只扩展从库
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: postgresql-replica-scaler
spec:
scaleTargetRef:
name: postgresql-replica # 只针对从库
minReplicaCount: 0
maxReplicaCount: 5
triggers:
- type: postgresql
metadata:
connectionString: postgresql://user:pass@postgresql-master:5432/db
query: "SELECT COUNT(*) FROM pg_stat_activity WHERE state = 'active' AND query NOT LIKE '%pg_stat_activity%'"
targetQueryValue: "10"
```
### 方案 3: 垂直扩展（推荐用于单实例）
对于单实例 PostgreSQL，使用 VPA (Vertical Pod Autoscaler) 更合适：
```yaml
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
name: postgresql-vpa
spec:
targetRef:
apiVersion: "apps/v1"
kind: StatefulSet
name: postgresql
updatePolicy:
updateMode: "Auto"
resourcePolicy:
containerPolicies:
- containerName: postgresql
minAllowed:
cpu: 250m
memory: 512Mi
maxAllowed:
cpu: 2000m
memory: 4Gi
```
## 当前部署建议
对于您当前的 PostgreSQL 部署（`/home/fei/k3s/010-中间件/002-postgresql/`）：
### ❌ 不要使用 KEDA 水平扩展
- 当前是单实例 StatefulSet
- 没有配置主从复制
- 直接扩展会导致数据问题
### ✅ 推荐的优化方案
1. **保持单实例运行**
```yaml
replicas: 1 # 固定不变
```
2. **优化资源配置**
```yaml
resources:
requests:
cpu: 500m
memory: 1Gi
limits:
cpu: 2000m
memory: 4Gi
```
3. **配置连接池**
- 使用 PgBouncer 作为连接池
- PgBouncer 可以使用 KEDA 扩展
4. **定期备份**
- 使用 Longhorn 快照
- 备份到 S3
## PgBouncer + KEDA 方案
这是最实用的方案：PostgreSQL 保持单实例，PgBouncer 使用 KEDA 扩展。
```yaml
# PostgreSQL - 固定单实例
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: postgresql
spec:
replicas: 1 # 固定
# ...
---
# PgBouncer - 连接池
apiVersion: apps/v1
kind: Deployment
metadata:
name: pgbouncer
spec:
# replicas 由 KEDA 管理
template:
spec:
containers:
- name: pgbouncer
image: pgbouncer/pgbouncer:latest
# ...
---
# KEDA ScaledObject - 扩展 PgBouncer
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: pgbouncer-scaler
spec:
scaleTargetRef:
name: pgbouncer
minReplicaCount: 1
maxReplicaCount: 10
triggers:
- type: postgresql
metadata:
connectionString: postgresql://postgres:postgres123@postgresql:5432/postgres
query: "SELECT COUNT(*) FROM pg_stat_activity WHERE state = 'active'"
targetQueryValue: "20"
```
## 总结
| 方案 | 适用场景 | 复杂度 | 推荐度 |
|------|---------|--------|--------|
| PostgreSQL Operator | 生产环境，需要高可用 | 高 | ⭐⭐⭐⭐⭐ |
| 读写分离 + KEDA | 读多写少场景 | 中 | ⭐⭐⭐⭐ |
| PgBouncer + KEDA | 连接数波动大 | 低 | ⭐⭐⭐⭐⭐ |
| VPA 垂直扩展 | 单实例，资源需求变化 | 低 | ⭐⭐⭐ |
| 直接 KEDA 扩展 | ❌ 不适用 | - | ❌ |
**对于当前部署，建议保持 PostgreSQL 单实例运行，不使用 KEDA 扩展。**
如果需要扩展能力，优先考虑：
1. 部署 PgBouncer 连接池 + KEDA
2. 或者迁移到 PostgreSQL Operator
---
**重要提醒：有状态服务的扩展需要特殊处理，不能简单地增加副本数！** ⚠️

23
009-基础设施/007-keda/scalers/redis-scaler.yaml Normal file
View File

@@ -0,0 +1,23 @@
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: redis-scaler
namespace: redis
spec:
scaleTargetRef:
name: redis
minReplicaCount: 0 # 空闲时缩容到 0
maxReplicaCount: 5 # 最多 5 个副本
pollingInterval: 30 # 每 30 秒检查一次
cooldownPeriod: 300 # 缩容冷却期 5 分钟
triggers:
- type: prometheus
metadata:
serverAddress: http://kube-prometheus-stack-prometheus.monitoring.svc.cluster.local:9090
metricName: redis_connected_clients
query: sum(redis_connected_clients{namespace="redis"})
threshold: "1" # 有连接时启动
- type: cpu
metricType: Utilization
metadata:
value: "70" # CPU 使用率超过 70% 时扩容

41
009-基础设施/007-keda/values.yaml Normal file
View File

@@ -0,0 +1,41 @@
# KEDA Helm 配置
# Operator 配置
operator:
replicaCount: 1
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 500m
memory: 512Mi
# Metrics Server 配置
metricsServer:
replicaCount: 1
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 500m
memory: 512Mi
# 与 Prometheus 集成
prometheus:
metricServer:
enabled: true
port: 9022
path: /metrics
operator:
enabled: true
port: 8080
path: /metrics
# ServiceMonitor 用于 Prometheus 抓取
serviceMonitor:
enabled: true
namespace: keda
additionalLabels:
release: kube-prometheus-stack

197
009-基础设施/007-keda/最终总结.md Normal file
View File

@@ -0,0 +1,197 @@
# KEDA 部署最终总结
## ✅ 成功部署
### KEDA 核心组件
- **keda-operator**: ✅ 运行中
- **keda-metrics-apiserver**: ✅ 运行中
- **keda-admission-webhooks**: ✅ 运行中
- **命名空间**: keda
### 已配置的服务
| 服务 | 状态 | 最小副本 | 最大副本 | 说明 |
|------|------|---------|---------|------|
| Navigation | ✅ 已应用 | 0 | 10 | 空闲时自动缩容到 0 |
| Redis | ⏳ 待应用 | 0 | 5 | 需要先配置 Prometheus exporter |
| PostgreSQL | ❌ 不适用 | - | - | 有状态服务，不能直接扩展 |
## ⚠️ 重要修正：PostgreSQL
### 问题说明
PostgreSQL 是有状态服务，**不能**直接使用 KEDA 扩展副本数，原因：
1. **存储冲突**: 多个 Pod 尝试挂载同一个 PVC 会失败
2. **数据损坏**: 如果使用 ReadWriteMany，多实例写入会导致数据损坏
3. **缺少复制**: 没有配置主从复制，无法保证数据一致性
### 正确方案
已创建详细说明文档：`/home/fei/k3s/009-基础设施/007-keda/scalers/postgresql-说明.md`
推荐方案：
1. **PostgreSQL Operator** (Zalando 或 CloudNativePG)
2. **PgBouncer + KEDA** (扩展连接池而非数据库)
3. **读写分离** (主库固定，从库使用 KEDA)
## 📁 文件结构
```
/home/fei/k3s/009-基础设施/007-keda/
├── deploy.sh # ✅ 部署脚本
├── values.yaml # ✅ KEDA Helm 配置
├── readme.md # ✅ 详细使用文档
├── 部署总结.md # ✅ 部署总结
└── scalers/
├── navigation-scaler.yaml # ✅ 已应用
├── redis-scaler.yaml # ⏳ 待应用
└── postgresql-说明.md # ⚠️ 重要说明
```
## 🧪 验证结果
### Navigation 服务自动扩缩容
```bash
# 当前状态
$ kubectl get deployment navigation -n navigation
NAME READY UP-TO-DATE AVAILABLE AGE
navigation 0/0 0 0 8h
# ScaledObject 状态
$ kubectl get scaledobject -n navigation
NAME READY ACTIVE TRIGGERS AGE
navigation-scaler True False prometheus,cpu 5m
# HPA 已自动创建
$ kubectl get hpa -n navigation
NAME REFERENCE MINPODS MAXPODS REPLICAS
keda-hpa-navigation-scaler Deployment/navigation 1 10 0
```
### 测试从 0 扩容
```bash
# 访问导航页面
curl https://dh.u6.net3w.com
# 观察副本数变化（10-30秒）
kubectl get deployment navigation -n navigation -w
# 预期: 0/0 → 1/1
```
## 📊 资源节省预期
| 服务 | 之前 | 现在 | 节省 |
|------|------|------|------|
| Navigation | 24/7 运行 | 按需启动 | 80-90% |
| Redis | 24/7 运行 | 按需启动 | 70-80% (配置后) |
| PostgreSQL | 24/7 运行 | 保持运行 | 不适用 |
## 🔧 已修复的问题
### 1. CPU 触发器配置错误
**问题**: 使用了已弃用的 `type` 字段
```yaml
# ❌ 错误
- type: cpu
metadata:
type: Utilization
value: "60"
```
**修复**: 改为 `metricType`
```yaml
# ✅ 正确
- type: cpu
metricType: Utilization
metadata:
value: "60"
```
### 2. Navigation 缺少资源配置
**修复**: 添加了 resources 配置
```yaml
resources:
requests:
cpu: 50m
memory: 64Mi
limits:
cpu: 200m
memory: 128Mi
```
### 3. PostgreSQL 配置错误
**修复**:
- 删除了 `postgresql-scaler.yaml`
- 创建了 `postgresql-说明.md` 详细说明
- 更新了所有文档，明确标注不适用
## 📚 文档
- **使用指南**: `/home/fei/k3s/009-基础设施/007-keda/readme.md`
- **部署总结**: `/home/fei/k3s/009-基础设施/007-keda/部署总结.md`
- **PostgreSQL 说明**: `/home/fei/k3s/009-基础设施/007-keda/scalers/postgresql-说明.md`
## 🎯 下一步建议
期（1周内）
1. ✅ 监控 Navigation 服务的扩缩容行为
2. ⏳ 为 Redis 配置 Prometheus exporter
3. ⏳ 应用 Redis ScaledObject
### 中期（1-2周）
1. ⏳ 在 Grafana 中导入 KEDA 仪表板 (ID: 14691)
2. ⏳ 根据实际使用情况调整触发阈值
3. ⏳ 为其他无状态服务配置 KEDA
### 长期（1个月+）
1. ⏳ 评估是否需要 PostgreSQL 高可用
2. ⏳ 如需要，部署 PostgreSQL Operator
3. ⏳ 或部署 PgBouncer 连接池 + KEDA
## ⚡ 快速命令
```bash
# 查看 KEDA 状态
kubectl get pods -n keda
# 查看所有 ScaledObject
kubectl get scaledobject -A
# 查看 HPA
kubectl get hpa -A
# 查看 Navigation 副本数
kubectl get deployment navigation -n navigation -w
# 测试扩容
curl https://dh.u6.net3w.com
# 查看 KEDA 日志
kubectl logs -n keda -l app.kubernetes.io/name=keda-operator -f
```
## 🎉 总结
✅ **KEDA 已成功部署并运行**
- Navigation 服务实现按需启动，空闲时自动缩容到 0
- 修复了所有配置问题
- 明确了有状态服务（PostgreSQL）的正确处理方式
- 提供了完整的文档和使用指南
⚠️ **重要提醒**
- 有状态服务不能简单地增加副本数
- PostgreSQL 需要使用专业的 Operator 或连接池方案
- 定期监控扩缩容行为，根据实际情况调整配置
---
**KEDA 让您的 K3s 集群更智能、更节省资源！** 🚀

260
009-基础设施/007-keda/部署总结.md Normal file
View File

@@ -0,0 +1,260 @@
# KEDA 自动扩缩容部署总结
部署时间: 2026-01-30
## ✅ 部署完成
### KEDA 核心组件
| 组件 | 状态 | 说明 |
|------|------|------|
| keda-operator | ✅ Running | KEDA 核心控制器 |
| keda-metrics-apiserver | ✅ Running | 指标 API 服务器 |
| keda-admission-webhooks | ✅ Running | 准入 Webhook |
**命名空间**: `keda`
### 已配置的自动扩缩容服务
#### 1. Navigation 导航服务 ✅
- **状态**: 已配置并运行
- **当前副本数**: 0（空闲状态）
- **配置**:
- 最小副本: 0
- 最大副本: 10
- 触发器: Prometheus (HTTP 请求) + CPU 使用率
- 冷却期: 3 分钟
**ScaledObject**: `navigation-scaler`
**HPA**: `keda-hpa-navigation-scaler`
#### 2. Redis 缓存服务 ⏳
- **状态**: 配置文件已创建，待应用
- **说明**: 需要先为 Redis 配置 Prometheus exporter
- **配置文件**: `scalers/redis-scaler.yaml`
#### 3. PostgreSQL 数据库 ❌
- **状态**: 不推荐使用 KEDA 扩展
- **原因**:
- PostgreSQL 是有状态服务，多副本会导致存储冲突
- 需要配置主从复制才能安全扩展
- 建议使用 PostgreSQL Operator 或 PgBouncer + KEDA
- **详细说明**: `scalers/postgresql-说明.md`
## 配置文件位置
```
/home/fei/k3s/009-基础设施/007-keda/
├── deploy.sh # 部署脚本
├── values.yaml # KEDA Helm 配置
├── readme.md # 详细文档
├── 部署总结.md # 本文档
└── scalers/ # ScaledObject 配置
├── navigation-scaler.yaml # ✅ 已应用
├── redis-scaler.yaml # ⏳ 待应用
└── postgresql-说明.md # ⚠️ PostgreSQL 不适合 KEDA
```
## 验证 KEDA 功能
### 测试缩容到 0
Navigation 服务已经自动缩容到 0：
```bash
kubectl get deployment navigation -n navigation
# 输出: READY 0/0
```
### 测试从 0 扩容
访问导航页面触发扩容：
```bash
# 1. 访问页面
curl https://dh.u6.net3w.com
# 2. 观察副本数变化
kubectl get deployment navigation -n navigation -w
# 预期: 10-30 秒内副本数从 0 变为 1
```
## 查看 KEDA 状态
### 查看所有 ScaledObject
```bash
kubectl get scaledobject -A
```
### 查看 HPA（自动创建）
```bash
kubectl get hpa -A
```
### 查看 KEDA 日志
```bash
kubectl logs -n keda -l app.kubernetes.io/name=keda-operator -f
```
## 下一步操作
### 1. 应用 Redis 自动扩缩容
```bash
# 首先需要为 Redis 添加 Prometheus exporter
# 然后应用 ScaledObject
kubectl apply -f /home/fei/k3s/009-基础设施/007-keda/scalers/redis-scaler.yaml
```
### 2. PostgreSQL 扩展方案
**不要使用 KEDA 直接扩展 PostgreSQL！**
推荐方案：
- **方案 1**: 使用 PostgreSQL Operator（Zalando 或 CloudNativePG）
- **方案 2**: 部署 PgBouncer 连接池 + KEDA 扩展 PgBouncer
- **方案 3**: 配置读写分离，只对只读副本使用 KEDA
详细说明：`/home/fei/k3s/009-基础设施/007-keda/scalers/postgresql-说明.md`
### 3. 监控扩缩容行为
在 Grafana 中导入 KEDA 仪表板：
- 访问: https://grafana.u6.net3w.com
- 导入仪表板 ID: **14691**
## 已修复的问题
### 问题 1: CPU 触发器配置错误
**错误信息**:
```
The 'type' setting is DEPRECATED and is removed in v2.18 - Use 'metricType' instead.
```
**解决方案**:
将 CPU 触发器配置从：
```yaml
- type: cpu
metadata:
type: Utilization
value: "60"
```
改为：
```yaml
- type: cpu
metricType: Utilization
metadata:
value: "60"
```
### 问题 2: Navigation 缺少资源配置
**解决方案**:
为 Navigation deployment 添加了 resources 配置：
```yaml
resources:
requests:
cpu: 50m
memory: 64Mi
limits:
cpu: 200m
memory: 128Mi
```
## 资源节省效果
### Navigation 服务
- **之前**: 24/7 运行 1 个副本
- **现在**: 空闲时 0 个副本，有流量时自动启动
- **预计节省**: 80-90% 资源（假设大部分时间空闲）
### 预期总体效果
- **Navigation**: 节省 80-90% 资源 ✅
- **Redis**: 节省 70-80% 资源（配置后）⏳
- **PostgreSQL**: ❌ 不使用 KEDA，保持单实例运行
## 监控指标
### Prometheus 查询
```promql
# KEDA Scaler 活跃状态
keda_scaler_active{namespace="navigation"}
# 当前指标值
keda_scaler_metrics_value{scaledObject="navigation-scaler"}
# HPA 当前副本数
kube_horizontalpodautoscaler_status_current_replicas{horizontalpodautoscaler="keda-hpa-navigation-scaler"}
```
## 注意事项
### 1. 冷启动时间
从 0 扩容到可用需要 10-30 秒：
- 拉取镜像（如果本地没有）
- 启动容器
- 健康检查通过
### 2. 连接保持
客户端需要支持重连机制，因为服务可能会缩容到 0。
### 3. 有状态服务
PostgreSQL 等有状态服务**不能**直接使用 KEDA 扩展：
- ❌ 多副本会导致存储冲突
- ❌ 没有主从复制会导致数据不一致
- ✅ 需要使用专业的 Operator 或连接池方案
## 故障排查
### ScaledObject 未生效
```bash
# 查看详细状态
kubectl describe scaledobject <name> -n <namespace>
# 查看事件
kubectl get events -n <namespace> --sort-by='.lastTimestamp'
```
### HPA 未创建
检查 KEDA operator 日志：
```bash
kubectl logs -n keda -l app.kubernetes.io/name=keda-operator
```
## 文档参考
- 详细使用文档: `/home/fei/k3s/009-基础设施/007-keda/readme.md`
- KEDA 官方文档: https://keda.sh/docs/
- Scalers 参考: https://keda.sh/docs/scalers/
## 总结
✅ **KEDA 已成功部署并运行**
- KEDA 核心组件运行正常
- Navigation 服务已配置自动扩缩容
- 已验证缩容到 0 功能正常
- 准备好为更多服务配置自动扩缩容
**下一步**: 根据实际使用情况，逐步为 Redis 和 PostgreSQL 配置自动扩缩容。
---
**KEDA 让您的 K3s 集群更智能、更节省资源！** 🚀